V4 DB RecordCommon

EPICS V4: Standard Support September 27 2005

---

Overview

For V4 dbCommon.dbd and RecordCommon.dbd replace the V3 dbCommon.dbd. dbCommon.dbd defines widely used definitions and RecordCommon.dbd defines the fields that are common to all record types.

This document requires that the reader be familiar with:

1. V3 iocCore
2. V4 DBD Statement Syntax
3. V4 DB Record Instance Syntax

---

dbCommon

Channel/Database Access Support

Data Structures

    struct(MonitorLinkData) {
        field(pvname,string) { link}
        field(process,bool) // process this record when monitor occurs
        field(inheritSeverity,bool) 
    }
    struct(InputLinkData) {
        field(pvname,string) { link}
        field(process,bool)
        field(wait,bool)
        field(block,bool)
        field(inheritSeverity,bool)
    }
    struct(OutputLinkData) {
        field(pvname,string) { link}
        field(process,bool)
        field(wait,bool)
        field(block,bool)
        field(inheritSeverity,bool)
    }
    struct(ProcessLinkData) {
        field(pvname,string) { link}
        field(wait,bool)
        field(block,bool)
    }

link support definitions

Link support is provided for

• input
  • monitor support
  • input support
• output
• process

For input and output The following data types are supported:

• primitive types
• string
• arrays of primitive types and strings

    link(in,"monitorLinkOctet","monitorLinkOctet",MonitorLinkData);
    link(in,"monitorLinkBoolean","monitorLinkBoolean",MonitorLinkData);
    link(in,"monitorLinkInt16","monitorLinkInt16",MonitorLinkData);
    link(in,"monitorLinkInt32","monitorLinkInt32",MonitorLinkData);
    link(in,"monitorLinkInt64","monitorLinkInt64",MonitorLinkData);
    link(in,"monitorLinkFloat32","monitorLinkFloat32",MonitorLinkData);
    link(in,"monitorLinkFloat64","monitorLinkFloat64",MonitorLinkData);
    link(in,"monitorLinkString","monitorLinkString",MonitorLinkData);
    link(in,"inputLinkOctet","inputLinkOctet",InputLinkData);
    link(in,"inputLinkBoolean","inputLinkBoolean",InputLinkData);
    link(in,"inputLinkInt16","inputLinkInt16",InputLinkData);
    link(in,"inputLinkInt32","inputLinkInt32",InputLinkData);
    link(in,"inputLinkInt64","inputLinkInt64",InputLinkData);
    link(in,"inputLinkFloat32","inputLinkFloat32",InputLinkData);
    link(in,"inputLinkFloat64","inputLinkFloat64",InputLinkData);
    link(in,"inputLinkString","inputLinkString",InputLinkData);
    link(out,"outputLinkOctet","outputLinkOctet",OutputLinkData);
    link(out,"outputLinkBoolean","outputLinkBoolean",OutputLinkData);
    link(out,"outputLinkInt16","outputLinkInt16",OutputLinkData);
    link(out,"outputLinkInt32","outputLinkInt32",OutputLinkData);
    link(out,"outputLinkInt64","outputLinkInt64",OutputLinkData);
    link(out,"outputLinkFloat32","outputLinkFloat32",OutputLinkData);
    link(out,"outputLinkFloat64","outputLinkFloat64",OutputLinkData);
    link(out,"outputLinkString","outputLinkString",OutputLinkData);

    link(in,"monitorLinkArrayOctet","monitorLinkArrayOctet",MonitorLinkData);
    link(in,"monitorLinkArrayBoolean","monitorLinkArrayBoolean",MonitorLinkData);
    link(in,"monitorLinkArrayInt16","monitorLinkArrayInt16",MonitorLinkData);
    link(in,"monitorLinkArrayInt32","monitorLinkArrayInt32",MonitorLinkData);
    link(in,"monitorLinkArrayInt64","monitorLinkArrayInt64",MonitorLinkData);
    link(in,"monitorLinkArrayFloat32","monitorLinkArrayFloat32",MonitorLinkData);
    link(in,"monitorLinkArrayFloat64","monitorLinkArrayFloat64",MonitorLinkData);
    link(in,"monitorLinkArrayString","monitorLinkArrayString",MonitorLinkData);
    link(in,"inputLinkArrayOctet","inputLinkArrayOctet",InputLinkData);
    link(in,"inputLinkArrayBoolean","inputLinkArrayBoolean",InputLinkData);
    link(in,"inputLinkArrayInt16","inputLinkArrayInt16",InputLinkData);
    link(in,"inputLinkArrayInt32","inputLinkArrayInt32",InputLinkData);
    link(in,"inputLinkArrayInt64","inputLinkArrayInt64",InputLinkData);
    link(in,"inputLinkArrayFloat32","inputLinkArrayFloat32",InputLinkData);
    link(in,"inputLinkArrayFloat64","inputLinkArrayFloat64",InputLinkData);
    link(in,"inputLinkArrayString","inputLinkArrayString",InputLinkData);
    link(out,"outputLinkArrayOctet","outputLinkArrayOctetData);
    link(out,"outputLinkArrayBoolean","outputLinkArrayBooleanData);
    link(out,"outputLinkArrayInt16","outputLinkArrayInt16",OutputLinkData);
    link(out,"outputLinkArrayInt32","outputLinkArrayInt32",OutputLinkData);
    link(out,"outputLinkArrayInt64","outputLinkArrayInt64",OutputLinkData);
    link(out,"outputLinkArrayFloat32","outputLinkArrayFloat32",OutputLinkData);
    link(out,"outputLinkArrayFloat64","outputLinkArrayFloat64",OutputLinkData);
    link(out,"outputLinkArrayString","outputLinkArrayString",OutputLinkData);

    link(process,"processLink",ProcessLink,ProcessLinkData);

asynDriver link support

Data Definitions

    struct(AsynDevice) }
        field(portName,string)
        field(addr,int32)
        field(timeout,float64)
        field(drvPvt,string)
    }

link definitions

    link(in,"asynInt32","asynInt32",AsynDevice)
    link(in,"asynInt32Average","asynInt32Average",AsynDevice)
    link(in,"asynInt32Monitor","asynInt32Monitor",AsynDevice)
    link(in,"asynFloat64","asynFloat64",AsynDevice)
    link(in,"asynFloat64Average","asynFloat64Average",AsynDevice)
    link(in,"asynFloat64Monitor","asynFloat64Monitor",AsynDevice)
    link(out,"asynInt32","asynInt32",AsynDevice)
    link(out,"asynFloat64","asynFloat64",AsynDevice)
    link(in,"asynDigital","asynDigital",AsynDevice)
    link(in,"asynDigitalMonitor","asynDigitalMonitor",AsynDevice)
    link(out,"asynDigital","asynDigital",AsynDevice)
    link(in,"asynInt32Array","asynInt32Array",AsynDevice)
    link(out,"asynInt32Array","asynInt32Array",AsynDevice)
    link(in,"asynFloat64Array","asynFloat64Array",AsynDevice)
    link(out,"asynFloat64Array","asynFloat64Array",AsynDevice)
    link(in,"asynOctetArray","asynOctetArray",AsynDevice)
    link(out,"asynOctetArray","asynOctetArray",AsynDevice)

Other common definitions

    menu(menuConvert) {
        choice(menuConvertRaw, "Raw")
        choice(menuConvertLinear, "Linear")
        choice(menuConvertTable, "Table")
    }

    # usefull struct definitions

    struct(LinearConvert) {
        field(full,float64) 
        field(egul,float64)
        field(slope,float64) 
        field(intercept,float64) 
    }

    struct(DisplayLimit) {
        field(low,float64) 
        field(high,float64)
    }
    struct(ControlLimit) {
        field(low,float64) 
        field(high,float64) 
    }
    struct(AlarmLimit) {
        field(low,float64) 
        field(lowSevr,menu(menuAlarmSevr)) 
        field(lowWarning,float64) 
        field(lowWarningSevr,menu(menuAlarmSevr)) 
        field(highWarning,float64) 
        field(highWarningSevr,menu(menuAlarmSevr)) 
        field(high,float64) 
        field(highSevr,menu(menuAlarmSevr)) 
    }

---

RecordCommon

Menu Definitions

    # menu definitions for RecordCommon fields
    menu(menuPriority) {
        choice(menuPriorityLow, "Low")
        choice(menuPriorityMedium, "Medium")
        choice(menuPriorityHigh, "High")
    }

    menu(menuScan) {
        choice(menuScanPassive, "Passive")
        choice(menuScanEvent, "Event")
        choice(menuScanInterrupt, "Interrupt")
        choice(menuScan10second, "10 second")
        choice(menuScan5second, "5 second")
        choice(menuScan2second, "2 second")
        choice(menuScan1second, "1 second")
        choice(menuScan_5second, ".5 second")
        choice(menuScan_2second, ".2 second")
        choice(menuScan_1second, ".1 second")
    }

    menu(menuAlarmSevr) {
        choice(menuAlarmSevrNone, "None")
        choice(menuAlarmSevrMinor, "Minor")
        choice(menuAlarmSevrMajor, "Major")
        choice(menuAlarmSevrInvalid, "Invalid")
    }

struct definitions for RecordSupport

    struct(TimeStamp) {
        field(secondsPastEpoch,int64)
        field(nanoSeconds,int32)
    }

    struct Scan {
        field(scan,menu(menuScan)) {
            special(yes)
        }
        field(phase,int16)
        field(priority,menu(menuPriority)) {
            special(yes)
        }
    }

Event NEEDS NEW DEFINITIONS

    struct Event {
        field(eventNumber,int16) {
            special(yes)
        }
        field(timeStampEvent,int16)
        field(timeStampLink,link(in))
    }

    struct Disable {
        field(disableValue,int16) {
            default("1")
        }
        field(disableInput,int16)
        field(disableLink,link(in))
        field(disableAlarmSeverity,menu(menuAlarmSevr))
    }

RecordCommon Record Definition

    record(RecordCommon) {
        field(description,string)
        field(scan,struct(Scan))
        field(event,struct(Event))
        field(accessSecurityGroup,string)
        field(pini,bool)
        field(disablePutField,bool)
        field(alarmAckSeverity,menu(menuAlarmSevr)) {
            design(no)
            readonly(yes)
        }
        field(alarmAckTransient,bool) {
            readonly(yes)
            default("YES")
        }
        field(udf,bool) {
            dynamic(yes)
            default("1")
        }
        field(time,struct(TimeStamp)) {
            design(no)
            dynamic(yes)
            readonly(yes)
        }
        field(disable,struct(Disable)) {
            special(yes)
        }
        field(alarmStatus,string) {
            default("UDF")
        }
        field(alarmSeverity,menu(menuAlarmSevr)) {
            readonly(yes)
            default("Invalid")
        }
        field(processLink,array(link[])) {
            special(yes)
        }
    }

Although it has many fewer fields, RecordCommon.dbd is a complete replacement for the V3 dbCommon. The following V3 fields are no longer needed:

• private fields - Private fields will truly be privaye to the implementation
• previous value fields - All puts to database fields will be posted. The layer above will decide if clients should be notified of changes.