Difference between revisions of "V4 DB RecordCommon"

From EPICSWIKI
Line 1: Line 1:
EPICS V4: RecordCommon September 22 2005  
EPICS V4: Standard Support September 27 2005  
----
----


Line 5: Line 5:


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


Line 11: Line 11:
This document requires that the reader be familiar with:
This document requires that the reader be familiar with:
# V3 iocCore
# V3 iocCore
# V4 Design: Record Processing
# V4 DBD Statement Syntax
# V4 Design: dbdInterfaces
# V4 DB Record Instance Syntax
 
Unless the reader is familiar with these most of this document will
be very difficult to understand.


----
----
Line 22: Line 19:
  </center>
  </center>


<tt>dbCommon.dbd</tt> defines the following:
== Channel/Database Access Support ==
 
    # menu definitions for RecordCommon fields
    menu(menuPriority) {
        choice(menuPriorityLow, "Low")
        choice(menuPriorityMedium, "Medium")
        choice(menuPriorityHigh, "High")
    }


    menu(menuScan) {
=== Data Structures ===
        choice(menuScanPassive, "Passive")
     struct(MonitorLinkData) {
        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")
    }
 
    menu(menuConvert) {
        choice(menuConvertRaw, "Raw")
        choice(menuConvertLinear, "Linear")
        choice(menuConvertTable, "Table")
    }
 
     struct(MonitorLink) {
         field(pvname,string) { link}
         field(pvname,string) { link}
         field(process,bool) // process this record when monitor occurs
         field(process,bool) // process this record when monitor occurs
         field(inheritSeverity,bool)  
         field(inheritSeverity,bool)  
     }
     }
     struct(InputLink) {
     struct(InputLinkData) {
         field(pvname,string) { link}
         field(pvname,string) { link}
        field(parallel,bool)
         field(process,bool)
         field(process,bool)
         field(wait,bool)
         field(wait,bool)
        field(block,bool)
         field(inheritSeverity,bool)
         field(inheritSeverity,bool)
     }
     }
     struct(OutputLink) {
     struct(OutputLinkData) {
         field(pvname,string) { link}
         field(pvname,string) { link}
        field(parallel,bool)
         field(process,bool)
         field(process,bool)
         field(wait,bool)
         field(wait,bool)
        field(block,bool)
         field(inheritSeverity,bool)
         field(inheritSeverity,bool)
     }
     }
     struct(ProcessLink) {
     struct(ProcessLinkData) {
         field(pvname,string) { link}
         field(pvname,string) { link}
        field(parallel,bool)
         field(wait,bool)
         field(wait,bool)
        field(block,bool)
     }
     }


     link(in,"monitorLink",MonitorLink);
=== link support definitions ===
     link(in,"inputLink",InputLink);
 
     link(out,"outputLink",OutputLink);
Link support is provided for
     link(process,"processLink",ProcessLink);
* 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);


    #definitions for common properties
== asynDriver link support ==
     struct(TimeStamp) {
=== Data Definitions ===
         field(secondsPastEpoch,int64)
 
         field(nanoSeconds,int32)
     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 ==


     struct Scan {
     menu(menuConvert) {
        field(scan,menu(menuScan)) {
        choice(menuConvertRaw, "Raw")
            special(yes)
         choice(menuConvertLinear, "Linear")
         }
         choice(menuConvertTable, "Table")
        field(phase,int16)
         field(priority,menu(menuPriority)) {
            special(yes)
        }
     }
     }


<b>Event NEEDS NEW DEFINITIONS</b>
    struct Event {
        field(eventNumber,int16) {
            special(yes)
        }
        field(timeStampEvent,int16)
        field(timeStampLink,link(in))
    }


     # usefull struct definitions
     # usefull struct definitions
Line 145: Line 183:
  </center>
  </center>


<tt>RecordCommon.dbd</tt> must be part of every record, and defines the following:
== 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)
        }
    }
<b>Event NEEDS NEW DEFINITIONS</b>
    struct Event {
        field(eventNumber,int16) {
            special(yes)
        }
        field(timeStampEvent,int16)
        field(timeStampLink,link(in))
    }


     struct Disable {
     struct Disable {
Line 155: Line 243:
         field(disableAlarmSeverity,menu(menuAlarmSevr))
         field(disableAlarmSeverity,menu(menuAlarmSevr))
     }
     }
== RecordCommon Record Definition ==


     record(RecordCommon) {
     record(RecordCommon) {

Revision as of 15:21, 27 September 2005

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