Difference between revisions of "V4 DB RecordCommon"

From EPICSWIKI
 
(One intermediate revision by the same user not shown)
Line 1: Line 1:
EPICS V4: Standard Support October 25 2005  
EPICS V4: Standard Support November 02 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 23: Line 22:
== Channel/Database Access Links ==
== Channel/Database Access Links ==


     struct(PvProcessLink) {
     struct(ProcessLink) {
         field(pvname,string) { link}
         field(pvname,string) { link}
         field(wait,boolean)
         field(wait,boolean)
         field(timeout,float64)
         field(timeout,float64)
     }
     }
     struct(PvMonitorLink) {
     struct(MonitorLink) {
         field(pvname,string) { link}
         field(pvname,string) { link}
         field(process,boolean) // process this record when monitor occurs
         field(process,boolean) // process this record when monitor occurs
         field(inheritSeverity,boolean)  
         field(inheritSeverity,boolean)  
     }
     }
     struct(PvInputLink) {
     struct(InputLink) {
         field(pvname,string) { link}
         field(pvname,string) { link}
         field(process,boolean)
         field(process,boolean)
Line 40: Line 39:
         field(inheritSeverity,boolean)
         field(inheritSeverity,boolean)
     }
     }
     struct(PvOutputLink) {
     struct(OutputLink) {
         field(pvname,string) { link}
         field(pvname,string) { link}
         field(process,boolean)
         field(process,boolean)
Line 106: Line 105:
         }
         }
         field(timeStampEvent,int16)
         field(timeStampEvent,int16)
         field(timeStampLink,link(in,interface(????))
         field(timeStampLink,link)
     }
     }


     struct Disable {
     struct Disable {
        field(disabled,boolean)
         field(disableValue,int16) {
         field(disableValue,int16) {
             default("1")
             default("1")
         }
         }
         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 120:
     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(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 ==
== Other common definitions ==
Line 132: Line 177:


     struct(LinearConvert) {
     struct(LinearConvert) {
         field(full,float64)  
         field(engUnitsHigh,float64)  
         field(egul,float64)
         field(engUnitsLow,float64)
         field(slope,float64)  
         field(slope,float64)  
         field(intercept,float64)  
         field(intercept,float64)  
Line 155: Line 200:
         field(high,float64)  
         field(high,float64)  
         field(highSevr,menu(menuAlarmSevr))  
         field(highSevr,menu(menuAlarmSevr))  
        field(hysteresis,float64)
    }
<b>MAY NEED NEW DEFINITION</b>
    struct(SimulationFloat64) {
        field(modeLink,link)
        field(mode,boolean)
        field(link,link)
        field(value,float64)
        field(alarmSevr,menu(menuAlarmSevr))
     }
     }


----
----
<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 242:
* arrays of primitive types and strings
* arrays of primitive types and strings


     link(process,processLink,PvProcessLink,interface(LinkProcess))
     support(processLink,ProcessLink)
    support(monitorLink,MonitorLink)
    support(monitorLinkArray,MonitorLink)
    support(inputLink,InputLink)
    support(inputLinkArray,InputLink)
    support(outputLink,OutputLink)
    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))
For linear conversion
     link(in,asynInt32Monitor,AsynLink,interface(LinkInt32))
     support(linearConvert)
    link(inout,asynFloat64,AsynLink,interface(LinkFloat64))
For simulation
    link(in,asynFloat64Average,AsynLink,interface(LinkFloat64))
     support(simulation)
     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)))

Latest revision as of 19:51, 2 November 2005

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)
Retrieved from "https://wiki-ext.aps.anl.gov/epics/index.php?title=V4_DB_RecordCommon&oldid=2742"