adorca/ADOrcaApp/Db/orca.template

# Database for the records specific to the Hamamatsu Orca Flash4.0 cameras
#

include "ADBase.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                                              #
###############################################################################

###############################################################################
#  These records control the data type and color.                             # 
###############################################################################

# 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(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):PS-1-Div-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):SoftSeq-0-Disable-Cmd CP")
}

record(seq, "$(P)$(R)#SoftSeqEnable") {
    field(SELM, "All")
    # reset prescaler
    field(DOL1, "123")
    field(LNK1, "$(EVR):Evt-ResetPS-SP PP")
    field(DOL2, "123")
    field(LNK2, "$(EVR):EvtCode-SP PP")
    # Enable sequencer 0
    field(LNK3, "$(EVR):SoftSeq-0-Enable-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):SoftSeq-0-NumOfStarts-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")
}

##########################################################################
# General properties                                                     #
##########################################################################
record(stringout, "$(P)$(R)EPICSName-RB"){
   field(DESC, "")
   field(DTYP, "asynOctetWrite")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_VENDOR")
   field(VAL, "$(P)$(R)")
}

record(stringin, "$(P)$(R)Vendor-RB"){
   field(DESC, "")
   field(DTYP, "asynOctetRead")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_VENDOR")
   field(SCAN, "I/O Intr")
}

record(stringin, "$(P)$(R)Model-RB"){
   field(DESC, "")
   field(DTYP, "asynOctetRead")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MODEL")
   field(SCAN, "I/O Intr")
}

record(stringin, "$(P)$(R)CameraID-RB"){
   field(DESC, "")
   field(DTYP, "asynOctetRead")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_CAMERAID")
   field(SCAN, "I/O Intr")
}

record(stringin, "$(P)$(R)Bus-RB"){
   field(DESC, "")
   field(DTYP, "asynOctetRead")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BUS")
   field(SCAN, "I/O Intr")
}

record(stringin, "$(P)$(R)CameraVersion-RB"){
   field(DESC, "")
   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, "")
   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, "")
   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, "")
   field(DTYP, "asynOctetRead")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_DCAM_API_VERSION")
   field(SCAN, "I/O Intr")
}


##########################################################################
# Sensor Mode and Speed                                                  #
##########################################################################
# Sensor Mode (mode 4)
#record(longout, "$(P)$(R)SensorMode-S") {
 record(mbbo, "$(P)$(R)SensorMode-S") {
   field(DESC,"")
   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(longin, "$(P)$(R)SensorMode-RB") {
record(mbbi, "$(P)$(R)SensorMode-RB") {
   field(DESC,"")
   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")
}

##########################################################################
# Readout Speed (long)
record(mbbo, "$(P)$(R)ReadoutSpeed-S") {
   field(DESC,"")
   field(PINI, "YES")
   field(DTYP, "asynInt32")
   field(ZRVL, "1")
   field(ZRST, "1")
   field(ONVL, "2")
   field(ONST, "2")
   #field(DRVL, "1")
   #field(DRVH, "2")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_READOUT_SPEED")  
   field(VAL,  "2")
}

record(mbbi, "$(P)$(R)ReadoutSpeed-RB") {
   field(DESC,"")
   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")
}

##########################################################################
# Readout Direction (mode 3)
# API shows there are only one posssible value... 5
# Documentation shows 3 different
record(mbbo, "$(P)$(R)ReadoutDirection-S") {
   field(DESC,"")
   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,"")
   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)BitPerChannel-S") {
   field(DESC,"")
   field(PINI, "YES")
   field(DTYP, "asynInt32")
   field(ZRVL, "12")
   field(ZRST, "12 bits")
   field(ONVL, "16")
   field(ONST, "16 bits")
#   field(DRVL, "12")
#   field(DRVH, "16")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BIT_PER_CHANNEL")  
   field(VAL,  "16")
}

record(mbbi, "$(P)$(R)BitPerChannel-RB") {
   field(DESC,"")
   field(ZRVL, "12")
   field(ZRST, "12 bits")
   field(ONVL, "16")
   field(ONST, "16 bits")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BIT_PER_CHANNEL")
   field(SCAN, "I/O Intr")
}




##########################################################################
# Trigger                                                                #
##########################################################################
# Trigger source (mode 4)
record(mbbo, "$(P)$(R)TriggerSource-S") {
    field(DESC,"")
    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,"")
   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")
}
##########################################################################
# Trigger mode (mode 2)
record(mbbo, "$(P)$(R)TriggerMode-S") {
   field(DESC,"")
   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,"")
   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")
}
##########################################################################
# Trigger Active (mode 3)
record(mbbo, "$(P)$(R)TriggerActive-S") {
   field(DESC,"")
   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(DRVL, "1")
#   field(DRVH, "3")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_ACTIVE")  
   field(VAL,  "1")
}

record(mbbi, "$(P)$(R)TriggerActive-RB") {
   field(DESC,"")
   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")
}
##########################################################################
# Trigger Global Exposure (mode 2)
# SOME ERROR either in the API or documentation.
# API function returns min:3
#                      max:5
#                      defaults:3
# But API function support only 1 - Delay
#                               2 - Global Reset 
record(mbbo, "$(P)$(R)TriggerGlobalExposure-S") {
   field(DESC,"")
   field(PINI, "YES")
   field(DTYP, "asynInt32")
   field(ZRVL, "3")
   field(ZRST, "Delayed")
   field(ONVL, "5")
   field(ONST, "Global Reset")
#   field(DRVL, "3")
#   field(DRVH, "5")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_GLOBAL_EXPOSURE")  
   field(VAL,  "3")
}

record(mbbi, "$(P)$(R)TriggerGlobalExposure-RB") {
   field(DESC, "")
   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")
}
##########################################################################
# Trigger Polarity (mode 2)
record(mbbo, "$(P)$(R)TriggerPolarity-S") {
   field(DESC, "")
   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_TRIGGER_POLARITY")  
   field(VAL,  "1")
}

record(mbbi, "$(P)$(R)TriggerPolarity-RB") {
   field(DESC, "")
   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")
}
##########################################################################
# Trigger Connector (mode 2)
record(mbbo, "$(P)$(R)TriggerConnector-S") {
   field(DESC, "")
   field(PINI, "YES")
   field(DTYP, "asynInt32")
   field(ZRVL, "1")
   field(ZRST, "Interface")
   field(ONVL, "2")
   field(ONST, "BNC")
#   field(DRVL, "1")
#   field(DRVH, "2")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_CONNECTOR")  
   field(VAL,  "2")
}

record(mbbi, "$(P)$(R)TriggerConnector-RB") {
   field(DESC, "")
   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")
}
##########################################################################
# Trigger Times 
record(ao, "$(P)$(R)TriggerTimes-S") {
   field(DESC, "")
   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,"")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_TIMES")
   field(SCAN, "I/O Intr")
}
##########################################################################
# Trigger Delay 
record(ao, "$(P)$(R)TriggerDelay-S") {
   field(DESC, "")
   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, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TRIGGER_DELAY")
   field(SCAN, "I/O Intr")
}
##########################################################################
# Internal Trigger Handling (mode 2)
record(mbbo, "$(P)$(R)InternalTriggerHandling-S") {
   field(DESC, "")
   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, "")
   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")
}


##########################################################################
# Sensor Cooler                                                          #
##########################################################################

record(ai, "$(P)$(R)Temperature-R") {
   field(DESC, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_TEMPERATURE")
   field(SCAN, "I/O Intr")
   field(TPRO, "1")
}

# record(mbbo, "$(P)$(R)Cooler-S") {
#   field(DESC, "")
#   field(ZRVL, "0")
#   field(ZRST, "OFF")
#   field(ONVL, "1")
#   field(ONST, "ON")
#   field(TWVL, "2")
#   field(TWST, "MAX")
#   field(DTYP, "asynInt32")
#   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_COOLER")
#}
#
#record(mbbi, "$(P)$(R)Cooler-RB") {
#   field(DESC, "")
#   field(ZRVL, "0")
#   field(ZRST, "OFF")
#   field(ONVL, "1")
#   field(ONST, "ON")
#   field(TWVL, "2")
#   field(TWST, "MAX")
#   field(DTYP, "asynInt32")
#   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_SENSOR_COOLER")
#   field(SCAN, "I/O Intr")
#}

record(mbbi, "$(P)$(R)CoolerStatus-R") {
   field(DESC, "")
   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")
}


##########################################################################
# Binning and ROI                                                        #
##########################################################################
# Binning
record(mbbo, "$(P)$(R)Binning-S") {
   field(DESC, "")
   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(DRVL, "1")
#   field(DRVH, "3")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BINNING")  
   field(VAL,  "0")
}

record(mbbi, "$(P)$(R)Binning-RB") {
   field(DESC, "")
   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")
}

# these records are defined in the ADBase.template
# SubarrayHPos
# SubarrayHSize
# SubarrayVPos
# SubarrayVSize

record(mbbo, "$(P)$(R)SubarrayMode-S") {
   field(DESC, "")
   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, "")
   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")
}


##########################################################################
# ALU                                                                    #
##########################################################################
# Defect Correct Mode
record(mbbo, "$(P)$(R)DefectCorrectMode-S") {
   field(DESC, "")
   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, "")
   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")
}

##########################################################################
# Hot Pixel Correct Level
record(mbbo, "$(P)$(R)HotPixelCorrectLevel-S") {
   field(DESC, "")
   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(DRVL, "1")
#   field(DRVH, "3")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_HOT_PIXEL_CORRECT_LEVEL")  
   field(VAL,  "1")
}

record(mbbi, "$(P)$(R)HotPixelCorrectLevel-RB") {
   field(DESC, "")
   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")
}

##########################################################################
# Intensity Lut
record(mbbo, "$(P)$(R)IntensityLutMode-S") {
   field(DESC, "")
   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, "")
   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")
}

##########################################################################
# Intensity Lut Page
#record(ao, "$(P)$(R)IntensityLutPage-S") {
#   field(DESC, "")
#   field(PINI, "YES")
#   field(DTYP, "asynInt32")
#   field(DRVL, "1")
#   field(DRVH, "1")
#   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTENSITY_LUT_PAGE")  
#   field(VAL,  "1")
#}

record(ai, "$(P)$(R)IntensityLutPage-RB") {
   field(DESC, "")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTENSITY_LUT_PAGE")
   field(SCAN, "I/O Intr")
}

##########################################################################
# Extraction Mode
record(ai, "$(P)$(R)ExtractionMode-RB") {
   field(DESC, "")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_EXTRACTION_MODE")
   field(SCAN, "I/O Intr")
}

##########################################################################
# Output Trigger                                                         #
##########################################################################
#Output Trigger Connector 
record(ai, "$(P)$(R)NumberOfOutputTriggerConnector-R") {
   field(DESC,"")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_NUMBEROF_OUTPUTTRIGGERCONNECTOR")
   field(SCAN, "I/O Intr")
}

##########################################################################
# Output Trigger Source 0 (mode 4)
record(mbbo, "$(P)$(R)OutputTriggerSource0-S") {
   field(DESC, "")
   field(PINI, "YES")
   field(DTYP, "asynInt32")
   field(ZRVL, "0")
   field(ZRST, "Read Out End")
   field(ONVL, "1")
   field(ONST, "VSync")
   field(TWVL, "2")
   field(TWST, "HSync")
   field(THVL, "3")
   field(THST, "Trigger")
#   field(DRVL, "2")
#   field(DRVH, "6")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_SOURCE0")  
   field(VAL,  "2")
}

record(mbbi, "$(P)$(R)OutputTriggerSource0-RB") {
   field(DESC, "")
   field(DTYP, "asynInt32")
   field(ZRVL, "0")
   field(ZRST, "Read Out 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")
}
##########################################################################
# Output Trigger Source 1 (mode 4)
record(mbbo, "$(P)$(R)OutputTriggerSource1-S") {
   field(DESC, "")
   field(PINI, "YES")
   field(DTYP, "asynInt32")
   field(ZRVL, "2")
   field(ZRST, "Read Out End")
   field(ONVL, "3")
   field(ONST, "VSync")
   field(TWVL, "4")
   field(TWST, "HSync")
   field(THVL, "6")
   field(THST, "Trigger")
#   field(DRVL, "2")
#   field(DRVH, "6")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_SOURCE1")  
   field(VAL,  "0")
}

record(mbbi, "$(P)$(R)OutputTriggerSource1-RB") {
   field(DESC, "")
   field(DTYP, "asynInt32")
   field(ZRVL, "2")
   field(ZRST, "Read Out 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")
}

# Output Trigger Source 2 (mode 4)
record(mbbo, "$(P)$(R)OutputTriggerSource2-S") {
   field(DESC, "")
   field(PINI, "YES")
   field(DTYP, "asynInt32")
   field(ZRVL, "2")
   field(ZRST, "Read Out End")
   field(ONVL, "3")
   field(ONST, "VSync")
   field(TWVL, "4")
   field(TWST, "HSync")
   field(THVL, "6")
   field(THST, "Trigger")
#   field(DRVL, "2")
#   field(DRVH, "6")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_SOURCE2")  
   field(VAL,  "0")
}

record(mbbi, "$(P)$(R)OutputTriggerSource2-RB") {
   field(DESC, "")
   field(DTYP, "asynInt32")
   field(ZRVL, "2")
   field(ZRST, "Read Out 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")
}

##########################################################################
# Output Trigger Polarity 0 (mode 2)
record(mbbo, "$(P)$(R)OutputTriggerPolarity0-S") {
   field(DESC, "")
   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, "")
   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")
}

# Output Trigger Polarity 1 (mode 2)
record(mbbo, "$(P)$(R)OutputTriggerPolarity1-S") {
   field(DESC, "")
   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_POLARITY1")  
   field(VAL,  "1")
}

record(mbbi, "$(P)$(R)OutputTriggerPolarity1-RB") {
   field(DESC, "")
   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")
}
# Output Trigger Polarity 2 (mode 2)
record(mbbo, "$(P)$(R)OutputTriggerPolarity2-S") {
   field(DESC, "")
   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_POLARITY2")  
   field(VAL,  "1")
}

record(mbbi, "$(P)$(R)OutputTriggerPolarity2-RB") {
   field(DESC, "")
   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")
}


##########################################################################
# Internal Trigger Active (mode 1)
record(mbbi, "$(P)$(R)OutputTriggerActive0-RB") {
   field(DESC, "")
   field(DTYP, "asynInt32")
   field(ZRVL, "1")
   field(ZRST, "Edge")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_ACTIVE0")  
   field(SCAN, "I/O Intr")
}

# Internal Trigger Active (mode 1)
record(mbbi, "$(P)$(R)OutputTriggerActive1-RB") {
   field(DESC, "")
   field(DTYP, "asynInt32")
   field(ZRVL, "1")
   field(ZRST, "Edge")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_ACTIVE1")  
   field(SCAN, "I/O Intr")
}

# Internal Trigger Active (mode 1)
record(mbbi, "$(P)$(R)OutputTriggerActive2-RB") {
   field(DESC, "")
   field(DTYP, "asynInt32")
   field(ZRVL, "1")
   field(ZRST, "Edge")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_ACTIVE2")  
   field(SCAN, "I/O Intr")
}

##########################################################################
# Output Trigger Delay 0
record(ao, "$(P)$(R)OutputTriggerDelay0-S") {
   field(DESC, "")
   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, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_DELAY0")  
   field(SCAN, "I/O Intr")
}

# Output Trigger Delay 1
record(ao, "$(P)$(R)OutputTriggerDelay1-1") {
   field(DESC, "")
   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, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_DELAY1")  
   field(SCAN, "I/O Intr")
}

# Output Trigger Delay 2
record(ao, "$(P)$(R)OutputTriggerDelay2-S") {
   field(DESC, "")
   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, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_DELAY2")  
   field(SCAN, "I/O Intr")
}

##########################################################################
# Output Trigger Period 0
record(ao, "$(P)$(R)OutputTriggerPeriod0-S") {
   field(DESC, "")
   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, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_PERIOD0")
   field(SCAN, "I/O Intr")
}

# Output Trigger Period 1
record(ao, "$(P)$(R)OutputTriggerPeriod1-S") {
   field(DESC, "")
   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, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_PERIOD1")
   field(SCAN, "I/O Intr")
}

# Output Trigger Period 2
record(ao, "$(P)$(R)OutputTriggerPeriod2-S") {
   field(DESC, "")
   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, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_PERIOD2")
   field(SCAN, "I/O Intr")
}

##########################################################################
# Output Trigger Kind 0 (mode 5)
record(mbbo, "$(P)$(R)OutputTriggerKind0-S") {
   field(DESC, "")
   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, "")
   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")
}

# Output Trigger Kind 1 (mode 5)
record(mbbo, "$(P)$(R)OutputTriggerKind1-S") {
   field(DESC, "")
   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, "")
   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")
}

# Output Trigger Kind 2 (mode 5)
record(mbbo, "$(P)$(R)OutputTriggerKind2-S") {
   field(DESC, "")
   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, "")
   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")
}

##########################################################################
# Output Trigger PreHsyncCount0
record(ao, "$(P)$(R)OutputTriggerPreHsyncCount-S") {
   field(DESC, "")
   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, "")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_PRE_HSYNC_COUNT")
   field(SCAN, "I/O Intr")
}

##########################################################################
# Output Trigger Base Sensor 0 (mode 4)
record(mbbo, "$(P)$(R)OutputTriggerBaseSensor0-S") {
   field(DESC, "")
   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(DRVL, "1")
#   field(DRVH, "4")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_BASE_SENSOR0")  
   field(VAL,  "1")
}

record(mbbi, "$(P)$(R)OutputTriggerBaseSensor0-RB") {
   field(DESC, "")
   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, "")
   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(DRVL, "1")
#   field(DRVH, "4")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_BASE_SENSOR1")  
   field(VAL,  "1")
}

record(mbbi, "$(P)$(R)OutputTriggerBaseSensor1-RB") {
   field(DESC, "")
   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, "")
   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(DRVL, "1")
#   field(DRVH, "4")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_OUTPUT_TRIGGER_BASE_SENSOR2")  
   field(VAL,  "1")
}

record(mbbi, "$(P)$(R)OutputTriggerBaseSensor2-RB") {
   field(DESC, "")
   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")
}


##########################################################################
# Master Pulse                                                           #
##########################################################################
# Master Pulse Mode
record(mbbo, "$(P)$(R)MasterPulseMode-S") {
   field(DESC, "")
   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, "")
   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")
}

##########################################################################
# Master Pulse Trigger Source
record(mbbo, "$(P)$(R)MasterPulseTriggerSource-S") {
   field(DESC, "")
   field(PINI, "YES")
   field(DTYP, "asynInt32")
   field(ZRVL, "1")
   field(ZRST, "External")
   field(ONVL, "2")
   field(ONST, "Software")
#   field(DRVL, "1")
#   field(DRVH, "2")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MASTERPULSE_TRIGGER_SOURCE")  
   field(VAL,  "1")
}

record(mbbi, "$(P)$(R)MasterPulseTriggerSource-RB") {
   field(DESC, "")
   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")
}

##########################################################################
# Mster Pulse Interval
record(ao, "$(P)$(R)MasterPulseInterval-S") {
   field(DESC, "")
   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, "")
   field(DTYP, "asynFloat64")
   field(PREC, "6")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MASTERPULSE_INTERVAL")  
   field(SCAN, "I/O Intr")
}

##########################################################################
# Mster Pulse Burst Times
record(ao, "$(P)$(R)MasterPulseBurstTimes-S") {
   field(DESC, "")
   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, "")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_MASTERPULSE_BURST_TIMES")  
   field(SCAN, "I/O Intr")
}

##########################################################################
# Synchronious Timing                                                    #
##########################################################################
# Timing Readout Time
record(ai, "$(P)$(R)TimingReadoutTime-RB") {
   field(DESC, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_READOUT_TIME")  
   field(EGU,  "Sec")
   field(PREC, "9")
   field(SCAN, "I/O Intr")
}

##########################################################################
# Timing Cycling Trigger Period
record(ai, "$(P)$(R)TimingCyclicTriggerPeriod-RB") {
   field(DESC, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_CYCLICTRIGGERPERIOD")  
   field(EGU,  "Sec")
   field(SCAN, "I/O Intr")
}

##########################################################################
# Timing minimum Trigger Blanking
record(ai, "$(P)$(R)TimingMinTriggerBlanking-RB") {
   field(DESC, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_MIN_TRIGGER_BLANKING")  
   field(EGU,  "Sec")
   field(SCAN, "I/O Intr")
}

##########################################################################
# Timing Trigger Interval
record(ai, "$(P)$(R)TimingMinTriggerInterval-RB") {
   field(DESC, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_MIN_TRIGGER_INTERVAL")  
   field(EGU,  "Sec")
   field(SCAN, "I/O Intr")
}

##########################################################################
# Timing Global Exposure Delay
record(ai, "$(P)$(R)TimingGlobalExposureDelay-RB") {
   field(DESC, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_MIN_TRIGGER_INTERVAL")  
   field(EGU,  "Sec")
   field(SCAN, "I/O Intr")
}

##########################################################################
# Timing Global Exposure Delay
record(mbbi, "$(P)$(R)TimingExposure-RB") {
   field(DESC, "")
   field(DTYP, "asynInt32")
   field(ZRVL, "3")
   field(ZRST, "Roling")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_EXPOSURE")  
   field(SCAN, "I/O Intr")
}

##########################################################################
# Timing Invalid Exposure Period
record(ai, "$(P)$(R)TimingInvalidExposurePeriod-RB") {
   field(DESC, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_TIMING_INVALID_EXPOSURE_PERIOD")  
   field(EGU,  "Sec")
   field(SCAN, "I/O Intr")
}

##########################################################################
# Internal Frame Rate 
record(ao, "$(P)$(R)InternalFrameRate-S") {
   field(DESC, "")
   field(DTYP, "asynFloat64")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_FRAME_RATE")  
   field(EGU,  "Hz")
}

record(ai, "$(P)$(R)InternalFrameRate-RB") {
   field(DESC, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_FRAME_RATE")  
   field(EGU,  "Hz")
   field(SCAN, "I/O Intr")
}

##########################################################################
# Internal Frame Interval
record(ao, "$(P)$(R)InternalFrameInternal-S") {
   field(DESC, "")
   field(DTYP, "asynFloat64")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_FRAME_INTERVAL")  
   field(EGU,  "Sec")
}

record(ai, "$(P)$(R)InternalFrameInternal-RB") {
   field(DESC, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_FRAME_INTERVAL")  
   field(EGU,  "Sec")
   field(SCAN, "I/O Intr")
}

##########################################################################
# Internal Line Speed
record(ao, "$(P)$(R)InternalLineSpeed-S") {
   field(DESC, "")
   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, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_LINE_SPEED")  
   field(EGU,  "m/s")
   field(SCAN, "I/O Intr")
}

##########################################################################
# Internal Line Interval
record(ao, "$(P)$(R)InternalLineInterval-S") {
   field(DESC, "")
   field(PINI, "YES")
   field(DTYP, "asynFloat64")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_LINE_INTERVAL")  
   field(EGU,  "Sec")
}

record(ai, "$(P)$(R)InternalLineInterval-RB") {
   field(DESC, "")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_INTERNAL_LINE_INTERVAL")  
   field(EGU,  "Sec")
   field(SCAN, "I/O Intr")
}

##########################################################################
# System Information                                                     #
##########################################################################

record(mbbi, "$(P)$(R)ColorType-R") {
   field(DESC,"")
   field(DTYP, "asynInt32")
   field(ZRVL, "1")
   field(ZRST, "B & W")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_COLOR_TYPE")
   field(SCAN, "I/O Intr")
}

record(mbbo, "$(P)$(R)BitsPerChannel-S") {
   field(DESC, "")
   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,"")
   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")
}
# implemented in ADBase as BINX_RBV
#record(ai, "$(P)$(R)ImageWidth-R") {
#   field(DESC,"")
#   field(DTYP, "asynInt32")
#   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_WIDTH")
#   field(SCAN, "I/O Intr")
#}

# implemented in ADBase as BINY_RBV
#record(ai, "$(P)$(R)ImageHeight-R") {
#   field(DESC,"")
#   field(DTYP, "asynInt32")
#   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_HEIGHT")
#   field(SCAN, "I/O Intr")
#}

record(ai, "$(P)$(R)RowBytes-R") {
   field(DESC,"")
   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,"")
   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,"")
   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,"")
   field(ZRVL, "0")
   field(ZRST, "MONO8")
   field(ONVL, "1")
   field(ONST, "MONO16")
   field(TWVL, "2")
   field(TWST, "MONO12")
   field(DTYP, "asynInt32")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_PIXEL_TYPE")
   field(VAL,  "1")
}

record(mbbi, "$(P)$(R)PixelType-RB") {
   field(DESC,"")
   field(ZRVL, "0")
   field(ZRST, "MONO8")
   field(ONVL, "1")
   field(ONST, "MONO16")
   field(TWVL, "2")
   field(TWST, "MONO12")
   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,"")
   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,"")
   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,"")
   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,"")
   field(DTYP, "asynInt32")
   field(ZRVL, "1")
   field(ZRST, "MONO8")
   field(ONVL, "2")
   field(ONST, "MONO16")
   field(TWVL, "3")
   field(TWST, "MONO12")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_BUFFER_PIXEL_TYPE")
   field(SCAN, "I/O Intr")
}

record(ai, "$(P)$(R)RecBytesPerFile-R") {
   field(DESC,"")
   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,"")
   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,"")
   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,"")
   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,"")
   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,"")
   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,"")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_NUMBER_OF_VIEW")
   field(SCAN, "I/O Intr")
}

record(ai, "$(P)$(R)ImageDetectorWidth-R") {
   field(DESC,"")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_DETECTOR_PIXEL_WIDTH")
   field(SCAN, "I/O Intr")
}

record(ai, "$(P)$(R)ImageDetectorHeight-R") {
   field(DESC,"")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_DETECTOR_PIXEL_HEIGHT")
   field(SCAN, "I/O Intr")
}

record(ai, "$(P)$(R)ImagePixelNumHorz-R") {
   field(DESC,"")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_DETECTOR_PIXEL_NUM_HORZ")
   field(SCAN, "I/O Intr")
}

record(ai, "$(P)$(R)ImagePixelNumVert-R") {
   field(DESC,"")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_IMAGE_DETECTOR_PIXEL_NUM_VERT")
   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,"")
   field(DTYP, "asynInt32")
   field(ZRVL, "2")
   field(ZRST, "FrameStamp DCAM Module")
   field(ONVL, "5")
   field(ONST, "FrameStamp Image Dev")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))H_FRAMESTAMP_PRODUCER")
   field(SCAN, "I/O Intr")
}