static int fetch_values(acalcoutRecord *pcalc) { DBLINK *plink; /* structure of the link field */ double *pvalue; double **pavalue; long status = 0; int i, j; unsigned short *plinkValid; long numElements; #if MIND_UNUSED_ELEMENTS numElements = pcalc->nelm; #else numElements = acalcGetNumElements( pcalc ); #endif if (aCalcoutRecordDebug >= 10) printf("acalcoutRecord(%s):fetch_values: entry\n", pcalc->name); for (i=0, plink=&pcalc->inpa, pvalue=&pcalc->a; i<MAX_FIELDS; i++, plink++, pvalue++) { status = dbGetLink(plink, DBR_DOUBLE, pvalue, 0, 0); if (!RTN_SUCCESS(status)) return(status); } if (aCalcoutRecordDebug >= 10) printf("acalcoutRecord(%s):fetch_values: arrays\n", pcalc->name); plinkValid = &pcalc->iaav; for (i=0, plink=&pcalc->inaa, pavalue=(double **)(&pcalc->aa); i<ARRAY_MAX_FIELDS; i++, plink++, pavalue++, plinkValid++) { if ((*plinkValid==acalcoutINAV_EXT) || (*plinkValid==acalcoutINAV_LOC)) { long nRequest; if (aCalcoutRecordDebug >= 10) printf("acalcoutRecord(%s):fetch_values: field %c%c, pointer=%p\n", pcalc->name, (int)('A'+i), (int)('A'+i), *pavalue); if (*pavalue == NULL) { if (aCalcoutRecordDebug) printf("acalcoutRecord(%s): allocating for field %c%c\n", pcalc->name, (int)('A'+i), (int)('A'+i)); *pavalue = (double *)calloc(pcalc->nelm, sizeof(double)); } /* save current array value */ if (pcalc->paa == NULL) { if (aCalcoutRecordDebug) printf("acalcoutRecord(%s): allocating for field PAA\n", pcalc->name); pcalc->paa = (double *)calloc(pcalc->nelm, sizeof(double)); } for (j=0; j<numElements; j++) pcalc->paa[j] = (*pavalue)[j]; /* get new value */ nRequest = acalcGetNumElements( pcalc ); status = dbGetLink(plink, DBR_DOUBLE, *pavalue, 0, &nRequest); if (!RTN_SUCCESS(status)) return(status); if (nRequest<numElements) { for (j=nRequest; j<numElements; j++) (*pavalue)[j] = 0; } /* compare new array value with saved value */ for (j=0; j<numElements; j++) { if (pcalc->paa[j] != (*pavalue)[j]) {pcalc->newm |= 1<<i; break;} } } } if (aCalcoutRecordDebug >= 10) printf("acalcoutRecord(%s):fetch_values: returning\n", pcalc->name); return(0); }
/************************************************** * scalerISRSetup() ***************************************************/ STATIC int scalerISRSetup(int card) { long status; volatile char *addr; int intLevel; Debug(5, "scalerISRSetup: Entry, card #%d\n", card); if ((card+1) > scaler_total_cards) return(ERROR); addr = scaler_state[card]->localAddr; status = devConnectInterrupt(intVME, vsc_InterruptVector + card, (void *) &scalerISR, (void *) card); if (!RTN_SUCCESS(status)) { errPrintf(status, __FILE__, __LINE__, "Can't connect to vector %ld\n", vsc_InterruptVector + card); return (ERROR); } /* get interrupt level from hardware, and enable that level in EPICS */ intLevel = readReg16(addr,IRQ_LEVEL_ENABLE_OFFSET) & 5 /*3*/; Debug(5, "scalerISRSetup: Interrupt level %d\n", intLevel); status = devEnableInterruptLevel(intVME, intLevel); if (!RTN_SUCCESS(status)) { errPrintf(status, __FILE__, __LINE__, "Can't enable enterrupt level %d\n", intLevel); return (ERROR); } /* Write interrupt vector to hardware */ writeReg16(addr,IRQ_VECTOR_OFFSET,(unsigned short) (vsc_InterruptVector + card)); Debug(5, "scalerISRSetup: Exit, card #%d\n", card); return (OK); }
/* * FETCH_VALUES * * fetch the values for the variables from which to select */ static int fetch_values(selRecord *prec) { struct link *plink; double *pvalue; int i; long status; plink = &prec->inpa; pvalue = &prec->a; /* If mechanism is selSELM_Specified, only get the selected input*/ if(prec->selm == selSELM_Specified) { /* fetch the select index */ status=dbGetLink(&(prec->nvl),DBR_USHORT,&(prec->seln),0,0); if (!RTN_SUCCESS(status) || (prec->seln >= SEL_MAX)) return(status); plink += prec->seln; pvalue += prec->seln; status=dbGetLink(plink,DBR_DOUBLE, pvalue,0,0); return(status); } /* fetch all inputs*/ for(i=0; i<SEL_MAX; i++, plink++, pvalue++) { status=dbGetLink(plink,DBR_DOUBLE, pvalue,0,0); } return(status); }
static long process(epidRecord *pepid) { struct epidDSET *pdset = (struct epidDSET *)(pepid->dset); long status; int pact=pepid->pact; if (!pact) { /* If this is not a callback from device support */ /* fetch the setpoint */ if(pepid->smsl == menuOmslclosed_loop) { status = dbGetLink(&(pepid->stpl),DBR_DOUBLE, &(pepid->val),0,0); if (RTN_SUCCESS(status)) pepid->udf=FALSE; } if (pepid->udf == TRUE ) { #if LT_EPICSBASE(3,15,0,2) recGblSetSevr(pepid,UDF_ALARM,INVALID_ALARM); #else recGblSetSevr(pepid,UDF_ALARM,pepid->udfs); #endif return(0); } } status = (*pdset->do_pid)(pepid); /* See if device support set pact=true, meaning it will call us back */ if (!pact && pepid->pact) return(0); pepid->pact = TRUE; recGblGetTimeStamp(pepid); checkAlarms(pepid); monitor(pepid); recGblFwdLink(pepid); pepid->pact=FALSE; return(status); }
static long writeValue(longoutRecord *prec) { long status; struct longoutdset *pdset = (struct longoutdset *) (prec->dset); if (prec->pact == TRUE){ status=(*pdset->write_longout)(prec); return(status); } status=dbGetLink(&(prec->siml),DBR_USHORT,&(prec->simm),0,0); if (!RTN_SUCCESS(status)) return(status); if (prec->simm == menuYesNoNO){ status=(*pdset->write_longout)(prec); return(status); } if (prec->simm == menuYesNoYES){ status=dbPutLink(&prec->siol,DBR_LONG,&prec->val,1); } else { status=-1; recGblSetSevr(prec,SOFT_ALARM,INVALID_ALARM); return(status); } recGblSetSevr(prec,SIMM_ALARM,prec->sims); return(status); }
/*----------------------------------------------------------------------*/ static long dsetRead_devSiSyncSoft(stringinRecord *psi) { long status; dsetLog(3, __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__, psi->name); status = dbGetLink(&psi->inp,DBR_STRING,psi->val,0,0); if(psi->inp.type!=CONSTANT && RTN_SUCCESS(status)) psi->udf=FALSE; dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__); return(status); }
static long dsetRead_devMbbiSyncSoft(mbbiRecord *pmbbi) { long status; dsetLog(3, __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__, pmbbi->name); status = dbGetLink(&pmbbi->inp,DBR_USHORT,&pmbbi->val,0,0); dsetLog(7, __FILE__ "[%d] %d -> %s\n", __LINE__, pmbbi->val, pmbbi->name); if(pmbbi->inp.type!=CONSTANT && RTN_SUCCESS(status)) pmbbi->udf=FALSE; dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__); return(DO_NOT_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); }
/************************************************** * scalerEndOfGateISRSetup() ***************************************************/ STATIC int scalerEndOfGateISRSetup(int card) { long status; volatile char *addr; volatile uint16 u16; Debug(5, "scalerEndOfGateISRSetup: Entry, card #%d\n", card); if (card >= scalerVS_total_cards) return(ERROR); addr = scalerVS_state[card]->localAddr; status = devConnectInterruptVME(vs_InterruptVector + card, (void *) &scalerEndOfGateISR, (void *)card); if (!RTN_SUCCESS(status)) { errPrintf(status, __FILE__, __LINE__, "Can't connect to vector %d\n", vs_InterruptVector + card); return (ERROR); } /* write interrupt level to hardware, and tell EPICS to enable that level */ u16 = readReg16(addr,IRQ_SETUP_OFFSET) & 0x0ff; /* OR in level for end-of-gate interrupt */ writeReg16(addr,IRQ_SETUP_OFFSET, u16 | (vs_InterruptLevel << 8)); status = devEnableInterruptLevelVME(vs_InterruptLevel); if (!RTN_SUCCESS(status)) { errPrintf(status, __FILE__, __LINE__, "Can't enable enterrupt level %d\n", vs_InterruptLevel); return (ERROR); } Debug(5, "scalerEndOfGateISRSetup: Wrote interrupt level, %d, to hardware\n", vs_InterruptLevel); /* Write interrupt vector to hardware */ writeReg16(addr,IRQ_3_GATE_VECTOR_OFFSET, (uint16)(vs_InterruptVector + card)); Debug(5, "scalerEndOfGateISRSetup: Wrote interrupt vector, %d, to hardware\n", vs_InterruptVector + card); Debug(5, "scalerEndOfGateISRSetup: Read interrupt vector, %d, from hardware\n", readReg16(addr,IRQ_3_GATE_VECTOR_OFFSET) & 0x0ff); Debug(5, "scalerEndOfGateISRSetup: Exit, card #%d\n", card); return (OK); }
static long dsetRead_devAiSyncSoft(aiRecord *pai) { long status; dsetLog(3, __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__, pai->name); status = dbGetLink(&(pai->inp),DBR_DOUBLE, &(pai->val),0,0); if (pai->inp.type!=CONSTANT && RTN_SUCCESS(status)) pai->udf = FALSE; dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__); return(DO_NOT_CONVERT); }
/*----------------------------------------------------------------------*/ static long dsetRead_devBiSyncSoft(biRecord *pbi) { long status; dsetLog(3, __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__, pbi->name); status = dbGetLink(&pbi->inp, DBR_USHORT, &pbi->val,0,0); if(pbi->inp.type!=CONSTANT && RTN_SUCCESS(status)) pbi->udf=FALSE; dsetLog(2, __FILE__ "[%d] %s --(%d)-> %s\n", __LINE__, pbi->inp.value.instio.string, pbi->val, pbi->name); dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__); return(DO_NOT_CONVERT); }
/*----------------------------------------------------------------------*/ static long dsetRead_devSiSyncSoft(stringinRecord *pstringin) { long status; #ifdef DEBUG1 printf( __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__,pstringin->name); #endif status = dbGetLink(&pstringin->inp,DBR_STRING,pstringin->val,0,0); if(pstringin->inp.type!=CONSTANT && RTN_SUCCESS(status)) pstringin->udf=FALSE; #ifdef DEBUG1 printf( __FILE__ "[%d] <- %s(%ld)\n", __LINE__, __func__, status); #endif return(status); }
static long process(selRecord *prec) { prec->pact = TRUE; if ( RTN_SUCCESS(fetch_values(prec)) ) { do_sel(prec); } recGblGetTimeStamp(prec); /* check for alarms */ checkAlarms(prec); /* check event list */ monitor(prec); /* process the forward scan link record */ recGblFwdLink(prec); prec->pact=FALSE; return(0); }
/*************************************************** * initialize all software and hardware * scaler_init() ****************************************************/ STATIC long scaler_init(int after) { volatile char *localAddr; unsigned long status; void *baseAddr; int card, i; uint32 probeValue = 0; Debug(2,"scaler_init(): entry, after = %d\n", after); if (after || (vsc_num_cards == 0)) return(0); /* allocate scaler_state structures, array of pointers */ if (scaler_state == NULL) { scaler_state = (struct scaler_state **) calloc(1, vsc_num_cards * sizeof(struct scaler_state *)); scaler_total_cards=0; for (card=0; card<vsc_num_cards; card++) { scaler_state[card] = (struct scaler_state *) calloc(1, sizeof(struct scaler_state)); } } /* Check out the hardware. */ for (card=0; card<vsc_num_cards; card++) { baseAddr = (void *)(vsc_addrs + card*CARD_ADDRESS_SPACE); /* Can we reserve the required block of VME address space? */ status = devRegisterAddress(__FILE__, atVMEA32, (size_t)baseAddr, CARD_ADDRESS_SPACE, (volatile void **)&localAddr); if (!RTN_SUCCESS(status)) { errPrintf(status, __FILE__, __LINE__, "Can't register 0x%x-byte block at address %p\n", CARD_ADDRESS_SPACE, baseAddr); return (ERROR); } if (devReadProbe(4,(volatile void *)(localAddr+DATA_0_OFFSET),(void*)&probeValue)) { printf("no VSC card at %p\n",localAddr); return(0); } /* Declare victory. */ Debug(2,"scaler_init: we own 256 bytes starting at %p\n",localAddr); scaler_state[card]->localAddr = localAddr; scaler_total_cards++; /* reset this card */ writeReg16(localAddr,RESET_OFFSET,0); /* get this card's identification */ scaler_state[card]->ident = readReg16(localAddr,REV_SERIAL_NO_OFFSET); Debug(3,"scaler_init: Serial # = %d\n", scaler_state[card]->ident); scaler_state[card]->card_exists = 1; /* get this card's type (8 or 16 channels?) */ Debug(2,"scaler_init:Base Address=0x%8.8x\n",(int)baseAddr); Debug(2,"scaler_init:Local Address=0x%8.8x\n",(int)localAddr); scaler_state[card]->num_channels = readReg16(localAddr,MODULE_TYPE_OFFSET) & 0x18; Debug(3,"scaler_init: nchan = %d\n", scaler_state[card]->num_channels); if (scaler_state[card]->num_channels < 8) { scaler_state[card]->card_exists = 0; continue; } for (i=0; i<MAX_SCALER_CHANNELS; i++) { scaler_state[card]->preset[i] = 0; } } Debug(3,"scaler_init: Total cards = %d\n\n",scaler_total_cards); #ifdef vxWorks if (epicsAtExit(scaler_shutdown, 0) < 0) epicsPrintf ("scaler_init: epicsAtExit() failed\n"); #endif Debug(3, "%s", "scaler_init: scalers initialized\n"); return(0); }
static long process(longoutRecord *prec) { struct longoutdset *pdset = (struct longoutdset *)(prec->dset); long status=0; epicsInt32 value; unsigned char pact=prec->pact; if( (pdset==NULL) || (pdset->write_longout==NULL) ) { prec->pact=TRUE; recGblRecordError(S_dev_missingSup,(void *)prec,"write_longout"); return(S_dev_missingSup); } if (!prec->pact) { if((prec->dol.type != CONSTANT) && (prec->omsl == menuOmslclosed_loop)) { status = dbGetLink(&(prec->dol),DBR_LONG, &value,0,0); if (prec->dol.type!=CONSTANT && RTN_SUCCESS(status)) prec->udf=FALSE; } else { value = prec->val; } if (!status) convert(prec,value); } /* check for alarms */ checkAlarms(prec); 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){ prec->val=prec->ivov; } status=writeValue(prec); /* write the new value */ break; default : status=-1; recGblRecordError(S_db_badField,(void *)prec, "longout:process Illegal IVOA field"); } } /* check if device support set pact */ if ( !pact && prec->pact ) return(0); prec->pact = TRUE; recGblGetTimeStamp(prec); /* check event list */ monitor(prec); /* process the forward scan link record */ recGblFwdLink(prec); prec->pact=FALSE; return(status); }
/*************************************************** * initialize all software and hardware * scalerVS_init() ****************************************************/ STATIC long scalerVS_init(int after) { volatile char *localAddr; unsigned long status; char *baseAddr; int card, card_type; uint32 probeValue = 0; Debug(2,"scalerVS_init(): entry, after = %d\n", after); if (after || (vs_num_cards == 0)) return(0); /* allocate scalerVS_state structures, array of pointers */ if (scalerVS_state == NULL) { scalerVS_state = (struct scalerVS_state **) calloc(1, vs_num_cards * sizeof(struct scalerVS_state *)); scalerVS_total_cards=0; for (card=0; card<vs_num_cards; card++) { scalerVS_state[card] = (struct scalerVS_state *) calloc(1, sizeof(struct scalerVS_state)); } } /* Check out the hardware. */ for (card=0; card<vs_num_cards; card++) { baseAddr = (char *)(vs_addrs + card*CARD_ADDRESS_SPACE); /* Can we reserve the required block of VME address space? */ status = devRegisterAddress(__FILE__, atVMEA16, (size_t)baseAddr, CARD_ADDRESS_SPACE, (volatile void **)&localAddr); if (!RTN_SUCCESS(status)) { errPrintf(status, __FILE__, __LINE__, "Can't register 2048-byte block in VME A16 at address %p\n", baseAddr); return (ERROR); } if (devReadProbe(4,(volatile void *)(localAddr+READ_XFER_REG_OFFSET),(void*)&probeValue)) { printf("scalerVS_init: no VSxx card at %p\n",localAddr); return(0); } /* Declare victory. */ Debug(2,"scalerVS_init: we own 2048 bytes in VME A16 starting at %p\n", localAddr); scalerVS_state[card]->localAddr = localAddr; scalerVS_total_cards++; /* reset this card */ /* any write to this address causes reset */ writeReg16(localAddr,MASTER_RESET_OFFSET,0); /* get this card's type and serial number */ scalerVS_state[card]->ident = readReg16(localAddr,ID_OFFSET); Debug(3,"scalerVS_init: Serial # = %d\n", scalerVS_state[card]->ident & 0x3FF); /* get this card's type */ card_type = scalerVS_state[card]->ident >> 10; if ((card_type > 22) || (card_type < 16)) { errPrintf(status, __FILE__, __LINE__, "unrecognized module\n"); scalerVS_state[card]->num_channels = 0; scalerVS_state[card]->card_exists = 0; /* * Something's wrong with this card, but we still count it in scalerVS_total_cards. * A bad card retains its address space; otherwise we can't talk to the next one. */ } else { scalerVS_state[card]->num_channels = VS_module_types[card_type-16].num_channels; scalerVS_state[card]->card_exists = 1; } Debug(3,"scalerVS_init: nchan = %d\n", scalerVS_state[card]->num_channels); } Debug(3,"scalerVS_init: Total cards = %d\n\n",scalerVS_total_cards); #ifdef vxWorks if (epicsAtExit(scalerVS_shutdown, 0) < 0) epicsPrintf ("scalerVS_init: epicsAtExit() failed\n"); #endif Debug(3,"%s", "scalerVS_init: scalers initialized\n"); return(0); }