Difference between revisions of "V4 DB RecordCommon"

From EPICSWIKI
Line 1: Line 1:
EPICS V4: Standard Support October 25 2005  
EPICS V4: Standard Support November 01 2005  
----
----


= Overview =
= Overview =


This document describes three base supplied components for EPICS V4 databases.
This document describes two base supplied components for EPICS V4 databases.
# menuStructBase.dbd - menu and struct definitions  
# menuStructBase.dbd - menu and struct definitions  
# recordCommon.dbd - common fields for record definitions
# baseSupport.dbd - link definitions for base supplied support
# baseSupport.dbd - link definitions for base supplied support


Line 106: Line 105:
         }
         }
         field(timeStampEvent,int16)
         field(timeStampEvent,int16)
         field(timeStampLink,link(in,interface(????))
         field(timeStampLink,link)
     }
     }


Line 114: Line 113:
         }
         }
         field(disableInput,int16)
         field(disableInput,int16)
         field(disableLink,link(in,interface(LinkBoolean)))
         field(disableLink,link)
         field(disableAlarmSeverity,menu(menuAlarmSevr))
         field(disableAlarmSeverity,menu(menuAlarmSevr))
     }
     }
Line 120: Line 119:
     struct(ProcessLink) {
     struct(ProcessLink) {
         field(block,boolean)
         field(block,boolean)
         field(link,link(process,interface(ProcessLink)))
         field(link,link)
     }
     }
    struct(RecordCommon) {
        field(description,string)
        field(scan,struct(Scan))
        field(event,struct(Event))
        field(accessSecurityGroup,string)
        field(pini,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(udf,boolean) {
            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(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 ==
== Other common definitions ==
Line 132: Line 176:


     struct(LinearConvert) {
     struct(LinearConvert) {
         field(full,float64)  
         field(eguf,float64)  
         field(egul,float64)
         field(egul,float64)
         field(slope,float64)  
         field(slope,float64)  
Line 159: Line 203:
----
----
<center>
<center>
= recordCommon.dbd =
= definition of record types =
  </center>
  </center>
This is a file that is included by most of the record types provided by
Most record types are defined as follows:
base. For example
     #include "menuStructBase.dbd"
     #include "menuStructBase.dbd"
     record(AiRecord) {
     record(AiRecord) {
     #include "recordCommon.dbd"
     field(common,struct(RecordCommon))
     ...
     ...
     }
     }
<tt>recordCommon.dbd</tt> contains the following definitions
        field(description,string)
        field(scan,struct(Scan))
        field(event,struct(Event))
        field(accessSecurityGroup,string)
        field(pini,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(udf,boolean) {
            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(ProcessLink[])) {
            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 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.


----
----
Line 231: Line 231:
* arrays of primitive types and strings
* arrays of primitive types and strings


     link(process,processLink,PvProcessLink,interface(LinkProcess))
     support(processLink,PvProcessLink)
    support(monitorLink,PvMonitorLink)
    support(monitorLinkArray,PvMonitorLink)
    support(inputLink,PvInputLink)
    support(inputLinkArray,PvInputLink)
    support(outputLink,PvOutputLink)
    support(outputLinkArray)


    link(in,monitorLink,PvMonitorLink,interface(
== asynDriver support ==
        LinkOctet,LinkBoolean,
        LinkInt16,LinkInt32,LinkInt64,
        LinkFloat32,LinkFloat64,
        LinkString
    ))
    link(in,monitorLinkArray,PvMonitorLink,interface(
        LinkArrayOctet,LinkArrayBoolean,
        LinkArrayInt16,LinkArrayInt32,LinkArrayInt64,
        LinkArrayFloat32,LinkArrayFloat64,
        LinkArrayString
    ))
    link(in,inputLink,PvInputLink, interface(
        LinkOctet,LinkBoolean,
        LinkInt16,LinkInt32,LinkInt64,
        LinkFloat32,LinkFloat64,
        LinkString
    ))
    link(in,inputLinkArray,PvInputLink, interface(
        LinkArrayOctet,LinkArrayBoolean,
        LinkArrayInt16,LinkArrayInt32,LinkArrayInt64,
        LinkArrayFloat32,LinkArrayFloat64,
        LinkArrayString
    ))
    link(out,outputLink,PvOutputLink, interface(
        LinkOctet,LinkBoolean,
        LinkInt16,LinkInt32,LinkInt64,
        LinkFloat32,LinkFloat64,
        LinkString
    ))
    link(out,outputLinkArray,PvOutputLink, interface(
        LinkArrayOctet,LinkArrayBoolean,
        LinkArrayInt16,LinkArrayInt32,LinkArrayInt64,
        LinkArrayFloat32,LinkArrayFloat64,
        LinkArrayString
    ))


    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)


== asynDriver support ==
== struct support ==
 
For RecordCommon
     link(inout,asynInt32,AsynLink,interface(LinkInt32))
     support(common) # no SupportStruct
    link(in,asynInt32Average,AsynLink,interface(LinkInt32))
    link(in,asynInt32Monitor,AsynLink,interface(LinkInt32))
    link(inout,asynFloat64,AsynLink,interface(LinkFloat64))
    link(in,asynFloat64Average,AsynLink,interface(LinkFloat64))
    link(in,asynFloat64Monitor,AsynLink,interface(LinkFloat64))
    link(in,asynDigitalMonitor,AsynLink,interface(AsynDigital))
    link(inout,asynDigital,AsynLink,interface(AsynDigital)))
    link(inout,asynInt32Array,AsynLink,interface(LinkArrayInt32)))
    link(inout,asynFloat64Array,AsynLink,interface(LinkArrayFloat64)))
    link(inout,asynOctet,AsynLink,interface(AsynOctet)))

Revision as of 20:27, 1 November 2005

EPICS V4: Standard Support November 01 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(PvProcessLink) {
        field(pvname,string) { link}
        field(wait,boolean)
        field(timeout,float64)
    }
    struct(PvMonitorLink) {
        field(pvname,string) { link}
        field(process,boolean) // process this record when monitor occurs
        field(inheritSeverity,boolean) 
    }
    struct(PvInputLink) {
        field(pvname,string) { link}
        field(process,boolean)
        field(wait,boolean)
        field(timeout,float64)
        field(inheritSeverity,boolean)
    }
    struct(PvOutputLink) {
        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(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(pini,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(udf,boolean) {
            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(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(eguf,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)) 
    }

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,PvProcessLink)
    support(monitorLink,PvMonitorLink)
    support(monitorLinkArray,PvMonitorLink)
    support(inputLink,PvInputLink)
    support(inputLinkArray,PvInputLink)
    support(outputLink,PvOutputLink)
    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
Retrieved from "https://wiki-ext.aps.anl.gov/epics/index.php?title=V4_DB_RecordCommon&oldid=580"