static void devNI6123_AO_DAQ_MAX_VOLT(ST_execParam *pParam)
{
ST_MASTER *pMaster = get_master();
ST_STD_device *pSTDdev = (ST_STD_device*) ellFirst(pMaster->pList_DeviceTask);
ST_NI6123 *pNI6123 = NULL;
kLog (K_DATA,"[devNI6123_AO_DAQ_MAX_VOLT] minVolt(%f)\n", pParam->setValue);
while(pSTDdev) {
if (pSTDdev->StatusDev & TASK_ARM_ENABLED) {
kLog (K_DATA,"[devNI6123_AO_DAQ_MAX_VOLT] %s: System is armed! \n", pSTDdev->taskName);
notify_error (1, "System is armed!", pSTDdev->taskName );
}
else {
pNI6123 = pSTDdev->pUser;
pNI6123->maxVal = pParam->setValue;
scanIoRequest(pSTDdev->ioScanPvt_userCall);
kLog (K_DATA,"[devNI6123_AO_DAQ_MAX_VOLT] task(%s) maxVolt(%.f)\n",
pSTDdev->taskName, pNI6123->maxVal);
}
pSTDdev = (ST_STD_device*) ellNext(&pSTDdev->node);
}
}
/* auto Run function */
static void devNI6123_BO_AUTO_RUN(ST_execParam *pParam)
{
ST_MASTER *pMaster = get_master();
ST_STD_device *pSTDdev = (ST_STD_device*) ellFirst(pMaster->pList_DeviceTask);
ST_NI6123 *pNI6123 = NULL;
kLog (K_TRACE, "[devNI6123_BO_AUTO_RUN] auto_run(%f)\n", pParam->setValue);
if( pMaster->StatusAdmin & TASK_WAIT_FOR_TRIGGER ||
pMaster->StatusAdmin & TASK_IN_PROGRESS ) {
kLog (K_ERR, "System is running! (0x%x)\n", pMaster->StatusAdmin);
notify_error (1, "System is running! (0x%x)\n", pMaster->StatusAdmin);
return;
}
if(pParam->setValue) {
if( !(pMaster->StatusAdmin & TASK_SYSTEM_IDLE) ) {
kLog (K_ERR, "System is busy! (0x%x)\n", pMaster->StatusAdmin);
notify_error (1, "System is busy! (0x%x)\n", pMaster->StatusAdmin);
return;
}
#if 0
char strBuf[24];
float stopT1;
/* remove this function because ECH has not LTU, so We donot use the DBproc_get function */
if( pSTDdev->ST_Base.opMode == OPMODE_REMOTE ){
DBproc_get (PV_LTU_TIG_T0_STR, strBuf); //Get T0 from LTU
DBproc_put (PV_START_TIG_T0_STR, strBuf); //Set T0 from LTU
sscanf(strBuf, "%f", &stopT1);
stopT1 = pNI6123->sample_time - stopT1;
sprintf(strBuf,"%f",stopT1);
DBproc_put (PV_STOP_TIG_T1_STR, strBuf); //Set T0 from LTU
}
#endif
while(pSTDdev) {
pSTDdev->StatusDev |= TASK_STANDBY;
pNI6123 = pSTDdev->pUser;
pNI6123->auto_run_flag = 1;
pSTDdev = (ST_STD_device*) ellNext(&pSTDdev->node);
}
}
else if(!pParam->setValue) {
while(pSTDdev) {
pNI6123 = pSTDdev->pUser;
pNI6123->auto_run_flag = 0;
pSTDdev = (ST_STD_device*) ellNext(&pSTDdev->node);
}
pMaster->n8EscapeWhile = 0;
epicsThreadSleep(3.0);
pMaster->n8EscapeWhile = 1;
admin_all_taskStatus_reset();
scanIoRequest(pMaster->ioScanPvt_status);
}
notify_refresh_master_status();
}
static void devNI6123_AO_BEAM_PLUSE(ST_execParam *pParam)
{
ST_MASTER *pMaster = get_master();
ST_STD_device *pSTDdev = (ST_STD_device*) ellFirst(pMaster->pList_DeviceTask);
ST_NI6123 *pNI6123 = NULL;
kLog (K_TRACE, "[devNI6123_AO_BEAM_PLUSE] beam_pulse(%f)\n", pParam->setValue);
while(pSTDdev) {
if (pSTDdev->StatusDev & TASK_ARM_ENABLED) {
kLog (K_ERR, "[devNI6123_AO_BEAM_PLUSE] %s: System is armed! \n", pSTDdev->taskName);
notify_error (1, "System is armed!", pSTDdev->taskName );
}
else {
pNI6123 = pSTDdev->pUser;
pNI6123->beam_pulse = pParam->setValue;
scanIoRequest(pSTDdev->ioScanPvt_userCall);
kLog (K_DEBUG, "[devNI6123_AO_BEAM_PLUSE] task(%s) pulse(%.f)\n",
pSTDdev->taskName, pNI6123->beam_pulse);
}
pSTDdev = (ST_STD_device*) ellNext(&pSTDdev->node);
}
}
static void devNI6250_AO_DAQ_GAIN(ST_execParam *pParam)
{
ST_MASTER *pMaster = get_master();
ST_STD_device *pSTDdev = (ST_STD_device*) ellFirst(pMaster->pList_DeviceTask);
ST_NI6250 *pNI6250 = NULL;
kLog (K_MON, "[devNI6250_AO_DAQ_GAIN] gain(%f)\n", pParam->setValue);
while(pSTDdev) {
if (pSTDdev->StatusDev & TASK_ARM_ENABLED) {
kLog (K_ERR, "[devNI6250_AO_DAQ_GAIN] %s: System is armed! \n", pSTDdev->taskName);
notify_error (1, "System is armed!", pSTDdev->taskName );
}
else {
pNI6250 = pSTDdev->pUser;
pNI6250->gain = pParam->setValue;
scanIoRequest(pSTDdev->ioScanPvt_userCall);
kLog (K_DEBUG, "[devNI6250_AO_DAQ_GAIN] task(%s) gain(%.f)\n",
pSTDdev->taskName, pNI6250->gain);
}
pSTDdev = (ST_STD_device*) ellNext(&pSTDdev->node);
}
}
static void devNI6123_AO_DAQ_SAMPLEING_RATE(ST_execParam *pParam)
{
ST_MASTER *pMaster = get_master();
ST_STD_device *pSTDdev = (ST_STD_device*) ellFirst(pMaster->pList_DeviceTask);
ST_NI6123 *pNI6123 = NULL;
kLog (K_DATA,"[devNI6123_AO_DAQ_SAMPLEING_RATE] sampleRate(%f)\n", pParam->setValue);
while(pSTDdev) {
if (pSTDdev->StatusDev & TASK_ARM_ENABLED) {
kLog (K_DATA,"[devNI6123_AO_DAQ_SAMPLEING_RATE] %s: System is armed! \n", pSTDdev->taskName);
notify_error (1, "System is armed!", pSTDdev->taskName );
}
else {
pNI6123 = pSTDdev->pUser;
if(pParam->setValue > pNI6123->sample_rateLimit){
/* Device Sampling Rate Limit Cut if User is over Sampling Rate Setting. */
pParam->setValue = pNI6123->sample_rateLimit;
} else if(pParam->setValue <= 0){
pParam->setValue = 1;
}
pNI6123->sample_rate = pParam->setValue;
scanIoRequest(pSTDdev->ioScanPvt_userCall);
kLog (K_DATA,"[devNI6123_AO_DAQ_SAMPLEING_RATE] task(%s) sampleRate(%.f)\n",
pSTDdev->taskName, pNI6123->sample_rate);
}
pSTDdev = (ST_STD_device*) ellNext(&pSTDdev->node);
}
}
int acq196_route_FPGA_to_FPGA(ST_STD_device *pSTDdev)
{
FILE *pfp;
char strCmd[128];
char buff[128];
ST_ACQ196 *pAcq196 = (ST_ACQ196 *)pSTDdev->pUser;
sprintf(strCmd, "acqcmd -s %d set.route d0 in fpga out fpga", pAcq196->slot);
pfp=popen( strCmd, "r");
if(!pfp) {
printf("\n>>> %s: set.route d0 in fpga ... failed\n", pSTDdev->taskName);
return WR_ERROR;
} else kLog (K_MON, "[acqcmd] %d : acq196_route_FPGA_to_FPGA(%s) \n",
pAcq196->slot, strCmd);
while(fgets(buff, 128, pfp) != NULL ) {
#if PRINT_ACQCMD
printf("\n>>> %s: %s: %s", pSTDdev->taskName, strCmd, buff);
#endif
} pclose(pfp);
sprintf(strCmd, "acqcmd -s %d set.route d3 in fpga out fpga", pAcq196->slot);
pfp=popen( strCmd, "r");
if(!pfp) {
printf("\n>>> %s: set.route d3 in fpga ... failed\n", pSTDdev->taskName);
return WR_ERROR;
} else kLog (K_MON, "[acqcmd] %d : acq196_route_FPGA_to_FPGA 2(%s) \n",
pAcq196->slot, strCmd);
while(fgets(buff, 128, pfp) != NULL ) {
#if PRINT_ACQCMD
printf("\n>>> %s: %s: %s", pSTDdev->taskName, strCmd, buff);
#endif
} pclose(pfp);
return WR_OK;
}
static long devWaveNI6123_init_record(waveformRecord *precord)
{
ST_dpvt *pSTdpvt = (ST_dpvt*) malloc(sizeof(ST_dpvt));
int i;
switch(precord->inp.type) {
case INST_IO:
strcpy(pSTdpvt->recordName, precord->name);
i = sscanf(precord->inp.value.instio.string, "%s %s %s",
pSTdpvt->devName, pSTdpvt->arg0, pSTdpvt->arg1);
kLog (K_INFO, "[devWaveNI6123_init_record] %d: %s %s %s\n",
i, pSTdpvt->devName, pSTdpvt->arg0, pSTdpvt->arg1);
pSTdpvt->pSTDdev = (ST_STD_device *)get_STDev_from_name(pSTdpvt->devName);
if (!pSTdpvt->pSTDdev) {
recGblRecordError(S_db_badField, (void*) precord,
"devWaveNI6123 (init_record) Illegal INP field: task name");
free(pSTdpvt);
precord->udf = TRUE;
precord->dpvt = NULL;
return S_db_badField;
}
break;
default:
recGblRecordError(S_db_badField, (void*) precord,
"devWaveNI6123 (init_record) Illegal INP field");
free(pSTdpvt);
precord->udf = TRUE;
precord->dpvt = NULL;
return S_db_badField;
}
pSTdpvt->ind = -1;
if (3 == i) {
if (!strcmp (pSTdpvt->arg1, WAVE_RAW_VALUE_STR)) {
pSTdpvt->ind = WAVE_RAW_VALUE;
pSTdpvt->n32Arg0 = strtoul(pSTdpvt->arg0, NULL, 0);
}
else if (!strcmp (pSTdpvt->arg1, WAVE_VALUE_STR)) {
pSTdpvt->ind = WAVE_VALUE;
pSTdpvt->n32Arg0 = strtoul(pSTdpvt->arg0, NULL, 0);
}
}
else {
kLog (K_ERR, "[devWaveNI6123_init_record] arg cnt (%d) \n", i );
return -1; /*returns: (-1,0)=>(failure,success)*/
}
precord->udf = FALSE;
precord->dpvt = (void*) pSTdpvt;
return 2; /* don't convert */
}
static long devBoNI6123_init_record(boRecord *precord)
{
ST_dpvt *pSTdpvt = (ST_dpvt*) malloc(sizeof(ST_dpvt));
int i;
switch(precord->out.type) {
case INST_IO:
strcpy(pSTdpvt->recordName, precord->name);
i = sscanf(precord->out.value.instio.string, "%s",
pSTdpvt->arg0);
kLog (K_INFO, "[devBoNI6123_init_record] arg num: %d: %s\n",i, pSTdpvt->arg0);
ST_MASTER *pMaster = get_master();
pSTdpvt->pSTDdev = (ST_STD_device*) ellFirst(pMaster->pList_DeviceTask);
if(!pSTdpvt->pSTDdev) {
recGblRecordError(S_db_badField, (void*) precord,
"devBoNI6123Control (init_record) Illegal INP field: task_name");
free(pSTdpvt);
precord->udf = TRUE;
precord->dpvt = NULL;
return S_db_badField;
}
break;
default:
recGblRecordError(S_db_badField,(void*) precord,
"devBoNI6123Control (init_record) Illegal OUT field");
free(pSTdpvt);
precord->udf = TRUE;
precord->dpvt = NULL;
return S_db_badField;
}
if(!strcmp(pSTdpvt->arg0, BO_AUTO_RUN_STR)) {
pSTdpvt->ind = BO_AUTO_RUN;
}
else if (!strcmp(pSTdpvt->arg0, BO_DAQ_STOP_STR)) {
pSTdpvt->ind = BO_DAQ_STOP;
}
else if (!strcmp(pSTdpvt->arg0, BO_TREND_RUN_STR)) {
pSTdpvt->ind = BO_TREND_RUN;
}
else if (!strcmp(pSTdpvt->arg0, BO_CALC_RUN_STR)) {
pSTdpvt->ind = BO_CALC_RUN;
}
else {
pSTdpvt->ind = -1;
kLog (K_ERR, "ERROR! devBoNI6123_init_record: arg0 \"%s\" \n", pSTdpvt->arg0 );
}
precord->udf = FALSE;
precord->dpvt = (void*) pSTdpvt;
return 2; /*returns:(0,2)=>(success,success no convert*/
}
static long devAiNI6254_read_ai(aiRecord *precord)
{
ST_dpvt *pSTdpvt = (ST_dpvt*) precord->dpvt;
ST_STD_device *pSTDdev;
ST_NI6254 *pNI6254 = NULL;
int chId;
if(!pSTdpvt) return 0;
pSTDdev = pSTdpvt->pSTDdev;
chId = pSTdpvt->n32Arg0;
if (NULL != pSTDdev) {
pNI6254 = (ST_NI6254*)pSTDdev->pUser;
}
switch (pSTdpvt->ind) {
case AI_RAW_VALUE :
precord->val = (float)pNI6254->ST_Ch[chId].rawValue;
kLog (K_DATA, "[devAiNI6254_read_ai.AI_RAW_VALUE] %s:%d raw value: %d (0x%x)\n",
pSTDdev->taskName, chId, (int)precord->val, (int)precord->val);
break;
case AI_VALUE :
precord->val = (float)pNI6254->ST_Ch[chId].euValue;
kLog (K_DATA, "[devAiNI6254_read_ai.AI_VALUE] %s:%d value: %f\n", pSTDdev->taskName, chId, precord->val);
break;
case AI_POWER :
precord->val = (float)pNI6254->ST_Ch[chId].power;
kLog (K_DATA, "[devAiNI6254_read_ai.AI_POWER] %s:%d power: %f\n", pSTDdev->taskName, chId, precord->val);
break;
case AI_FLOW :
precord->val = (float)pNI6254->ST_Ch[chId].flow;
kLog (K_DATA, "[devAiNI6254_read_ai.AI_FLOW] %s:%d power: %f\n", pSTDdev->taskName, chId, precord->val);
break;
case AI_READ_STATE :
precord->val = pSTDdev->StatusDev;
break;
default:
kLog (K_ERR, "[devAiNI6254_read_ai] task(%s) ind(%d) is invalid\n", pSTDdev->taskName, pSTdpvt->ind);
break;
}
return (2);
}
static long devBiNI6254_init_record(biRecord *precord)
{
ST_dpvt *pSTdpvt = (ST_dpvt*) malloc(sizeof(ST_dpvt));
int i;
switch(precord->inp.type) {
case INST_IO:
strcpy(pSTdpvt->recordName, precord->name);
i = sscanf(precord->inp.value.instio.string, "%s", pSTdpvt->arg0);
kLog (K_INFO, "[devBiNI6254_init_record] %d: %s\n", i, pSTdpvt->arg0);
pSTdpvt->pMaster = get_master();
if (!pSTdpvt->pMaster) {
recGblRecordError(S_db_badField, (void*) precord,
"devBiNI6254 (init_record) Illegal INP field: task name");
free(pSTdpvt);
precord->udf = TRUE;
precord->dpvt = NULL;
return S_db_badField;
}
break;
default:
recGblRecordError(S_db_badField, (void*) precord,
"devBiNI6254 (init_record) Illegal INP field");
free(pSTdpvt);
precord->udf = TRUE;
precord->dpvt = NULL;
return S_db_badField;
}
pSTdpvt->ind = -1;
if (0) {
}
else {
kLog (K_ERR, "[devBiNI6254_init_record] arg cnt (%d) \n", i );
return -1; /*returns: (-1,0)=>(failure,success)*/
}
precord->udf = FALSE;
precord->dpvt = (void*) pSTdpvt;
return 0;
}
int acq196_set_ARM(ST_STD_device *pSTDdev)
{
FILE *pfp;
char buff[128];
char strCmd[128];
ST_ACQ196 *pAcq196 = (ST_ACQ196 *)pSTDdev->pUser;
/* TG change sprintf(strCmd, "acqcmd -b %d -- setArm", pAcq196->slot ); */
sprintf(strCmd, "acqcmd -b %d setArm", pAcq196->slot );
pfp=popen( strCmd, "r");
if(!pfp) {
printf("\n>>> acq196_set_ARM ... failed\n");
return WR_ERROR;
} else kLog (K_MON, "[acqcmd] %d : acq196_set_ARM(%s) \n",
pAcq196->slot, strCmd);
while(fgets(buff, 128, pfp) != NULL ) {
#if PRINT_ACQCMD
printf("\n>>> %s: %s: %s", pSTDdev->taskName, strCmd, buff);
#endif
} pclose(pfp);
// system(strCmd);
return WR_OK;
}
int acq196_set_externalClk_DI0(ST_STD_device *pSTDdev)
{
FILE *pfp;
char strCmd[128];
char buff[128];
ST_ACQ196 *pAcq196 = (ST_ACQ196 *)pSTDdev->pUser;
/* Modify TG Lee
sprintf(strCmd, "acqcmd -b %d setExternalClock DI0 %d", pAcq196->slot, pAcq196->clockDivider);
acqcmd -b 100 setExternalClock DI0 0 => ACQ32:ERROR bad arg "0" div wanted
*/
sprintf(strCmd, "acqcmd -b %d setExternalClock DI0", pAcq196->slot);
pfp=popen( strCmd, "r");
if(!pfp) {
printf("\n>>> %s: acqcmd -b %d setExternalClock DI0", pSTDdev->taskName, pAcq196->slot);
return WR_ERROR;
} else kLog (K_MON, "[acqcmd] %d : acq196_set_externalClk_DI0(%s) \n",
pAcq196->slot, strCmd);
while(fgets(buff, 128, pfp) != NULL ) {
#if PRINT_ACQCMD
printf("\n>>> %s: %s: %s", pSTDdev->taskName, strCmd, buff);
#endif
} pclose(pfp);
return WR_OK;
}
static long devAoNI6254_init_record(aoRecord *precord)
{
ST_dpvt *pSTdpvt = (ST_dpvt*) malloc(sizeof(ST_dpvt));
int i;
switch(precord->out.type) {
case INST_IO:
strcpy(pSTdpvt->recordName, precord->name);
i = sscanf(precord->out.value.instio.string, "%s %s %s",
pSTdpvt->arg0, pSTdpvt->devName, pSTdpvt->arg1);
kLog (K_INFO, "[devAoNI6254_init_record] %d: %s %s %s\n",
i, pSTdpvt->devName, pSTdpvt->arg0, pSTdpvt->arg1);
if (1 == i) {
ST_MASTER *pMaster = get_master();
pSTdpvt->pSTDdev = (ST_STD_device*) ellFirst(pMaster->pList_DeviceTask);
}
else if (3 == i) {
pSTdpvt->pSTDdev = (ST_STD_device *)get_STDev_from_name(pSTdpvt->devName);
}
if (!pSTdpvt->pSTDdev) {
recGblRecordError(S_db_badField, (void*) precord,
"devAoNI6254Control (init_record) Illegal INP field: task_name");
free(pSTdpvt);
precord->udf = TRUE;
precord->dpvt = NULL;
return S_db_badField;
}
break;
default:
recGblRecordError(S_db_badField,(void*) precord,
"devAoNI6254Control (init_record) Illegal OUT field");
free(pSTdpvt);
precord->udf = TRUE;
precord->dpvt = NULL;
return S_db_badField;
}
if (!strcmp(pSTdpvt->arg0, AO_DAQ_BEAM_PULSE_STR)) {
pSTdpvt->ind = AO_DAQ_BEAM_PULSE;
pSTdpvt->n32Arg0 = strtoul(pSTdpvt->arg1, NULL, 0);
}
else if (!strcmp(pSTdpvt->arg0, AO_INTEGRAL_STIME_STR)) {
pSTdpvt->ind = AO_INTEGRAL_STIME;
pSTdpvt->n32Arg0 = strtoul(pSTdpvt->arg1, NULL, 0);
}
else if (!strcmp(pSTdpvt->arg0, AO_INTEGRAL_TIME_STR)) {
pSTdpvt->ind = AO_INTEGRAL_TIME;
pSTdpvt->n32Arg0 = strtoul(pSTdpvt->arg1, NULL, 0);
}
precord->udf = FALSE;
precord->dpvt = (void*) pSTdpvt;
return 2; /* don't convert */
}
static void devNI6254_BO_TREND_RUN(ST_execParam *pParam)
{
kLog (K_MON, "[devNI6254_BO_TREND_RUN] setValue(%f)\n", pParam->setValue);
if (pParam->setValue) {
processTrendRun ();
}
}
static void devNI6123_BO_CALC_RUN(ST_execParam *pParam)
{
kLog (K_MON, "[devNI6123_BO_CALC_RUN] setValue(%f)\n", pParam->setValue);
if (pParam->setValue) {
/* processCalcRun (); */
}
}
static void devNI6254_AO_INTEGRAL_STIME(ST_execParam *pParam)
{
ST_STD_device *pSTDdev = pParam->pSTDdev;
int nIonSrcNum;
kLog (K_MON, "[devNI6254_AO_INTEGRAL_STIME] integral_stime(%f)\n", pParam->setValue);
if (pSTDdev->StatusDev & TASK_ARM_ENABLED) {
kLog (K_ERR, "[devNI6254_AO_INTEGRAL_STIME] %s: System is armed! \n", pSTDdev->taskName);
notify_error (1, "System is armed!", pSTDdev->taskName );
}
else {
nIonSrcNum = pParam->n32Arg0;
gIonSourceSetup[nIonSrcNum].integral_stime = pParam->setValue;
kLog (K_MON, "[devNI6254_AO_INTEGRAL_STIME] task(%s) integral_stime(%.f) IS(%d)\n",
pSTDdev->taskName, gIonSourceSetup[nIonSrcNum].integral_stime, nIonSrcNum);
}
}
static long devAiNI6250_read_ai(aiRecord *precord)
{
ST_dpvt *pSTdpvt = (ST_dpvt*) precord->dpvt;
ST_STD_device *pSTDdev;
ST_NI6250 *pNI6250 = NULL;
int chId;
if(!pSTdpvt) return 0;
pSTDdev = pSTdpvt->pSTDdev;
chId = pSTdpvt->n32Arg0;
pNI6250 = (ST_NI6250*)pSTDdev->pUser;
switch (pSTdpvt->ind) {
case AI_READ_STATE :
precord->val = pSTDdev->StatusDev;
kLog (K_DATA, "[devAiNI6250_read_ai.AI_READ_STATE] %s : value(%f)\n", pSTDdev->taskName, precord->val);
break;
case AI_RAW_VALUE :
precord->val = pNI6250->ST_Ch[chId].rawValue;
kLog (K_DATA, "[devAiNI6250_read_ai.AI_RAW_VALUE] %s : ch(%d) raw(%d) (0x%x)\n",
pSTDdev->taskName, chId, (int)precord->val, (int)precord->val);
break;
case AI_VALUE :
precord->val = (float)pNI6250->ST_Ch[chId].euValue;
//precord->val = pNI6250->ST_Ch[chId].euValue * pNI6250->gain + pNI6250->offset;
kLog (K_DATA, "[devAiNI6250_read_ai.AI_VALUE] %s : ch(%d) value(%f) eu(%f) gain(%f) offset(%f)\n",
pSTDdev->taskName, chId, precord->val,
pNI6250->ST_Ch[chId].euValue, pNI6250->gain, pNI6250->offset);
break;
default:
kLog (K_ERR, "[devAiNI6250_read_ai] %s : ind(%d) is invalid\n", pSTDdev->taskName, pSTdpvt->ind);
break;
}
return (2);
}
static long devWaveNI6123_read_wave(waveformRecord *precord)
{
ST_dpvt *pSTdpvt = (ST_dpvt*) precord->dpvt;
ST_STD_device *pSTDdev;
ST_NI6123 *pNI6123 = NULL;
int chId;
unsigned long sampleRate; /* wave form record Number of Elements and Number elements read field */
if(!pSTdpvt) return 0;
pSTDdev = pSTdpvt->pSTDdev;
chId = pSTdpvt->n32Arg0;
pNI6123 = (ST_NI6123*)pSTDdev->pUser;
sampleRate = (unsigned long)pNI6123->sample_rate;
switch (pSTdpvt->ind) {
case WAVE_RAW_VALUE :
if(sampleRate > 0) precord->nelm = sampleRate;
precord->bptr = pNI6123->ST_Ch[chId].fScaleReadChannel;
if(sampleRate > 0) precord->nord = sampleRate;
kLog (K_DATA, "[devWaveNI6123_read_wave.WAVE_RAW_VALUE] %s:%d raw value: %f \n",
pSTDdev->taskName, chId, pNI6123->ST_Ch[chId].fScaleReadChannel[0]);
break;
case WAVE_VALUE :
if(sampleRate > 0) precord->nelm = sampleRate;
precord->bptr = pNI6123->ST_Ch[chId].calcDensity;
if(sampleRate > 0) precord->nord = sampleRate;
kLog (K_DATA, "[devWaveNI6123_read_wave.WAVE_VALUE] %s:%d value: %f\n", pSTDdev->taskName, chId, pNI6123->ST_Ch[chId].fScaleReadChannel[0]);
break;
default:
kLog (K_ERR, "[devWaveNI6123_read_wave] task(%s) ind(%d) is invalid\n", pSTDdev->taskName, pSTdpvt->ind);
break;
}
return (2);
}
static void devNI6123_AO_DAQ_SAMPLEING_TIME(ST_execParam *pParam)
{
ST_MASTER *pMaster = get_master();
ST_STD_device *pSTDdev = (ST_STD_device*) ellFirst(pMaster->pList_DeviceTask);
ST_NI6123 *pNI6123 = NULL;
kLog (K_DATA,"[devNI6123_AO_DAQ_SAMPLEING_TIME] sampleTime(%f)\n", pParam->setValue);
#if 0
char strBuf[24];
float stopT1;
/* remove this function because ECH has not LTU, so We donot use the DBproc_get function */
if (!(pSTDdev->StatusDev & TASK_ARM_ENABLED)) {
/* Change T0 value form LUT when Remote Mode TG */
if( pSTDdev->ST_Base.opMode == OPMODE_REMOTE ){
/* DBproc_get (PV_LTU_TIG_T0_STR, strBuf); Get T0 from LTU - ECH Not yet ready LTU*/
DBproc_put (PV_START_TIG_T0_STR, strBuf); //Set T0 from LTU
sscanf(strBuf, "%f", &stopT1);
stopT1 = pParam->setValue - stopT1;
sprintf(strBuf,"%f",stopT1);
DBproc_put (PV_STOP_TIG_T1_STR, strBuf); //Set T0 from LTU
}
}
#endif
while(pSTDdev) {
if (pSTDdev->StatusDev & TASK_ARM_ENABLED) {
kLog (K_DATA,"[devNI6123_AO_DAQ_SAMPLEING_TIME] %s: System is armed! \n", pSTDdev->taskName);
notify_error (1, "System is armed!", pSTDdev->taskName );
}
else {
pNI6123 = pSTDdev->pUser;
pNI6123->sample_time = pParam->setValue;
scanIoRequest(pSTDdev->ioScanPvt_userCall);
kLog (K_DATA,"[devNI6123_AO_DAQ_SAMPLEING_TIME] task(%s) sampleTime(%.f)\n",
pSTDdev->taskName, pNI6123->sample_rate);
}
pSTDdev = (ST_STD_device*) ellNext(&pSTDdev->node);
}
}
static long devBiNI6254_read_bi(biRecord *precord)
{
ST_dpvt *pSTdpvt = (ST_dpvt*) precord->dpvt;
if(!pSTdpvt) return 0;
switch (pSTdpvt->ind) {
default:
kLog (K_ERR, "[devBiNI6254_read_bi] ind(%d) is invalid\n", pSTdpvt->ind);
break;
}
return (2);
}
int acq196_set_TriggerConfig(ST_STD_device *pSTDdev)
{
FILE *pfp;
char strCmd[128];
char buff[128];
ST_ACQ196 *pAcq196 = (ST_ACQ196 *)pSTDdev->pUser;
sprintf(strCmd, "acqcmd -s %d set.trig DI3 rising", pAcq196->slot);
pfp=popen( strCmd, "r");
if(!pfp) {
printf("\n>>> %s: set.trig DI3 rising ... failed\n", pSTDdev->taskName);
return WR_ERROR;
}else kLog (K_MON, "[acqcmd] %d : acq196_set_TriggerConfig(%s) \n",
pAcq196->slot, strCmd);
while(fgets(buff, 128, pfp) != NULL ) {
#if PRINT_ACQCMD
printf("\n>>> %s: %s: %s", pSTDdev->taskName, strCmd, buff);
#endif
} pclose(pfp);
#if 0
// TG Remove -- error ??? I have to check
sprintf(strCmd, "acqcmd -s %d set.event0 DI3 falling", pAcq196->slot);
pfp=popen( strCmd, "r");
if(!pfp) {
printf("\n>>> %s: set.event0 DI3 falling ... failed\n", pSTDdev->taskName);
return WR_ERROR;
}else kLog (K_MON, "[acqcmd] %d : acq196_set_TriggerConfig 2(%s) \n",
pAcq196->slot, strCmd);
while(fgets(buff, 128, pfp) != NULL ) {
#if PRINT_ACQCMD
printf("\n>>> %s: %s: %s", pSTDdev->taskName, strCmd, buff);
#endif
} pclose(pfp);
#endif
return WR_OK;
}
static void devNI6123_AO_MDS_PARAM_VALUE5(ST_execParam *pParam)
{
ST_STD_device *pSTDdev = pParam->pSTDdev;
ST_NI6123 *pNI6123 = pSTDdev->pUser;
int chId;
chId = pParam->n32Arg0;
pNI6123 = (ST_NI6123*)pSTDdev->pUser;
kLog (K_TRACE, "[devNI6123_AO_MDS_PARAM_VALUE5] %s : ch(%d) MDSplus Param value(%f)\n",
pSTDdev->taskName, chId, pParam->setValue);
pNI6123->ST_Ch[chId].mdsParam5 = pParam->setValue;
scanIoRequest(pSTDdev->ioScanPvt_userCall);
}
static void devNI6123_AO_CONSTANT_D(ST_execParam *pParam)
{
ST_STD_device *pSTDdev = pParam->pSTDdev;
ST_NI6123 *pNI6123 = pSTDdev->pUser;
int chId;
chId = pParam->n32Arg0;
pNI6123 = (ST_NI6123*)pSTDdev->pUser;
kLog (K_TRACE, "[devNI6123_AO_CONSTANT_D] %s : ch(%d) density constant D(%f)\n",
pSTDdev->taskName, chId, pParam->setValue);
pNI6123->ST_Ch[chId].conD = pParam->setValue;
scanIoRequest(pSTDdev->ioScanPvt_userCall);
}
static void devNI6123_AO_LIMITE_LOW(ST_execParam *pParam)
{
ST_STD_device *pSTDdev = pParam->pSTDdev;
ST_NI6123 *pNI6123 = pSTDdev->pUser;
int chId;
chId = pParam->n32Arg0;
pNI6123 = (ST_NI6123*)pSTDdev->pUser;
kLog (K_TRACE, "[devNI6123_AO_LIMITE_LOW] %s : ch(%d) density limite lower(%f)\n",
pSTDdev->taskName, chId, pParam->setValue);
pNI6123->ST_Ch[chId].dLimLow = pParam->setValue;
scanIoRequest(pSTDdev->ioScanPvt_userCall);
}
static void devNI6123_AO_INTEGRAL_TIME(ST_execParam *pParam)
{
ST_STD_device *pSTDdev = pParam->pSTDdev;
ST_NI6123 *pNI6123 = NULL;
int chId;
chId = pParam->n32Arg0;
pNI6123 = (ST_NI6123*)pSTDdev->pUser;
kLog (K_TRACE, "[devNI6123_AO_INTEGRAL_TIME] %s : ch(%d) time(%f)\n",
pSTDdev->taskName, chId, pParam->setValue);
pNI6123->ST_Ch[chId].integral_time = pParam->setValue;
scanIoRequest(pSTDdev->ioScanPvt_userCall);
}
static void devNI6254_BO_DAQ_STOP(ST_execParam *pParam)
{
kLog (K_MON, "[devNI6254_BO_DAQ_STOP] daq_stop(%f)\n", pParam->setValue);
if (0 == pParam->setValue) {
return;
}
resetDeviceAll ();
notify_refresh_master_status();
scanIoRequest(get_master()->ioScanPvt_status);
DBproc_put("NB1_LODAQ_DAQ_STOP", "0");
DBproc_put("NB1_LODAQ_TREND_RUN", "0");
DBproc_put("NB1_LODAQ_CALC_RUN", "0");
}
static void devNI6250_BO_DAQ_STOP(ST_execParam *pParam)
{
kLog (K_MON, "[devNI6250_BO_DAQ_STOP] daq_stop(%f)\n", pParam->setValue);
if (0 == pParam->setValue) {
return;
}
resetDeviceAll ();
notify_refresh_master_status();
scanIoRequest(get_master()->ioScanPvt_status);
DBproc_put(PV_SYS_ARMING_STR, "0");
DBproc_put(PV_SYS_RUN_STR, "0");
DBproc_put(PV_DAQ_STOP_STR, "0");
}
char handleMessage(char* message) {
char collectionStatus;
unsigned long startTime;
unsigned long measureTime;
Key primaryKey;
Key secondKey;
getPrimaryKey(&primaryKey, message);
switch (getMessageStatus(message)) {
case MESSAGE_TYPE_REGULAR: {
startTime = getULongNano();
collectionStatus = collection.find(&primaryKey);
measureTime = calcOffsetULong(startTime);
if (FIND_SUCCESS == collectionStatus) logPrimary(measureTime);
else kLog("Unsuccess find", &primaryKey);
}
break;
case MESSAGE_TYPE_ALTER: {
getSecondKey(&secondKey, message);
startTime = getULongNano();
collectionStatus = collection.alter(&primaryKey,
&secondKey);
measureTime = calcOffsetULong(startTime);
if (ALTER_SUCCESS != collectionStatus)
dkLog("Unsuccess alter", &primaryKey, &secondKey);
else logSecondary(measureTime);
}
break;
default:
printf("%s", "Invalid message type\n");
return MESSAGE_INVALID;
}
return MESSAGE_VALID;
}
static void devNI6123_BO_DAQ_STOP(ST_execParam *pParam)
{
kLog (K_MON, "[devNI6123_BO_DAQ_STOP] daq_stop(%f)\n", pParam->setValue);
if (0 == pParam->setValue) {
return;
}
resetDeviceAll ();
notify_refresh_master_status();
scanIoRequest(get_master()->ioScanPvt_status);
DBproc_put(PV_DAQ_STOP_STR, "0");
/* remove tglee
DBproc_put(PV_TREND_RUN_STR, "0");
DBproc_put(PV_CALC_RUN_STR, "0");
*/
}
int acq196_set_internalClk_DO0(ST_STD_device *pSTDdev)
{
FILE *pfp;
char strCmd[128];
char buff[128];
ST_ACQ196 *pAcq196 = (ST_ACQ196 *)pSTDdev->pUser;
sprintf(strCmd, "acqcmd -b %d setInternalClock %d", pAcq196->slot, pSTDdev->ST_Base.nSamplingRate);
pfp=popen( strCmd, "r");
if(!pfp) {
printf("\n>>> %s: setInternalClock ... failed\n", pSTDdev->taskName);
return WR_ERROR;
} else kLog (K_MON, "[acqcmd] %d : acq196_set_internalClk_DO0(%s) \n",
pAcq196->slot, strCmd);
while(fgets(buff, 128, pfp) != NULL ) {
#if PRINT_ACQCMD
printf("\n>>> %s: %s: %s", pSTDdev->taskName, strCmd, buff);
#endif
} pclose(pfp);
return WR_OK;
}
