V4 DBD Examples - Revision history

MartyKraimer at 19:54, 2 November 2005

2005-11-02T19:54:24Z

← Older revision		Revision as of 19:54, 2 November 2005
Line 1:		Line 1:
	Example Record Types November 01 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 13:		Line 13:
	record(AoRecord) {		record(AoRecord) {
	field(common,struct(RecordCommon))		field(common,struct(RecordCommon))
	field(~~value~~, float64) {		field(desiredValue, float64) {
	asl(0)		asl(0)
	}		}
	field(~~outValue~~, float64) {		field(currentValue, float64) {
	readonly(yes)		readonly(yes)
	}		}
Line 35:		Line 35:
	field(controlLimit, struct(ControlLimit))		field(controlLimit, struct(ControlLimit))
	field(alarmLimit, struct(AlarmLimit))		field(alarmLimit, struct(AlarmLimit))
	~~field(alarmDeadband, float64)~~
	field(rawValue, int32) {		field(rawValue, int32) {
	design(no)		design(no)
Line 43:		Line 42:
	readonly(yes)		readonly(yes)
	}		}
	field(~~init~~, ~~bool) {~~		field(simulation,struct(SimulationFloat64))
	~~design~~(~~no)~~
	~~readonly(yes)~~
	}
	~~field(simOutputLink,link)~~

	~~field(simModeLink,link)~~
	~~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 105:		Line 92:
	record(CalcRecord){		record(CalcRecord){
	field(common,struct(RecordCommon))		field(common,struct(RecordCommon))
	field(~~result~~,float64) {		field(value,float64) {
	asl(0)		asl(0)
	}		}
Line 115:		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) {

MartyKraimer at 20:25, 1 November 2005

2005-11-01T20:25:03Z

← Older revision		Revision as of 20:25, 1 November 2005
Line 1:		Line 1:
	Example Record Types ~~Sept 28~~ 2005		Example Record Types November 01 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(common,struct(RecordCommon))
	field(value, float64) {		field(value, float64) {
	asl(0)		asl(0)
Line 18:		Line 19:
	readonly(yes)		readonly(yes)
	}		}
	field(out,		field(out,link)
	link~~(out,interface( LinkInt64, LinkFloat64))~~
	)
	field(outputRateOfChange, float64)		field(outputRateOfChange, float64)
	field(desiredOutputLink,		field(desiredOutputLink,link)
	link~~(in,interface(LinkFloat64))~~
	)
	field(closedLoop, bool)		field(closedLoop, bool)
	field(outputIncremental, bool)		field(outputIncremental, bool)
Line 33:		Line 30:
	special(yes)		special(yes)
	}		}
			field(convertTable,string);
	field(units, string)		field(units, string)
	field(displayLimit, struct(DisplayLimit))		field(displayLimit, struct(DisplayLimit))
Line 38:		Line 36:
	field(alarmLimit, struct(AlarmLimit))		field(alarmLimit, struct(AlarmLimit))
	field(alarmDeadband, float64)		field(alarmDeadband, float64)
	field(rawValue, ~~int64~~) {		field(rawValue, int32) {
	design(no)		design(no)
	}		}
	~~field(prevRawValue, int64) {~~		field(readBackValue, int32) {
	~~design(no)~~
	~~readonly(yes)~~
	}
	field(readBackValue, ~~int64~~) {
	design(no)		design(no)
	readonly(yes)		readonly(yes)
Line 53:		Line 47:
	readonly(yes)		readonly(yes)
	}		}
	field(simOutputLink,		field(simOutputLink,link)
	link~~(out,interface(LinkFloat64))~~
	)

	field(simModeLink,		field(simModeLink,link)
	link~~(in,interface(LinkBoolean))~~
	)
	field(simMode, bool)		field(simMode, bool)
	field(simSevr, menu(menuAlarmSevr))		field(simSevr, menu(menuAlarmSevr))
Line 106:		Line 96:
	calcRecord.dbd defines the following:		calcRecord.dbd defines the following:

	include "~~dbCommon~~.dbd"		include "menuStructBase.dbd"
	struct(CalcInpLink) {		struct(CalcInpLink) {
	field(link,link~~(in,interface(LinkFloat64)~~)		field(block,boolean)
			field(link,link)
	field(value,float64)		field(value,float64)
	}		}

	record(CalcRecord) ~~extends~~ RecordCommon {		record(CalcRecord){
			field(common,struct(RecordCommon))
	field(result,float64) {		field(result,float64) {
	asl(0)		asl(0)
Line 151:		Line 143:
	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 157:		Line 149:
	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 170:		Line 163:
	field(unknownStateSeverity, menu(menuAlarmSevr))		field(unknownStateSeverity, menu(menuAlarmSevr))
	field(changeStateSeverity, menu(menuAlarmSevr))		field(changeStateSeverity, menu(menuAlarmSevr))
	field(inp, link~~(in,interface(LinkOctetArray,AsynDigital)~~)		field(inp, link)
	field(rawValue, array(octet[])) {		field(rawValue, array(octet[])) {
	design(no)		design(no)
Line 201:		Line 194:
	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 208:		Line 202:
	}		}
	field(reArm,bool)		field(reArm,bool)
	field(io,		field(io,link)
	link~~(inout,interface(~~
	~~"LinkArrayOctet",~~
	~~"LinkArrayBoolean",~~
	~~"LinkArrayInt16",~~
	~~"LinkArrayInt32",~~
	~~"LinkArrayInt64",~~
	~~"LinkArrayFloat32",~~
	~~"LinkArrayFloat64",~~
	~~"LinkArrayString",~~
	~~} ))~~
	)
	field(units,string)		field(units,string)
	field(displayLimit,struct(DisplayLimit))		field(displayLimit,struct(DisplayLimit))

MartyKraimer at 19:30, 28 September 2005

2005-09-28T19:30:45Z

← Older revision		Revision as of 19:30, 28 September 2005
Line 1:		Line 1:
	Example Record Types Sept 27 2005		Example Record Types Sept 28 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 19:		Line 19:
	}		}
	field(out,		field(out,
	link(out,~~array~~(~~string[3]) = {~~		link(out,interface( LinkInt64, LinkFloat64))
	~~"outputLinkInt64"~~,
	~~"outputLinkFloat64",~~
	~~"asynInt32",~~
	~~"asynFloat64"~~
	} ))
	)		)
	field(outputRateOfChange, float64)		field(outputRateOfChange, float64)
	field(desiredOutputLink,		field(desiredOutputLink,
	link(in,~~array~~(~~string[2]) = {~~		link(in,interface(LinkFloat64))
	~~"monitorLinkFloat64",~~
	~~"inputLinkFloat64"~~
	} ))
	)		)
	field(closedLoop, bool)		field(closedLoop, bool)
Line 62:		Line 54:
	}		}
	field(simOutputLink,		field(simOutputLink,
	link(out,~~array~~(~~string[2]) = {~~		link(out,interface(LinkFloat64))
	~~"outputLinkInt64",~~
	~~"outputLinkFloat64",~~
	} ))
	)		)

	field(simModeLink,		field(simModeLink,
	link(in,~~array~~(~~string[2]) = {~~		link(in,interface(LinkBoolean))
	~~"monitorLinkString",~~
	~~"inputLinkString"~~
	} ))
	)		)
	field(simMode, bool)		field(simMode, bool)
Line 122:		Line 108:
	include "dbCommon.dbd"		include "dbCommon.dbd"
	struct(CalcInpLink) {		struct(CalcInpLink) {
	field(link,~~link(in))~~		field(link,link(in,interface(LinkFloat64))
	link(in,~~array~~(~~string[2]) = {~~
	~~"monitorLinkFloat64",~~
	~~"inputLinkFloat64"~~
	~~} )~~)
	)
	field(value,float64)		field(value,float64)
	}		}
Line 189:		Line 170:
	field(unknownStateSeverity, menu(menuAlarmSevr))		field(unknownStateSeverity, menu(menuAlarmSevr))
	field(changeStateSeverity, menu(menuAlarmSevr))		field(changeStateSeverity, menu(menuAlarmSevr))
	field(inp,		field(inp, link(in,interface(LinkOctetArray,AsynDigital))
	link(in,~~array~~(~~string[3]) = {~~
	~~"inputLinkOctet"~~,
	~~"asynDigital",~~
	~~} )~~)
	)
	field(rawValue, array(octet[])) {		field(rawValue, array(octet[])) {
	design(no)		design(no)
Line 233:		Line 209:
	field(reArm,bool)		field(reArm,bool)
	field(io,		field(io,
	link(inout,~~array~~(~~string[4]) = {~~		link(inout,interface(
	"~~monitorLinkArrayOctet~~",		"LinkArrayOctet",
	"~~monitorLinkArrayBoolean~~",		"LinkArrayBoolean",
	"~~monitorLinkArrayInt16~~",		"LinkArrayInt16",
	"~~monitorLinkArrayInt32~~",		"LinkArrayInt32",
	"~~monitorLinkArrayInt64~~",		"LinkArrayInt64",
	"~~monitorLinkArrayFloat32~~",		"LinkArrayFloat32",
	"~~monitorLinkArrayFloat64~~",		"LinkArrayFloat64",
	"~~monitorLinkArrayString~~",		"LinkArrayString",
	~~"inputLinkArrayOctet",~~
	~~"inputLinkArrayBoolean",~~
	~~"inputLinkArrayInt16",~~
	~~... all input and link types~~
	} ))		} ))
	)		)

MartyKraimer at 15:23, 27 September 2005

2005-09-27T15:23:02Z

← Older revision		Revision as of 15:23, 27 September 2005
Line 1:		Line 1:
	Example Record Types Sept 22 2005		Example Record Types Sept 27 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 18:		Line 18:
	readonly(yes)		readonly(yes)
	}		}
	field(out, ~~device~~(out,~~analogOut~~))		field(out,
			link(out,array(string[3]) = {
			"outputLinkInt64",
			"outputLinkFloat64",
			"asynInt32",
			"asynFloat64"
			} ))
			)
	field(outputRateOfChange, float64)		field(outputRateOfChange, float64)
	field(desiredOutputLink, link(in))		field(desiredOutputLink,
			link(in,array(string[2]) = {
			"monitorLinkFloat64",
			"inputLinkFloat64"
			} ))
			)
	field(closedLoop, bool)		field(closedLoop, bool)
	field(outputIncremental, bool)		field(outputIncremental, bool)
Line 49:		Line 61:
	readonly(yes)		readonly(yes)
	}		}
	field(simOutputLink, link(out))		field(simOutputLink,
	field(simModeLink, link(in))		link(out,array(string[2]) = {
			"outputLinkInt64",
			"outputLinkFloat64",
			} ))
			)

			field(simModeLink,
			link(in,array(string[2]) = {
			"monitorLinkString",
			"inputLinkString"
			} ))
			)
	field(simMode, bool)		field(simMode, bool)
	field(simSevr, menu(menuAlarmSevr))		field(simSevr, menu(menuAlarmSevr))
Line 89:		Line 112:
	}		}
	}		}
	}		}


	<center>		<center>
Line 101:		Line 123:
	struct(CalcInpLink) {		struct(CalcInpLink) {
	field(link,link(in))		field(link,link(in))
			link(in,array(string[2]) = {
			"monitorLinkFloat64",
			"inputLinkFloat64"
			} ))
			)
	field(value,float64)		field(value,float64)
	}		}

	record(CalcRecord) extends RecordCommon {		record(CalcRecord) extends RecordCommon {
	field(result,float64) {		field(result,float64) {
Line 161:		Line 189:
	field(unknownStateSeverity, menu(menuAlarmSevr))		field(unknownStateSeverity, menu(menuAlarmSevr))
	field(changeStateSeverity, menu(menuAlarmSevr))		field(changeStateSeverity, menu(menuAlarmSevr))
	field(inp, ~~device~~(in, ~~digitalInput~~))		field(inp,
			link(in,array(string[3]) = {
			"inputLinkOctet",
			"asynDigital",
			} ))
			)
	field(rawValue, array(octet[])) {		field(rawValue, array(octet[])) {
	design(no)		design(no)
Line 172:		Line 205:
	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 204:		Line 232:
	}		}
	field(reArm,bool)		field(reArm,bool)
	field(~~inp~~,~~device~~(in,~~waveformIO~~))		field(io,
			link(inout,array(string[4]) = {
			"monitorLinkArrayOctet",
			"monitorLinkArrayBoolean",
			"monitorLinkArrayInt16",
			"monitorLinkArrayInt32",
			"monitorLinkArrayInt64",
			"monitorLinkArrayFloat32",
			"monitorLinkArrayFloat64",
			"monitorLinkArrayString",
			"inputLinkArrayOctet",
			"inputLinkArrayBoolean",
			"inputLinkArrayInt16",
			... all input and link types
			} ))
			)
	field(units,string)		field(units,string)
	field(displayLimit,struct(DisplayLimit))		field(displayLimit,struct(DisplayLimit))
Line 211:		Line 254:
	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) {

MartyKraimer at 13:11, 22 September 2005

2005-09-22T13:11:51Z

← Older revision		Revision as of 13:11, 22 September 2005
Line 1:		Line 1:
	Example Record Types Sept 16 2005		Example Record Types Sept 22 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 11:		Line 11:

	include "dbCommon.dbd"		include "dbCommon.dbd"
	record(ao) extends RecordCommon {		record(AoRecord) extends RecordCommon {
	field(value, float64) {		field(value, float64) {
	asl(0)		asl(0)
Line 26:		Line 26:
	special(yes)		special(yes)
	}		}
	field(linearConvert, struct(~~linearConvert~~)) {		field(linearConvert, struct(LinearConvert)) {
	special(yes)		special(yes)
	}		}
	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(alarmDeadband, float64)
	field(rawValue, ~~int32~~) {		field(rawValue, int64) {
	design(no)		design(no)
	}		}
	field(prevRawValue, ~~int32~~) {		field(prevRawValue, int64) {
	design(no)		design(no)
	readonly(yes)		readonly(yes)
	}		}
	field(readBackValue, ~~int32~~) {		field(readBackValue, int64) {
	design(no)		design(no)
	readonly(yes)		readonly(yes)
Line 99:		Line 99:

	include "dbCommon.dbd"		include "dbCommon.dbd"
	struct(~~calcInpLink~~) {		struct(CalcInpLink) {
	field(link,link(in))		field(link,link(in))
	field(value,float64)		field(value,float64)
	}		}
	record(~~calc~~) extends RecordCommon {		record(CalcRecord) extends RecordCommon {
	field(result,float64) {		field(result,float64) {
	asl(0)		asl(0)
Line 110:		Line 110:
	special(yes)		special(yes)
	}		}
	field(~~inp~~,array(struct(~~calcInpLink~~)[]))		field(input,array(struct(CalcInpLink)[]))
	field(units,string)		field(units,string)
	field(displayLimit,struct(~~displayLimit~~))		field(displayLimit,struct(DisplayLimit))
	field(alarmLimit,struct(~~alarmLimit~~))		field(alarmLimit,struct(AlarmLimit))
	field(alarmDeadband,float64)		field(alarmDeadband,float64)
	field(lastValueAlarmed,float64) {		field(lastValueAlarmed,float64) {
Line 143:		Line 143:

	include "dbCommon.dbd"		include "dbCommon.dbd"
	struct(~~mbbiState~~) {		struct(MbbiState) {
	field(name, string)		field(name, string)
	field(value, array(octet[]))		field(value, array(octet[]))
	field(severity, menu(menuAlarmSevr))		field(severity, menu(menuAlarmSevr))
	}		}
	record(~~mbbi~~) extends RecordCommon {		record(MbbiRecord) extends RecordCommon {
	field(~~states~~, array(struct(~~mbbiState~~)[])) {		field(state, array(struct(MbbiState)[])) {
	special(yes)		special(yes)
	}		}
	field(value, enum(~~states~~)) {		#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)		asl(0)
	}		}
Line 194:		Line 198:

	include "dbCommon.dbd"		include "dbCommon.dbd"
	record(~~waveform~~) extends RecordCommon {		record(WaveformRecord) extends RecordCommon {
	field(value, array([])) {		field(value, array([])) {
	asl(0)		asl(0)
Line 202:		Line 206:
	field(inp,device(in,waveformIO))		field(inp,device(in,waveformIO))
	field(units,string)		field(units,string)
	field(displayLimit,struct(~~displayLimit~~))		field(displayLimit,struct(DisplayLimit))
	field(busy,bool) {		field(busy,bool) {
	design(no)		design(no)

MartyKraimer at 15:27, 16 September 2005

2005-09-16T15:27:26Z

Show changes

AndrewJohnson: /* mbbiRecord */

2005-05-26T22:32:28Z

mbbiRecord

← Older revision		Revision as of 22:32, 26 May 2005
Line 166:		Line 166:

	include "dbCommon.dbd"		include "dbCommon.dbd"
			struct(mbbiState) {
			field(severity, menu(menuAlarmSevr))
			field(rawValue, uint64)
			field(value, int16) {
			design(no)
			readonly(yes)
			}
			}
	record(mbbi) extends iocRecord {		record(mbbi) extends iocRecord {
	field(value,enum(~~stateNames~~)) {		field(states, map(struct(mbbiState))) {
			special(yes)
			}
			field(value, enum(states)) {
	asl(0)		asl(0)
	dynamic(yes)		dynamic(yes)
	}		}
	field(~~stateNames, array(string[]))~~		field(unknownStateSeverity, menu(menuAlarmSevr))
	~~field(stateSeverities~~,~~array(~~menu(menuAlarmSevr~~)[]~~))		field(changeStateSeverity, menu(menuAlarmSevr))
	field(~~unknownStateSeverity~~,menu(menuAlarmSevr))		field(inp, device(in, digitalInput))
	field(~~changeStateSeverity~~,~~menu~~(~~menuAlarmSevr~~))		field(rawValue, uint64) {
	field(~~mask~~,~~array(uint32[])~~) {		design(no)
	~~special(yes)~~
	}
	~~field~~(~~nbits,int16~~) {
	readonly(yes)		readonly(yes)
			dynamic(yes)
	}		}
	field(~~inp~~,~~device(in,digitalInput))~~		field(oldRawValue, uint64) {
	~~field(raw,uint32~~) {
	design(no)		design(no)
	readonly(yes)		readonly(yes)
	dynamic(yes)		dynamic(yes)
	}		}
	field(~~oldRaw~~,~~uint32~~) {		field(hardwareShift, uint16) {
	~~design(no)~~
	readonly(yes)		readonly(yes)
	~~dynamic(yes)~~
	}		}
	field(hardwareMask,uint64 {		field(hardwareMask, uint64 {
	readonly(yes)		readonly(yes)
	}		}
	field(lastValueAlarmed,int16) {		field(lastValueAlarmed, int16) {
	design(no)		design(no)
	readonly(yes)		readonly(yes)
	dynamic(yes)		dynamic(yes)
	}		}
	~~field(shift,uint16) {~~		field(simInputLink, link(in))
	field(simInputLink,link(in))		field(simValue, uint64) {
	field(simValue,uint64)		dynamic(yes)
	field(simModeLink,link(in))		}
	field(simMode,menu(menuYesNo)) {		field(simModeLink, link(in))
			field(simMode, menu(menuYesNo)) {
	dynamic(yes)		dynamic(yes)
	}		}
	field(simSevr,menu(menuAlarmSevr))		field(simSevr, menu(menuAlarmSevr))
	view(choice) {		view(choice) {
	property(value, value) {		property(value, value) {
Line 221:		Line 228:
	}		}
	}		}


	== waveformRecord ==		== waveformRecord ==

AndrewJohnson at 20:20, 17 May 2005

2005-05-17T20:20:40Z

New page

= Example Record Types =

== aoRecord ==

aoRecord.dbd might be defined as follows:

include "dbCommon.dbd"
record(ao) extends iocRecord {
field(value, float64) {
asl(0)
dynamic(yes)
}
field(outValue, float64) {
readonly(yes)
dynamic(yes)
}
field(out, device(out,analogOut))
field(outputRateOfChange, float64)
field(desiredOutputLink, link(in))
field(closedLoop, bool)
field(outputIncremental, bool)
field(convert, menu(menuConvert)) {
special(yes)
}
field(linearConvert, struct(linearConvert)) {
special(yes)
}
field(units, string)
field(displayLimit, struct(displayLimitF64))
field(controlLimit, struct(controlLimitF64))
field(alarmLimit, struct(alarmLimitF64))
field(alarmDeadband, float64)
field(rawValue, int32) {
design(no)
dynamic(yes)
}
field(prevRawValue, int32) {
design(no)
readonly(yes)
dynamic(yes)
}
field(readBackValue, int32) {
design(no)
readonly(yes)
dynamic(yes)
}
field(oldReadBackValue, int32) {
design(no)
readonly(yes)
dynamic(yes)
}
field(prevValue, float64) {
design(no)
readonly(yes)
dynamic(yes)
}
field(lastValueAlarmed, float64) {
design(no)
readonly(yes)
dynamic(yes)
}
field(pbrk, private("void *"))
field(init, bool) {
design(no)
readonly(yes)
}
field(lbrk, int16) {
design(no)
readonly(yes)
dynamic(yes)
}
field(simOutputLink, link(out))
field(simModeLink, link(in))
field(simMode, bool) {
dynamic(yes)
}
field(simSevr, menu(menuAlarmSevr))
field(invalidAction, menu(menuIvoa))
field(invalidValue, float64)
field(outValueModified, 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)
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 "dbCommon.dbd"
struct(calcInpLink) {
field(link,link(in))
field(value,float64)
}
record(calc) extends iocRecord {
field(result,float64) {
asl(0)
dynamic(yes)
}
field(calc,string) {
special(yes)
}
field(inp,array(struct(calcInpLink)[])) {
dynamic(yes)
}
field(units,string)
field(displayLimit,struct(displayLimitF64))
field(alarmLimit,struct(alarmLimitF64))
field(alarmDeadband,float64)
field(lastValueAlarmed,float64) {
design(no)
readonly(yes)
dynamic(yes)
}
field(rpcl,private("char *"))
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 "dbCommon.dbd"
record(mbbi) extends iocRecord {
field(value,enum(stateNames)) {
asl(0)
dynamic(yes)
}
field(stateNames, array(string[]))
field(stateSeverities,array(menu(menuAlarmSevr)[]))
field(unknownStateSeverity,menu(menuAlarmSevr))
field(changeStateSeverity,menu(menuAlarmSevr))
field(mask,array(uint32[])) {
special(yes)
}
field(nbits,int16) {
readonly(yes)
}
field(inp,device(in,digitalInput))
field(raw,uint32) {
design(no)
readonly(yes)
dynamic(yes)
}
field(oldRaw,uint32) {
design(no)
readonly(yes)
dynamic(yes)
}
field(hardwareMask,uint64 {
readonly(yes)
}
field(lastValueAlarmed,int16) {
design(no)
readonly(yes)
dynamic(yes)
}
field(shift,uint16) {
field(simInputLink,link(in))
field(simValue,uint64)
field(simModeLink,link(in))
field(simMode,menu(menuYesNo)) {
dynamic(yes)
}
field(simSevr,menu(menuAlarmSevr))
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 "dbCommon.dbd"
record(waveform) extends iocRecord {
field(value, array([])) {
asl(0)
special(yes)
dynamic(yes)
}
field(reArm,bool)
field(inp,device(in,waveformIO))
field(units,string)
field(displayLimit,struct(displayLimit))
field(busy,bool) {
design(no)
readonly(yes)
}
field(simInputLink,link(in))
field(simModeLink,link(in))
field(simMode,menu(menuYesNo)) {
dynamic(yes)
}
field(simSevr,menu(menuYesNo))
view(value) {
property(value, value) {
property(units, units)
property(timeStamp, time)
property(alarmSeverity, alarmSeverity)
property(alarmStatus, alarmStatus)
property(displayLimit, displayLimit)
}
}
}