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 long init_record(void *rec_p, int pass) { rfmRecord *precord = (rfmRecord*)rec_p; rfmdset *pdset = NULL; long status = OK; if(pass==0) return status; /* check device entry table */ if((pdset = (rfmdset*)(precord->dset)) == NULL) { recGblRecordError((status = S_dev_noDSET), precord, "rfm: init_record"); return status; } /* must have read_rfm function defined */ if((pdset->number<5) ||(pdset->read_rfm == NULL)) { recGblRecordError((status = S_dev_missingSup), precord, "rfm: init_record"); return status; } /* execute device support level initialization */ if(pdset->init_record) status = (*pdset->init_record)(precord); return status; }
static long init_record(stringoutRecord *prec, int pass) { STATIC_ASSERT(sizeof(prec->oval)==sizeof(prec->val)); struct stringoutdset *pdset; long status=0; if (pass==0) return(0); if (prec->siml.type == CONSTANT) { recGblInitConstantLink(&prec->siml,DBF_USHORT,&prec->simm); } if(!(pdset = (struct stringoutdset *)(prec->dset))) { recGblRecordError(S_dev_noDSET,(void *)prec,"stringout: init_record"); return(S_dev_noDSET); } /* must have write_stringout functions defined */ if( (pdset->number < 5) || (pdset->write_stringout == NULL) ) { recGblRecordError(S_dev_missingSup,(void *)prec,"stringout: init_record"); return(S_dev_missingSup); } /* get the initial value dol is a constant*/ if (prec->dol.type == CONSTANT){ if(recGblInitConstantLink(&prec->dol,DBF_STRING,prec->val)) prec->udf=FALSE; } if( pdset->init_record ) { if((status=(*pdset->init_record)(prec))) return(status); } strcpy(prec->oval,prec->val); return(0); }
/***************************************************************************** * * Init the record, then call the device support module to let it know that * this record intends on using it. * ******************************************************************************/ static long init_record(void *precord, int pass) { vsRecord *pvs = (vsRecord *)precord; vsdset *pdset; long status; if (pass == 0) return (0); pvs->chgc = 0; if ( (pdset = (vsdset *)(pvs->dset) )== NULL) { recGblRecordError(S_dev_noDSET, (void *)pvs, "vs: init_record"); return (S_dev_noDSET); } /*** must have readWrite_vs function defined ***/ if ((pdset->number < 5) || (pdset->readWrite_vs == NULL)) { recGblRecordError(S_dev_missingSup, (void *)pvs, "vs: init_record"); return (S_dev_missingSup); } /*** if everything is OK init the record ***/ if (pdset->init_record) { if ((status = (*pdset->init_record) (pvs))) { return (status); } } return (0); }
static long init_record(subArrayRecord *prec, int pass) { struct sadset *pdset; if (pass==0){ if (prec->malm <= 0) prec->malm = 1; if (prec->ftvl > DBF_ENUM) prec->ftvl = DBF_UCHAR; prec->bptr = callocMustSucceed(prec->malm, dbValueSize(prec->ftvl), "subArrayRecord calloc failed"); prec->nord = 0; return 0; } /* must have dset defined */ if (!(pdset = (struct sadset *)(prec->dset))) { recGblRecordError(S_dev_noDSET,(void *)prec,"sa: init_record"); return S_dev_noDSET; } /* must have read_sa function defined */ if ( (pdset->number < 5) || (pdset->read_sa == NULL) ) { recGblRecordError(S_dev_missingSup,(void *)prec,"sa: init_record"); return S_dev_missingSup; } if (pdset->init_record) return (*pdset->init_record)(prec); return 0; }
static long init_record(stringinRecord *prec, int pass) { STATIC_ASSERT(sizeof(prec->oval)==sizeof(prec->val)); struct stringindset *pdset; long status; if (pass==0) return(0); if (prec->siml.type == CONSTANT) { recGblInitConstantLink(&prec->siml,DBF_USHORT,&prec->simm); } /* stringin.siol must be a CONSTANT or a PV_LINK or a DB_LINK */ if (prec->siol.type == CONSTANT) { recGblInitConstantLink(&prec->siol,DBF_STRING,prec->sval); } if(!(pdset = (struct stringindset *)(prec->dset))) { recGblRecordError(S_dev_noDSET,(void *)prec,"stringin: init_record"); return(S_dev_noDSET); } /* must have read_stringin function defined */ if( (pdset->number < 5) || (pdset->read_stringin == NULL) ) { recGblRecordError(S_dev_missingSup,(void *)prec,"stringin: init_record"); return(S_dev_missingSup); } if( pdset->init_record ) { if((status=(*pdset->init_record)(prec))) return(status); } strcpy(prec->oval,prec->val); return(0); }
static long init_wf_wr(struct waveformRecord *pwf) { int parmOK = 0; if (pwf->inp.type!=VME_IO) { recGblRecordError(S_db_badField, (void *)pwf, "devWfWrD212 Init_record, Illegal INP"); pwf->pact=TRUE; return (S_db_badField); } pwf->dpvt = (void*) calloc(1, sizeof(recPrivate*)); ((recPrivate*) pwf->dpvt)->pCard = getCardStruct(pwf->inp.value.vmeio.card); do { CHECK_WFPARM("WF_WR_1", CPCI_WF_WR_1); } while(0); if (!parmOK) { recGblRecordError(S_db_badField, (void *)pwf, "devWfWrD212 Init_record, bad parm"); pwf->pact=TRUE; return (S_db_badField); } if (pwf->ftvl != DBF_FLOAT) { recGblRecordError(S_db_badField, (void *)pwf, "devWfWrD212 (init_record) Illegal FTVL field"); return(S_db_badField); } return 0; }
static long init_record(longoutRecord *prec, int pass) { struct longoutdset *pdset; long status=0; if (pass==0) return(0); if (prec->siml.type == CONSTANT) { recGblInitConstantLink(&prec->siml,DBF_USHORT,&prec->simm); } if(!(pdset = (struct longoutdset *)(prec->dset))) { recGblRecordError(S_dev_noDSET,(void *)prec,"longout: init_record"); return(S_dev_noDSET); } /* must have write_longout functions defined */ if( (pdset->number < 5) || (pdset->write_longout == NULL) ) { recGblRecordError(S_dev_missingSup,(void *)prec,"longout: init_record"); return(S_dev_missingSup); } if (prec->dol.type == CONSTANT) { if(recGblInitConstantLink(&prec->dol,DBF_LONG,&prec->val)) prec->udf=FALSE; } if( pdset->init_record ) { if((status=(*pdset->init_record)(prec))) return(status); } prec->mlst = prec->val; prec->alst = prec->val; prec->lalm = prec->val; return(0); }
static long init_record(mbbiRecord *prec, int pass) { struct mbbidset *pdset; long status; if (pass==0) return(0); if (prec->siml.type == CONSTANT) { recGblInitConstantLink(&prec->siml,DBF_USHORT,&prec->simm); } if (prec->siol.type == CONSTANT) { recGblInitConstantLink(&prec->siol,DBF_USHORT,&prec->sval); } if(!(pdset = (struct mbbidset *)(prec->dset))) { recGblRecordError(S_dev_noDSET,(void *)prec,"mbbi: init_record"); return(S_dev_noDSET); } /* must have read_mbbi function defined */ if( (pdset->number < 5) || (pdset->read_mbbi == NULL) ) { recGblRecordError(S_dev_missingSup,(void *)prec,"mbbi: init_record"); return(S_dev_missingSup); } /* initialize mask*/ prec->mask = (1 << prec->nobt) - 1; if( pdset->init_record ) { if((status=(*pdset->init_record)(prec))) return(status); } init_common(prec); prec->mlst = prec->val; prec->lalm = prec->val; prec->oraw = prec->rval; return(0); }
static long ai_init_record(aiRecord* pr) { int i; char *parm; pvtArea *pvt = NULL; if(pr->inp.type!=INST_IO) { recGblRecordError(S_db_badField,(void*)pr, "devAiStats (init_record) Illegal INP field"); return S_db_badField; } parm = pr->inp.value.instio.string; for(i=0;statsGetParms[i].name && pvt==NULL;i++) { if(strcmp(parm,statsGetParms[i].name)==0) { pvt=(pvtArea*)malloc(sizeof(pvtArea)); pvt->index=i; pvt->type=statsGetParms[i].type; } } if(pvt==NULL) { recGblRecordError(S_db_badField,(void*)pr, "devAiStats (init_record) Illegal INP parm field"); return S_db_badField; } /* Make sure record processing routine does not perform any conversion*/ pr->linr=0; pr->dpvt=pvt; return 0; }
static long init_record(epidRecord *pepid, int pass) { struct epidDSET *pdset; int status; if (pass==0) return(0); /* initialize the setpoint for constant setpoint */ if (pepid->stpl.type == CONSTANT) { if(recGblInitConstantLink(&pepid->stpl,DBF_DOUBLE,&pepid->val)) pepid->udf = FALSE; } /* must have dset defined */ if (!(pdset = (struct epidDSET *)(pepid->dset))) { recGblRecordError(S_dev_noDSET,(void *)pepid,"epid: init_record1"); return(S_dev_noDSET); } /* must have do_pid function defined */ if ( (pdset->number < 5) || (pdset->do_pid == NULL) ) { recGblRecordError(S_dev_missingSup,(void *)pepid,"epid: init_record2"); printf("%ld %p\n",pdset->number, pdset->do_pid); return(S_dev_missingSup); } if (pdset->init_record) { if ((status=(*pdset->init_record)(pepid))) return(status); } return(0); }
static long stringin_init_record(stringinRecord* pr) { int i; char *parm; pvtArea *pvt = NULL; if(pr->inp.type!=INST_IO) { recGblRecordError(S_db_badField,(void*)pr, "devStringinStats (init_record) Illegal INP field"); return S_db_badField; } parm = pr->inp.value.instio.string; for(i=0;statsGetStrParms[i].name && pvt==NULL;i++) { if(strcmp(parm,statsGetStrParms[i].name)==0) { pvt=(pvtArea*)malloc(sizeof(pvtArea)); pvt->index=i; pvt->type=statsGetStrParms[i].type; } } if(pvt==NULL) { recGblRecordError(S_db_badField,(void*)pr, "devStringinStats (init_record) Illegal INP parm field"); return S_db_badField; } pr->dpvt=pvt; return 0; /* success */ }
static long init_ai(aiRecord *prec) { int i; if (prec->inp.type != INST_IO) { recGblRecordError(S_db_badField, (void *)prec, "devAiGeneralTime::init_ai: Illegal INP field"); prec->pact = TRUE; return S_db_badField; } for (i = 0; i < NELEMENTS(ai_channels); i++) { struct ai_channel *pchan = &ai_channels[i]; if (!epicsStrCaseCmp(prec->inp.value.instio.string, pchan->name)) { prec->dpvt = pchan; return 0; } } recGblRecordError(S_db_badField, (void *)prec, "devAiGeneralTime::init_ai: Bad parm"); prec->pact = TRUE; prec->dpvt = NULL; return S_db_badField; }
static long init_record(boRecord *prec,int pass) { struct bodset *pdset; long status=0; myCallback *pcallback; if (pass==0) return(0); /* bo.siml must be a CONSTANT or a PV_LINK or a DB_LINK */ if (prec->siml.type == CONSTANT) { recGblInitConstantLink(&prec->siml,DBF_USHORT,&prec->simm); } if(!(pdset = (struct bodset *)(prec->dset))) { recGblRecordError(S_dev_noDSET,(void *)prec,"bo: init_record"); return(S_dev_noDSET); } /* must have write_bo functions defined */ if( (pdset->number < 5) || (pdset->write_bo == NULL) ) { recGblRecordError(S_dev_missingSup,(void *)prec,"bo: init_record"); return(S_dev_missingSup); } /* get the initial value */ if (prec->dol.type == CONSTANT) { unsigned short ival = 0; if(recGblInitConstantLink(&prec->dol,DBF_USHORT,&ival)) { if (ival == 0) prec->val = 0; else prec->val = 1; prec->udf = FALSE; } } pcallback = (myCallback *)(calloc(1,sizeof(myCallback))); prec->rpvt = (void *)pcallback; callbackSetCallback(myCallbackFunc,&pcallback->callback); callbackSetUser(pcallback,&pcallback->callback); pcallback->precord = (struct dbCommon *)prec; if( pdset->init_record ) { status=(*pdset->init_record)(prec); if(status==0) { if(prec->rval==0) prec->val = 0; else prec->val = 1; prec->udf = FALSE; } else if (status==2) status=0; } prec->mlst = prec->val; /* convert val to rval */ if ( prec->mask != 0 ) { if(prec->val==0) prec->rval = 0; else prec->rval = prec->mask; } else prec->rval = (epicsUInt32)prec->val; prec->mlst = prec->val; prec->lalm = prec->val; prec->oraw = prec->rval; prec->orbv = prec->rbv; return(status); }
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 */ }
LOCAL long init_lo (struct longoutRecord *prec) { struct abio *pabio; devPvt *pdevPvt; abStatus drvStatus; long status = 0; void *drvPvt; short value[2]; if (prec->out.type != AB_IO) { recGblRecordError (S_db_badField, (void *) prec, "init_lo: Bad OUT field"); return (S_db_badField); } pabio = (struct abio *) &(prec->out.value); drvStatus = (*pabDrv->registerCard) (pabio->link, pabio->adapter, pabio->card, typeBo, "BINARY", NULL, &drvPvt); switch (drvStatus) { case abSuccess : pdevPvt = (devPvt *) (*pabDrv->getUserPvt) (drvPvt); prec->dpvt = pdevPvt; break; case abNewCard : pdevPvt = calloc (1, sizeof (devPvt)); pdevPvt->drvPvt = drvPvt; prec->dpvt = pdevPvt; (*pabDrv->setUserPvt) (drvPvt, (void *) pdevPvt); drvStatus = (*pabDrv->setNbits) (drvPvt, abBit16); if (drvStatus != abSuccess) { status = S_db_badField; recGblRecordError (status, (void *) prec, "init_lo: setNbits"); return (status); } break; default: status = S_db_badField; printf ("init_lo: %s\n", abStatusMessage[drvStatus]); recGblRecordError (status, (void *) prec, "init_lo: registerCard"); return (status); } drvStatus = (*pabDrv->readBo) (drvPvt, (unsigned long *)value, 0x0000ffff); if (drvStatus == abSuccess) { prec->val = (long)value[1]; status = 0; } else { status = 2; } return (status); }
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 process(stringoutRecord *prec) { struct stringoutdset *pdset = (struct stringoutdset *)(prec->dset); long status=0; unsigned char pact=prec->pact; if( (pdset==NULL) || (pdset->write_stringout==NULL) ) { prec->pact=TRUE; recGblRecordError(S_dev_missingSup,(void *)prec,"write_stringout"); return(S_dev_missingSup); } if (!prec->pact && (prec->dol.type != CONSTANT) && (prec->omsl == menuOmslclosed_loop)) { status = dbGetLink(&(prec->dol), DBR_STRING,prec->val,0,0); if(prec->dol.type!=CONSTANT && RTN_SUCCESS(status)) prec->udf=FALSE; } if(prec->udf == TRUE ){ recGblSetSevr(prec,UDF_ALARM,INVALID_ALARM); } if (prec->nsev < INVALID_ALARM ) status=writeValue(prec); /* write the new value */ else { switch (prec->ivoa) { case (menuIvoaContinue_normally) : status=writeValue(prec); /* write the new value */ break; case (menuIvoaDon_t_drive_outputs) : break; case (menuIvoaSet_output_to_IVOV) : if(prec->pact == FALSE){ strcpy(prec->val,prec->ivov); } status=writeValue(prec); /* write the new value */ break; default : status=-1; recGblRecordError(S_db_badField,(void *)prec, "stringout:process Illegal IVOA field"); } } /* check if device support set pact */ if ( !pact && prec->pact ) return(0); prec->pact = TRUE; recGblGetTimeStamp(prec); monitor(prec); recGblFwdLink(prec); prec->pact=FALSE; return(status); }
static long devAoXXX_init_record(aoRecord *precord) { ST_dpvt *pDpvt = (ST_dpvt*) malloc(sizeof(ST_dpvt)); int nval; char arg0[SIZE_DPVT_ARG]; char arg1[SIZE_DPVT_ARG]; char arg2[SIZE_DPVT_ARG]; switch(precord->out.type) { case INST_IO: nval = sscanf(precord->out.value.instio.string, "%s %s %s %s", pDpvt->devName, arg0, arg1, arg2); pDpvt->pSTDdev = get_STDev_from_name(pDpvt->devName); if(!pDpvt->pSTDdev) { recGblRecordError(S_db_badField, (void*) precord, "devAoXXX (init_record) Illegal OUT field: task_name"); free(pDpvt); precord->udf = TRUE; precord->dpvt = NULL; return S_db_badField; } break; default: recGblRecordError(S_db_badField,(void*) precord, "devAoXXX (init_record) Illegal OUT field"); free(pDpvt); precord->udf = TRUE; precord->dpvt = NULL; return S_db_badField; } if (!strcmp(arg0, AO_TEST_1_STR)) pDpvt->ind = AO_TEST_1; else if (!strcmp(arg0, AO_TEST_2_STR)) { pDpvt->ind = AO_TEST_2; pDpvt->n32Arg0 = strtoul(arg1, NULL, 0); /* chennel id */ pDpvt->n32Arg1 = strtoul(arg2, NULL, 0); /* section id */ } else { pDpvt->ind = -1; epicsPrintf("ERROR!! devAoXXX_init_record: arg0 \"%s\" \n", arg0 ); } precord->udf = FALSE; precord->dpvt = (void*) pDpvt; return 2; /*returns: (0,2)=>(success,success no convert)*/ }
static long init_ai(struct aiRecord *pai) { int signal; int parmOK=0; signal = pai->inp.value.vmeio.signal; if (pai->inp.type!=VME_IO) { recGblRecordError(S_db_badField, (void *)pai, "devLiD212 Init_record, Illegal INP"); pai->pact=TRUE; return (S_db_badField); } pai->dpvt = (void*) calloc(1, sizeof(recPrivate*)); ((recPrivate*) pai->dpvt)->pCard = getCardStruct(pai->inp.value.vmeio.card); do { CHECK_AIPARM("FIX_FREQUENCY", CPCI_AI_FIX_FREQUENCY); CHECK_AIPARM("WORK_PERIOD", CPCI_AI_WORK_PERIOD); CHECK_AIPARM("AMP_SET", CPCI_AI_AMP_SET); CHECK_AIPARM("AMP_COEFFICIENT", CPCI_AI_AMP_COEFFICIENT); CHECK_AIPARM("AMP_P_SET", CPCI_AI_AMP_P_SET); CHECK_AIPARM("AMP_I_SET", CPCI_AI_AMP_I_SET); CHECK_AIPARM("AMP_I1_SET", CPCI_AI_AMP_I_SET1); CHECK_AIPARM("AMP_I2_SET", CPCI_AI_AMP_I_SET2); CHECK_AIPARM("AMP_I3_SET", CPCI_AI_AMP_I_SET3); CHECK_AIPARM("BIAS_SET", CPCI_AI_BIAS_SET); CHECK_AIPARM("FIX_TUNING_ANGLE", CPCI_AI_FIX_TUNING_ANGLE); CHECK_AIPARM("TUNING_ANGLE_OFFSET", CPCI_AI_TUNING_ANGLE_OFFSET); CHECK_AIPARM("TUNE_P_SET", CPCI_AI_TUNE_P_SET); CHECK_AIPARM("TUNE_I_SET", CPCI_AI_TUNE_I_SET); CHECK_AIPARM("TUNE_I1_SET", CPCI_AI_TUNE_I_SET1); CHECK_AIPARM("TUNE_I2_SET", CPCI_AI_TUNE_I_SET2); CHECK_AIPARM("TUNE_I3_SET", CPCI_AI_TUNE_I_SET3); CHECK_AIPARM("FRONT_BIAS_SET", CPCI_AI_FRONT_BIAS_SET); CHECK_AIPARM("FRONT_TUNE_P_SET", CPCI_AI_FRONT_TUNE_P_SET); CHECK_AIPARM("FRONT_TUNE_I_SET", CPCI_AI_FRONT_TUNE_I_SET); CHECK_AIPARM("FRONT_FIX_TUNING_ANGLE", CPCI_AI_FRONT_FIX_TUNING_ANGLE); CHECK_AIPARM("PHASE_I", CPCI_AI_PHASE_I); CHECK_AIPARM("PHASE_P", CPCI_AI_PHASE_P); CHECK_AIPARM("INITIAL_PHASE", CPCI_AI_INITIAL_PHASE); CHECK_AIPARM("FF_DELAY", CPCI_AI_FF_DELAY); CHECK_AIPARM("ARC_COUNT", CPCI_AI_ARC_COUNT); } while(0); if (!parmOK) { recGblRecordError(S_db_badField, (void *)pai, "devLiD212 Init_record, bad parm"); pai->pact=TRUE; return (S_db_badField); } return 0; }
static long add_record(dbCommon *pcommon) { aiRecord *prec = (aiRecord *)pcommon; DBLINK *plink = &prec->inp; dbChannel *chan; devPvt *pdevPvt; processNotify *ppn; if (plink->type == CONSTANT) return 0; if (plink->type != PV_LINK) { long status = S_db_badField; recGblRecordError(status, (void *)prec, "devAiSoftCallback (add_record) Illegal INP field"); return status; } chan = dbChannelCreate(plink->value.pv_link.pvname); if (!chan) { long status = S_db_notFound; recGblRecordError(status, (void *)prec, "devAiSoftCallback (add_record) link target not found"); return status; } pdevPvt = calloc(1, sizeof(*pdevPvt)); if (!pdevPvt) { long status = S_db_noMemory; recGblRecordError(status, (void *)prec, "devAiSoftCallback (add_record) out of memory, calloc() failed"); return status; } ppn = &pdevPvt->pn; plink->type = PN_LINK; plink->value.pv_link.precord = pcommon; plink->value.pv_link.pvlMask &= pvlOptMsMode; /* Severity flags only */ ppn->usrPvt = prec; ppn->chan = chan; ppn->getCallback = getCallback; ppn->doneCallback = doneCallback; ppn->requestType = processGetRequest; pdevPvt->options = GET_OPTIONS; prec->dpvt = pdevPvt; return 0; }
static long devAoRfm5565_init_record(aoRecord *precord) { ST_dpvt *pDpvt = (ST_dpvt*) malloc(sizeof(ST_dpvt)); int nval; switch(precord->out.type) { case INST_IO: strcpy(pDpvt->recordName, precord->name); nval = sscanf(precord->out.value.instio.string, "%s %s", pDpvt->devName, pDpvt->arg0 ); #if 0 printf("devAo arg num: %d: %s %s\n", nval, pDpvt->arg0, pDpvt->arg1); #endif pDpvt->pSTDdev = get_STDev_from_name(pDpvt->devName); if(!pDpvt->pSTDdev) { recGblRecordError(S_db_badField, (void*) precord, "devAoRfm5565 (init_record) Illegal OUT field: task_name"); free(pDpvt); precord->udf = TRUE; precord->dpvt = NULL; return S_db_badField; } break; default: recGblRecordError(S_db_badField,(void*) precord, "devAo (init_record) Illegal OUT field"); free(pDpvt); precord->udf = TRUE; precord->dpvt = NULL; return S_db_badField; } if (!strcmp(pDpvt->arg0, AO_SET_READ_OFFSET_STR)) { pDpvt->ind = AO_SET_READ_OFFSET; } else if (!strcmp(pDpvt->arg0, AO_RFM_WRITE_VALUE_STR)) { pDpvt->ind = AO_RFM_WRITE_VALUE; } else { pDpvt->ind = -1; epicsPrintf("ERROR_Rfm5565! devAoRfm5565_init_record: arg0 \"%s\" \n", pDpvt->arg0 ); } precord->udf = FALSE; precord->dpvt = (void*) pDpvt; return 2; /*returns: (0,2)=>(success,success no convert)*/ }
static long init_bi(struct biRecord *pbi) { int parmOK = 0; if (pbi->inp.type != VME_IO) { recGblRecordError(S_db_badField, (void *)pbi, "devBiD212 Init_record, Illegal INP"); pbi->pact = TRUE; return (S_db_badField); } pbi->dpvt = (void*) calloc(1, sizeof(recPrivate*)); ((recPrivate*) pbi->dpvt)->pCard = getCardStruct(pbi->inp.value.vmeio.card); do { /******* no int *********** CHECK_BIPARM("RUN_MODE", CPCI_BI_RUN_MODE); ****************************/ CHECK_BIPARM("INT_ENABLE", CPCI_BI_INT_ENABLE); CHECK_BIPARM("RF_RESET", CPCI_BI_RF_RESET); CHECK_BIPARM("SWEEP_OPTION", CPCI_BI_SWEEP_OPTION); CHECK_BIPARM("AMP_OPTION", CPCI_BI_AMP_OPTION); CHECK_BIPARM("AMP_FF_OPTION", CPCI_BI_AMP_FF_OPTION); CHECK_BIPARM("AMP_MODIFY_OPTION", CPCI_BI_AMP_MODIFY_OPTION); CHECK_BIPARM("TUNE_OPTION", CPCI_BI_TUNE_OPTION); CHECK_BIPARM("FRONT_TUNE_OPTION", CPCI_BI_FRONT_TUNE_OPTION); CHECK_BIPARM("TUNE_FF_OPTION", CPCI_BI_TUNE_FF_OPTION); CHECK_BIPARM("TUNE_MODIFY_OPTION", CPCI_BI_TUNE_MODIFY_OPTION); CHECK_BIPARM("PHASE_OPTION", CPCI_BI_PHASE_OPTION); CHECK_BIPARM("POINT_SWEEP", CPCI_BI_POINT_SWEEP); CHECK_BIPARM("ALARM0", CPCI_BI_ALARM0); CHECK_BIPARM("ALARM1", CPCI_BI_ALARM1); CHECK_BIPARM("ALARM2", CPCI_BI_ALARM2); CHECK_BIPARM("ALARM3", CPCI_BI_ALARM3); CHECK_BIPARM("ALARM4", CPCI_BI_ALARM4); CHECK_BIPARM("ALARM5", CPCI_BI_ALARM5); CHECK_BIPARM("ALARM6", CPCI_BI_ALARM6); CHECK_BIPARM("ALARM7", CPCI_BI_ALARM7); CHECK_BIPARM("PHASE_FF_OPTION", CPCI_BI_PHASE_FF_OPTION); CHECK_BIPARM("PHASE_MODIFY_OPTION", CPCI_BI_PHASE_MODIFY_OPTION); CHECK_BIPARM("DRV_RESET", CPCI_BI_DRV_RESET); CHECK_BIPARM("SG_MODE", CPCI_BI_SG_MODE); } while(0); if (!parmOK) { recGblRecordError(S_db_badField, (void *)pbi, "devBiD212 Init_record, bad parm"); pbi->pact=TRUE; return (S_db_badField); } return 0; }
static long devStringinAdmin_init_record(stringinRecord *precord) { ST_devAdmin_dpvt *pdevAdmin_dpvt = (ST_devAdmin_dpvt*) malloc(sizeof(ST_devAdmin_dpvt)); int nval; switch(precord->inp.type) { case INST_IO: strcpy(pdevAdmin_dpvt->recordName, precord->name); nval = sscanf(precord->inp.value.instio.string, "%s", pdevAdmin_dpvt->arg0 ); #if PRINT_DEV_SUPPORT_ARG printf("devStringinAdmin arg num: %d: %s\n",nval, pdevAdmin_dpvt->arg0); #endif pdevAdmin_dpvt->ptaskConfig = drvAdmin_get_AdminPtr(); if(!pdevAdmin_dpvt->ptaskConfig) { recGblRecordError(S_db_badField, (void*) precord, "devStringinAdmin (init_record) Illegal INP field: task_name"); free(pdevAdmin_dpvt); precord->udf = TRUE; precord->dpvt = NULL; return S_db_badField; } break; default: recGblRecordError(S_db_badField,(void*) precord, "devStringinAdmin (init_record) Illegal INP field"); free(pdevAdmin_dpvt); precord->udf = TRUE; precord->dpvt = NULL; return S_db_badField; } if(!strcmp(pdevAdmin_dpvt->arg0, STRINGIN_ERROR_STRING_STR)) { pdevAdmin_dpvt->ind = STRINGIN_ERROR_STRING; } else { pdevAdmin_dpvt->ind = -1; epicsPrintf("ERROR! devStringinAdmin_init_record: arg0 \"%s\" \n", pdevAdmin_dpvt->arg0 ); } precord->udf = FALSE; precord->dpvt = (void*) pdevAdmin_dpvt; return 0; /*returns: (-1,0)=>(failure,success)*/ }
static long devStringoutV792Control_init_record(stringoutRecord *precord) { ST_dpvt *pST_dpvt = (ST_dpvt*) malloc(sizeof(ST_dpvt)); int i; char arg0[SIZE_DPVT_ARG]; char arg1[SIZE_DPVT_ARG]; switch(precord->out.type) { case INST_IO: i = sscanf(precord->out.value.instio.string, "%s %s %s", pST_dpvt->devName, arg0, arg1); #if PRINT_DEV_SUPPORT_ARG epicsPrintf("devAoV792Control arg num: %d: %s %s\n",i, pST_dpvt->devName, arg0, arg1); #endif pST_dpvt->pSTDdev = get_STDev_from_name(pST_dpvt->devName); if(!pST_dpvt->pSTDdev) { recGblRecordError(S_db_badField, (void*) precord, "devStringoutV792Control (init_record) Illegal INP field: task_name"); free(pST_dpvt); precord->udf = TRUE; precord->dpvt = NULL; return S_db_badField; } break; default: recGblRecordError(S_db_badField,(void*) precord, "devStringoutV792Control (init_record) Illegal OUT field"); free(pST_dpvt); precord->udf = TRUE; precord->dpvt = NULL; return S_db_badField; } if(!strcmp(arg0, STRINGOUT_TAG_STR)) { pST_dpvt->ind = STRINGOUT_TAG; pST_dpvt->n32Arg0 = strtoul(arg1, NULL, 0); /* port id */ } else { pST_dpvt->ind = -1; epicsPrintf("ERROR! devStringoutV792Control_init_record: arg0 \"%s\" \n", pST_dpvt->arg0 ); } precord->udf = FALSE; precord->dpvt = (void*) pST_dpvt; return 0; /*returns: (-1,0)=>(failure,success)*/ }
static long init_record(lsoRecord *prec, int pass) { lsodset *pdset; if (pass == 0) { size_t sizv = prec->sizv; if (sizv < 16) { sizv = 16; /* Enforce a minimum size for the VAL field */ prec->sizv = sizv; } prec->val = callocMustSucceed(1, sizv, "lso::init_record"); prec->len = 0; prec->oval = callocMustSucceed(1, sizv, "lso::init_record"); prec->olen = 0; return 0; } dbLoadLink(&prec->siml, DBF_USHORT, &prec->simm); pdset = (lsodset *) prec->dset; if (!pdset) { recGblRecordError(S_dev_noDSET, prec, "lso: init_record"); return S_dev_noDSET; } /* must have a write_string function defined */ if (pdset->number < 5 || !pdset->write_string) { recGblRecordError(S_dev_missingSup, prec, "lso: init_record"); return S_dev_missingSup; } dbLoadLinkLS(&prec->dol, prec->val, prec->sizv, &prec->len); if (pdset->init_record) { long status = pdset->init_record(prec); if (status) return status; } if (prec->len) { strcpy(prec->oval, prec->val); prec->olen = prec->len; prec->udf = FALSE; } return 0; }
static long devBiXXX_init_record(biRecord *precord) { ST_dpvt *pDpvt = (ST_dpvt*) malloc(sizeof(ST_dpvt)); int nval; char arg0[SIZE_DPVT_ARG]; char arg1[SIZE_DPVT_ARG]; switch(precord->inp.type) { case INST_IO: nval = sscanf(precord->inp.value.instio.string, "%s %s %s", pDpvt->devName, arg0, arg1); pDpvt->pSTDdev = get_STDev_from_name(pDpvt->devName); if(!pDpvt->pSTDdev) { recGblRecordError(S_db_badField, (void*) precord, "devBiXXX (init_record) Illegal INP field: task name"); free(pDpvt); precord->udf = TRUE; precord->dpvt = NULL; return S_db_badField; } break; default: recGblRecordError(S_db_badField, (void*) precord, "devBiXXX (init_record) Illegal INP field"); free(pDpvt); precord->udf = TRUE; precord->dpvt = NULL; return S_db_badField; } if(!strcmp(arg0, BI_TEST_1_STR)) { pDpvt->ind = BI_TEST_1; pDpvt->n32Arg0 = strtoul(arg1, NULL, 0); /* chennel id */ } else if(!strcmp(arg0, BI_TEST_2_STR)) pDpvt->ind = BI_TEST_2; else { pDpvt->ind = -1; epicsPrintf("ERROR!! devBiXXX_init_record: arg0 \"%s\" \n", arg0 ); } precord->udf = FALSE; precord->dpvt = (void*) pDpvt; return 0; /*returns: (-1,0)=>(failure,success)*/ }
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; }
/*************************************************** * scaler_init_record() ****************************************************/ STATIC long scaler_init_record(struct scalerRecord *psr, CALLBACK *pcallback) { int card = psr->out.value.vmeio.card; int status; devScalerPvt *dpvt; Debug(5,"scaler_init_record: card %d\n", card); dpvt = (devScalerPvt *)calloc(1, sizeof(devScalerPvt)); dpvt->card = card; psr->dpvt = dpvt; if (scaler_state == NULL) { recGblRecordError(S_dev_noDevSup,(void *)psr, ""); return(S_dev_noDevSup); } scaler_state[card]->psr = psr; /* out must be an VME_IO */ switch (psr->out.type) { case (VME_IO) : break; default: recGblRecordError(S_dev_badBus,(void *)psr, "devScaler (init_record) Illegal OUT Bus Type"); return(S_dev_badBus); } Debug(5,"VME scaler: card %d\n", card); if (!scaler_state[card]->card_exists) { recGblRecordError(S_dev_badCard,(void *)psr, "devScaler (init_record) card does not exist!"); return(S_dev_badCard); } if (scaler_state[card]->card_in_use) { recGblRecordError(S_dev_badSignal,(void *)psr, "devScaler (init_record) card already in use!"); return(S_dev_badSignal); } scaler_state[card]->card_in_use = 1; psr->nch = scaler_state[card]->num_channels; /* setup interrupt handler */ scaler_state[card]->pcallback = pcallback; status = scalerISRSetup(card); return(0); }
LOCAL long init_signed_ai (struct aiRecord *prec) { struct abio *pabio; devPvt *pdevPvt; abStatus drvStatus; long status = 0; void *drvPvt; if (prec->inp.type != AB_IO) { recGblRecordError (S_db_badField, (void *) prec, "init_signed_ai: Bad INP field"); return (S_db_badField); } /* set linear conversion slope*/ prec->eslo = (prec->eguf -prec->egul)/65535.0; /* pointer to the data addess structure */ pabio = (struct abio *) &(prec->inp.value); drvStatus = (*pabDrv->registerCard) (pabio->link, pabio->adapter, pabio->card, typeBi, "BINARY", devCallback, &drvPvt); switch (drvStatus) { case abSuccess : pdevPvt = (devPvt *) (*pabDrv->getUserPvt) (drvPvt); prec->dpvt = pdevPvt; break; case abNewCard : pdevPvt = calloc (1, sizeof (devPvt)); pdevPvt->drvPvt = drvPvt; prec->dpvt = pdevPvt; (*pabDrv->setUserPvt) (drvPvt, (void *) pdevPvt); scanIoInit (&pdevPvt->ioscanpvt); drvStatus = (*pabDrv->setNbits) (drvPvt, abBit16); if (drvStatus != abSuccess) { status = S_db_badField; recGblRecordError (status, (void *) prec, "init_signed_ai: setNbits"); } break; default: status = S_db_badField; recGblRecordError (status, (void *)prec, "init_signed_ai: registerCard"); break; } return (status); }