static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd) { subArrayRecord *prec = (subArrayRecord *) paddr->precord; switch (dbGetFieldIndex(paddr)) { case subArrayRecordVAL: pcd->upper_ctrl_limit = prec->hopr; pcd->lower_ctrl_limit = prec->lopr; break; case subArrayRecordINDX: pcd->upper_ctrl_limit = prec->malm - 1; pcd->lower_ctrl_limit = 0; break; case subArrayRecordNELM: pcd->upper_ctrl_limit = prec->malm; pcd->lower_ctrl_limit = 1; break; default: recGblGetControlDouble(paddr, pcd); } return 0; }
static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd) { subArrayRecord *prec = (subArrayRecord *) paddr->precord; switch (dbGetFieldIndex(paddr)) { case subArrayRecordVAL: pgd->upper_disp_limit = prec->hopr; pgd->lower_disp_limit = prec->lopr; break; case subArrayRecordINDX: pgd->upper_disp_limit = prec->malm - 1; pgd->lower_disp_limit = 0; break; case subArrayRecordNELM: pgd->upper_disp_limit = prec->malm; pgd->lower_disp_limit = 1; break; default: recGblGetGraphicDouble(paddr, pgd); } return 0; }
static long get_control_double(DBADDR *paddr,struct dbr_ctrlDouble *pcd) { longoutRecord *prec=(longoutRecord *)paddr->precord; switch (dbGetFieldIndex(paddr)) { case indexof(VAL): case indexof(HIHI): case indexof(HIGH): case indexof(LOW): case indexof(LOLO): case indexof(LALM): case indexof(ALST): case indexof(MLST): /* do not change pre drvh/drvl behavior */ if(prec->drvh > prec->drvl) { pcd->upper_ctrl_limit = prec->drvh; pcd->lower_ctrl_limit = prec->drvl; } else { pcd->upper_ctrl_limit = prec->hopr; pcd->lower_ctrl_limit = prec->lopr; } break; default: recGblGetControlDouble(paddr,pcd); } return(0); }
static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd) { subRecord *prec = (subRecord *)paddr->precord; int fieldIndex = dbGetFieldIndex(paddr); switch (fieldIndex) { case subRecordVAL: case subRecordHIHI: case subRecordHIGH: case subRecordLOW: case subRecordLOLO: case subRecordA: case subRecordB: case subRecordC: case subRecordD: case subRecordE: case subRecordF: case subRecordG: case subRecordH: case subRecordI: case subRecordJ: case subRecordK: case subRecordL: case subRecordLA: case subRecordLB: case subRecordLC: case subRecordLD: case subRecordLE: case subRecordLF: case subRecordLG: case subRecordLH: case subRecordLI: case subRecordLJ: case subRecordLK: case subRecordLL: pgd->upper_disp_limit = prec->hopr; pgd->lower_disp_limit = prec->lopr; break; default: recGblGetGraphicDouble(paddr, pgd); } return 0; }
static long get_control_double(struct dbAddr *paddr, struct dbr_ctrlDouble *pcd) { epidRecord *pepid=(epidRecord *)paddr->precord; int fieldIndex = dbGetFieldIndex(paddr); if ( fieldIndex == epidRecordVAL || fieldIndex == epidRecordHIHI || fieldIndex == epidRecordHIGH || fieldIndex == epidRecordLOW || fieldIndex == epidRecordLOLO || fieldIndex == epidRecordCVAL) { pcd->upper_ctrl_limit = pepid->hopr; pcd->lower_ctrl_limit = pepid->lopr; } else if ( fieldIndex == epidRecordOVAL || fieldIndex == epidRecordP || fieldIndex == epidRecordI || fieldIndex == epidRecordD) { pcd->upper_ctrl_limit = pepid->drvh; pcd->lower_ctrl_limit = pepid->drvl; } else recGblGetControlDouble(paddr,pcd); return(0); }
static long get_control_double(dbAddr *paddr, struct dbr_ctrlDouble *pcd) { acalcoutRecord *pcalc=(acalcoutRecord *)paddr->precord; int fieldIndex = dbGetFieldIndex(paddr); switch (fieldIndex) { case acalcoutRecordVAL: case acalcoutRecordHIHI: case acalcoutRecordHIGH: case acalcoutRecordLOW: case acalcoutRecordLOLO: pcd->upper_ctrl_limit = pcalc->hopr; pcd->lower_ctrl_limit = pcalc->lopr; return(0); default: break; } if (fieldIndex >= acalcoutRecordA && fieldIndex <= acalcoutRecordL) { pcd->upper_ctrl_limit = pcalc->hopr; pcd->lower_ctrl_limit = pcalc->lopr; return(0); } if (fieldIndex >= acalcoutRecordPA && fieldIndex <= acalcoutRecordPL) { pcd->upper_ctrl_limit = pcalc->hopr; pcd->lower_ctrl_limit = pcalc->lopr; return(0); } return(0); }
/***************************************************************************** * * Allow for only sensible values for displays * ******************************************************************************/ static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd) { vsRecord *pvs = (vsRecord *)paddr->precord; int fieldIndex = dbGetFieldIndex(paddr); if (fieldIndex == vsRecordVAL || fieldIndex == vsRecordPRES) { pgd->upper_disp_limit = pvs->hopr; pgd->lower_disp_limit = pvs->lopr; } else if (fieldIndex == vsRecordCGAP) { pgd->upper_disp_limit = pvs->hapr; pgd->lower_disp_limit = pvs->lapr; } else if (fieldIndex == vsRecordCGBP) { pgd->upper_disp_limit = pvs->hbpr; pgd->lower_disp_limit = pvs->lbpr; } else if (fieldIndex == vsRecordLPRS) { pgd->upper_disp_limit = pvs->hlpr; pgd->lower_disp_limit = pvs->llpr; } else if (fieldIndex == vsRecordLCAP) { pgd->upper_disp_limit = pvs->halr; pgd->lower_disp_limit = pvs->lalr; } else if (fieldIndex == vsRecordLCBP) { pgd->upper_disp_limit = pvs->hblr; pgd->lower_disp_limit = pvs->lblr; } else recGblGetGraphicDouble(paddr, pgd); return (0); }
static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd) { subRecord *prec = (subRecord *)paddr->precord; int fieldIndex = dbGetFieldIndex(paddr); int linkNumber; switch (fieldIndex) { case indexof(VAL): case indexof(HIHI): case indexof(HIGH): case indexof(LOW): case indexof(LOLO): case indexof(LALM): case indexof(ALST): case indexof(MLST): pgd->lower_disp_limit = prec->lopr; pgd->upper_disp_limit = prec->hopr; break; default: linkNumber = get_linkNumber(fieldIndex); if (linkNumber >= 0) { dbGetGraphicLimits(&prec->inpa + linkNumber, &pgd->lower_disp_limit, &pgd->upper_disp_limit); } else recGblGetGraphicDouble(paddr,pgd); } return 0; }
static long get_precision(DBADDR *paddr, long *pprecision) { calcoutRecord *prec = (calcoutRecord *)paddr->precord; int fieldIndex = dbGetFieldIndex(paddr); int linkNumber; if (fieldIndex == indexof(ODLY)) { *pprecision = calcoutODLYprecision; return 0; } *pprecision = prec->prec; if (fieldIndex == indexof(VAL)) return 0; linkNumber = get_linkNumber(fieldIndex); if (linkNumber >= 0) { short precision; if (dbGetPrecision(&prec->inpa + linkNumber, &precision) == 0) *pprecision = precision; } else recGblGetPrec(paddr, pprecision); return 0; }
static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd) { calcoutRecord *prec = (calcoutRecord *)paddr->precord; switch (dbGetFieldIndex(paddr)) { case indexof(VAL): case indexof(HIHI): case indexof(HIGH): case indexof(LOW): case indexof(LOLO): case indexof(LALM): case indexof(ALST): case indexof(MLST): pcd->lower_ctrl_limit = prec->lopr; pcd->upper_ctrl_limit = prec->hopr; break; case indexof(ODLY): pcd->lower_ctrl_limit = 0.0; pcd->upper_ctrl_limit = calcoutODLYlimit; break; default: recGblGetControlDouble(paddr,pcd); } return 0; }
static long cvt_dbaddr(DBADDR *paddr) { aSubRecord *prec = (aSubRecord *)paddr->precord; int fieldIndex = dbGetFieldIndex(paddr); if (fieldIndex >= aSubRecordA && fieldIndex <= aSubRecordU) { int offset = fieldIndex - aSubRecordA; paddr->pfield = (&prec->a )[offset]; paddr->no_elements = (&prec->noa)[offset]; paddr->field_type = (&prec->fta)[offset]; } else if (fieldIndex >= aSubRecordVALA && fieldIndex <= aSubRecordVALU) { int offset = fieldIndex - aSubRecordVALA; paddr->pfield = (&prec->vala)[offset]; paddr->no_elements = (&prec->nova)[offset]; paddr->field_type = (&prec->ftva)[offset]; } else { errlogPrintf("aSubRecord::cvt_dbaddr called for %s\n", prec->name); return 0; } paddr->dbr_field_type = paddr->field_type; paddr->field_size = dbValueSize(paddr->field_type); return 0; }
static long get_array_info(struct dbAddr *paddr, long *no_elements, long *offset) { acalcoutRecord *pcalc = (acalcoutRecord *) paddr->precord; int i, fieldIndex = dbGetFieldIndex(paddr); double **ppd; if (aCalcoutRecordDebug >= 20) printf("acalcoutRecord(%s):get_array_info: paddr->pfield = %p\n", pcalc->name, (void *)paddr->pfield); if ((fieldIndex>=acalcoutRecordAA) && (fieldIndex<=acalcoutRecordLL)) { i = fieldIndex-acalcoutRecordAA; ppd = &(pcalc->aa); if (ppd[i] == NULL) { if (aCalcoutRecordDebug) printf("acalcoutRecord(%s):get_array_info: allocating for field %c%c\n", pcalc->name, (int)('A'+i), (int)('A'+i)); ppd[i] = (double *)calloc(pcalc->nelm, sizeof(double)); } } if ((fieldIndex==acalcoutRecordAVAL) && (pcalc->aval == NULL)) { pcalc->aval = (double *)calloc(pcalc->nelm, sizeof(double)); } if ((fieldIndex==acalcoutRecordOAV) && (pcalc->oav == NULL)) { pcalc->oav = (double *)calloc(pcalc->nelm, sizeof(double)); } *no_elements = acalcGetNumElements( pcalc ); *offset = 0; return(0); }
static long cvt_dbaddr(DBADDR *paddr) { lsoRecord *prec = (lsoRecord *) paddr->precord; int fieldIndex = dbGetFieldIndex(paddr); if (fieldIndex == lsoRecordVAL) { paddr->pfield = prec->val; paddr->special = SPC_MOD; } else if (fieldIndex == lsoRecordOVAL) { paddr->pfield = prec->oval; paddr->special = SPC_NOMOD; } else { errlogPrintf("lsoRecord::cvt_dbaddr called for %s.%s\n", prec->name, paddr->pfldDes->name); return -1; } paddr->no_elements = 1; paddr->field_type = DBF_STRING; paddr->dbr_field_type = DBF_STRING; paddr->field_size = prec->sizv; return 0; }
static long get_precision(DBADDR *paddr, long *precision) { if(dbGetFieldIndex(paddr) == indexof(HIGH)) *precision = boHIGHprecision; else recGblGetPrec(paddr,precision); return(0); }
LOCAL long get_array_info(struct dbAddr *paddr,long *no_elements,long *offset) { ab1771IXRecord *precord; recordPvt *precordPvt; precord = (ab1771IXRecord *)paddr->precord; precordPvt = (recordPvt *)precord->dpvt; if(dbGetFieldIndex(paddr)==ab1771IXRecordINPM) { *no_elements = NUM_WORDS_IN; *offset = 0; } else if(dbGetFieldIndex(paddr)==ab1771IXRecordOUTM) { *no_elements = NUM_WORDS_OUT; *offset = 0; } else { errlogPrintf("%s get_array_info for illegal field\n",precord->name); } return(0); }
static long get_control_double(DBADDR *paddr,struct dbr_ctrlDouble *pcd) { if(dbGetFieldIndex(paddr) == indexof(HIGH)) { pcd->lower_ctrl_limit = 0.0; pcd->upper_ctrl_limit = boHIGHlimit; } else recGblGetControlDouble(paddr,pcd); return(0); }
static long get_precision(dbAddr *paddr, long *precision) { acalcoutRecord *pcalc=(acalcoutRecord *)paddr->precord; int fieldIndex = dbGetFieldIndex(paddr); *precision = pcalc->prec; if (fieldIndex == acalcoutRecordVAL) return(0); recGblGetPrec(paddr,precision); return(0); }
static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd) { waveformRecord *prec = (waveformRecord *) paddr->precord; if (dbGetFieldIndex(paddr) == waveformRecordVAL) { pgd->upper_disp_limit = prec->hopr; pgd->lower_disp_limit = prec->lopr; } else recGblGetGraphicDouble(paddr, pgd); return 0; }
static long get_precision(DBADDR *paddr, long *precision) { subRecord *prec = (subRecord *)paddr->precord; int fieldIndex = dbGetFieldIndex(paddr); *precision = prec->prec; if (fieldIndex != subRecordVAL) recGblGetPrec(paddr, precision); return 0; }
static long get_precision(struct dbAddr *paddr, long *precision) { struct epidRecord *pepid=(struct epidRecord *)paddr->precord; int fieldIndex = dbGetFieldIndex(paddr); *precision = pepid->prec; if (fieldIndex == epidRecordVAL || fieldIndex == epidRecordCVAL) return(0); recGblGetPrec(paddr,precision); return(0); }
static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd) { waveformRecord *prec = (waveformRecord *) paddr->precord; if (dbGetFieldIndex(paddr) == waveformRecordVAL) { pcd->upper_ctrl_limit = prec->hopr; pcd->lower_ctrl_limit = prec->lopr; } else recGblGetControlDouble(paddr, pcd); return 0; }
static long get_units(DBADDR *paddr, char *units) { calcoutRecord *prec = (calcoutRecord *)paddr->precord; int fieldIndex = dbGetFieldIndex(paddr); int linkNumber; if(fieldIndex == indexof(ODLY)) { strcpy(units, "s"); return 0; } if(paddr->pfldDes->field_type == DBF_DOUBLE) { linkNumber = get_linkNumber(dbGetFieldIndex(paddr)); if (linkNumber >= 0) dbGetUnits(&prec->inpa + linkNumber, units, DB_UNITS_SIZE); else strncpy(units,prec->egu,DB_UNITS_SIZE); } return 0; }
static long get_alarm_double(DBADDR *paddr, struct dbr_alDouble *pad) { aoRecord *prec=(aoRecord *)paddr->precord; if(dbGetFieldIndex(paddr) == indexof(VAL)){ pad->upper_alarm_limit = prec->hhsv ? prec->hihi : epicsNAN; pad->upper_warning_limit = prec->hsv ? prec->high : epicsNAN; pad->lower_warning_limit = prec->lsv ? prec->low : epicsNAN; pad->lower_alarm_limit = prec->llsv ? prec->lolo : epicsNAN; } else recGblGetAlarmDouble(paddr,pad); return(0); }
static long get_alarm_double(DBADDR *paddr,struct dbr_alDouble *pad) { longoutRecord *prec=(longoutRecord *)paddr->precord; if(dbGetFieldIndex(paddr) == indexof(VAL)) { pad->upper_alarm_limit = prec->hihi; pad->upper_warning_limit = prec->high; pad->lower_warning_limit = prec->low; pad->lower_alarm_limit = prec->lolo; } else recGblGetAlarmDouble(paddr,pad); return(0); }
static long put_array_info(struct dbAddr *paddr, long nNew) { acalcoutRecord *pcalc = (acalcoutRecord *) paddr->precord; double **ppd, *pd = NULL; long i; long numElements; int fieldIndex = dbGetFieldIndex(paddr); if (aCalcoutRecordDebug >= 20) { printf("acalcoutRecord(%s):put_array_info: paddr->pfield = %p, pcalc->aa=%p, nNew=%ld\n", pcalc->name, (void *)paddr->pfield, (void *)pcalc->aa, nNew); } if ((fieldIndex>=acalcoutRecordAA) && (fieldIndex<=acalcoutRecordLL)) { i = fieldIndex-acalcoutRecordAA; ppd = &(pcalc->aa); if (ppd[i] == NULL) { if (aCalcoutRecordDebug) printf("acalcoutRecord(%s):put_array_info: allocating for field %c%c\n", pcalc->name, (int)('A'+i), (int)('A'+i)); ppd[i] = (double *)calloc(pcalc->nelm, sizeof(double)); } pd = ppd[i]; } else if (fieldIndex==acalcoutRecordAVAL) { if (pcalc->aval == NULL) pcalc->aval = (double *)calloc(pcalc->nelm, sizeof(double)); pd = pcalc->aval; } else if (fieldIndex==acalcoutRecordOAV) { if (pcalc->oav == NULL) pcalc->oav = (double *)calloc(pcalc->nelm, sizeof(double)); pd = pcalc->oav; } if (aCalcoutRecordDebug >= 20) { printf("acalcoutRecord(%s):put_array_info: pd=%p\n", pcalc->name, (void *)pd); } #if MIND_UNUSED_ELEMENTS numElements = pcalc->nelm; #else numElements = acalcGetNumElements( pcalc ); #endif if ( pd && (nNew < numElements) ) for (i=nNew; i<numElements; i++) pd[i] = 0.; /* We could set nuse to the number of elements just written, but that would also * affect the other arrays. For now, with all arrays sharing a single value of nuse, * it seems better to require that nuse be set explicitly. Currently, I'm leaving * unanswered the question of whether each array should have its own 'nuse'. The * array-calc engine currently doesn't support per-array 'nuse'. */ return(0); }
static long get_alarm_double(DBADDR *paddr,struct dbr_alDouble *pad) { rdbpostgreSQLRecord *prec=(rdbpostgreSQLRecord *)paddr->precord; int fieldIndex = dbGetFieldIndex(paddr); if(fieldIndex == rdbpostgreSQLRecordVAL) { pad->upper_alarm_limit = prec->hhsv ? prec->hihi : epicsNAN; pad->upper_warning_limit = prec->hsv ? prec->high : epicsNAN; pad->lower_warning_limit = prec->lsv ? prec->low : epicsNAN; pad->lower_alarm_limit = prec->llsv ? prec->lolo : epicsNAN; } else recGblGetAlarmDouble(paddr,pad); return(0); }
static long get_alarm_double(struct dbAddr *paddr, struct dbr_alDouble *pad) { struct epidRecord *pepid=(struct epidRecord *)paddr->precord; int fieldIndex = dbGetFieldIndex(paddr); if(fieldIndex == epidRecordVAL) { pad->upper_alarm_limit = pepid->hihi; pad->upper_warning_limit = pepid->high; pad->lower_warning_limit = pepid->low; pad->lower_alarm_limit = pepid->lolo; } else recGblGetAlarmDouble(paddr,pad); return(0); }
static long get_alarm_double(DBADDR *paddr,struct dbr_alDouble *pad) { ushortRecord *pushort=(ushortRecord *)paddr->precord; int fieldIndex = dbGetFieldIndex(paddr); if(fieldIndex == ushortRecordVAL) { pad->upper_alarm_limit = pushort->hihi; pad->upper_warning_limit = pushort->high; pad->lower_warning_limit = pushort->low; pad->lower_alarm_limit = pushort->lolo; } else recGblGetAlarmDouble(paddr,pad); return(0); }
/***************************************************************************** * * Allow for only sensible values for entries * ******************************************************************************/ static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble * pcd) { vsRecord *pvs = (vsRecord *)paddr->precord; int fieldIndex = dbGetFieldIndex(paddr); if (fieldIndex == vsRecordVAL || fieldIndex == vsRecordPRES || fieldIndex == vsRecordCGAP || fieldIndex == vsRecordCGBP) { pcd->upper_ctrl_limit = pvs->hopr; pcd->lower_ctrl_limit = pvs->lopr; } else recGblGetControlDouble(paddr, pcd); return (0); }
static long get_precision(struct dbAddr *paddr, long *precision) { struct cvtRecord *pcvt = (struct cvtRecord *)paddr->precord; int fieldIndex = dbGetFieldIndex(paddr); switch (fieldIndex) { case cvtRecordVAL: *precision = pcvt->prec; break; default: recGblGetPrec(paddr, precision); } return 0; }