# Database for the records specific to the Pilatus driver
# Mark Rivers
# July 25, 2008

# We redefine the states for the TriggerMode records defined in ADBase.template
record(mbbo,"$(P)$(R)TriggerMode") {
    field(DESC,"Acquire mode")
    field(ZRVL,"0")
    field(ZRST,"Internal")
    field(ONVL,"1")
    field(ONST,"Ext. Enable")
    field(TWVL,"2")
    field(TWST,"Ext. Trigger")
    field(THVL,"3")
    field(THST,"Mult. Trigger")
    field(FRVL,"4")
    field(FRST,"Alignment")
}

record(mbbi,"$(P)$(R)TriggerMode_RBV") {
    field(DESC,"Acquire mode")
    field(ZRVL,"0")
    field(ZRST,"Internal")
    field(ONVL,"1")
    field(ONST,"Ext. Enable")
    field(TWVL,"2")
    field(TWST,"Ext. Trigger")
    field(THVL,"3")
    field(THST,"Mult. Trigger")
    field(FRVL,"4")
    field(FRST,"Alignment")
}

# We redefine the states for the FileFormat records defined in NDFile.template
record(mbbo, "$(P)$(R)FileFormat")
{
    field(ZRST, "TIFF")
    field(ZRVL, "0")
    field(ONST, "Invalid")
    field(ONVL, "1")
}

record(mbbi, "$(P)$(R)FileFormat_RBV")
{
    field(ZRST, "TIFF")
    field(ZRVL, "0")
    field(ONST, "Invalid")
    field(ONVL, "1")
}

# Armed flag, which indicates Pilatus is ready for external triggers
record(bi, "$(P)$(R)Armed")
{
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARMED")
    field(ZNAM, "Unarmed")
    field(ONAM, "Armed")
    field(SCAN, "I/O Intr")
}

# Delay time in External Trigger mode.
record(ao, "$(P)$(R)DelayTime")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))DELAY_TIME")
    field(EGU,  "s")
    field(VAL,  "0")
    field(PREC, "6")
}

record(ai, "$(P)$(R)DelayTime_RBV")
{
    field(DTYP, "asynFloat64")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))DELAY_TIME")
    field(EGU,  "s")
    field(PREC, "6")
    field(SCAN, "I/O Intr")
}

# Threshold energy
record(ao, "$(P)$(R)ThresholdEnergy")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))THRESHOLD")
    field(DESC, "Energy threshold")
    field(EGU,  "keV")
    field(PREC, "3")
    field(VAL, "10.000")
}

record(ai, "$(P)$(R)ThresholdEnergy_RBV")
{
    field(DTYP, "asynFloat64")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))THRESHOLD")
    field(DESC, "Energy threshold")
    field(EGU,  "keV")
    field(PREC, "3")
    field(SCAN, "I/O Intr")
}

# Threshold apply command
record(busy, "$(P)$(R)ThresholdApply")
{
    field(DTYP, "asynInt32")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))THRESHOLD_APPLY")
    field(ZNAM, "Done")
    field(ONAM, "Apply")
    field(VAL,  "0")
}

# Threshold auto apply flag
record(bo, "$(P)$(R)ThresholdAutoApply")
{
    field(PINI, "YES")
    field(DTYP, "asynInt32")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))THRESHOLD_AUTO_APPLY")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(VAL,  "1")
}

# Threshold auto apply flag
record(bi, "$(P)$(R)ThresholdAutoApply_RBV")
{
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))THRESHOLD_AUTO_APPLY")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(SCAN, "I/O Intr")
}

# Gain menu.  This writes to the Gain PV in the base database.
record(mbbo, "$(P)$(R)GainMenu")
{
    field(DESC, "Shaping time and gain")
    field(OUT,  "$(P)$(R)Gain.VAL PP MS")
    field(ZRST, "7-30KeV/Fast/LowG")
    field(ZRVL, "0")
    field(ONST, "5-18KeV/Med/MedG")
    field(ONVL, "1")
    field(TWST, "3-6KeV/Slow/HighG")
    field(TWVL, "2")
    field(THST, "2-5KeV/Slow/UltraG")
    field(THVL, "3")
    field(VAL,  "1")
}


# Timeout waiting for image to be written to file system
record(ao, "$(P)$(R)ImageFileTmot")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))IMAGE_FILE_TMOT")
    field(DESC, "Timeout for image file")
    field(VAL,  "20")
    field(EGU,  "s")
    field(PREC, "3")
}

# Bad pixel file
record(waveform, "$(P)$(R)BadPixelFile")
{
    field(PINI, "YES")
    field(DTYP, "asynOctetWrite")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))BAD_PIXEL_FILE")
    field(FTVL, "CHAR")
    field(NELM, "256")
}

# Number of bad pixels
record(longin, "$(P)$(R)NumBadPixels")
{
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))NUM_BAD_PIXELS")
    field(DESC, "Number of bad pixels")
    field(SCAN, "I/O Intr")
}

# Flat field file
record(waveform, "$(P)$(R)FlatFieldFile")
{
    field(PINI, "YES")
    field(DTYP, "asynOctetWrite")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))FLAT_FIELD_FILE")
    field(FTVL, "CHAR")
    field(NELM, "256")
}

# Minimum flat field value
record(longout, "$(P)$(R)MinFlatField")
{
    field(PINI, "YES")
    field(DTYP, "asynInt32")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))MIN_FLAT_FIELD")
    field(DESC, "Minimum flat field value")
    field(VAL,  "100")
    field(EGU,  "Counts")
}

record(longin, "$(P)$(R)MinFlatField_RBV")
{
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))MIN_FLAT_FIELD")
    field(DESC, "Minimum flat field value")
    field(EGU,  "Counts")
    field(SCAN, "I/O Intr")
}

# Flat field valid flag.
record(bi, "$(P)$(R)FlatFieldValid")
{
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))FLAT_FIELD_VALID")
    field(DESC, "Flat field valid")
    field(ZNAM, "No")
    field(ONAM, "Yes")
    field(SCAN, "I/O Intr")
}

record(mbbo, "$(P)$(R)GapFill")
{
   field(PINI, "YES")
   field(DTYP, "asynInt32")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))GAP_FILL")
   field(ZRST, "N.A.")
   field(ZRVL, "2")
   field(ONST, "0")
   field(ONVL, "0")
   field(TWST, "-1")
   field(TWVL, "-1")
   field(VAL,  "0")
}

record(mbbi, "$(P)$(R)GapFill_RBV")
{
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))GAP_FILL")
   field(ZRST, "N.A.")
   field(ZRVL, "2")
   field(ONST, "0")
   field(ONVL, "0")
   field(TWST, "-1")
   field(TWVL, "-1")
   field(SCAN, "I/O Intr")
}


# asyn record for interactive communication with camserver
record(asyn, "$(P)$(R)CamserverAsyn")
{
    field(PORT,  "$(CAMSERVER_PORT)")
    field(IMAX, "64")
    field(OMAX, "64")
    field(AUCT, "0")
}

# ancillary information

record(ao, "$(P)$(R)Wavelength")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))WAVELENGTH")
    field(PREC, "4")
    field(VAL,  "1.54")
    field(EGU,  "Angstroms")
}

record(ao, "$(P)$(R)EnergyLow")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENERGY_LOW")
    field(PREC, "3")
    field(VAL,  "0")
    field(EGU,  "eV")
}

record(ao, "$(P)$(R)EnergyHigh")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENERGY_HIGH")
    field(PREC, "3")
    field(VAL,  "0")
    field(EGU,  "eV")
}

record(ao, "$(P)$(R)DetDist")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))DET_DIST")
    field(PREC, "3")
    field(VAL,  "1000")
    field(EGU,  "mm")
}

record(ao, "$(P)$(R)DetVOffset")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))DET_VOFFSET")
    field(PREC, "3")
    field(VAL,  "0")
    field(EGU,  "mm")
}

record(ao, "$(P)$(R)BeamX")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))BEAM_X")
    field(PREC, "3")
    field(VAL,  "0")
    field(EGU,  "pixels")
}

record(ao, "$(P)$(R)BeamY")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))BEAM_Y")
    field(PREC, "3")
    field(VAL,  "0")
    field(EGU,  "pixels")
}

record(ao, "$(P)$(R)Flux")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))FLUX")
    field(PREC, "4")
    field(VAL,  "0")
    field(EGU,  "ph/s")
}

record(ao, "$(P)$(R)FilterTransm")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_TRANSM")
    field(VAL,  "1.0")
    field(PREC, "4")
}

record(ao, "$(P)$(R)StartAngle")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))START_ANGLE")
    field(PREC, "4")
    field(VAL,  "0")
    field(EGU,  "deg")
}

record(ao, "$(P)$(R)AngleIncr")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))ANGLE_INCR")
    field(PREC, "4")
    field(VAL,  "0.1")
    field(EGU,  "deg")
}

record(ao, "$(P)$(R)Det2theta")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))DET_2THETA")
    field(PREC, "4")
    field(VAL,  "0")
    field(EGU,  "deg")
}

record(ao, "$(P)$(R)Polarization")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))POLARIZATION")
    field(PREC, "4")
    field(VAL,  "0.99")
}

record(ao, "$(P)$(R)Alpha")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))ALPHA")
    field(PREC, "4")
    field(VAL,  "0")
    field(EGU,  "deg")
}

record(ao, "$(P)$(R)Kappa")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))KAPPA")
    field(PREC, "4")
    field(VAL,  "0")
    field(EGU,  "deg")
}

record(ao, "$(P)$(R)Phi")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))PHI")
    field(PREC, "4")
    field(VAL,  "0")
    field(EGU,  "deg")
}

record(ao, "$(P)$(R)Chi")
{
    field(PINI, "YES")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))CHI")
    field(PREC, "4")
    field(VAL,  "0")
    field(EGU,  "deg")
}

record(stringout, "$(P)$(R)OscillAxis")
{
    field(PINI, "YES")
    field(DTYP, "asynOctetWrite")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))OSCILL_AXIS")
    field(VAL,  "X, CW")
}

record(longout, "$(P)$(R)NumOscill")
{
    field(PINI, "YES")
    field(DTYP, "asynInt32")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))NUM_OSCILL")
    field(VAL,  "1")
}


# Set DISA for PVs in ADBase that do not apply to Pilatus

record(mbbo, "$(P)$(R)DataType")
{
    field(DISA, "1")
}
record(mbbi, "$(P)$(R)DataType_RBV")
{
    field(DISA, "1")
}
record(mbbo, "$(P)$(R)ColorMode")
{
    field(DISA, "1")
}
record(mbbi, "$(P)$(R)ColorMode_RBV")
{
    field(DISA, "1")
}
record(longout, "$(P)$(R)BinX")
{
    field(DISA, "1")
}
record(longin, "$(P)$(R)BinX_RBV")
{
    field(DISA, "1")
}
record(longout, "$(P)$(R)BinY")
{
    field(DISA, "1")
}
record(longin, "$(P)$(R)BinY_RBV")
{
    field(DISA, "1")
}
record(longout, "$(P)$(R)MinX")
{
    field(DISA, "1")
}
record(longin, "$(P)$(R)MinX_RBV")
{
    field(DISA, "1")
}
record(longout, "$(P)$(R)MinY")
{
    field(DISA, "1")
}
record(longin, "$(P)$(R)MinY_RBV")
{
    field(DISA, "1")
}
record(longout, "$(P)$(R)SizeX")
{
    field(DISA, "1")
}
record(longin, "$(P)$(R)SizeX_RBV")
{
    field(DISA, "1")
}
record(longout, "$(P)$(R)SizeY")
{
    field(DISA, "1")
}
record(longin, "$(P)$(R)SizeY_RBV")
{
    field(DISA, "1")
}
record(bo, "$(P)$(R)ReverseX")
{
    field(DISA, "1")
}
record(bi, "$(P)$(R)ReverseX_RBV")
{
    field(DISA, "1")
}
record(bo, "$(P)$(R)ReverseY")
{
    field(DISA, "1")
}
record(bi, "$(P)$(R)ReverseY_RBV")
{
    field(DISA, "1")
}

record(ai, "$(P)$(R)PixelCutOff_RBV")
{
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))PIXEL_CUTOFF")
    field(EGU,  "counts")
    field(SCAN, "I/O Intr")
    field(VAL,  "0")
}

record(ai, "$(P)$(R)Temp0_RBV")
{
    field(DTYP, "asynFloat64")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))TH_TEMP_0")
    field(EGU,  "C")
    field(SCAN, "I/O Intr")
    field(VAL,  "0")
    field(PREC, "1")
}

record(ai, "$(P)$(R)Temp1_RBV")
{
    field(DTYP, "asynFloat64")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))TH_TEMP_1")
    field(EGU,  "C")
    field(SCAN, "I/O Intr")
    field(VAL,  "0")
    field(PREC, "1")
}

record(ai, "$(P)$(R)Temp2_RBV")
{
    field(DTYP, "asynFloat64")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))TH_TEMP_2")
    field(EGU,  "C")
    field(SCAN, "I/O Intr")
    field(VAL,  "0")
    field(PREC, "1")
}

record(ai, "$(P)$(R)Humid0_RBV")
{
    field(DTYP, "asynFloat64")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))TH_HUMID_0")
    field(EGU,  "%")
    field(SCAN, "I/O Intr")
    field(VAL,  "0")
    field(PREC, "1")
}

record(ai, "$(P)$(R)Humid1_RBV")
{
    field(DTYP, "asynFloat64")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))TH_HUMID_1")
    field(EGU,  "%")
    field(SCAN, "I/O Intr")
    field(VAL,  "0")
    field(PREC, "1")
}

record(ai, "$(P)$(R)Humid2_RBV")
{
    field(DTYP, "asynFloat64")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))TH_HUMID_2")
    field(EGU,  "%")
    field(SCAN, "I/O Intr")
    field(VAL,  "0")
    field(PREC, "1")
}

record(stringin, "$(P)$(R)TVXVersion_RBV")
{
   field(DTYP, "asynOctetRead")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))TVXVERSION")
   field(VAL,  "Unknown")
   field(SCAN, "I/O Intr")
}

record(waveform, "$(P)$(R)CbfTemplateFile")
{
    field(PINI, "YES")
    field(DTYP, "asynOctetWrite")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))CBFTEMPLATEFILE")
    field(FTVL, "CHAR")
    field(NELM, "256")
}