V4 DB RecordCommon

EPICS V4: Standard Support November 02 2005

---

Overview

This document describes two base supplied components for EPICS V4 databases.

1. menuStructBase.dbd - menu and struct definitions
2. baseSupport.dbd - link definitions for base supplied support

This document requires that the reader be familiar with:

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

NOTE: This document is ahead of the two above V4 documents so it may use slightly different syntax.

---

menuStructBase.dbd

Channel/Database Access Links

    struct(ProcessLink) {
        field(pvname,string) { link}
        field(wait,boolean)
        field(timeout,float64)
    }
    struct(MonitorLink) {
        field(pvname,string) { link}
        field(process,boolean) // process this record when monitor occurs
        field(inheritSeverity,boolean) 
    }
    struct(InputLink) {
        field(pvname,string) { link}
        field(process,boolean)
        field(wait,boolean)
        field(timeout,float64)
        field(inheritSeverity,boolean)
    }
    struct(OutputLink) {
        field(pvname,string) { link}
        field(process,boolean)
        field(wait,boolean)
        field(timeout,float64)
        field(inheritSeverity,boolean)
    }

asynDriver Link

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

Definitions for recordCommon

    # 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 recordCommon
    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)
    }

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

    struct(ProcessLink) {
        field(block,boolean)
        field(link,link)
    }

    struct(RecordCommon) {
        field(description,string)
        field(scan,struct(Scan))
        field(event,struct(Event))
        field(accessSecurityGroup,string)
        field(processAtInit,boolean)
        field(disablePutField,boolean)
        field(alarmAckSeverity,menu(menuAlarmSevr)) {
            design(no)
            readonly(yes)
        }
        field(alarmNoAckTransient,menu(menuAlarmSevr)) {
        # highest level of alarm that does not have to be acknowledged"
        }
        field(undefined,boolean) {
            dynamic(yes)
            default(true)
        }
        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(ProcessLink[])) {
            special(yes)
        }
    }

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

• private fields - Private fields will truly be private 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.

Other common definitions

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

    struct(LinearConvert) {
        field(engUnitsHigh,float64) 
        field(engUnitsLow,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)) 
        field(hysteresis,float64)
    }

MAY NEED NEW DEFINITION

    struct(SimulationFloat64) {
        field(modeLink,link)
        field(mode,boolean)
        field(link,link)
        field(value,float64)
        field(alarmSevr,menu(menuAlarmSevr))
    }

---

definition of record types

Most record types are defined as follows:

    #include "menuStructBase.dbd"
    record(AiRecord) {
    field(common,struct(RecordCommon))
    ...
    }

---

baseSupport.dbd

Channel/Database Access Support

Link support is provided for

• monitor support
• input support
• output
• process

For monitor, input, and output The following data types are supported:

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

    support(processLink,ProcessLink)
    support(monitorLink,MonitorLink)
    support(monitorLinkArray,MonitorLink)
    support(inputLink,InputLink)
    support(inputLinkArray,InputLink)
    support(outputLink,OutputLink)
    support(outputLinkArray)

asynDriver support

    support(asynInt32,AsynLink)
    support(asynInt32Average,AsynLink)
    support(asynInt32Monitor,AsynLink)
    support(asynFloat64,AsynLink)
    support(asynFloat64Average,AsynLink)
    support(asynFloat64Monitor,AsynLink)
    support(asynDigitalMonitor,AsynLink)
    support(asynDigital,AsynLink)
    support(asynInt32Array,AsynLink)
    support(asynFloat64Array,AsynLink)
    support(asynOctet,AsynLink)

struct support

For RecordCommon

    support(common) # no SupportStruct

For linear conversion

    support(linearConvert)

For simulation

    support(simulation)