1720 lines
48 KiB
Plaintext
1720 lines
48 KiB
Plaintext
# Database for the records specific to the Hamamatsu Orca Flash4.0 cameras
|
|
|
|
include "ADBase.template"
|
|
include "AlarmsOverride.template"
|
|
|
|
# Note: The following are records defined in ADBase.template. #
|
|
# We are changing some of the fields here to reflect valid values for #
|
|
# Hamamatsu Orca Flash4.0 #
|
|
|
|
# Only unsigned 16 and 32 bit integers are supported. Determined by PixelEncoding
|
|
record(mbbo, "$(P)$(R)DataType") {
|
|
field(ZRST, "UInt16")
|
|
field(ZRVL, "3")
|
|
field(ONST, "UInt32")
|
|
field(ONVL, "5")
|
|
field(TWST, "")
|
|
field(TWVL, "")
|
|
field(THST, "")
|
|
field(THVL, "")
|
|
field(FRST, "")
|
|
field(FRVL, "")
|
|
field(FVST, "")
|
|
field(FVVL, "")
|
|
field(SXST, "")
|
|
field(SXVL, "")
|
|
field(SVST, "")
|
|
field(SVVL, "")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)DataType_RBV") {
|
|
field(ZRST, "UInt16")
|
|
field(ZRVL, "3")
|
|
field(ONST, "UInt32")
|
|
field(ONVL, "5")
|
|
field(TWST, "")
|
|
field(TWVL, "")
|
|
field(THST, "")
|
|
field(THVL, "")
|
|
field(FRST, "")
|
|
field(FRVL, "")
|
|
field(FVST, "")
|
|
field(FVVL, "")
|
|
field(SXST, "")
|
|
field(SXVL, "")
|
|
field(SVST, "")
|
|
field(SVVL, "")
|
|
}
|
|
|
|
# Only Mono color mode is supported at this time
|
|
record(mbbo, "$(P)$(R)ColorMode") {
|
|
field(ZRST, "Mono")
|
|
field(ZRVL, "0")
|
|
field(ONST, "")
|
|
field(ONVL, "")
|
|
field(TWST, "")
|
|
field(TWVL, "")
|
|
field(THST, "")
|
|
field(THVL, "")
|
|
field(FRST, "")
|
|
field(FRVL, "")
|
|
field(FVST, "")
|
|
field(FVVL, "")
|
|
field(SXST, "")
|
|
field(SXVL, "")
|
|
field(SVST, "")
|
|
field(SVVL, "")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)ColorMode_RBV") {
|
|
field(ZRST, "Mono")
|
|
field(ZRVL, "0")
|
|
field(ONST, "")
|
|
field(ONVL, "")
|
|
field(TWST, "")
|
|
field(TWVL, "")
|
|
field(THST, "")
|
|
field(THVL, "")
|
|
field(FRST, "")
|
|
field(FRVL, "")
|
|
field(FVST, "")
|
|
field(FVVL, "")
|
|
field(SXST, "")
|
|
field(SXVL, "")
|
|
field(SVST, "")
|
|
field(SVVL, "")
|
|
}
|
|
|
|
record("*", "$(P)$(R)SizeX") {
|
|
field(DRVH, "2048")
|
|
field(DRVL, "4")
|
|
}
|
|
|
|
record("*", "$(P)$(R)SizeY") {
|
|
field(DRVH, "2048")
|
|
field(DRVL, "4")
|
|
}
|
|
|
|
record("*", "$(P)$(R)MinX") {
|
|
field(DRVH, "2044")
|
|
field(DRVL, "0")
|
|
}
|
|
|
|
record("*", "$(P)$(R)MinY") {
|
|
field(DRVH, "2044")
|
|
field(DRVL, "0")
|
|
}
|
|
|
|
record("*", "$(P)$(R)AcquirePeriod_RBV") {
|
|
field(FLNK, "$(P)$(R)#EVRAcquireTime-S.PROC PP MS")
|
|
}
|
|
|
|
record("*", "$(P)$(R)AcquireTime") {
|
|
field(VAL, "0.9")
|
|
}
|
|
|
|
record("*", "$(P)$(R)AcquirePeriod") {
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(calcout, "$(P)$(R)#EVRAcquireTime-S") {
|
|
field(DESC, "Set EVR acquire time in seconds")
|
|
field(CALC, "A=0?B:A*B")
|
|
field(INPA, "$(P)$(R)AcquirePeriod_RBV")
|
|
field(INPB, "88052500")
|
|
field(OUT, "$(EVR):PS1Div-SP PP")
|
|
}
|
|
|
|
record(stringin, "$(P)$(R)#EVRTimeProc") {
|
|
field(DESC, "Start proce the EVRTime record")
|
|
field(DTYP, "Soft Timestamp")
|
|
field(SDIS, "$(EVR):Evt$(E)Cnt-I CP MS")
|
|
field(DISV, "-1")
|
|
field(TSEL, "$(EVR):Evt$(E)Cnt-I.TIME")
|
|
field(INP, "@%s.%f")
|
|
field(FLNK, "$(P)$(R)EVRTime-R.PROC PP MS")
|
|
}
|
|
|
|
# holds TS value in 'sec.nsec' format
|
|
record(stringout, "$(P)$(R)EVRTime-R") {
|
|
field(DESC, "EPICS epoch EVRTime timestamp")
|
|
field(DOL, "$(P)$(R)#EVRTimeProc MS")
|
|
field(OMSL, "closed_loop")
|
|
field(DTYP, "asynOctetWrite")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))EVR_TIMESTAMP")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)FrameRate-R") {
|
|
field(DESC, "Acquisition frame rate")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_FRAMERATE")
|
|
field(PREC, "2")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(seq, "$(P)$(R)#SoftSeqDisable") {
|
|
field(SELM, "All")
|
|
# Disable sequencer 0
|
|
field(DOL1, "1")
|
|
field(LNK1, "$(EVR):SoftSeq0Disable-Cmd CP")
|
|
}
|
|
|
|
record(seq, "$(P)$(R)#SoftSeqEnable") {
|
|
field(SELM, "All")
|
|
# reset prescaler
|
|
field(DOL1, "123")
|
|
field(LNK1, "$(EVR):EvtResetPS-SP PP")
|
|
field(DOL2, "123")
|
|
field(LNK2, "$(EVR):EvtCode-SP PP")
|
|
# Enable sequencer 0
|
|
field(LNK3, "$(EVR):SoftSeq0Enable-Cmd.PROC PP")
|
|
}
|
|
|
|
record(longin, "$(P)$(R)#AcquireCtrl") {
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_ACQ_CONTROL")
|
|
field(FLNK, "$(P)$(R)#SeqAcquire PP MS")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(seq, "$(P)$(R)#SeqAcquire") {
|
|
field(SELM, "All")
|
|
# Save current number of cycles
|
|
field(DOL1, "$(P)$(R)Cycle-Cnt")
|
|
field(LNK1, "$(P)$(R)#NCyclesPartial PP")
|
|
# Process CalcSoftSeqCtrl
|
|
field(DOL2, "1")
|
|
field(LNK2, "$(P)$(R)#CalcSoftSeqCtrl.PROC PP")
|
|
}
|
|
|
|
record(calcout, "$(P)$(R)#CalcSoftSeqCtrl") {
|
|
field(DESC, "Calc software sequencer control")
|
|
field(CALC, "(A = 1 && B = 1) ? 1 : 0")
|
|
field(INPA, "$(P)$(R)Acquire")
|
|
field(INPB, "$(P)$(R)TriggerSource-RB")
|
|
field(OOPT, "Transition To Non-zero")
|
|
field(OUT, "$(P)$(R)#SoftSeqEnable PP")
|
|
}
|
|
|
|
record(longin, "$(P)$(R)Cycle-Cnt") {
|
|
field(DESC, "Cycle Counter")
|
|
field(SCAN, "Passive")
|
|
field(INP, "$(EVR):SoftSeq-0-NumOfStarts-I CPP")
|
|
}
|
|
|
|
# Acts as a variable to store num. cycles before burst
|
|
record(ai, "$(P)$(R)#NCyclesPartial") {
|
|
field(DESC, "Num. cycles before burst")
|
|
field(DTYP, "Soft Channel")
|
|
field(SCAN, "Passive")
|
|
}
|
|
|
|
## Stop sequence after N cycles
|
|
record(calcout, "$(P)$(R)#StopAfterCycles") {
|
|
field(DESC, "StopAfterCycles")
|
|
field(CALC, "(C < (A + B)) || (D=2)")
|
|
field(INPA, "$(P)$(R)#NCyclesPartial NPP")
|
|
field(INPB, "$(P)$(R)NumImages_RBV NPP")
|
|
field(INPC, "$(P)$(R)Cycle-Cnt CPP")
|
|
field(INPD, "$(P)$(R)ImageMode_RBV NPP")
|
|
field(OOPT, "When Zero")
|
|
field(OUT, "$(P)$(R)#SoftSeqDisable PP")
|
|
}
|
|
|
|
record(calcout, "$(P)$(R)#StopAfterAcq0") {
|
|
field(DESC, "Stop seq when acquire 0")
|
|
field(CALC, "A = 0")
|
|
field(INPA, "$(P)$(R)Acquire CPP")
|
|
field(OOPT, "When Non-zero")
|
|
field(OUT, "$(P)$(R)#SoftSeqDisable PP")
|
|
}
|
|
|
|
record(longin, "$(P)$(R)#Cycle-Cnt") {
|
|
field(DESC, "Cycle Counter")
|
|
field(SCAN, "Passive")
|
|
field(INP, "$(EVR):SoftSeq0NumOfStarts-I CPP")
|
|
field(FLNK, "$(P)$(R)#CountSeq")
|
|
}
|
|
|
|
record(seq, "$(P)$(R)#CountSeq") {
|
|
field(SELM, "All")
|
|
field(DOL1, "$(P)$(R)#Cycle-Cnt")
|
|
field(LNK1, "$(P)$(R)#EVRCounts PP")
|
|
}
|
|
|
|
record(ao, "$(P)$(R)#EVRCounts") {
|
|
field(DTYP, "asynInt32")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))EVR_COUNTS")
|
|
}
|
|
|
|
record(longin, "$(P)$(R)#TriggerSinceStart") {
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))EVR_TRIGGERS_SINCE_ACQ_START")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(longin, "$(P)$(R)TriggerDropped-RB") {
|
|
field(DESC, "Counter with EVR trigger dropped")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))EVR_TRIGGER_DROPPED")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(stringin, "$(P)$(R)Vendor-RB"){
|
|
field(DESC, "Vendor name")
|
|
field(DTYP, "asynOctetRead")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_VENDOR")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(stringin, "$(P)$(R)Model-RB"){
|
|
field(DESC, "Model version")
|
|
field(DTYP, "asynOctetRead")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MODEL")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(stringin, "$(P)$(R)CameraID-RB"){
|
|
field(DESC, "Camera serial number")
|
|
field(DTYP, "asynOctetRead")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_CAMERAID")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(stringin, "$(P)$(R)Bus-RB"){
|
|
field(DESC, "Bus info")
|
|
field(DTYP, "asynOctetRead")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BUS")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(stringin, "$(P)$(R)CameraVersion-RB"){
|
|
field(DESC, "Camera version")
|
|
field(DTYP, "asynOctetRead")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_CAMERA_VERSION")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(stringin, "$(P)$(R)DriverVersion-RB"){
|
|
field(DESC, "Driver version")
|
|
field(DTYP, "asynOctetRead")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_DRIVER_VERSION")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(stringin, "$(P)$(R)ModuleVersion-RB"){
|
|
field(DESC, "Camera module version")
|
|
field(DTYP, "asynOctetRead")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MODULE_VERSION")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(stringin, "$(P)$(R)DcamApiVersion-RB"){
|
|
field(DESC, "API version")
|
|
field(DTYP, "asynOctetRead")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_DCAM_API_VERSION")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)SensorMode-S") {
|
|
field(DESC, "Sensor mode")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Area")
|
|
field(ONVL, "12")
|
|
field(ONST, "Progressive")
|
|
field(TWVL, "14")
|
|
field(TWST, "Splitview")
|
|
field(THVL, "16")
|
|
field(THST, "Duallightsheet")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_MODE")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)SensorMode-RB") {
|
|
field(DESC, "Sensor mode")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Area")
|
|
field(ONVL, "12")
|
|
field(ONST, "Progressive")
|
|
field(TWVL, "14")
|
|
field(TWST, "Splitview")
|
|
field(THVL, "16")
|
|
field(THST, "Duallightsheet")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_MODE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)ReadoutSpeed-S") {
|
|
field(DESC, "Readout speed")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "1")
|
|
field(ONVL, "2")
|
|
field(ONST, "2")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_READOUT_SPEED")
|
|
field(VAL, "2")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)ReadoutSpeed-RB") {
|
|
field(DESC, "Readout speed")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "1")
|
|
field(ONVL, "2")
|
|
field(ONST, "2")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_READOUT_SPEED")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)ReadoutDirection-S") {
|
|
field(DESC, "Readout direction")
|
|
field(PINI, "YES")
|
|
field(ZRVL, "5")
|
|
field(ZRST, "Diverge")
|
|
field(ONVL, "1")
|
|
field(ONST, "Forward")
|
|
field(TWVL, "2")
|
|
field(TWST, "Backward")
|
|
field(DTYP, "asynInt32")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_READOUT_DIRECTION")
|
|
field(VAL, "5")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)ReadoutDirection-RB") {
|
|
field(DESC, "Readout direction")
|
|
field(ZRVL, "5")
|
|
field(ZRST, "Diverge")
|
|
field(ONVL, "1")
|
|
field(ONST, "Forward")
|
|
field(TWVL, "2")
|
|
field(TWST, "Backward")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_READOUT_DIRECTION")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)TriggerSource-S") {
|
|
field(DESC, "Trigger source")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Internal")
|
|
field(ONVL, "2")
|
|
field(ONST, "External")
|
|
field(TWVL, "3")
|
|
field(TWST, "Software")
|
|
field(THVL, "4")
|
|
field(THST, "Master pulse")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_SOURCE")
|
|
field(VAL, "1")
|
|
field(FLNK, "$(P)$(R)AcquirePeriod.PROC PP MS")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)TriggerSource-RB") {
|
|
field(DESC, "Trigger source")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Internal")
|
|
field(ONVL, "2")
|
|
field(ONST, "External")
|
|
field(TWVL, "3")
|
|
field(TWST, "Software")
|
|
field(THVL, "4")
|
|
field(THST, "Master pulse")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_SOURCE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)TriggerMode-S") {
|
|
field(DESC, "Trigger mode")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Normal")
|
|
field(ONVL, "6")
|
|
field(ONST, "Start")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_MODE")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)TriggerMode-RB") {
|
|
field(DESC, "Trigger mode")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Normal")
|
|
field(ONVL, "6")
|
|
field(ONST, "Start")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_MODE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)TriggerActive-S") {
|
|
field(DESC, "Trigger active")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Edge")
|
|
field(ONVL, "2")
|
|
field(ONST, "Level")
|
|
field(TWVL, "3")
|
|
field(TWST, "Sync Readout")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_ACTIVE")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)TriggerActive-RB") {
|
|
field(DESC, "Trigger active")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Edge")
|
|
field(ONVL, "2")
|
|
field(ONST, "Level")
|
|
field(TWVL, "3")
|
|
field(TWST, "Sync Readout")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_ACTIVE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)TriggerGlobalExposure-S") {
|
|
field(DESC, "Trigger global exposure")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "3")
|
|
field(ZRST, "Delayed")
|
|
field(ONVL, "5")
|
|
field(ONST, "Global Reset")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_GLOBAL_EXPOSURE")
|
|
field(VAL, "3")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)TriggerGlobalExposure-RB") {
|
|
field(DESC, "Trigger global exposure")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "3")
|
|
field(ZRST, "Delayed")
|
|
field(ONVL, "5")
|
|
field(ONST, "Global Reset")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_GLOBAL_EXPOSURE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)TriggerPolarity-S") {
|
|
field(DESC, "Trigger polarity")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Negative")
|
|
field(ONVL, "2")
|
|
field(ONST, "Positive")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_POLARITY")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)TriggerPolarity-RB") {
|
|
field(DESC, "Trigger polarity")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Negative")
|
|
field(ONVL, "2")
|
|
field(ONST, "Positive")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_POLARITY")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)TriggerConnector-S") {
|
|
field(DESC, "Trigger connector")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Interface")
|
|
field(ONVL, "2")
|
|
field(ONST, "BNC")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_CONNECTOR")
|
|
field(VAL, "2")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)TriggerConnector-RB") {
|
|
field(DESC, "Trigger connector")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Interface")
|
|
field(ONVL, "2")
|
|
field(ONST, "BNC")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_CONNECTOR")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ao, "$(P)$(R)TriggerTimes-S") {
|
|
field(DESC, "Trigger times")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(DRVL, "1")
|
|
field(DRVH, "10000")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_TIMES")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)TriggerTimes-RB") {
|
|
field(DESC, "Trigger times")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_TIMES")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ao, "$(P)$(R)TriggerDelay-S") {
|
|
field(DESC, "Trigger delay")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynFloat64")
|
|
field(DRVL, "0")
|
|
field(DRVH, "10.0")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_DELAY")
|
|
field(VAL, "0")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)TriggerDelay-RB") {
|
|
field(DESC, "Trigger delay")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_DELAY")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)InternalTriggerHandling-S") {
|
|
field(DESC, "Internal trigger handling")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Short Exposure")
|
|
field(ONVL, "7")
|
|
field(ONST, "Individual")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_TRIGGER_HANDLING")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)InternalTriggerHandling-RB") {
|
|
field(DESC, "Internal trigger handling")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Short Exposure")
|
|
field(ONVL, "7")
|
|
field(ONST, "Individual")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_TRIGGER_HANDLING")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)Temperature-R") {
|
|
field(DESC, "Current temperature")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_TEMPERATURE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)CoolerStatus-R") {
|
|
field(DESC, "Sensor cooler status")
|
|
field(ZRVL, "0")
|
|
field(ZRST, "Off")
|
|
field(ONVL, "1")
|
|
field(ONST, "Ready")
|
|
field(TWVL, "2")
|
|
field(TWST, "Busy")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_COOLER_STATUS")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)Binning-S") {
|
|
field(DESC, "Binning")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "1x1")
|
|
field(ONVL, "2")
|
|
field(ONST, "2x2")
|
|
field(TWVL, "4")
|
|
field(TWST, "4x4")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BINNING")
|
|
field(VAL, "0")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)Binning-RB") {
|
|
field(DESC, "Binning")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "1x1")
|
|
field(ONVL, "2")
|
|
field(ONST, "2x2")
|
|
field(TWVL, "4")
|
|
field(TWST, "4x4")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BINNING")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)SubarrayMode-S") {
|
|
field(DESC, "Sub array mode")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Off")
|
|
field(ONVL, "2")
|
|
field(ONST, "On")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SUBARRAY_MODE")
|
|
field(VAL, "0")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)SubarrayMode-RB") {
|
|
field(DESC, "Sub array mode")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Off")
|
|
field(ONVL, "2")
|
|
field(ONST, "On")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SUBARRAY_MODE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)DefectCorrectMode-S") {
|
|
field(DESC, "Defect correct mode")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Off")
|
|
field(ONVL, "2")
|
|
field(ONST, "On")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_DEFECTCORRECT_MODE")
|
|
field(VAL, "2")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)DefectCorrectMode-RB") {
|
|
field(DESC, "Defect correct mode")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Off")
|
|
field(ONVL, "2")
|
|
field(ONST, "On")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_DEFECTCORRECT_MODE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)HotPixelCorrectLevel-S") {
|
|
field(DESC, "Hot pixel correct level")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Standard")
|
|
field(ONVL, "2")
|
|
field(ONST, "Minimum")
|
|
field(TWVL, "3")
|
|
field(TWST, "Aggressive")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_HOT_PIXEL_CORRECT_LEVEL")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)HotPixelCorrectLevel-RB") {
|
|
field(DESC, "Hot pixel correct level")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Standard")
|
|
field(ONVL, "2")
|
|
field(ONST, "Minimum")
|
|
field(TWVL, "3")
|
|
field(TWST, "Aggressive")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_HOT_PIXEL_CORRECT_LEVEL")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)IntensityLutMode-S") {
|
|
field(DESC, "Intensity LUT")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Through")
|
|
field(ONVL, "2")
|
|
field(ONST, "Page")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTENSITY_LUT_MODE")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)IntensityLutMode-RB") {
|
|
field(DESC, "Intensity LUT")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Through")
|
|
field(ONVL, "2")
|
|
field(ONST, "Page")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTENSITY_LUT_MODE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)IntensityLutPage-RB") {
|
|
field(DESC, "Intensity LUT Page")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTENSITY_LUT_PAGE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)ExtractionMode-RB") {
|
|
field(DESC, "Extraction mode")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_EXTRACTION_MODE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)NumberOfOutputTriggerConnector-R") {
|
|
field(DESC, "Number of output trigger connector")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_NUMBEROF_OUTPUTTRIGGERCONNECTOR")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)OutputTriggerSource0-S") {
|
|
field(DESC, "Output trigger source 0")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "0")
|
|
field(ZRST, "Readout end")
|
|
field(ONVL, "1")
|
|
field(ONST, "VSync")
|
|
field(TWVL, "2")
|
|
field(TWST, "HSync")
|
|
field(THVL, "3")
|
|
field(THST, "Trigger")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_SOURCE0")
|
|
field(VAL, "2")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)OutputTriggerSource0-RB") {
|
|
field(DESC, "Output trigger source 0")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "0")
|
|
field(ZRST, "Readout end")
|
|
field(ONVL, "1")
|
|
field(ONST, "VSync")
|
|
field(TWVL, "2")
|
|
field(THST, "HSync")
|
|
field(THVL, "3")
|
|
field(THST, "Trigger")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_SOURCE0")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)OutputTriggerSource1-S") {
|
|
field(DESC, "Output trigger source 1")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "2")
|
|
field(ZRST, "Readout end")
|
|
field(ONVL, "3")
|
|
field(ONST, "VSync")
|
|
field(TWVL, "4")
|
|
field(TWST, "HSync")
|
|
field(THVL, "6")
|
|
field(THST, "Trigger")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_SOURCE1")
|
|
field(VAL, "0")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)OutputTriggerSource1-RB") {
|
|
field(DESC, "Output trigger source 1")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "2")
|
|
field(ZRST, "Readout end")
|
|
field(ONVL, "3")
|
|
field(ONST, "VSync")
|
|
field(TWVL, "4")
|
|
field(THST, "HSync")
|
|
field(THVL, "6")
|
|
field(THST, "Trigger")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_SOURCE1")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)OutputTriggerSource2-S") {
|
|
field(DESC, "Output trigger source 2")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "2")
|
|
field(ZRST, "Readout end")
|
|
field(ONVL, "3")
|
|
field(ONST, "VSync")
|
|
field(TWVL, "4")
|
|
field(TWST, "HSync")
|
|
field(THVL, "6")
|
|
field(THST, "Trigger")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_SOURCE2")
|
|
field(VAL, "0")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)OutputTriggerSource2-RB") {
|
|
field(DESC, "Output trigger source 0")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "2")
|
|
field(ZRST, "Readout end")
|
|
field(ONVL, "3")
|
|
field(ONST, "VSync")
|
|
field(TWVL, "4")
|
|
field(THST, "HSync")
|
|
field(THVL, "6")
|
|
field(THST, "Trigger")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_SOURCE2")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)OutputTriggerPolarity0-S") {
|
|
field(DESC, "Output trigger polarity 0")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Negative")
|
|
field(ONVL, "2")
|
|
field(ONST, "Positive")
|
|
# field(DRVL, "1")
|
|
# field(DRVH, "2")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_POLARITY0")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)OutputTriggerPolarity0-RB") {
|
|
field(DESC, "Output trigger polarity 0")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Negative")
|
|
field(ONVL, "2")
|
|
field(ONST, "Positive")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_POLARITY0")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)OutputTriggerPolarity1-S") {
|
|
field(DESC, "Output trigger polarity 1")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Negative")
|
|
field(ONVL, "2")
|
|
field(ONST, "Positive")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_POLARITY1")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)OutputTriggerPolarity1-RB") {
|
|
field(DESC, "Output trigger polarity 1")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Negative")
|
|
field(ONVL, "2")
|
|
field(ONST, "Positive")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_POLARITY1")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)OutputTriggerPolarity2-S") {
|
|
field(DESC, "Output trigger polarity 2")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Negative")
|
|
field(ONVL, "2")
|
|
field(ONST, "Positive")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_POLARITY2")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)OutputTriggerPolarity2-RB") {
|
|
field(DESC, "Output trigger polarity 2")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Negative")
|
|
field(ONVL, "2")
|
|
field(ONST, "Positive")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_POLARITY2")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)OutputTriggerActive0-RB") {
|
|
field(DESC, "Internal trigger active 0")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Edge")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_ACTIVE0")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)OutputTriggerActive1-RB") {
|
|
field(DESC, "Internal trigger active 1")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Edge")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_ACTIVE1")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)OutputTriggerActive2-RB") {
|
|
field(DESC, "Internal trigger active 2")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Edge")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_ACTIVE2")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ao, "$(P)$(R)OutputTriggerDelay0-S") {
|
|
field(DESC, "Output trigger delay 0")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynFloat64")
|
|
field(DRVL, "0")
|
|
field(DRVH, "10.0")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_DELAY0")
|
|
field(VAL, "0")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)OutputTriggerDelay0-RB") {
|
|
field(DESC, "Output trigger delay 0")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_DELAY0")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ao, "$(P)$(R)OutputTriggerDelay1-S") {
|
|
field(DESC, "Output trigger delay 1")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynFloat64")
|
|
field(DRVL, "0")
|
|
field(DRVH, "10.0")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_DELAY1")
|
|
field(VAL, "0")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)OutputTriggerDelay1-RB") {
|
|
field(DESC, "Output trigger delay 1")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_DELAY1")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ao, "$(P)$(R)OutputTriggerDelay2-S") {
|
|
field(DESC, "Output trigger delay 2")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynFloat64")
|
|
field(DRVL, "0")
|
|
field(DRVH, "10.0")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_DELAY2")
|
|
field(VAL, "0")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)OutputTriggerDelay2-RB") {
|
|
field(DESC, "Output trigger delay 2")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_DELAY2")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ao, "$(P)$(R)OutputTriggerPeriod0-S") {
|
|
field(DESC, "Output trigger period 0")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynFloat64")
|
|
field(DRVL, "0.000001")
|
|
field(DRVH, "10.0")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_PERIOD0")
|
|
field(VAL, "0.000001")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)OutputTriggerPeriod0-RB") {
|
|
field(DESC, "Output trigger period 0")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_PERIOD0")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ao, "$(P)$(R)OutputTriggerPeriod1-S") {
|
|
field(DESC, "Output trigger period 1")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynFloat64")
|
|
field(DRVL, "0.000001")
|
|
field(DRVH, "10.0")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_PERIOD1")
|
|
field(VAL, "0.000001")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)OutputTriggerPeriod1-RB") {
|
|
field(DESC, "Output trigger period 1")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_PERIOD1")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ao, "$(P)$(R)OutputTriggerPeriod2-S") {
|
|
field(DESC, "Output trigger period 2")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynFloat64")
|
|
field(DRVL, "0.000001")
|
|
field(DRVH, "10.0")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_PERIOD2")
|
|
field(VAL, "0.000001")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)OutputTriggerPeriod2-RB") {
|
|
field(DESC, "Output trigger period 2")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_PERIOD2")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)OutputTriggerKind0-S") {
|
|
field(DESC, "Output trigger kind 0")
|
|
field(DTYP, "asynInt32")
|
|
field(PINI, "YES")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Low")
|
|
field(ONVL, "2")
|
|
field(ONST, "Global Exposure")
|
|
field(TWVL, "3")
|
|
field(TWST, "Programable")
|
|
field(THVL, "4")
|
|
field(THST, "Trigger Ready")
|
|
field(FRVL, "5")
|
|
field(FRST, "High")
|
|
field(FVVL, "6")
|
|
field(FVST, "Any Row Exposure")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_KIND0")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)OutputTriggerKind0-RB") {
|
|
field(DESC, "Output trigger kind 0")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Low")
|
|
field(ONVL, "2")
|
|
field(ONST, "Global Exposure")
|
|
field(TWVL, "3")
|
|
field(TWST, "Programable")
|
|
field(THVL, "4")
|
|
field(THST, "Trigger Ready")
|
|
field(FRVL, "5")
|
|
field(FRST, "High")
|
|
field(FVVL, "6")
|
|
field(FVST, "Any Row Exposure")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_KIND0")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)OutputTriggerKind1-S") {
|
|
field(DESC, "Output trigger kind 1")
|
|
field(DTYP, "asynInt32")
|
|
field(PINI, "YES")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Low")
|
|
field(ONVL, "2")
|
|
field(ONST, "Global exposure")
|
|
field(TWVL, "3")
|
|
field(TWST, "Programable")
|
|
field(THVL, "4")
|
|
field(THST, "Trigger ready")
|
|
field(FRVL, "5")
|
|
field(FRST, "High")
|
|
field(FVVL, "6")
|
|
field(FVST, "Any row exposure")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_KIND1")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)OutputTriggerKind1-RB") {
|
|
field(DESC, "Output trigger kind 1")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Low")
|
|
field(ONVL, "2")
|
|
field(ONST, "Global exposure")
|
|
field(TWVL, "3")
|
|
field(TWST, "Programable")
|
|
field(THVL, "4")
|
|
field(THST, "Trigger ready")
|
|
field(FRVL, "5")
|
|
field(FRST, "High")
|
|
field(FVVL, "6")
|
|
field(FVST, "Any row exposure")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_KIND1")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)OutputTriggerKind2-S") {
|
|
field(DESC, "Output trigger kind 2")
|
|
field(DTYP, "asynInt32")
|
|
field(PINI, "YES")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Low")
|
|
field(ONVL, "2")
|
|
field(ONST, "Global exposure")
|
|
field(TWVL, "3")
|
|
field(TWST, "Programable")
|
|
field(THVL, "4")
|
|
field(THST, "Trigger ready")
|
|
field(FRVL, "5")
|
|
field(FRST, "High")
|
|
field(FVVL, "6")
|
|
field(FVST, "Any row exposure")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_KIND2")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)OutputTriggerKind2-RB") {
|
|
field(DESC, "Output trigger kind 2")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Low")
|
|
field(ONVL, "2")
|
|
field(ONST, "Global exposure")
|
|
field(TWVL, "3")
|
|
field(TWST, "Programable")
|
|
field(THVL, "4")
|
|
field(THST, "Trigger ready")
|
|
field(FRVL, "5")
|
|
field(FRST, "High")
|
|
field(FVVL, "6")
|
|
field(FVST, "Any row exposure")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_KIND2")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ao, "$(P)$(R)OutputTriggerPreHsyncCount-S") {
|
|
field(DESC, "Output trigger preHsyncCount0")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(DRVL, "0")
|
|
field(DRVH, "2047")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_PRE_HSYNC_COUNT")
|
|
field(VAL, "0")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)OutputTriggerPreHsyncCount-RB") {
|
|
field(DESC, "Output trigger preHsyncCount0")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_PRE_HSYNC_COUNT")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)OutputTriggerBaseSensor0-S") {
|
|
field(DESC, "Output trigger base sensor 0")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "View 1")
|
|
field(ONVL, "2")
|
|
field(ONST, "View 2")
|
|
field(TWVL, "15")
|
|
field(TWST, "Any view")
|
|
field(THVL, "16")
|
|
field(THST, "All views")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_BASE_SENSOR0")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)OutputTriggerBaseSensor0-RB") {
|
|
field(DESC, "Output trigger base sensor 0")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "View 1")
|
|
field(ONVL, "2")
|
|
field(ONST, "View 2")
|
|
field(TWVL, "15")
|
|
field(TWST, "Any view")
|
|
field(THVL, "16")
|
|
field(THST, "All views")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_BASE_SENSOR0")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
# Output Trigger Base Sensor 1 (mode 4)
|
|
record(mbbo, "$(P)$(R)OutputTriggerBaseSensor1-S") {
|
|
field(DESC, "Output trigger base sensor 1")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "View 1")
|
|
field(ONVL, "2")
|
|
field(ONST, "View 2")
|
|
field(TWVL, "15")
|
|
field(TWST, "Any view")
|
|
field(THVL, "16")
|
|
field(THST, "All views")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_BASE_SENSOR1")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)OutputTriggerBaseSensor1-RB") {
|
|
field(DESC, "Output trigger base sensor 1")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "View 1")
|
|
field(ONVL, "2")
|
|
field(ONST, "View 2")
|
|
field(TWVL, "15")
|
|
field(TWST, "Any view")
|
|
field(THVL, "16")
|
|
field(THST, "All views")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_BASE_SENSOR1")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
# Output Trigger Base Sensor 2 (mode 4)
|
|
record(mbbo, "$(P)$(R)OutputTriggerBaseSensor2-S") {
|
|
field(DESC, "Output trigger base sensor 2")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "View 1")
|
|
field(ONVL, "2")
|
|
field(ONST, "View 2")
|
|
field(TWVL, "15")
|
|
field(TWST, "Any view")
|
|
field(THVL, "16")
|
|
field(THST, "All views")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_BASE_SENSOR2")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)OutputTriggerBaseSensor2-RB") {
|
|
field(DESC, "Output trigger base sensor 2")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "View 1")
|
|
field(ONVL, "2")
|
|
field(ONST, "View 2")
|
|
field(TWVL, "15")
|
|
field(TWST, "Any view")
|
|
field(THVL, "16")
|
|
field(THST, "All views")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_BASE_SENSOR2")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)MasterPulseMode-S") {
|
|
field(DESC, "Master pulse mode")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Continous")
|
|
field(ONVL, "2")
|
|
field(ONST, "Start")
|
|
field(TWVL, "3")
|
|
field(THST, "Burst")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MASTERPULSE_MODE")
|
|
field(VAL, "0")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)MasterPulseMode-RB") {
|
|
field(DESC, "Master pulse mode")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Continous")
|
|
field(ONVL, "2")
|
|
field(ONST, "Start")
|
|
field(TWVL, "3")
|
|
field(TWST, "Burst")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MASTERPULSE_MODE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)MasterPulseTriggerSource-S") {
|
|
field(DESC, "Master pulse trigger source")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "External")
|
|
field(ONVL, "2")
|
|
field(ONST, "Software")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MASTERPULSE_TRIGGER_SOURCE")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)MasterPulseTriggerSource-RB") {
|
|
field(DESC, "Master pulse trigger source")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "External")
|
|
field(ONVL, "2")
|
|
field(ONST, "Software")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MASTERPULSE_TRIGGER_SOURCE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ao, "$(P)$(R)MasterPulseInterval-S") {
|
|
field(DESC, "Master pulse interval")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynFloat64")
|
|
field(PREC, "6")
|
|
field(DRVL, "0.00001")
|
|
field(DRVH, "10")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MASTERPULSE_INTERVAL")
|
|
field(VAL, "0.1")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)MasterPulseInterval-RB") {
|
|
field(DESC, "Master pulse interval")
|
|
field(DTYP, "asynFloat64")
|
|
field(PREC, "6")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MASTERPULSE_INTERVAL")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ao, "$(P)$(R)MasterPulseBurstTimes-S") {
|
|
field(DESC, "Master pulse burst times")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(DRVL, "1")
|
|
field(DRVH, "10000")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MASTERPULSE_BURST_TIMES")
|
|
field(VAL, "0")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)MasterPulseBurstTimes-RB") {
|
|
field(DESC, "Master pulse burst times")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MASTERPULSE_BURST_TIMES")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)TimingReadoutTime-RB") {
|
|
field(DESC, "Timing readout time")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_READOUT_TIME")
|
|
field(EGU, "Sec")
|
|
field(PREC, "9")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)TimingCyclicTriggerPeriod-RB") {
|
|
field(DESC, "Timing cycling trigger period")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_CYCLICTRIGGERPERIOD")
|
|
field(EGU, "Sec")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)TimingMinTriggerBlanking-RB") {
|
|
field(DESC, "Timing minimum trigger blanking")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_MIN_TRIGGER_BLANKING")
|
|
field(EGU, "Sec")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)TimingMinTriggerInterval-RB") {
|
|
field(DESC, "Timing minimum trigger interval")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_MIN_TRIGGER_INTERVAL")
|
|
field(EGU, "Sec")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)TimingGlobalExposureDelay-RB") {
|
|
field(DESC, "Timing global exposure delay")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_MIN_TRIGGER_INTERVAL")
|
|
field(EGU, "Sec")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)TimingExposure-RB") {
|
|
field(DESC, "Timing exposure")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "3")
|
|
field(ZRST, "Roling")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_EXPOSURE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)TimingInvalidExposurePeriod-RB") {
|
|
field(DESC, "Timing invalid exposure period")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_INVALID_EXPOSURE_PERIOD")
|
|
field(EGU, "Sec")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ao, "$(P)$(R)InternalFrameRate-S") {
|
|
field(DESC, "Internal frame rate")
|
|
field(DTYP, "asynFloat64")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_FRAME_RATE")
|
|
field(EGU, "Hz")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)InternalFrameRate-RB") {
|
|
field(DESC, "Internal frame rate")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_FRAME_RATE")
|
|
field(EGU, "Hz")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ao, "$(P)$(R)InternalFrameInternal-S") {
|
|
field(DESC, "Internal period between two frames")
|
|
field(DTYP, "asynFloat64")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_FRAME_INTERVAL")
|
|
field(EGU, "Sec")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)InternalFrameInternal-RB") {
|
|
field(DESC, "Internal period between two frames")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_FRAME_INTERVAL")
|
|
field(EGU, "Sec")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ao, "$(P)$(R)InternalLineSpeed-S") {
|
|
field(DESC, "Internal line speed")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynFloat64")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_LINE_SPEED")
|
|
field(EGU, "m/s")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)InternalLineSpeed-RB") {
|
|
field(DESC, "Internal line speed")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_LINE_SPEED")
|
|
field(EGU, "m/s")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ao, "$(P)$(R)InternalLineInterval-S") {
|
|
field(DESC, "Internal Line Interval")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynFloat64")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_LINE_INTERVAL")
|
|
field(EGU, "s")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)InternalLineInterval-RB") {
|
|
field(DESC, "Internal Line Interval")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_LINE_INTERVAL")
|
|
field(EGU, "s")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)ColorType-R") {
|
|
field(DESC, "Color type")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Black and white")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_COLOR_TYPE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)BitsPerChannel-S") {
|
|
field(DESC, "Bits per channel")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "12")
|
|
field(ZRST, "12 bits")
|
|
field(ONVL, "16")
|
|
field(ONST, "16 bits")
|
|
field(VAL, "16")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BIT_PER_CHANNEL")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)BitsPerChannel-R") {
|
|
field(DESC, "Bits per channel")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "12")
|
|
field(ZRST, "12 bits")
|
|
field(ONVL, "16")
|
|
field(ONST, "16 bits")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BIT_PER_CHANNEL")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)RowBytes-R") {
|
|
field(DESC, "Byte size of row line")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_ROWBYTES")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)FrameBytes-R") {
|
|
field(DESC, "Byte size of row line")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_FRAMEBYTES")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)TopOffsetBytes-R") {
|
|
field(DESC, "Offset bytes to point first data image")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_TOP_OFFSETBYTES")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)PixelType-S") {
|
|
field(DESC, "Pixel type")
|
|
field(ZRVL, "0")
|
|
field(ZRST, "Monochromatic 8 bits")
|
|
field(ONVL, "1")
|
|
field(ZRST, "Monochromatic 16 bits")
|
|
field(TWVL, "2")
|
|
field(ZRST, "Monochromatic 12 bits")
|
|
field(DTYP, "asynInt32")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_PIXEL_TYPE")
|
|
field(VAL, "1")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)PixelType-RB") {
|
|
field(DESC, "Pixel type")
|
|
field(ZRVL, "0")
|
|
field(ZRST, "Monochromatic 8 bits")
|
|
field(ONVL, "1")
|
|
field(ZRST, "Monochromatic 16 bits")
|
|
field(TWVL, "2")
|
|
field(ZRST, "Monochromatic 12 bits")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_PIXEL_TYPE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)BufRowBytes-R") {
|
|
field(DESC, "Buffer row bytes")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BUFFER_ROWBYTES")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)BufFrameBytes-R") {
|
|
field(DESC, "Buffer row bytes")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BUFFER_FRAMEBYTES")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)BufTopOffsetBytes-R") {
|
|
field(DESC, "Buffer top offset bytes")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BUFFER_TOP_OFFSETBYTES")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)BufPixelType-R") {
|
|
field(DESC, "Buffer pixel type")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Monochromatic 8 bits")
|
|
field(ONVL, "2")
|
|
field(ONST, "Monochromatic 16 bits")
|
|
field(TWVL, "3")
|
|
field(TWST, "Monochromatic 12 bits")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BUFFER_PIXEL_TYPE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)RecBytesPerFile-R") {
|
|
field(DESC, "Recorded fixed bytes per file")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_RECORD_FIXED_BYTES_PER_FILE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)RecBytesPerSesion-R") {
|
|
field(DESC, "Recorded fixed bytes per session")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_RECORD_FIXED_BYTES_PER_SESION")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)RecBytesPerFrame-R") {
|
|
field(DESC, "Recorded fixed bytes per frame")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_RECORD_FIXED_BYTES_PER_FRAME")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)SystemAlive-R") {
|
|
field(DESC, "System alive heartbeat")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Offline")
|
|
field(ONVL, "2")
|
|
field(ONST, "Online")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SYSTEM_ALIVE")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)ConversionFactorOffset-R") {
|
|
field(DESC, "Conversion factor offset")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_CONVERSIONFACTOR_OFFSET")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)ConversionFactorCoeff-R") {
|
|
field(DESC, "Conversion factor offset")
|
|
field(DTYP, "asynFloat64")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_CONVERSIONFACTOR_COEFF")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(ai, "$(P)$(R)NumberOfView-R") {
|
|
field(DESC, "Number of view")
|
|
field(DTYP, "asynInt32")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_NUMBER_OF_VIEW")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)TimeStampProd-R") {
|
|
field(DESC, "Timestamp produced source")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "None")
|
|
field(ONVL, "2")
|
|
field(ONST, "DCAM module")
|
|
field(TWVL, "3")
|
|
field(TWST, "Kernel driver")
|
|
field(THVL, "4")
|
|
field(THST, "Frame grabber")
|
|
field(FRVL, "5")
|
|
field(FRST, "Camera")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMESTAMP_PRODUCER")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)FrameStampProd-R") {
|
|
field(DESC, "Timestamp produced source")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "2")
|
|
field(ZRST, "DCAM module")
|
|
field(ONVL, "5")
|
|
field(ONST, "Image device")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_FRAMESTAMP_PRODUCER")
|
|
field(SCAN, "I/O Intr")
|
|
}
|
|
|
|
record(mbbo, "$(P)$(R)SensorCooler-S") {
|
|
field(DESC, "Sensor cooler")
|
|
field(PINI, "YES")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Off")
|
|
field(ONVL, "2")
|
|
field(ONST, "On")
|
|
field(TWVL, "4")
|
|
field(TWST, "Max")
|
|
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_COOLER")
|
|
field(VAL, "0")
|
|
}
|
|
|
|
record(mbbi, "$(P)$(R)SensorCooler-RB") {
|
|
field(DESC, "Sensor cooler")
|
|
field(DTYP, "asynInt32")
|
|
field(ZRVL, "1")
|
|
field(ZRST, "Off")
|
|
field(ONVL, "2")
|
|
field(ONST, "On")
|
|
field(TWVL, "4")
|
|
field(TWST, "Max")
|
|
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_COOLER")
|
|
field(SCAN, "I/O Intr")
|
|
}
|