Difference between revisions of "V4 DB RecordCommon"

From EPICSWIKI
Line 1: Line 1:
EPICS V4: Standard Support September 28 2005  
EPICS V4: Standard Support September 30 2005  
----
----


Line 64: Line 64:
* arrays of primitive types and strings
* arrays of primitive types and strings


     link(process,processLink,ProcessLink,ProcessLinkData);
     link(process,processLink,ProcessLinkData,interface(ProcessLink))


     link(in,monitorLinkArrayOctet,LinkArrayOctet,MonitorLinkData);
     link(in,monitorLink,MonitorLinkData interface(
    link(in,inputLinkArrayOctet,LinkArrayOctet,InputLinkData);
        LinkBoolean,
    link(out,outputLinkArrayOctet,LinkArrayOctet,OutputLinkData);
        LinkInt16,LinkInt32,LinkInt64,
 
        LinkFloat32,LinkFloat64,
     link(in,monitorLinkBoolean,LinkBoolean,MonitorLinkData);
        LinkString
     link(in,monitorLinkArrayBoolean,LinkArrayBoolean,MonitorLinkData);
     ))
    link(in,inputLinkBoolean,LinkBoolean,InputLinkData);
     link(in,monitorLinkArray,MonitorLinkData interface(
    link(in,inputLinkArrayBoolean,LinkArrayBoolean,InputLinkData);
        LinkArrayOctet,LinkArrayBoolean,
    link(out,outputLinkBoolean,LinkBoolean,OutputLinkData);
        LinkArrayInt16,LinkArrayInt32,LinkArrayInt64,
    link(out,outputLinkArrayBoolean,LinkArrayBooleanData);
        LinkArrayFloat32,LinkArrayFloat64,
 
        LinkArrayString
     link(in,monitorLinkInt16,LinkInt16,MonitorLinkData);
     ))
    link(in,monitorLinkInt32,LinkInt32,MonitorLinkData);
     link(in,inputLink,InputLinkData interface(
    link(in,monitorLinkInt64,LinkInt64,MonitorLinkData);
        LinkBoolean,
     link(in,inputLinkInt16,LinkInt16,InputLinkData);
        LinkInt16,LinkInt32,LinkInt64,
    link(in,inputLinkInt32,LinkInt32,InputLinkData);
        LinkFloat32,LinkFloat64,
    link(in,inputLinkInt64,LinkInt64,InputLinkData);
        LinkString
    link(out,outputLinkInt16,LinkInt16,OutputLinkData);
     ))
    link(out,outputLinkInt32,LinkInt32,OutputLinkData);
     link(in,inputLinkArray,InputLinkData interface(
    link(out,outputLinkInt64,LinkInt64,OutputLinkData);
        LinkArrayOctet,LinkArrayBoolean,
    link(in,monitorLinkArrayInt16,LinkArrayInt16,MonitorLinkData);
        LinkArrayInt16,LinkArrayInt32,LinkArrayInt64,
     link(in,monitorLinkArrayInt32,LinkArrayInt32,MonitorLinkData);
        LinkArrayFloat32,LinkArrayFloat64,
    link(in,monitorLinkArrayInt64,LinkArrayInt64,MonitorLinkData);
        LinkArrayString
     link(in,inputLinkArrayInt16,LinkArrayInt16,InputLinkData);
     ))
    link(in,inputLinkArrayInt32,LinkArrayInt32,InputLinkData);
     link(in,outputLink,OutputLinkData interface(
    link(in,inputLinkArrayInt64,LinkArrayInt64,InputLinkData);
        LinkBoolean,
    link(out,outputLinkArrayInt16,LinkArrayInt16,OutputLinkData);
        LinkInt16,LinkInt32,LinkInt64,
     link(out,outputLinkArrayInt32,LinkArrayInt32,OutputLinkData);
        LinkFloat32,LinkFloat64,
     link(out,outputLinkArrayInt64,LinkArrayInt64,OutputLinkData);
        LinkString
 
     ))
    link(in,monitorLinkFloat32,LinkFloat32,MonitorLinkData);
     link(in,outputLinkArray,OutputLinkData interface(
    link(in,monitorLinkFloat64,LinkFloat64,MonitorLinkData);
        LinkArrayOctet,LinkArrayBoolean,
    link(in,monitorLinkString,LinkString,MonitorLinkData);
        LinkArrayInt16,LinkArrayInt32,LinkArrayInt64,
    link(in,inputLinkFloat32,LinkFloat32,InputLinkData);
        LinkArrayFloat32,LinkArrayFloat64,
    link(in,inputLinkFloat64,LinkFloat64,InputLinkData);
        LinkArrayString
    link(in,inputLinkString,LinkString,InputLinkData);
     ))
     link(out,outputLinkFloat32,LinkFloat32,OutputLinkData);
     link(out,outputLinkFloat64,LinkFloat64,OutputLinkData);
    link(out,outputLinkString,LinkString,OutputLinkData);
    link(in,inputLinkArrayFloat32,LinkArrayFloat32,InputLinkData);
    link(in,inputLinkArrayFloat64,LinkArrayFloat64,InputLinkData);
    link(out,outputLinkArrayFloat32,LinkArrayFloat32,OutputLinkData);
    link(out,outputLinkArrayFloat64,LinkArrayFloat64,OutputLinkData);
 
 
    link(in,monitorLinkArrayString,LinkArrayString,MonitorLinkData);
     link(in,inputLinkArrayString,LinkArrayString,InputLinkData);
    link(out,outputLinkArrayString,LinkArrayString,OutputLinkData);




Line 127: Line 115:
=== link definitions ===
=== link definitions ===


     link(inout,asynInt32,LinkInt32,AsynLinkData)
     link(inout,asynInt32,AsynLinkData,interface(LinkInt32))
     link(in,asynInt32Average,LinkInt32,AsynLinkData)
     link(in,asynInt32Average,AsynLinkData,interface(LinkInt32))
     link(in,asynInt32Monitor,LinkInt32,AsynLinkData)
     link(in,asynInt32Monitor,AsynLinkData,interface(LinkInt32))
     link(inout,asynFloat64,LinkFloat64,AsynLinkData)
     link(inout,asynFloat64,AsynLinkData,interface(LinkFloat64))
     link(in,asynFloat64Average,LinkFloat64,AsynLinkData)
     link(in,asynFloat64Average,AsynLinkData,interface(LinkFloat64))
     link(in,asynFloat64Monitor,LinkFloat64,AsynLinkData)
     link(in,asynFloat64Monitor,AsynLinkData,interface(LinkFloat64))
     link(in,asynDigitalMonitor,AsynDigital,AsynLinkData)
     link(in,asynDigitalMonitor,AsynLinkData,interface(AsynDigital))
     link(inout,asynDigital,AsynDigital,AsynLinkData)
     link(inout,asynDigital,AsynLinkData,interface(AsynDigital)))
     link(inout,asynInt32Array,LinkArrayInt32,AsynLinkData)
     link(inout,asynInt32Array,AsynLinkData,interface(LinkArrayInt32)))
     link(inout,asynFloat64Array,LinkArrayFloat64,AsynLinkData)
     link(inout,asynFloat64Array,AsynLinkData,interface(LinkArrayFloat64)))
     link(inout,asynOctet,AsynOctet,AsynLinkData)
     link(inout,asynOctet,AsynLinkData,interface(AsynOctet)))
== Other common definitions ==
== Other common definitions ==


Revision as of 15:11, 30 September 2005

EPICS V4: Standard Support September 30 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,boolean) // process this record when monitor occurs
        field(inheritSeverity,boolean) 
    }
    struct(InputLinkData) {
        field(pvname,string) { link}
        field(process,boolean)
        field(wait,boolean)
        field(timeout,float64)
        field(block,boolean)
        field(inheritSeverity,boolean)
    }
    struct(OutputLinkData) {
        field(pvname,string) { link}
        field(process,boolean)
        field(wait,boolean)
        field(timeout,float64)
        field(block,boolean)
        field(inheritSeverity,boolean)
    }
    struct(ProcessLinkData) {
        field(pvname,string) { link}
        field(wait,boolean)
        field(timeout,float64)
        field(block,boolean)
    }

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(process,processLink,ProcessLinkData,interface(ProcessLink))

    link(in,monitorLink,MonitorLinkData interface(
        LinkBoolean,
        LinkInt16,LinkInt32,LinkInt64,
        LinkFloat32,LinkFloat64,
        LinkString
    ))
    link(in,monitorLinkArray,MonitorLinkData interface(
        LinkArrayOctet,LinkArrayBoolean,
        LinkArrayInt16,LinkArrayInt32,LinkArrayInt64,
        LinkArrayFloat32,LinkArrayFloat64,
        LinkArrayString
    ))
    link(in,inputLink,InputLinkData interface(
        LinkBoolean,
        LinkInt16,LinkInt32,LinkInt64,
        LinkFloat32,LinkFloat64,
        LinkString
    ))
    link(in,inputLinkArray,InputLinkData interface(
        LinkArrayOctet,LinkArrayBoolean,
        LinkArrayInt16,LinkArrayInt32,LinkArrayInt64,
        LinkArrayFloat32,LinkArrayFloat64,
        LinkArrayString
    ))
    link(in,outputLink,OutputLinkData interface(
        LinkBoolean,
        LinkInt16,LinkInt32,LinkInt64,
        LinkFloat32,LinkFloat64,
        LinkString
    ))
    link(in,outputLinkArray,OutputLinkData interface(
        LinkArrayOctet,LinkArrayBoolean,
        LinkArrayInt16,LinkArrayInt32,LinkArrayInt64,
        LinkArrayFloat32,LinkArrayFloat64,
        LinkArrayString
    ))


asynDriver link support

Data Definitions

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

link definitions

    link(inout,asynInt32,AsynLinkData,interface(LinkInt32))
    link(in,asynInt32Average,AsynLinkData,interface(LinkInt32))
    link(in,asynInt32Monitor,AsynLinkData,interface(LinkInt32))
    link(inout,asynFloat64,AsynLinkData,interface(LinkFloat64))
    link(in,asynFloat64Average,AsynLinkData,interface(LinkFloat64))
    link(in,asynFloat64Monitor,AsynLinkData,interface(LinkFloat64))
    link(in,asynDigitalMonitor,AsynLinkData,interface(AsynDigital))
    link(inout,asynDigital,AsynLinkData,interface(AsynDigital)))
    link(inout,asynInt32Array,AsynLinkData,interface(LinkArrayInt32)))
    link(inout,asynFloat64Array,AsynLinkData,interface(LinkArrayFloat64)))
    link(inout,asynOctet,AsynLinkData,interface(AsynOctet)))

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,interface(????))
    }

    struct Disable {
        field(disableValue,int16) {
            default("1")
        }
        field(disableInput,int16)
        field(disableLink,link(in,interface(LinkBoolean)))
        field(disableAlarmSeverity,menu(menuAlarmSevr))
    }

RecordCommon Record Definition

    struct(RecordCommonProcessLink) {
        field(link,link(process,interface(ProcessLink)))
    }

    record(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(alarmAckTransient,boolean) {
            readonly(yes)
            default("YES")
        }
        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(RecordCommonProcessLink[])) {
            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=564"