Difference between revisions of "V4 DBD Examples"

From EPICSWIKI
 
(3 intermediate revisions by the same user not shown)
Line 1: Line 1:
Example Record Types Sept 22 2005
Example Record Types November 02 2005
= Overview =
= Overview =
This document present proposed V4 replacements for a few of the
This document present proposed V4 replacements for a few of the
Line 10: Line 10:
aoRecord.dbd might be defined as follows:
aoRecord.dbd might be defined as follows:


  include "dbCommon.dbd"
  include "menuStructBase.dbd"
  record(AoRecord) extends RecordCommon {
  record(AoRecord) {
     field(value, float64) {
    field(common,struct(RecordCommon))
     field(desiredValue, float64) {
         asl(0)
         asl(0)
     }
     }
     field(outValue, float64) {
     field(currentValue, float64) {
         readonly(yes)
         readonly(yes)
     }
     }
     field(out, device(out,analogOut))
     field(out,link)
     field(outputRateOfChange, float64)
     field(outputRateOfChange, float64)
     field(desiredOutputLink, link(in))
     field(desiredOutputLink,link)
     field(closedLoop, bool)
     field(closedLoop, bool)
     field(outputIncremental, bool)
     field(outputIncremental, bool)
Line 29: Line 30:
         special(yes)
         special(yes)
     }
     }
    field(convertTable,string);
     field(units, string)
     field(units, string)
     field(displayLimit, struct(DisplayLimit))
     field(displayLimit, struct(DisplayLimit))
     field(controlLimit, struct(ControlLimit))
     field(controlLimit, struct(ControlLimit))
     field(alarmLimit, struct(AlarmLimit))
     field(alarmLimit, struct(AlarmLimit))
    field(alarmDeadband, float64)
     field(rawValue, int32) {
     field(rawValue, int64) {
         design(no)
         design(no)
     }
     }
     field(prevRawValue, int64) {
     field(readBackValue, int32) {
         design(no)
         design(no)
         readonly(yes)
         readonly(yes)
     }
     }
     field(readBackValue, int64) {
     field(simulation,struct(SimulationFloat64))
        design(no)
        readonly(yes)
    }
    field(init, bool) {
        design(no)
        readonly(yes)
    }
    field(simOutputLink, link(out))
    field(simModeLink, link(in))
    field(simMode, bool)
    field(simSevr, menu(menuAlarmSevr))
     field(invalidAction, menu(menuIvoa))
     field(invalidAction, menu(menuIvoa))
     field(invalidValue, float64)
     field(invalidValue, float64)
    field(outValueModified, bool) {
        design(no)
        readonly(yes)
    }
     view(value) {
     view(value) {
         property(value, value) {
         property(value, value) {
Line 89: Line 75:
         }
         }
     }
     }
  }
  }  
 


<center>
<center>
Line 98: Line 83:
calcRecord.dbd defines the following:
calcRecord.dbd defines the following:


  include "dbCommon.dbd"
  include "menuStructBase.dbd"
  struct(CalcInpLink) {
  struct(CalcInpLink) {
     field(link,link(in))
    field(block,boolean)
     field(link,link)
     field(value,float64)
     field(value,float64)
  }
  }
  record(CalcRecord) extends RecordCommon {
 
     field(result,float64) {
  record(CalcRecord){
    field(common,struct(RecordCommon))
     field(value,float64) {
         asl(0)
         asl(0)
     }
     }
Line 114: Line 102:
     field(displayLimit,struct(DisplayLimit))
     field(displayLimit,struct(DisplayLimit))
     field(alarmLimit,struct(AlarmLimit))
     field(alarmLimit,struct(AlarmLimit))
    field(alarmDeadband,float64)
    field(lastValueAlarmed,float64) {
        design(no)
        readonly(yes)
    }
    field(rpcl,private("char *"))
     view(result) {
     view(result) {
         property(value, result) {
         property(value, result) {
Line 142: Line 124:
mbbiRecord.dbd could be:
mbbiRecord.dbd could be:


  include "dbCommon.dbd"
  include "menuStructBase.dbd"
  struct(MbbiState) {
  struct(MbbiState) {
     field(name, string)
     field(name, string)
Line 148: Line 130:
     field(severity, menu(menuAlarmSevr))
     field(severity, menu(menuAlarmSevr))
  }
  }
  record(MbbiRecord) extends RecordCommon {
  record(MbbiRecord) {
    field(common,struct(RecordCommon))
     field(state, array(struct(MbbiState)[])) {
     field(state, array(struct(MbbiState)[])) {
         special(yes)
         special(yes)
Line 161: Line 144:
     field(unknownStateSeverity, menu(menuAlarmSevr))
     field(unknownStateSeverity, menu(menuAlarmSevr))
     field(changeStateSeverity, menu(menuAlarmSevr))
     field(changeStateSeverity, menu(menuAlarmSevr))
     field(inp, device(in, digitalInput))
     field(inp, link)
     field(rawValue, array(octet[])) {
     field(rawValue, array(octet[])) {
         design(no)
         design(no)
Line 172: Line 155:
         readonly(yes)
         readonly(yes)
     }
     }
    field(simInputLink, link(in))
    field(simValue,  array(octet[])
    field(simModeLink, link(in))
    field(simMode, menu(menuYesNo))
    field(simSevr, menu(menuAlarmSevr))
     view(choice) {
     view(choice) {
         property(value, value) {
         property(value, value) {
Line 197: Line 175:
waveformRecord.dbd defines the following:
waveformRecord.dbd defines the following:


  include "dbCommon.dbd"
  include "menuStructBase.dbd"
  record(WaveformRecord) extends RecordCommon {
  record(WaveformRecord) {
    field(common,struct(RecordCommon))
     field(value, array([])) {
     field(value, array([])) {
         asl(0)
         asl(0)
Line 204: Line 183:
     }
     }
     field(reArm,bool)
     field(reArm,bool)
     field(inp,device(in,waveformIO))
     field(io,link)
     field(units,string)
     field(units,string)
     field(displayLimit,struct(DisplayLimit))
     field(displayLimit,struct(DisplayLimit))
Line 211: Line 190:
         readonly(yes)
         readonly(yes)
     }
     }
    field(simInputLink,link(in))
    field(simModeLink,link(in))
    field(simMode,menu(menuYesNo))
    field(simSevr,menu(menuYesNo))
     view(value) {
     view(value) {
         property(value, value) {
         property(value, value) {

Latest revision as of 19:54, 2 November 2005

Example Record Types November 02 2005

Overview

This document present proposed V4 replacements for a few of the V3 record types.

aoRecord

aoRecord.dbd might be defined as follows:

include "menuStructBase.dbd"
record(AoRecord) {
    field(common,struct(RecordCommon))
    field(desiredValue, float64) {
        asl(0)
    }
    field(currentValue, float64) {
        readonly(yes)
    }
    field(out,link)
    field(outputRateOfChange, float64)
    field(desiredOutputLink,link)
    field(closedLoop, bool)
    field(outputIncremental, bool)
    field(convert, menu(menuConvert)) {
        special(yes)
    }
    field(linearConvert, struct(LinearConvert)) {
        special(yes)
    }
    field(convertTable,string);
    field(units, string)
    field(displayLimit, struct(DisplayLimit))
    field(controlLimit, struct(ControlLimit))
    field(alarmLimit, struct(AlarmLimit))
    field(rawValue, int32) {
        design(no)
    }
    field(readBackValue, int32) {
        design(no)
        readonly(yes)
    }
    field(simulation,struct(SimulationFloat64))
    field(invalidAction, menu(menuIvoa))
    field(invalidValue, float64)
    view(value) {
        property(value, value) {
            property(units, units)
            property(timeStamp, time)
            property(alarmSeverity, alarmSeverity)
            property(alarmStatus, alarmStatus)
            property(displayLimit, displayLimit)
            property(controlLimit, controlLimit)
            property(alarmLimit, alarmLimit)
        }
    }
    view(output) {
        property(value, outValue) {
            property(units, units)
            property(timeStamp, time)
            property(alarmSeverity, alarmSeverity)
            property(alarmStatus, alarmStatus)
            property(displayLimit, displayLimit)
        }
    }
    view(raw) {
        property(value, rawValue) {
            property(timeStamp, time)
        }
    }
    view(readback) {
        property(value, readBackValue) {
            property(timeStamp, time)
        }
    }
} 

calcRecord

calcRecord.dbd defines the following:

include "menuStructBase.dbd"
struct(CalcInpLink) {
    field(block,boolean)
    field(link,link)
    field(value,float64)
}
record(CalcRecord){
    field(common,struct(RecordCommon))
    field(value,float64) {
        asl(0)
    }
    field(calc,string) {
        special(yes)
    }
    field(input,array(struct(CalcInpLink)[])) 
    field(units,string)
    field(displayLimit,struct(DisplayLimit))
    field(alarmLimit,struct(AlarmLimit))
    view(result) {
        property(value, result) {
            property(units, units)
            property(timeStamp, time)
            property(alarmSeverity, alarmSeverity)
            property(alarmStatus, alarmStatus)
            property(displayLimit, displayLimit)
            property(alarmLimit, alarmLimit)
        }
    }
    view(expression) {
        property(value, calc)
    }
}


mbbiRecord

mbbiRecord.dbd could be:

include "menuStructBase.dbd"
struct(MbbiState) {
    field(name, string)
    field(value, array(octet[]))
    field(severity, menu(menuAlarmSevr))
}
record(MbbiRecord) {
    field(common,struct(RecordCommon))
    field(state, array(struct(MbbiState)[])) {
        special(yes)
    }
  1. NOTE: stateName needed because enum must refer to array of string
    field(stateName,array(string[])) {
        design(no) readonly(yes)
    }
    field(value, enum(stateName)) {
        asl(0)
    }
    field(unknownStateSeverity, menu(menuAlarmSevr))
    field(changeStateSeverity, menu(menuAlarmSevr))
    field(inp, link)
    field(rawValue, array(octet[])) {
        design(no)
        readonly(yes)
    }
    field(hardwareShift, int16) {
        readonly(yes)
    }
    field(hardwareMask, array(octet[]) {
        readonly(yes)
    }
    view(choice) {
        property(value, value) {
            property(timeStamp, time)
            property(alarmSeverity, alarmSeverity)
            property(alarmStatus, alarmStatus)
        }
    }
    view(raw) {
        property(value, raw) {
            property(timeStamp, time)
        }
    }
}

waveformRecord

waveformRecord.dbd defines the following:

include "menuStructBase.dbd"
record(WaveformRecord) {
    field(common,struct(RecordCommon))
    field(value, array([])) {
        asl(0)
        special(yes)
    }
    field(reArm,bool)
    field(io,link)
    field(units,string)
    field(displayLimit,struct(DisplayLimit))
    field(busy,bool) {
        design(no)
        readonly(yes)
    }
    view(value) {
        property(value, value) {
            property(units, units)
            property(timeStamp, time)
            property(alarmSeverity, alarmSeverity)
            property(alarmStatus, alarmStatus)
            property(displayLimit, displayLimit)
        }
    }
}