Difference between revisions of "V4 DB RecordCommon"

From EPICSWIKI
 
(6 intermediate revisions by the same user not shown)
Line 1: Line 1:
EPICS V4: Standard Support September 27 2005  
EPICS V4: Standard Support November 02 2005  
----
----


= Overview =
= Overview =


For V4 dbCommon.dbd and RecordCommon.dbd replace the V3 dbCommon.dbd.
This document describes two base supplied components for EPICS V4 databases.
dbCommon.dbd defines widely used definitions and RecordCommon.dbd defines
# menuStructBase.dbd - menu and struct definitions
the fields that are common to all record types.
# baseSupport.dbd - link definitions for base supplied support
 


This document requires that the reader be familiar with:
This document requires that the reader be familiar with:
Line 14: Line 13:
# V4 DB Record Instance Syntax
# V4 DB Record Instance Syntax


NOTE: This document is ahead of the two above V4 documents so it may use
slightly different syntax.
----
----
<center>
<center>
= dbCommon =
= menuStructBase.dbd =
  </center>
  </center>


== Channel/Database Access Support ==
== Channel/Database Access Links ==


=== Data Structures ===
     struct(ProcessLink) {
     struct(MonitorLinkData) {
         field(pvname,string) { link}
         field(pvname,string) { link}
         field(process,bool) // process this record when monitor occurs
         field(wait,boolean)
         field(inheritSeverity,bool)  
         field(timeout,float64)
     }
     }
     struct(InputLinkData) {
     struct(MonitorLink) {
         field(pvname,string) { link}
         field(pvname,string) { link}
         field(process,bool)
         field(process,boolean) // process this record when monitor occurs
        field(wait,bool)
         field(inheritSeverity,boolean)  
        field(block,bool)
         field(inheritSeverity,bool)
     }
     }
     struct(OutputLinkData) {
     struct(InputLink) {
         field(pvname,string) { link}
         field(pvname,string) { link}
         field(process,bool)
         field(process,boolean)
         field(wait,bool)
         field(wait,boolean)
         field(block,bool)
         field(timeout,float64)
         field(inheritSeverity,bool)
         field(inheritSeverity,boolean)
     }
     }
     struct(ProcessLinkData) {
     struct(OutputLink) {
         field(pvname,string) { link}
         field(pvname,string) { link}
         field(wait,bool)
        field(process,boolean)
         field(block,bool)
         field(wait,boolean)
        field(timeout,float64)
         field(inheritSeverity,boolean)
     }
     }


=== link support definitions ===
== asynDriver Link ==
 
     struct(AsynLink) {
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(portName,string)
         field(addr,int32)
         field(addr,int32)
         field(timeout,float64)
         field(timeout,float64)
         field(drvPvt,string)
         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))
     }
     }


----
== Definitions for recordCommon ==
<center>
= RecordCommon =
</center>
 
== Menu Definitions ==


     # menu definitions for RecordCommon fields
     # menu definitions for recordCommon fields
     menu(menuPriority) {
     menu(menuPriority) {
         choice(menuPriorityLow, "Low")
         choice(menuPriorityLow, "Low")
Line 211: Line 83:
         choice(menuAlarmSevrInvalid, "Invalid")
         choice(menuAlarmSevrInvalid, "Invalid")
     }
     }
== struct definitions for RecordSupport ==
 
    #struct definitions for recordCommon
     struct(TimeStamp) {
     struct(TimeStamp) {
         field(secondsPastEpoch,int64)
         field(secondsPastEpoch,int64)
Line 232: Line 105:
         }
         }
         field(timeStampEvent,int16)
         field(timeStampEvent,int16)
         field(timeStampLink,link(in))
         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))
         field(disableLink,link)
         field(disableAlarmSeverity,menu(menuAlarmSevr))
         field(disableAlarmSeverity,menu(menuAlarmSevr))
     }
     }


== RecordCommon Record Definition ==
    struct(ProcessLink) {
        field(block,boolean)
        field(link,link)
    }


     record(RecordCommon) {
     struct(RecordCommon) {
         field(description,string)
         field(description,string)
         field(scan,struct(Scan))
         field(scan,struct(Scan))
         field(event,struct(Event))
         field(event,struct(Event))
         field(accessSecurityGroup,string)
         field(accessSecurityGroup,string)
         field(pini,bool)
         field(processAtInit,boolean)
         field(disablePutField,bool)
         field(disablePutField,boolean)
         field(alarmAckSeverity,menu(menuAlarmSevr)) {
         field(alarmAckSeverity,menu(menuAlarmSevr)) {
             design(no)
             design(no)
             readonly(yes)
             readonly(yes)
         }
         }
         field(alarmAckTransient,bool) {
         field(alarmNoAckTransient,menu(menuAlarmSevr)) {
            readonly(yes)
        # highest level of alarm that does not have to be acknowledged"
            default("YES")
         }
         }
         field(udf,bool) {
         field(undefined,boolean) {
             dynamic(yes)
             dynamic(yes)
             default("1")
             default(true)
         }
         }
         field(time,struct(TimeStamp)) {
         field(time,struct(TimeStamp)) {
Line 280: Line 156:
             default("Invalid")
             default("Invalid")
         }
         }
         field(processLink,array(link[])) {
         field(processLink,array(ProcessLink[])) {
             special(yes)
             special(yes)
         }
         }
Line 286: Line 162:


Although it has many fewer fields,
Although it has many fewer fields,
RecordCommon.dbd is a complete replacement for the V3 dbCommon.
RecordCommon is a complete replacement for the V3 dbCommon.
The following V3 fields are no longer needed:
The following V3 fields are no longer needed:
* private fields - Private fields will truly be privaye to the implementation
* 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.
* 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)
    }
<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>
= definition of record types =
</center>
Most record types are defined as follows:
    #include "menuStructBase.dbd"
    record(AiRecord) {
    field(common,struct(RecordCommon))
    ...
    }
----
<center>
= baseSupport.dbd =
</center>
== 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)

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"