Deleted all files except Andor ones
This commit is contained in:
Mark Rivers
@@ -1,929 +0,0 @@
|
||||
# Database for area detector control using asyn driver and standard asyn device support
|
||||
# Mark Rivers
|
||||
# March 9, 2008
|
||||
|
||||
###################################################################
|
||||
# This record contains the asyn port name of this detector #
|
||||
###################################################################
|
||||
|
||||
record(stringin, "$(P)$(R)PortName_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PORT_NAME_SELF")
|
||||
field(VAL, "Unknown")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control basic information #
|
||||
# about the detector #
|
||||
###################################################################
|
||||
|
||||
record(stringin, "$(P)$(R)Manufacturer_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MANUFACTURER")
|
||||
field(VAL, "Unknown")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(stringin, "$(P)$(R)Model_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MODEL")
|
||||
field(VAL, "Unknown")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MaxSizeX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAX_SIZE_X")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MaxSizeY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAX_SIZE_Y")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the data type #
|
||||
###################################################################
|
||||
|
||||
record(mbbo, "$(P)$(R)DataType")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DATA_TYPE")
|
||||
field(ZRST, "Int8")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "UInt8")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Int16")
|
||||
field(TWVL, "2")
|
||||
field(THST, "UInt16")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Int32")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "UInt32")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "Float32")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "Float64")
|
||||
field(SVVL, "7")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)DataType_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DATA_TYPE")
|
||||
field(ZRST, "Int8")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "UInt8")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Int16")
|
||||
field(TWVL, "2")
|
||||
field(THST, "UInt16")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Int32")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "UInt32")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "Float32")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "Float64")
|
||||
field(SVVL, "7")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the color mode #
|
||||
# These choices must agree with NDColorMode_t in NDArray.h #
|
||||
###################################################################
|
||||
|
||||
record(mbbo, "$(P)$(R)ColorMode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COLOR_MODE")
|
||||
field(ZRST, "Mono")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Bayer")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "RGB1")
|
||||
field(TWVL, "2")
|
||||
field(THST, "RGB2")
|
||||
field(THVL, "3")
|
||||
field(FRST, "RGB3")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "YUV444")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "YUV422")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "YUV421")
|
||||
field(SVVL, "7")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ColorMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COLOR_MODE")
|
||||
field(ZRST, "Mono")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Bayer")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "RGB1")
|
||||
field(TWVL, "2")
|
||||
field(THST, "RGB2")
|
||||
field(THVL, "3")
|
||||
field(FRST, "RGB3")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "YUV444")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "YUV422")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "YUV421")
|
||||
field(SVVL, "7")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the detector readout #
|
||||
# including binning, region start and size #
|
||||
###################################################################
|
||||
|
||||
record(longout, "$(P)$(R)BinX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))BIN_X")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)BinX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))BIN_X")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)BinY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))BIN_Y")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)BinY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))BIN_Y")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)MinX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MIN_X")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MinX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MIN_X")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)MinY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MIN_Y")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MinY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MIN_Y")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)SizeX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIZE_X")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)SizeX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIZE_X")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)SizeY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIZE_Y")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)SizeY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIZE_Y")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)ReverseX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))REVERSE_X")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)ReverseX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))REVERSE_X")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)ReverseY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))REVERSE_Y")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)ReverseY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))REVERSE_Y")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)ArraySizeX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_SIZE_X")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)ArraySizeY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_SIZE_Y")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)ArraySizeZ_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_SIZE_Z")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)ArraySize_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the acquisition time and #
|
||||
# period #
|
||||
###################################################################
|
||||
record(ao, "$(P)$(R)AcquireTime")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ACQ_TIME")
|
||||
field(PREC, "3")
|
||||
field(VAL, "1.0")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)AcquireTime_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ACQ_TIME")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)AcquirePeriod")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ACQ_PERIOD")
|
||||
field(PREC, "3")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)AcquirePeriod_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ACQ_PERIOD")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)TimeRemaining_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TIME_REMAINING")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the gain #
|
||||
###################################################################
|
||||
record(ao, "$(P)$(R)Gain")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))GAIN")
|
||||
field(VAL, "1.0")
|
||||
field(PREC, "3")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)Gain_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))GAIN")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the frame type #
|
||||
###################################################################
|
||||
record(mbbo, "$(P)$(R)FrameType")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FRAME_TYPE")
|
||||
field(ZRST, "Normal")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Background")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "FlatField")
|
||||
field(TWVL, "2")
|
||||
field(THST, "DblCorrelation")
|
||||
field(THVL, "3")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)FrameType_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FRAME_TYPE")
|
||||
field(ZRST, "Normal")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Background")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "FlatField")
|
||||
field(TWVL, "2")
|
||||
field(THST, "DblCorrelation")
|
||||
field(THVL, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the acquisition mode #
|
||||
###################################################################
|
||||
record(mbbo, "$(P)$(R)ImageMode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))IMAGE_MODE")
|
||||
field(ZRST, "Single")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Multiple")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Continuous")
|
||||
field(TWVL, "2")
|
||||
field(VAL, "2")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ImageMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))IMAGE_MODE")
|
||||
field(ZRST, "Single")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Multiple")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Continuous")
|
||||
field(TWVL, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the trigger mode #
|
||||
###################################################################
|
||||
record(mbbo, "$(P)$(R)TriggerMode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TRIGGER_MODE")
|
||||
field(ZRST, "Internal")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "External")
|
||||
field(ONVL, "1")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)TriggerMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TRIGGER_MODE")
|
||||
field(ZRST, "Internal")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "External")
|
||||
field(ONVL, "1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the number of exposures and #
|
||||
# number of images #
|
||||
###################################################################
|
||||
record(longout, "$(P)$(R)NumExposures")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NEXPOSURES")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NumExposures_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NEXPOSURES")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NumExposuresCounter_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NEXPOSURES_COUNTER")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
record(longout, "$(P)$(R)NumImages")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NIMAGES")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NumImages_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NIMAGES")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NumImagesCounter_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NIMAGES_COUNTER")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control acquisition start and #
|
||||
# and stop #
|
||||
###################################################################
|
||||
|
||||
record(busy, "$(P)$(R)Acquire") {
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ACQUIRE")
|
||||
field(ZNAM, "Done")
|
||||
field(ONAM, "Acquire")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)Acquire_RBV") {
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ACQUIRE")
|
||||
field(ZNAM, "Done")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(ONAM, "Acquiring")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records provide statistics on array callbacks and #
|
||||
# array callback rates #
|
||||
###################################################################
|
||||
record(longout, "$(P)$(R)ArrayCounter")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_COUNTER")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)ArrayCounter_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_COUNTER")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# This record needs work, because .B should reflect the time since last processed
|
||||
record(calc, "$(P)$(R)ArrayRate_RBV")
|
||||
{
|
||||
field(INPA, "$(P)$(R)ArrayRate_RBV.B NPP NMS") # Previous counter value
|
||||
field(INPB, "$(P)$(R)ArrayCounter_RBV NPP NMS") # Current counter value
|
||||
field(INPC, "1.0") # Delta time, needs work
|
||||
field(CALC, "(B-A)/C")
|
||||
field(PREC, "1")
|
||||
field(SCAN, "1 second")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records are for the detector state #
|
||||
###################################################################
|
||||
|
||||
record(mbbi, "$(P)$(R)DetectorState_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))STATUS")
|
||||
field(ZRST, "Idle")
|
||||
field(ZRVL, "0")
|
||||
field(ZRSV, "NO_ALARM")
|
||||
field(ONST, "Acquire")
|
||||
field(ONVL, "1")
|
||||
field(ONSV, "NO_ALARM")
|
||||
field(TWST, "Readout")
|
||||
field(TWVL, "2")
|
||||
field(TWSV, "NO_ALARM")
|
||||
field(THST, "Correct")
|
||||
field(THVL, "3")
|
||||
field(THSV, "NO_ALARM")
|
||||
field(FRST, "Saving")
|
||||
field(FRVL, "4")
|
||||
field(FRSV, "NO_ALARM")
|
||||
field(FVST, "Aborting")
|
||||
field(FVVL, "5")
|
||||
field(FVSV, "MINOR")
|
||||
field(SXST, "Error")
|
||||
field(SXVL, "6")
|
||||
field(SXSV, "MAJOR")
|
||||
field(SVST, "Waiting")
|
||||
field(SVVL, "7")
|
||||
field(SVSV, "NO_ALARM")
|
||||
field(EIST, "Initializing")
|
||||
field(EIVL, "8")
|
||||
field(EISV, "NO_ALARM")
|
||||
field(NIST, "Disconnected")
|
||||
field(NIVL, "9")
|
||||
field(NISV, "INVALID")
|
||||
field(TEST, "Aborted")
|
||||
field(TEVL, "10")
|
||||
field(TESV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control NDArray callacks #
|
||||
###################################################################
|
||||
record(bo, "$(P)$(R)ArrayCallbacks")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_CALLBACKS")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)ArrayCallbacks_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_CALLBACKS")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# This record is the name of a file defining attributes #
|
||||
###################################################################
|
||||
|
||||
record(waveform, "$(P)$(R)NDAttributesFile")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ND_ATTRIBUTES_FILE")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records provide status information #
|
||||
###################################################################
|
||||
|
||||
# Status message.
|
||||
record(waveform, "$(P)$(R)StatusMessage_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))STATUS_MESSAGE")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)StringToServer_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))STRING_TO_SERVER")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)StringFromServer_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))STRING_FROM_SERVER")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
################################################################@###
|
||||
# This record can be used to force a read of the detector status #
|
||||
####################################################################
|
||||
record(bo,"$(P)$(R)ReadStatus") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))READ_STATUS")
|
||||
field(VAL, "1")
|
||||
field(SCAN,"Passive")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the shutter #
|
||||
###################################################################
|
||||
|
||||
record(mbbo, "$(P)$(R)ShutterMode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SHUTTER_MODE")
|
||||
field(ZRST, "None")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "EPICS PV")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Detector output")
|
||||
field(TWVL, "2")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ShutterMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SHUTTER_MODE")
|
||||
field(ZRST, "None")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "EPICS PV")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Camera output")
|
||||
field(TWVL, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)ShutterControl")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SHUTTER_CONTROL")
|
||||
field(ZNAM, "Close")
|
||||
field(ONAM, "Open")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)ShutterControl_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SHUTTER_CONTROL")
|
||||
field(ZNAM, "Close")
|
||||
field(ONAM, "Open")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)ShutterStatus_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SHUTTER_STATUS")
|
||||
field(ZNAM, "Closed")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(ONAM, "Open")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)ShutterOpenDelay")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SHUTTER_OPEN_DELAY")
|
||||
field(PREC, "3")
|
||||
field(VAL, "0.0")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)ShutterOpenDelay_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SHUTTER_OPEN_DELAY")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)ShutterCloseDelay")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SHUTTER_CLOSE_DELAY")
|
||||
field(PREC, "3")
|
||||
field(VAL, "0.0")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)ShutterCloseDelay_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SHUTTER_CLOSE_DELAY")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# This record changes state when the driver opens/closes an EPICS shutter
|
||||
record(bi, "$(P)$(R)ShutterControlEPICS")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SHUTTER_CONTROL_EPICS")
|
||||
field(ZNAM, "Closed")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(ONAM, "Open")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(FLNK, "$(P)$(R)ShutterFanout.PROC")
|
||||
}
|
||||
|
||||
record(fanout, "$(P)$(R)ShutterFanout")
|
||||
{
|
||||
field(LNK1, "$(P)$(R)ShutterOpenEPICS.PROC PP MS")
|
||||
field(LNK2, "$(P)$(R)ShutterCloseEPICS.PROC PP MS")
|
||||
}
|
||||
|
||||
record(calcout, "$(P)$(R)ShutterOpenEPICS")
|
||||
{
|
||||
field(INPA, "$(P)$(R)ShutterControlEPICS.VAL NPP NMS")
|
||||
field(CALC, "A")
|
||||
field(OOPT, "Transition To Non-zero")
|
||||
field(DOPT, "Use OCAL")
|
||||
field(OCAL, "1")
|
||||
field(OUT, "")
|
||||
}
|
||||
|
||||
record(calcout, "$(P)$(R)ShutterCloseEPICS")
|
||||
{
|
||||
field(INPA, "$(P)$(R)ShutterControlEPICS.VAL NPP NMS")
|
||||
field(CALC, "A")
|
||||
field(OOPT, "Transition To Zero")
|
||||
field(DOPT, "Use OCAL")
|
||||
field(OCAL, "0")
|
||||
field(OUT, "")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ShutterStatusEPICS_RBV")
|
||||
{
|
||||
field(DTYP, "Raw Soft Channel")
|
||||
field(INP, "test CP MS")
|
||||
field(ZRVL, "0")
|
||||
field(ZRST, "Closed")
|
||||
field(ZRSV, "NO_ALARM")
|
||||
field(ONVL, "1")
|
||||
field(ONST, "Open")
|
||||
field(ONSV, "MINOR")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the detector temperature #
|
||||
###################################################################
|
||||
|
||||
record(ao, "$(P)$(R)Temperature")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TEMPERATURE")
|
||||
field(PREC, "3")
|
||||
field(VAL, "25.0")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)Temperature_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TEMPERATURE")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)TemperatureActual")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TEMPERATURE_ACTUAL")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
###################################################################
|
||||
# Status of NDArrayPool - number of buffers, memory used etc. #
|
||||
###################################################################
|
||||
|
||||
record(ai, "$(P)$(R)PoolMaxMem")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))POOL_MAX_MEMORY")
|
||||
field(PREC, "1")
|
||||
field(EGU, "MB")
|
||||
field(SCAN, "Passive")
|
||||
field(PINI, "YES")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PoolMaxBuffers")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))POOL_MAX_BUFFERS")
|
||||
field(SCAN, "Passive")
|
||||
field(PINI, "YES")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)PoolUsedMem")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))POOL_USED_MEMORY")
|
||||
field(PREC, "1")
|
||||
field(EGU, "MB")
|
||||
field(SCAN, "1 second")
|
||||
field(FLNK, "$(P)$(R)PoolAllocBuffers")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PoolAllocBuffers")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))POOL_ALLOC_BUFFERS")
|
||||
field(FLNK, "$(P)$(R)PoolFreeBuffers")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PoolFreeBuffers")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))POOL_FREE_BUFFERS")
|
||||
field(FLNK, "$(P)$(R)PoolUsedBuffers")
|
||||
}
|
||||
|
||||
record(calc, "$(P)$(R)PoolUsedBuffers")
|
||||
{
|
||||
field(INPA, "$(P)$(R)PoolAllocBuffers NPP MS")
|
||||
field(INPB, "$(P)$(R)PoolFreeBuffers NPP MS")
|
||||
field(CALC, "A-B")
|
||||
}
|
||||
|
||||
|
||||
###################################################################
|
||||
# The asynRecord is used for mainly for trace mask #
|
||||
###################################################################
|
||||
|
||||
# Set ASYN_TRACEIO_HEX bit by default
|
||||
record(asyn,"$(P)$(R)AsynIO")
|
||||
{
|
||||
field(PORT, $(PORT))
|
||||
field(TIB2,"1")
|
||||
info("ADType", "ADDriver")
|
||||
}
|
||||
|
||||
@@ -1,33 +0,0 @@
|
||||
$(P)$(R)DataType
|
||||
$(P)$(R)ColorMode
|
||||
$(P)$(R)BinX
|
||||
$(P)$(R)BinY
|
||||
$(P)$(R)MinX
|
||||
$(P)$(R)MinY
|
||||
$(P)$(R)SizeX
|
||||
$(P)$(R)SizeY
|
||||
$(P)$(R)ReverseX
|
||||
$(P)$(R)ReverseY
|
||||
$(P)$(R)AcquireTime
|
||||
$(P)$(R)AcquirePeriod
|
||||
$(P)$(R)Gain
|
||||
$(P)$(R)FrameType
|
||||
$(P)$(R)ImageMode
|
||||
$(P)$(R)TriggerMode
|
||||
$(P)$(R)NumExposures
|
||||
$(P)$(R)NumImages
|
||||
$(P)$(R)ArrayCallbacks
|
||||
$(P)$(R)ShutterMode
|
||||
$(P)$(R)ShutterOpenDelay
|
||||
$(P)$(R)ShutterCloseDelay
|
||||
$(P)$(R)ShutterOpenEPICS.OUT
|
||||
$(P)$(R)ShutterCloseEPICS.OUT
|
||||
$(P)$(R)ShutterOpenEPICS.OCAL
|
||||
$(P)$(R)ShutterCloseEPICS.OCAL
|
||||
$(P)$(R)ShutterStatusEPICS_RBV.INP
|
||||
$(P)$(R)ShutterStatusEPICS_RBV.ZRVL
|
||||
$(P)$(R)ShutterStatusEPICS_RBV.ONVL
|
||||
$(P)$(R)Temperature
|
||||
$(P)$(R)ReadStatus.SCAN
|
||||
$(P)$(R)NDAttributesFile
|
||||
$(P)$(R)PoolUsedMem.SCAN
|
||||
@@ -1,9 +0,0 @@
|
||||
# Database contains a waveform record to hold a list of channel prefixes for area detector elements in an ioc
|
||||
# John Hammonds
|
||||
# May 3, 2010
|
||||
record(waveform, "$(P)$(R)ChannelPrefixes")
|
||||
{
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, $(NELEMENTS))
|
||||
}
|
||||
|
||||
@@ -1,104 +0,0 @@
|
||||
# Database for the records specific to the BIS driver
|
||||
# Jeff Gebhardt and Mark Rivers
|
||||
|
||||
# Timeout waiting for SFRM file.
|
||||
record(ao, "$(P)$(R)ReadSFRMTimeout")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SFRM_TIMEOUT")
|
||||
field(DESC, "Timeout for SFRM file")
|
||||
field(VAL, "30")
|
||||
field(EGU, "s")
|
||||
field(PREC, "3")
|
||||
}
|
||||
|
||||
# Status string from BIS
|
||||
record(waveform, "$(P)$(R)BISStatus")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))BIS_STATUS")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "512")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Number of dark fields
|
||||
record(longout, "$(P)$(R)NumDarks")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NUM_DARKS")
|
||||
field(VAL, "2")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NumDarks_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NUM_DARKS")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
# We replace the file format choices from ADBase.template
|
||||
record(mbbo, "$(P)$(R)FileFormat")
|
||||
{
|
||||
field(ZRST, "SRFM")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Invalid")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)FileFormat_RBV")
|
||||
{
|
||||
field(ZRST, "SRFM")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Invalid")
|
||||
field(ONVL, "1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# We replace the choice fields for FrameType from ADBase.template
|
||||
record(mbbo, "$(P)$(R)FrameType")
|
||||
{
|
||||
field(ZRST, "Normal")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Dark")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Raw")
|
||||
field(TWVL, "2")
|
||||
field(THST, "DblCorrelation")
|
||||
field(THVL, "3")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)FrameType_RBV")
|
||||
{
|
||||
field(ZRST, "Normal")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Dark")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Raw")
|
||||
field(TWVL, "2")
|
||||
field(THST, "DblCorrelation")
|
||||
field(THVL, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Change the PREC of the temperature and time remaining records to 2
|
||||
record(ai, "$(P)$(R)Temperature_RBV")
|
||||
{
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)TimeRemaining_RBV")
|
||||
{
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
# asyn record for interactive communication with BIS
|
||||
record(asyn, "$(P)$(R)BISAsyn")
|
||||
{
|
||||
field(PORT, "$(BIS_PORT)")
|
||||
field(IMAX, "256")
|
||||
field(OMAX, "256")
|
||||
}
|
||||
@@ -1,3 +0,0 @@
|
||||
$(P)$(R)ReadSFRMTimeout
|
||||
$(P)$(R)NumDarks
|
||||
|
||||
@@ -1,571 +0,0 @@
|
||||
# Database for the records specific to the LightField driver
|
||||
# Mark Rivers
|
||||
# September 5, 2013
|
||||
|
||||
# These are the records from ADBase.template that we modify some fields for
|
||||
|
||||
# We replace the choice fields for ImageMode from ADBase.template
|
||||
record(mbbo, "$(P)$(R)ImageMode")
|
||||
{
|
||||
field(ZRST, "Normal")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Preview")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Background")
|
||||
field(TWVL, "2")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ImageMode_RBV")
|
||||
{
|
||||
field(ZRST, "Normal")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Preview")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Background")
|
||||
field(TWVL, "2")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)TriggerMode")
|
||||
{
|
||||
field(ZRST, "Internal")
|
||||
field(ZRVL, "2")
|
||||
field(ONST, "External")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)TriggerMode_RBV")
|
||||
{
|
||||
field(ZRST, "Internal")
|
||||
field(ZRVL, "2")
|
||||
field(ONST, "External")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
# Change state 7 (ADStatusWaiting) string to Busy and alarm status to minor
|
||||
record(mbbi, "$(P)$(R)DetectorState_RBV")
|
||||
{
|
||||
field(SVST, "Busy")
|
||||
field(SVVL, "7")
|
||||
field(SVSV, "MINOR")
|
||||
}
|
||||
|
||||
|
||||
# We change the precision on the Gain record to 0, because it is an integer on LightField
|
||||
record(ao, "$(P)$(R)Gain")
|
||||
{
|
||||
field(PREC, "0")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)Gain_RBV")
|
||||
{
|
||||
field(PREC, "0")
|
||||
}
|
||||
|
||||
|
||||
# These are new records for the LightField detector
|
||||
|
||||
record(longout, "$(P)$(R)NumAccumulations")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_NUM_ACCUMULATIONS")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NumAccumulations_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_NUM_ACCUMULATIONS")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)NumAcquisitions")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_NUM_ACQUISITIONS")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NumAcquisitions_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_NUM_ACQUISITIONS")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NumAcquisitionsCounter_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_NUM_ACQUISITIONS_COUNTER")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)LFGain")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_GAIN")
|
||||
field(ZRST, "Low")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "Medium")
|
||||
field(ONVL, "2")
|
||||
field(TWST, "High")
|
||||
field(TWVL, "3")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)LFGain_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_GAIN")
|
||||
field(ZRST, "Low")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "Medium")
|
||||
field(ONVL, "2")
|
||||
field(TWST, "High")
|
||||
field(TWVL, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)LFShutterMode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_SHUTTER_MODE")
|
||||
field(ZRST, "Normal")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "Always closed")
|
||||
field(ONVL, "2")
|
||||
field(TWST, "Always open")
|
||||
field(TWVL, "3")
|
||||
field(THST, "Open before trigger")
|
||||
field(THVL, "4")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)LFShutterMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_SHUTTER_MODE")
|
||||
field(ZRST, "Normal")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "Always closed")
|
||||
field(ONVL, "2")
|
||||
field(TWST, "Always open")
|
||||
field(TWVL, "3")
|
||||
field(THST, "Open before trigger")
|
||||
field(THVL, "4")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)LFExperimentName")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_EXPERIMENT_NAME")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)LFExperimentName_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_EXPERIMENT_NAME")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)LFUpdateExperiments")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_UPDATE_EXPERIMENTS")
|
||||
field(ZNAM, "Done")
|
||||
field(ONAM, "Update")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)LFGrating")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_GRATING")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)LFGrating_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_GRATING")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)LFGratingWavelength")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_GRATING_WAVELENGTH")
|
||||
field(PREC, "3")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)LFGratingWavelength_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_GRATING_WAVELENGTH")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "3")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)LFEntranceWidth")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_ENTRANCE_SIDE_WIDTH")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)LFEntranceWidth_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_ENTRANCE_SIDE_WIDTH")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)LFExitPort")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_EXIT_SELECTED")
|
||||
field(ZRST, "Side")
|
||||
field(ZRVL, "5")
|
||||
field(ONST, "Front")
|
||||
field(ONVL, "4")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)LFExitPort_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_EXIT_SELECTED")
|
||||
field(ZRST, "Side")
|
||||
field(ZRVL, "5")
|
||||
field(ONST, "Front")
|
||||
field(ONVL, "4")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)LFFilePath_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_FILE_PATH")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)LFFileName_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_FILE_NAME")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)LFBackgroundPath")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_BACKGROUND_PATH")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)LFBackgroundPath_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_BACKGROUND_PATH")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)LFBackgroundFile")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_BACKGROUND_FILE")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)LFBackgroundFile_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_BACKGROUND_FILE")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)LFBackgroundFullFile_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_BACKGROUND_FULL_FILE")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)LFBackgroundEnable")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_BACKGROUND_ENABLE")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)LFBackgroundEnable_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_BACKGROUND_ENABLE")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)LFIntensifierEnable")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_INTENSIFIER_ENABLE")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)LFIntensifierEnable_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_INTENSIFIER_ENABLE")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)LFIntensifierGain")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_INTENSIFIER_GAIN")
|
||||
field(PREC, "0")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)LFIntensifierGain_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_INTENSIFIER_GAIN")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "0")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)LFGatingMode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_GATING_MODE")
|
||||
field(ZRST, "Repetitive")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "Sequential")
|
||||
field(ONVL, "2")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)LFGatingMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_GATING_MODE")
|
||||
field(ZRST, "Repetitive")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "Sequential")
|
||||
field(ONVL, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)LFTriggerFrequency")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_TRIGGER_FREQUENCY")
|
||||
field(PREC, "0")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)LFTriggerFrequency_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_TRIGGER_FREQUENCY")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "0")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)LFSyncMasterEnable")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_SYNCMASTER_ENABLE")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)LFSyncMasterEnable_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_SYNCMASTER_ENABLE")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)LFSyncMaster2Delay")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_SYNCMASTER2_DELAY")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)LFSyncMaster2Delay_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_SYNCMASTER2_DELAY")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)LFRepGateWidth")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_REP_GATE_WIDTH")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)LFRepGateWidth_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_REP_GATE_WIDTH")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)LFRepGateDelay")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_REP_GATE_DELAY")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)LFRepGateDelay_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_REP_GATE_DELAY")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)LFSeqStartGateWidth")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_SEQ_START_GATE_WIDTH")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)LFSeqStartGateWidth_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_SEQ_START_GATE_WIDTH")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)LFSeqStartGateDelay")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_SEQ_START_GATE_DELAY")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)LFSeqStartGateDelay_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_SEQ_START_GATE_DELAY")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)LFSeqEndGateWidth")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_SEQ_END_GATE_WIDTH")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)LFSeqEndGateWidth_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_SEQ_END_GATE_WIDTH")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)LFSeqEndGateDelay")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_SEQ_END_GATE_DELAY")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)LFSeqEndGateDelay_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_SEQ_END_GATE_DELAY")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)LFAuxWidth")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_AUX_WIDTH")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)LFAuxWidth_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_AUX_WIDTH")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)LFAuxDelay")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_AUX_DELAY")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)LFAuxDelay_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_AUX_DELAY")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)LFReadyToRun")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LF_READY_TO_RUN")
|
||||
field(ZNAM, "NotReady")
|
||||
field(ZSV, "MAJOR")
|
||||
field(ONAM, "Ready")
|
||||
field(OSV, "NO_ALARM")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
@@ -1,27 +0,0 @@
|
||||
$(P)$(R)NumAccumulations
|
||||
$(P)$(R)NumAcquisitions
|
||||
$(P)$(R)LFGain
|
||||
$(P)$(R)LFShutterMode
|
||||
$(P)$(R)LFExperimentName
|
||||
$(P)$(R)LFGrating
|
||||
$(P)$(R)LFGratingWavelength
|
||||
$(P)$(R)LFEntranceWidth
|
||||
$(P)$(R)LFExitPort
|
||||
$(P)$(R)LFBackgroundPath
|
||||
$(P)$(R)LFBackgroundFile
|
||||
$(P)$(R)LFBackgroundEnable
|
||||
$(P)$(R)LFIntensifierEnable
|
||||
$(P)$(R)LFIntensifierGain
|
||||
$(P)$(R)LFGatingMode
|
||||
$(P)$(R)LFTriggerFrequency
|
||||
$(P)$(R)LFSyncMasterEnable
|
||||
$(P)$(R)LFSyncMaster2Delay
|
||||
$(P)$(R)LFRepGateWidth
|
||||
$(P)$(R)LFRepGateDelay
|
||||
$(P)$(R)LFSeqStartGateWidth
|
||||
$(P)$(R)LFSeqStartGateDelay
|
||||
$(P)$(R)LFSeqEndGateWidth
|
||||
$(P)$(R)LFSeqEndGateDelay
|
||||
$(P)$(R)LFAuxWidth
|
||||
$(P)$(R)LFAuxDelay
|
||||
|
||||
@@ -1,80 +0,0 @@
|
||||
# Database forNDPluginColorConvert
|
||||
# Mark Rivers
|
||||
# December 23, 2008
|
||||
|
||||
###################################################################
|
||||
# These records control the color mode #
|
||||
# These choices must agree with NDColorMode_t in NDArray.h #
|
||||
###################################################################
|
||||
|
||||
record(mbbo, "$(P)$(R)ColorModeOut")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COLOR_MODE_OUT")
|
||||
field(ZRST, "Mono")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Bayer")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "RGB1")
|
||||
field(TWVL, "2")
|
||||
field(THST, "RGB2")
|
||||
field(THVL, "3")
|
||||
field(FRST, "RGB3")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "YUV444")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "YUV422")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "YUV421")
|
||||
field(SVVL, "7")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ColorModeOut_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COLOR_MODE_OUT")
|
||||
field(ZRST, "Mono")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Bayer")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "RGB1")
|
||||
field(TWVL, "2")
|
||||
field(THST, "RGB2")
|
||||
field(THVL, "3")
|
||||
field(FRST, "RGB3")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "YUV444")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "YUV422")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "YUV421")
|
||||
field(SVVL, "7")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)FalseColor")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FALSE_COLOR")
|
||||
field(ZRST, "None")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Rainbow")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Iron")
|
||||
field(TWVL, "2")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)FalseColor_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FALSE_COLOR")
|
||||
field(ZRST, "None")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Rainbow")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Iron")
|
||||
field(TWVL, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
@@ -1 +0,0 @@
|
||||
$(P)$(R)ColorModeOut
|
||||
@@ -1,331 +0,0 @@
|
||||
# Database for NDFile driver, which saves files for NDArray data.
|
||||
# Mark Rivers
|
||||
# April 7, 2008
|
||||
|
||||
###################################################################
|
||||
# These records control file I/O #
|
||||
###################################################################
|
||||
|
||||
# File path.
|
||||
record(waveform, "$(P)$(R)FilePath")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_PATH")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)FilePath_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_PATH")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)FilePathExists_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_PATH_EXISTS")
|
||||
field(ZNAM, "No")
|
||||
field(ZSV, "MAJOR")
|
||||
field(ONAM, "Yes")
|
||||
field(OSV, "NO_ALARM")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Filename
|
||||
record(waveform, "$(P)$(R)FileName")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_NAME")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)FileName_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_NAME")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)FileNumber")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(OUT, "$(P)$(R)FileNumber_write PP")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)FileNumber_write")
|
||||
{
|
||||
field(SDIS, "$(P)$(R)FileNumber_Sync.PACT")
|
||||
field(DISV, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_NUMBER")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)FileNumber_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_NUMBER")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(FLNK, "$(P)$(R)FileNumber_Sync")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)FileNumber_Sync")
|
||||
{
|
||||
field(DOL, "$(P)$(R)FileNumber_RBV NPP")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUT, "$(P)$(R)FileNumber PP")
|
||||
}
|
||||
|
||||
# Autoincrement flag
|
||||
record(bo, "$(P)$(R)AutoIncrement")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))AUTO_INCREMENT")
|
||||
field(VAL, "1")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)AutoIncrement_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))AUTO_INCREMENT")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# File template
|
||||
record(waveform, "$(P)$(R)FileTemplate")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_TEMPLATE")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)FileTemplate_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_TEMPLATE")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Full filename, including path
|
||||
record(waveform, "$(P)$(R)FullFileName_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FULL_FILE_NAME")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Autosave flag
|
||||
record(bo, "$(P)$(R)AutoSave")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))AUTO_SAVE")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)AutoSave_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))AUTO_SAVE")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Write file
|
||||
record(busy, "$(P)$(R)WriteFile")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))WRITE_FILE")
|
||||
field(ZNAM, "Done")
|
||||
field(ONAM, "Write")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)WriteFile_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))WRITE_FILE")
|
||||
field(ZNAM, "Done")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(ONAM, "Writing")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
# Read file
|
||||
record(busy, "$(P)$(R)ReadFile")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))READ_FILE")
|
||||
field(ZNAM, "Done")
|
||||
field(ONAM, "Read")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)ReadFile_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))READ_FILE")
|
||||
field(ZNAM, "Done")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(ONAM, "Reading")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# File data format
|
||||
record(mbbo, "$(P)$(R)FileFormat")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_FORMAT")
|
||||
field(VAL, "0")
|
||||
field(ZRST, "Undefined")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Invalid")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)FileFormat_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_FORMAT")
|
||||
field(ZRST, "netCDF")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Undefined")
|
||||
field(ONVL, "1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# File save mode
|
||||
record(mbbo, "$(P)$(R)FileWriteMode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))WRITE_MODE")
|
||||
field(VAL, "0")
|
||||
field(ZRST, "Single")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Capture")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Stream")
|
||||
field(TWVL, "2")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)FileWriteMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))WRITE_MODE")
|
||||
field(ZRST, "Single")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Capture")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Stream")
|
||||
field(TWVL, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Capture data
|
||||
record(busy, "$(P)$(R)Capture")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))CAPTURE")
|
||||
field(ZNAM, "Done")
|
||||
field(ONAM, "Capture")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)Capture_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))CAPTURE")
|
||||
field(ZNAM, "Done")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(ONAM, "Capturing")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)NumCapture")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NUM_CAPTURE")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NumCapture_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NUM_CAPTURE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NumCaptured_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NUM_CAPTURED")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Delete driver file flag
|
||||
record(bo, "$(P)$(R)DeleteDriverFile")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DELETE_DRIVER_FILE")
|
||||
field(VAL, "0")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)DeleteDriverFile_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DELETE_DRIVER_FILE")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)WriteStatus")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))WRITE_STATUS")
|
||||
field(ZNAM, "Write OK")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(ONAM, "Write error")
|
||||
field(OSV, "MAJOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)WriteMessage")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))WRITE_MESSAGE")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
@@ -1,391 +0,0 @@
|
||||
# Database for NDFileHDF5 driver, which saves files for NDArray data.
|
||||
|
||||
# Macros:
|
||||
# % macro, P, Device Prefix
|
||||
# % macro, R, Device Suffix
|
||||
# % macro, PORT, Asyn Port name
|
||||
|
||||
# % gdatag, template, NDFileHDF5, $(PORT)_NDFileHDF5, $(PORT) NDFileHDF5 class instance
|
||||
|
||||
# This associates the template with an edm screen
|
||||
# % gui, $(PORT), edmtab, NDFileHDF5.edl, P=$(P),R=$(R)
|
||||
|
||||
# We replace some fields in records defined in NDFile.template
|
||||
# File data format
|
||||
record(mbbo, "$(P)$(R)FileFormat")
|
||||
{
|
||||
field(ZRST, "HDF5")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Invalid")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)FileFormat_RBV")
|
||||
{
|
||||
field(ZRST, "HDF5")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Undefined")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
# % gdatag, pv, rw, $(PORT)_NDFileHDF5, NumRowChunks, Number of rows to use per chunk
|
||||
record(longout, "$(P)$(R)NumRowChunks")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),0)HDF5_nRowChunks")
|
||||
field(PINI, "YES")
|
||||
}
|
||||
|
||||
# % gdatag, pv, ro, $(PORT)_NDFileHDF5, NumRowChunks_RBV, Readback of number of rows to use per chunk
|
||||
record(longin, "$(P)$(R)NumRowChunks_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_nRowChunks")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# % gdatag, pv, rw, $(PORT)_NDFileHDF5, NumColChunks, Number of columns to use per chunk
|
||||
record(longout, "$(P)$(R)NumColChunks")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),0)HDF5_nColChunks")
|
||||
field(PINI, "YES")
|
||||
}
|
||||
|
||||
# % gdatag, pv, ro, $(PORT)_NDFileHDF5, NumColChunks_RBV, Readback of number of columns to use per chunk
|
||||
record(longin, "$(P)$(R)NumColChunks_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_nColChunks")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# % gdatag, pv, rw, $(PORT)_NDFileHDF5, NumFramesChunks, Number of frames to cache and use per chunk
|
||||
record(longout, "$(P)$(R)NumFramesChunks")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),0)HDF5_nFramesChunks")
|
||||
field(PINI, "YES")
|
||||
}
|
||||
|
||||
# % gdatag, pv, ro, $(PORT)_NDFileHDF5, NumFramesChunks_RBV, Readback of number of frames to use and cache per chunk
|
||||
record(longin, "$(P)$(R)NumFramesChunks_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_nFramesChunks")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)BoundaryAlign")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),0)HDF5_chunkBoundaryAlign")
|
||||
field(PINI, "YES")
|
||||
field(VAL, "0")
|
||||
field(EGU, "bytes")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)BoundaryAlign_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_chunkBoundaryAlign")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(EGU, "bytes")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)BoundaryThreshold")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),0)HDF5_chunkBoundaryThreshold")
|
||||
field(PINI, "YES")
|
||||
field(VAL, "1")
|
||||
field(EGU, "bytes")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)BoundaryThreshold_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_chunkBoundaryThreshold")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(EGU, "bytes")
|
||||
}
|
||||
|
||||
# % gdatag, pv, rw, $(PORT)_NDFileHDF5, NumExtraDims, Number of extra dimensions [0..2]
|
||||
record(longout, "$(P)$(R)NumExtraDims")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),0)HDF5_nExtraDims")
|
||||
field(PINI, "YES")
|
||||
}
|
||||
|
||||
# % gdatag, pv, ro, $(PORT)_NDFileHDF5, NumExtraDims_RBV, Readback number of extra dimensions
|
||||
record(longin, "$(P)$(R)NumExtraDims_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_nExtraDims")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# % gdatag, pv, rw, $(PORT)_NDFileHDF5, ExtraDimSizeN, Size of extra dimension N (no. of frames per point)
|
||||
record(longout, "$(P)$(R)ExtraDimSizeN")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),0)HDF5_extraDimSizeN")
|
||||
field(PINI, "YES")
|
||||
}
|
||||
|
||||
# % gdatag, pv, ro, $(PORT)_NDFileHDF5, ExtraDimSizeN_RBV, Readback size of extra dimension N (no. of frames per point)
|
||||
record(longin, "$(P)$(R)ExtraDimSizeN_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_extraDimSizeN")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(stringin, "$(P)$(R)ExtraDimNameN_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_extraDimNameN")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# % gdatag, pv, rw, $(PORT)_NDFileHDF5, ExtraDimSizeX, Size of extra dimension X
|
||||
record(longout, "$(P)$(R)ExtraDimSizeX")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),0)HDF5_extraDimSizeX")
|
||||
field(PINI, "YES")
|
||||
}
|
||||
|
||||
# % gdatag, pv, ro, $(PORT)_NDFileHDF5, ExtraDimSizeX_RBV, Readback size of extra dimension X
|
||||
record(longin, "$(P)$(R)ExtraDimSizeX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_extraDimSizeX")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(stringin, "$(P)$(R)ExtraDimNameX_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_extraDimNameX")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# % gdatag, pv, rw, $(PORT)_NDFileHDF5, ExtraDimSizeY, Size of extra dimension Y
|
||||
record(longout, "$(P)$(R)ExtraDimSizeY")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),0)HDF5_extraDimSizeY")
|
||||
field(PINI, "YES")
|
||||
}
|
||||
|
||||
# % gdatag, pv, ro, $(PORT)_NDFileHDF5, ExtraDimSizeY_RBV, Readback size of extra dimension Y
|
||||
record(longin, "$(P)$(R)ExtraDimSizeY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_extraDimSizeY")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(stringin, "$(P)$(R)ExtraDimNameY_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_extraDimNameY")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)StoreAttr")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),0)HDF5_storeAttributes")
|
||||
field(PINI, "NO")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)StoreAttr_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_storeAttributes")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)StorePerform")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),0)HDF5_storePerformance")
|
||||
field(PINI, "NO")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)StorePerform_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_storePerformance")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
# % gdatag, pv, ro, $(PORT)_NDFileHDF5, runtime, Total runtime from first frame to file closed
|
||||
record(ai, "$(P)$(R)RunTime")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_totalRuntime")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "3")
|
||||
field(EGU, "s")
|
||||
}
|
||||
|
||||
# % gdatag, pv, ro, $(PORT)_NDFileHDF5, IOSpeed, Overall IO speed from first frame to file closed
|
||||
record(ai, "$(P)$(R)IOSpeed")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_totalIoSpeed")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "1")
|
||||
field(EGU, "Mbit/s")
|
||||
}
|
||||
|
||||
# % gdatag, pv, rw, $(PORT)_NDFileHDF5, NumFramesFlush, Flush to file every Nth frame
|
||||
record(longout, "$(P)$(R)NumFramesFlush")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),0)HDF5_flushNthFrame")
|
||||
field(PINI, "NO")
|
||||
}
|
||||
|
||||
# % gdatag, pv, rw, $(PORT)_NDFileHDF5, NumFramesFlush_RBV, Readback the number of frames between file flush
|
||||
record(longin, "$(P)$(R)NumFramesFlush_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_flushNthFrame")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# % gdatag, mbbinary, rw, $(PORT)_NDFileHDF5, Compression, Select or switch off compression filter
|
||||
record(mbbo, "$(P)$(R)Compression")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),0)HDF5_compressionType")
|
||||
field(ZRST, "None")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "N-bit")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "szip")
|
||||
field(TWVL, "2")
|
||||
field(THST, "zlib")
|
||||
field(THVL, "3")
|
||||
}
|
||||
|
||||
# % gdatag, mbbinary, ro, $(PORT)_NDFileHDF5, Compression_RBV, Readback selected compression filter
|
||||
record(mbbi, "$(P)$(R)Compression_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_compressionType")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZRST, "None")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "nbit")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "szip")
|
||||
field(TWVL, "2")
|
||||
field(THST, "zlib")
|
||||
field(THVL, "3")
|
||||
}
|
||||
|
||||
# % gdatag, pv, rw, $(PORT)_NDFileHDF5, NumBitPrecision, N-bit compression filter: number of data bits per pixel
|
||||
record(longout, "$(P)$(R)NumDataBits")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),0)HDF5_nbitsPrecision")
|
||||
field(PINI, "NO")
|
||||
field(EGU, "bit")
|
||||
}
|
||||
|
||||
# % gdatag, pv, ro, $(PORT)_NDFileHDF5, NumBitPrecision_RBV, Readback N-bit compression filter: number of data bits per pixel
|
||||
record(longin, "$(P)$(R)NumDataBits_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_nbitsPrecision")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(EGU, "bit")
|
||||
}
|
||||
|
||||
# % gdatag, pv, rw, $(PORT)_NDFileHDF5, NumBitOffset, N-bit compression filter: dataword bit-offset in pixel
|
||||
record(longout, "$(P)$(R)DataBitsOffset")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),0)HDF5_nbitsOffset")
|
||||
field(PINI, "NO")
|
||||
field(EGU, "bit")
|
||||
}
|
||||
|
||||
# % gdatag, pv, ro, $(PORT)_NDFileHDF5, NumBitOffset_RBV, Readback N-bit compression filter: dataword bit-offset in pixel
|
||||
record(longin, "$(P)$(R)DataBitsOffset_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_nbitsOffset")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(EGU, "bit")
|
||||
}
|
||||
|
||||
# % gdatag, pv, rw, $(PORT)_NDFileHDF5, szipNumPixels, szip compression filter: number of pixels in filter
|
||||
record(longout, "$(P)$(R)SZipNumPixels")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),0)HDF5_szipNumPixels")
|
||||
field(PINI, "NO")
|
||||
field(EGU, "bit")
|
||||
}
|
||||
|
||||
# % gdatag, pv, ro, $(PORT)_NDFileHDF5, szipNumPixels_RBV, Readback szip compression filter: number of pixels in filter
|
||||
record(longin, "$(P)$(R)SZipNumPixels_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_szipNumPixels")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(EGU, "bit")
|
||||
}
|
||||
|
||||
# % gdatag, pv, rw, $(PORT)_NDFileHDF5, ZCompressLevel, zlib compression filter: compression level
|
||||
record(longout, "$(P)$(R)ZLevel")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),0)HDF5_zCompressLevel")
|
||||
field(PINI, "NO")
|
||||
}
|
||||
|
||||
# % gdatag, pv, ro, $(PORT)_NDFileHDF5, ZCompressLevel_RBV, Readback zlib compression filter: compression level
|
||||
record(longin, "$(P)$(R)ZLevel_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),0)HDF5_zCompressLevel")
|
||||
field(PINI, "NO")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
@@ -1,18 +0,0 @@
|
||||
$(P)$(R)NumRowChunks
|
||||
$(P)$(R)NumColChunks
|
||||
$(P)$(R)NumFramesChunks
|
||||
$(P)$(R)BoundaryAlign
|
||||
$(P)$(R)BoundaryThreshold
|
||||
$(P)$(R)NumFramesFlush
|
||||
$(P)$(R)Compression
|
||||
$(P)$(R)NumDataBits
|
||||
$(P)$(R)DataBitsOffset
|
||||
$(P)$(R)SZipNumPixels
|
||||
$(P)$(R)ZLevel
|
||||
$(P)$(R)StorePerform
|
||||
$(P)$(R)StoreAttr
|
||||
$(P)$(R)NumExtraDims
|
||||
$(P)$(R)ExtraDimSizeN
|
||||
$(P)$(R)ExtraDimSizeX
|
||||
$(P)$(R)ExtraDimSizeY
|
||||
|
||||
@@ -1,44 +0,0 @@
|
||||
# Database for NDFileJPEG driver, which saves NDArray data
|
||||
# in the JPEG file format
|
||||
# Mark Rivers
|
||||
# May 10, 2009
|
||||
|
||||
# We replace some fields in records defined in NDFile.template
|
||||
# File data format
|
||||
record(mbbo, "$(P)$(R)FileFormat")
|
||||
{
|
||||
field(ZRST, "JPEG")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Invalid")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)FileFormat_RBV")
|
||||
{
|
||||
field(ZRST, "JPEG")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Undefined")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
# File quality
|
||||
record(longout, "$(P)$(R)JPEGQuality")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))JPEG_QUALITY")
|
||||
field(VAL, "50")
|
||||
field(LOPR, "0")
|
||||
field(DRVL, "0")
|
||||
field(HOPR, "100")
|
||||
field(DRVH, "100")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)JPEGQuality_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))JPEG_QUALITY")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "100")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
@@ -1 +0,0 @@
|
||||
$(P)$(R)JPEGQuality
|
||||
@@ -1,121 +0,0 @@
|
||||
# Database for NDFileMagick driver, which saves NDArray data
|
||||
# in any file format supported by Magick.
|
||||
# The file format is determined by the file extension
|
||||
# Mark Rivers
|
||||
# May 10, 2009
|
||||
|
||||
# We replace some fields in records defined in NDFile.template
|
||||
# File data format
|
||||
record(mbbo, "$(P)$(R)FileFormat")
|
||||
{
|
||||
field(ZRST, "Use extension")
|
||||
field(ZRVL, "0")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)FileFormat_RBV")
|
||||
{
|
||||
field(ZRST, "Use extension")
|
||||
field(ZRVL, "0")
|
||||
}
|
||||
|
||||
# File quality
|
||||
record(longout, "$(P)$(R)Quality")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAGICK_QUALITY")
|
||||
field(VAL, "100")
|
||||
field(LOPR, "0")
|
||||
field(DRVL, "0")
|
||||
field(HOPR, "100")
|
||||
field(DRVH, "100")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)Quality_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAGICK_QUALITY")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "100")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the bit depth #
|
||||
###################################################################
|
||||
|
||||
record(mbbo, "$(P)$(R)BitDepth")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAGICK_BIT_DEPTH")
|
||||
field(ZRST, "1")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "8")
|
||||
field(ONVL, "8")
|
||||
field(TWST, "16")
|
||||
field(TWVL, "16")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)BitDepth_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAGICK_BIT_DEPTH")
|
||||
field(ZRST, "1")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "8")
|
||||
field(ONVL, "8")
|
||||
field(TWST, "16")
|
||||
field(TWVL, "16")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the compression #
|
||||
###################################################################
|
||||
|
||||
record(mbbo, "$(P)$(R)CompressType")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAGICK_COMPRESS_TYPE")
|
||||
field(ZRST, "None")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "BZip")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "FAX")
|
||||
field(TWVL, "2")
|
||||
field(THST, "Group 4")
|
||||
field(THVL, "3")
|
||||
field(FRST, "JPEG")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "LZW")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "RLE")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "Zip")
|
||||
field(SVVL, "7")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)CompressType_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAGICK_COMPRESS_TYPE")
|
||||
field(ZRST, "None")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "BZip")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "FAX")
|
||||
field(TWVL, "2")
|
||||
field(THST, "Group 4")
|
||||
field(THVL, "3")
|
||||
field(FRST, "JPEG")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "LZW")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "RLE")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "Zip")
|
||||
field(SVVL, "7")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
@@ -1,3 +0,0 @@
|
||||
$(P)$(R)Quality
|
||||
$(P)$(R)CompressType
|
||||
$(P)$(R)BitDepth
|
||||
@@ -1,23 +0,0 @@
|
||||
# Database for NDFileNetCDF driver, which saves NDArray data
|
||||
# in the netCDF file format
|
||||
# Mark Rivers
|
||||
# May 10, 2009
|
||||
|
||||
# We replace some fields in records defined in NDFile.template
|
||||
# File data format
|
||||
record(mbbo, "$(P)$(R)FileFormat")
|
||||
{
|
||||
field(ZRST, "netCDF")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Invalid")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)FileFormat_RBV")
|
||||
{
|
||||
field(ZRST, "netCDF")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Undefined")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
@@ -1,69 +0,0 @@
|
||||
# Database for NDFileNexus driver, which saves files for NDArray data.
|
||||
|
||||
# We replace some fields in records defined in NDFile.template
|
||||
# File data format
|
||||
record(mbbo, "$(P)$(R)FileFormat")
|
||||
{
|
||||
field(ZRST, "NeXus")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Invalid")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)FileFormat_RBV")
|
||||
{
|
||||
field(ZRST, "NeXus")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Undefined")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
|
||||
# These records are specific to NeXus file format
|
||||
# Template File path.
|
||||
record(waveform, "$(P)$(R)TemplateFilePath")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TEMPLATE_FILE_PATH")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TemplateFilePath_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TEMPLATE_FILE_PATH")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Template Filename
|
||||
record(waveform, "$(P)$(R)TemplateFileName")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TEMPLATE_FILE_NAME")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TemplateFileName_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TEMPLATE_FILE_NAME")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)FileTemplateValid")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TEMPLATE_FILE_VALID")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
@@ -1,2 +0,0 @@
|
||||
$(P)$(R)TemplateFilePath
|
||||
$(P)$(R)TemplateFileName
|
||||
@@ -1,23 +0,0 @@
|
||||
# Database for NDFileTIFF driver, which saves NDArray data
|
||||
# in the TIFF file format
|
||||
# Mark Rivers
|
||||
# May 10, 2009
|
||||
|
||||
# We replace some fields in records defined in NDFile.template
|
||||
# File data format
|
||||
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, "Undefined")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
@@ -1,10 +0,0 @@
|
||||
$(P)$(R)FilePath
|
||||
$(P)$(R)FileName
|
||||
$(P)$(R)FileNumber
|
||||
$(P)$(R)AutoIncrement
|
||||
$(P)$(R)FileTemplate
|
||||
$(P)$(R)AutoSave
|
||||
$(P)$(R)FileFormat
|
||||
$(P)$(R)FileWriteMode
|
||||
$(P)$(R)NumCapture
|
||||
$(P)$(R)DeleteDriverFile
|
||||
@@ -1,18 +0,0 @@
|
||||
# Database for NDPluginOverlay asyn driver and standard asyn device support
|
||||
# Mark Rivers
|
||||
# March 25, 2010
|
||||
|
||||
# These are the array dimensions in X, Y order. Used for setting HOPR on sliders
|
||||
record(longin, "$(P)$(R)MaxSizeX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAX_SIZE_X")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MaxSizeY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAX_SIZE_Y")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
@@ -1,270 +0,0 @@
|
||||
# Database for NDOverlays
|
||||
# Mark Rivers
|
||||
# March 22, 2010
|
||||
|
||||
###################################################################
|
||||
# These records control the label for the overlay #
|
||||
###################################################################
|
||||
record(stringout, "$(P)$(R)Name")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NAME")
|
||||
field(VAL, "$(NAME)")
|
||||
}
|
||||
|
||||
record(stringin, "$(P)$(R)Name_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NAME")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
###################################################################
|
||||
# These records control whether this overlay is used #
|
||||
###################################################################
|
||||
record(bo, "$(P)$(R)Use")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))USE")
|
||||
field(VAL, "0")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)Use_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))USE")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the overlay definition #
|
||||
###################################################################
|
||||
|
||||
record(longout, "$(P)$(R)PositionXLink")
|
||||
{
|
||||
field(DOL, "$(XPOS) CP MS")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUT, "$(P)$(R)PositionX PP")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PositionX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_POSITION_X")
|
||||
field(LOPR, "1")
|
||||
field(HOPR, "1024")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PositionX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_POSITION_X")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PositionYLink")
|
||||
{
|
||||
field(DOL, "$(YPOS) CP MS")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUT, "$(P)$(R)PositionY PP")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PositionY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_POSITION_Y")
|
||||
field(LOPR, "1")
|
||||
field(HOPR, "1024")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PositionY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_POSITION_Y")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)SizeXLink")
|
||||
{
|
||||
field(DOL, "$(XSIZE) CP MS")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUT, "$(P)$(R)SizeX PP")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)SizeX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_SIZE_X")
|
||||
field(LOPR, "1")
|
||||
field(HOPR, "1024")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)SizeX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_SIZE_X")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)SizeYLink")
|
||||
{
|
||||
field(DOL, "$(YSIZE) CP MS")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUT, "$(P)$(R)SizeY PP")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)SizeY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_SIZE_Y")
|
||||
field(LOPR, "1")
|
||||
field(HOPR, "1024")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)SizeY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_SIZE_Y")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)Shape")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_SHAPE")
|
||||
field(ZRST, "Cross")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Rectangle")
|
||||
field(ONVL, "1")
|
||||
field(VAL, "$(SHAPE)")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)Shape_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_SHAPE")
|
||||
field(ZRST, "Cross")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Rectangle")
|
||||
field(ONVL, "1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)DrawMode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_DRAW_MODE")
|
||||
field(ZRST, "Set")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "XOR")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)DrawMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_DRAW_MODE")
|
||||
field(ZRST, "Set")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "XOR")
|
||||
field(ONVL, "1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)Red")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_RED")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)Red_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_RED")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)Green")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_GREEN")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)Green_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_GREEN")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)Blue")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_BLUE")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)Blue_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OVERLAY_BLUE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records set the HOPR and LOPR values for the position #
|
||||
# and size to the maximum for the input array #
|
||||
###################################################################
|
||||
|
||||
record(longin, "$(P)$(R)MaxSizeX")
|
||||
{
|
||||
field(INP, "$(P)$(O)MaxSizeX_RBV CP")
|
||||
field(FLNK, "$(P)$(R)SetXHOPR.PROC PP")
|
||||
}
|
||||
|
||||
record(dfanout, "$(P)$(R)SetXHOPR")
|
||||
{
|
||||
field(DOL, "$(P)$(R)MaxSizeX NPP")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUTA, "$(P)$(R)PositionX.HOPR NPP")
|
||||
field(OUTB, "$(P)$(R)SizeX.HOPR NPP")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MaxSizeY")
|
||||
{
|
||||
field(INP, "$(P)$(O)MaxSizeY_RBV CP")
|
||||
field(FLNK, "$(P)$(R)SetYHOPR.PROC PP")
|
||||
}
|
||||
|
||||
record(dfanout, "$(P)$(R)SetYHOPR")
|
||||
{
|
||||
field(DOL, "$(P)$(R)MaxSizeY NPP")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUTA, "$(P)$(R)PositionY.HOPR NPP")
|
||||
field(OUTB, "$(P)$(R)SizeY.HOPR NPP")
|
||||
}
|
||||
|
||||
@@ -1,15 +0,0 @@
|
||||
$(P)$(R)Name
|
||||
$(P)$(R)Use
|
||||
$(P)$(R)PositionXLink.DOL
|
||||
$(P)$(R)PositionX
|
||||
$(P)$(R)PositionYLink.DOL
|
||||
$(P)$(R)PositionY
|
||||
$(P)$(R)SizeXLink.DOL
|
||||
$(P)$(R)SizeX
|
||||
$(P)$(R)SizeYLink.DOL
|
||||
$(P)$(R)SizeY
|
||||
$(P)$(R)DrawMode
|
||||
$(P)$(R)Shape
|
||||
$(P)$(R)Red
|
||||
$(P)$(R)Green
|
||||
$(P)$(R)Blue
|
||||
@@ -1 +0,0 @@
|
||||
# Nothing extra needed beyond NDPluginBase_settings.req for now
|
||||
@@ -1,476 +0,0 @@
|
||||
# Database for NDPluginBase, i.e. records common to all plugins
|
||||
# Mark Rivers
|
||||
# April 25, 2008
|
||||
|
||||
###################################################################
|
||||
# This record contains the asyn port name of this plugin #
|
||||
###################################################################
|
||||
|
||||
record(stringin, "$(P)$(R)PortName_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PORT_NAME_SELF")
|
||||
field(VAL, "Unknown")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# This record contains the type of plugin #
|
||||
###################################################################
|
||||
|
||||
record(stringin, "$(P)$(R)PluginType_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PLUGIN_TYPE")
|
||||
field(VAL, "Unknown")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the connection of the server to #
|
||||
# an NDArray driver port and address #
|
||||
###################################################################
|
||||
# Array port name
|
||||
record(stringout, "$(P)$(R)NDArrayPort")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NDARRAY_PORT")
|
||||
field(VAL, "$(NDARRAY_PORT)")
|
||||
}
|
||||
|
||||
record(stringin, "$(P)$(R)NDArrayPort_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NDARRAY_PORT")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)NDArrayAddress")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NDARRAY_ADDR")
|
||||
field(VAL, "$(NDARRAY_ADDR)")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NDArrayAddress_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NDARRAY_ADDR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control whether callbacks are enabled and #
|
||||
# minimum time between callbacks #
|
||||
###################################################################
|
||||
record(bo, "$(P)$(R)EnableCallbacks")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_CALLBACKS")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)EnableCallbacks_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_CALLBACKS")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)MinCallbackTime")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MIN_CALLBACK_TIME")
|
||||
field(EGU, "s")
|
||||
field(PREC, "3")
|
||||
field(VAL, "0.0")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)MinCallbackTime_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MIN_CALLBACK_TIME")
|
||||
field(EGU, "s")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control whether callbacks block or not #
|
||||
###################################################################
|
||||
record(bo, "$(P)$(R)BlockingCallbacks")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))BLOCKING_CALLBACKS")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)BlockingCallbacks_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))BLOCKING_CALLBACKS")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
###################################################################
|
||||
# These records provide statistics on array callbacks and #
|
||||
# array callback rates #
|
||||
###################################################################
|
||||
record(longout, "$(P)$(R)ArrayCounter")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_COUNTER")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)ArrayCounter_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_COUNTER")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# This record needs work, because B should reflect the time since last processed
|
||||
record(calc, "$(P)$(R)ArrayRate_RBV")
|
||||
{
|
||||
field(INPA, "$(P)$(R)ArrayRate_RBV.B NPP NMS") # Previous counter value
|
||||
field(INPB, "$(P)$(R)ArrayCounter_RBV NPP NMS") # Current counter value
|
||||
field(INPC, "1.0") # Delta time, needs work
|
||||
field(CALC, "(B-A)/C")
|
||||
field(PREC, "1")
|
||||
field(SCAN, "1 second")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)DroppedArrays")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DROPPED_ARRAYS")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)DroppedArrays_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DROPPED_ARRAYS")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)QueueSize")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))QUEUE_SIZE")
|
||||
field(PINI, "YES")
|
||||
field(FLNK, "$(P)$(R)QueueFreeLow")
|
||||
}
|
||||
|
||||
record(calcout, "$(P)$(R)QueueFreeLow") {
|
||||
field(CALC, "A*0.25")
|
||||
field(INPA, "$(P)$(R)QueueSize")
|
||||
field(OUT, "$(P)$(R)QueueFree.LOW")
|
||||
field(FLNK, "$(P)$(R)QueueUseHIGH")
|
||||
}
|
||||
|
||||
# Set a HIGH warning level for the input queue fill level to 75%
|
||||
# of the full size of the queue
|
||||
record(calcout, "$(P)$(R)QueueUseHIGH") {
|
||||
field(CALC, "A*0.75")
|
||||
field(INPA, "$(P)$(R)QueueSize")
|
||||
field(OUT, "$(P)$(R)QueueUse.HIGH")
|
||||
field(FLNK, "$(P)$(R)QueueUseHIHI")
|
||||
}
|
||||
|
||||
# Set a HIHI level for the input queue fill level to indicate an error
|
||||
# (MAJOR alarm) when it fills up to the full size of the queue (frames start dropping)
|
||||
record(calcout, "$(P)$(R)QueueUseHIHI") {
|
||||
field(CALC, "A*1.0")
|
||||
field(INPA, "$(P)$(R)QueueSize")
|
||||
field(OUT, "$(P)$(R)QueueUse.HIHI")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)QueueFree")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))QUEUE_FREE")
|
||||
field(LLSV, "MAJOR")
|
||||
field(LSV, "MINOR")
|
||||
field(LOLO, "0")
|
||||
field(HYST, "1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Display the fill level on the plugins input queue
|
||||
record(calc, "$(P)$(R)QueueUse") {
|
||||
field(CALC, "A-B")
|
||||
field(INPA, "$(P)$(R)QueueSize")
|
||||
field(INPB, "$(P)$(R)QueueFree CP")
|
||||
field(SCAN, "Passive")
|
||||
field(HHSV, "MAJOR")
|
||||
field(HSV, "MINOR")
|
||||
field(HYST, "1")
|
||||
}
|
||||
|
||||
|
||||
###################################################################
|
||||
# These records are the array size and data type #
|
||||
###################################################################
|
||||
# The number of dimensions
|
||||
record(longin, "$(P)$(R)NDimensions_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_NDIMENSIONS")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# The array dimensions waveform record
|
||||
record(waveform, "$(P)$(R)Dimensions_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_DIMENSIONS")
|
||||
field(FTVL, "LONG")
|
||||
field(NELM, "10")
|
||||
field(FLNK, "$(P)$(R)Dim0SA")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Note, we only extract the first 2 dimensions here, but this
|
||||
# can easily be extended up to the maximum of 10 dimensions
|
||||
record(subArray, "$(P)$(R)Dim0SA")
|
||||
{
|
||||
field(INP, "$(P)$(R)Dimensions_RBV NPP NMS")
|
||||
field(FTVL, "LONG")
|
||||
field(MALM, "10")
|
||||
field(NELM, "1")
|
||||
field(INDX, "0")
|
||||
field(FLNK, "$(P)$(R)ArraySize0_RBV")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)ArraySize0_RBV")
|
||||
{
|
||||
field(INP, "$(P)$(R)Dim0SA")
|
||||
field(FLNK, "$(P)$(R)Dim1SA")
|
||||
}
|
||||
|
||||
record(subArray, "$(P)$(R)Dim1SA")
|
||||
{
|
||||
field(INP, "$(P)$(R)Dimensions_RBV NPP NMS")
|
||||
field(FTVL, "LONG")
|
||||
field(MALM, "10")
|
||||
field(NELM, "1")
|
||||
field(INDX, "1")
|
||||
field(FLNK, "$(P)$(R)ArraySize1_RBV")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)ArraySize1_RBV")
|
||||
{
|
||||
field(INP, "$(P)$(R)Dim1SA")
|
||||
field(FLNK, "$(P)$(R)Dim2SA")
|
||||
}
|
||||
|
||||
record(subArray, "$(P)$(R)Dim2SA")
|
||||
{
|
||||
field(INP, "$(P)$(R)Dimensions_RBV NPP NMS")
|
||||
field(FTVL, "LONG")
|
||||
field(MALM, "10")
|
||||
field(NELM, "1")
|
||||
field(INDX, "2")
|
||||
field(FLNK, "$(P)$(R)ArraySize2_RBV")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)ArraySize2_RBV")
|
||||
{
|
||||
field(INP, "$(P)$(R)Dim2SA")
|
||||
# field(FLNK, "$(P)$(R)Dim3SA")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)DataType_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DATA_TYPE")
|
||||
field(ZRST, "Int8")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "UInt8")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Int16")
|
||||
field(TWVL, "2")
|
||||
field(THST, "UInt16")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Int32")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "UInt32")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "Float32")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "Float64")
|
||||
field(SVVL, "7")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ColorMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COLOR_MODE")
|
||||
field(ZRST, "Mono")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Bayer")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "RGB1")
|
||||
field(TWVL, "2")
|
||||
field(THST, "RGB2")
|
||||
field(THVL, "3")
|
||||
field(FRST, "RGB3")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "YUV444")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "YUV422")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "YUV421")
|
||||
field(SVVL, "7")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)BayerPattern_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))BAYER_PATTERN")
|
||||
field(ZRST, "RGGB")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "GBRG")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "GRBG")
|
||||
field(TWVL, "2")
|
||||
field(THST, "BGGR")
|
||||
field(THVL, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records are the uniqueId and time stamps of the array #
|
||||
###################################################################
|
||||
record(longin, "$(P)$(R)UniqueId_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))UNIQUE_ID")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)TimeStamp_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TIME_STAMP")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)EpicsTSSec_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))EPICS_TS_SEC")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)EpicsTSNsec_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))EPICS_TS_NSEC")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# This record is the name of a file defining attributes #
|
||||
###################################################################
|
||||
|
||||
record(waveform, "$(P)$(R)NDAttributesFile")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ND_ATTRIBUTES_FILE")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
|
||||
###################################################################
|
||||
# Status of NDArrayPool - number of buffers, memory used etc. #
|
||||
# This is only really useful information for plugins that #
|
||||
# produce output (callbacks) that other plugins can attach to #
|
||||
###################################################################
|
||||
|
||||
record(ai, "$(P)$(R)PoolMaxMem")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))POOL_MAX_MEMORY")
|
||||
field(PREC, "1")
|
||||
field(EGU, "MB")
|
||||
field(SCAN, "Passive")
|
||||
field(PINI, "YES")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PoolMaxBuffers")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))POOL_MAX_BUFFERS")
|
||||
field(SCAN, "Passive")
|
||||
field(PINI, "YES")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)PoolUsedMem")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))POOL_USED_MEMORY")
|
||||
field(PREC, "1")
|
||||
field(EGU, "MB")
|
||||
field(SCAN, "1 second")
|
||||
field(FLNK, "$(P)$(R)PoolAllocBuffers")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PoolAllocBuffers")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))POOL_ALLOC_BUFFERS")
|
||||
field(FLNK, "$(P)$(R)PoolFreeBuffers")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PoolFreeBuffers")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))POOL_FREE_BUFFERS")
|
||||
field(FLNK, "$(P)$(R)PoolUsedBuffers")
|
||||
}
|
||||
|
||||
record(calc, "$(P)$(R)PoolUsedBuffers")
|
||||
{
|
||||
field(INPA, "$(P)$(R)PoolAllocBuffers NPP MS")
|
||||
field(INPB, "$(P)$(R)PoolFreeBuffers NPP MS")
|
||||
field(CALC, "A-B")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# The asynRecord is used for mainly for trace mask #
|
||||
###################################################################
|
||||
|
||||
# Set ASYN_TRACEIO_HEX bit by default
|
||||
record(asyn,"$(P)$(R)AsynIO")
|
||||
{
|
||||
field(PORT, $(PORT))
|
||||
field(TIB2,"1")
|
||||
info("ADType", "ADPlugin")
|
||||
}
|
||||
|
||||
@@ -1,6 +0,0 @@
|
||||
$(P)$(R)NDArrayPort
|
||||
$(P)$(R)NDArrayAddress
|
||||
$(P)$(R)EnableCallbacks
|
||||
$(P)$(R)MinCallbackTime
|
||||
$(P)$(R)BlockingCallbacks
|
||||
$(P)$(R)NDAttributesFile
|
||||
@@ -1,842 +0,0 @@
|
||||
# Database for ND PluginProcess
|
||||
# Mark Rivers
|
||||
# March 14, 2010
|
||||
|
||||
###################################################################
|
||||
# These records control the data type of the array data #
|
||||
# The last entry is "Automatic" meaning preserve the data type #
|
||||
# of the input array. #
|
||||
###################################################################
|
||||
|
||||
record(mbbo, "$(P)$(R)DataTypeOut")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PROCESS_DATA_TYPE")
|
||||
field(ZRST, "Int8")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "UInt8")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Int16")
|
||||
field(TWVL, "2")
|
||||
field(THST, "UInt16")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Int32")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "UInt32")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "Float32")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "Float64")
|
||||
field(SVVL, "7")
|
||||
field(EIST, "Automatic")
|
||||
field(EIVL, "-1")
|
||||
field(VAL, "8")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)DataTypeOut_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PROCESS_DATA_TYPE")
|
||||
field(ZRST, "Int8")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "UInt8")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Int16")
|
||||
field(TWVL, "2")
|
||||
field(THST, "UInt16")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Int32")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "UInt32")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "Float32")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "Float64")
|
||||
field(SVVL, "7")
|
||||
field(EIST, "Automatic")
|
||||
field(EIVL, "-1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the background array processing #
|
||||
###################################################################
|
||||
record(bo, "$(P)$(R)SaveBackground")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SAVE_BACKGROUND")
|
||||
field(VAL, "1")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)SaveBackground_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SAVE_BACKGROUND")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)EnableBackground")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_BACKGROUND")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)EnableBackground_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_BACKGROUND")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)ValidBackground_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))VALID_BACKGROUND")
|
||||
field(ZNAM, "Invalid")
|
||||
field(ONAM, "Valid")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the flat field array processing #
|
||||
###################################################################
|
||||
record(bo, "$(P)$(R)SaveFlatField")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SAVE_FLAT_FIELD")
|
||||
field(VAL, "1")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)SaveFlatField_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SAVE_FLAT_FIELD")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)EnableFlatField")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_FLAT_FIELD")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)EnableFlatField_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_FLAT_FIELD")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)ValidFlatField_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))VALID_FLAT_FIELD")
|
||||
field(ZNAM, "Invalid")
|
||||
field(ONAM, "Valid")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)ScaleFlatField")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SCALE_FLAT_FIELD")
|
||||
field(VAL, "255.")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)ScaleFlatField_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SCALE_FLAT_FIELD")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the offset and scale #
|
||||
###################################################################
|
||||
record(bo, "$(P)$(R)EnableOffsetScale")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_OFFSET_SCALE")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
# Oneshot record for calculating scale and offset
|
||||
record(busy, "$(P)$(R)AutoOffsetScale")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))AUTO_OFFSET_SCALE")
|
||||
field(ZNAM, "Done")
|
||||
field(ONAM, "Calculating")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)EnableOffsetScale_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_OFFSET_SCALE")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)Offset")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OFFSET")
|
||||
field(PREC, "2")
|
||||
field(VAL, "0.0")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)Offset_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OFFSET")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)Scale")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SCALE")
|
||||
field(PREC, "2")
|
||||
field(VAL, "1.0")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)Scale_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SCALE")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the high and low clipping #
|
||||
###################################################################
|
||||
record(bo, "$(P)$(R)EnableLowClip")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_LOW_CLIP")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)EnableLowClip_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_LOW_CLIP")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)LowClip")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LOW_CLIP")
|
||||
field(VAL, "0.0")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)LowClip_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LOW_CLIP")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)EnableHighClip")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_HIGH_CLIP")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)EnableHighClip_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_HIGH_CLIP")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)HighClip")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))HIGH_CLIP")
|
||||
field(VAL, "100.0")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)HighClip_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))HIGH_CLIP")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control frame filtering #
|
||||
###################################################################
|
||||
record(bo, "$(P)$(R)EnableFilter")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_FILTER")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)EnableFilter_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_FILTER")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)ResetFilter")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))RESET_FILTER")
|
||||
field(VAL, "1")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)ResetFilter_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))RESET_FILTER")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)AutoResetFilter")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))AUTO_RESET_FILTER")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)AutoResetFilter_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))AUTO_RESET_FILTER")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)FilterCallbacks")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_CALLBACKS")
|
||||
field(ZNAM, "Every array")
|
||||
field(ONAM, "Array N only")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)FilterCallbacks_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_CALLBACKS")
|
||||
field(ZNAM, "Every array")
|
||||
field(ONAM, "Array N only")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)NumFilter")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NUM_FILTER")
|
||||
field(VAL, "1")
|
||||
field(FLNK, "$(P)$(R)NumFilterRecip.PROC PP")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NumFilter_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NUM_FILTER")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# This is 1/NumFilter, used in RecursiveSum filter
|
||||
# If this value changes we need to process FilterType to make it update filter coefficients
|
||||
record(calc, "$(P)$(R)NumFilterRecip")
|
||||
{
|
||||
field(INPA, "$(P)$(R)NumFilter.VAL NPP")
|
||||
field(CALC, "1./A")
|
||||
field(FLNK, "$(P)$(R)FilterType.PROC PP")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NumFiltered_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NUM_FILTERED")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)OOffset")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OOFFSET")
|
||||
field(VAL, "0.0")
|
||||
field(PREC, "2")
|
||||
}
|
||||
record(ai, "$(P)$(R)OOffset_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OOFFSET")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)OScale")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OSCALE")
|
||||
field(VAL, "1.0")
|
||||
field(PREC, "2")
|
||||
}
|
||||
record(ai, "$(P)$(R)OScale_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OSCALE")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)OC1")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OC1")
|
||||
field(VAL, "1.0")
|
||||
field(PREC, "2")
|
||||
}
|
||||
record(ai, "$(P)$(R)OC1_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OC1")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)OC2")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OC2")
|
||||
field(VAL, "-1.0")
|
||||
field(PREC, "2")
|
||||
}
|
||||
record(ai, "$(P)$(R)OC2_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OC2")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)OC3")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OC3")
|
||||
field(VAL, "0.0")
|
||||
field(PREC, "2")
|
||||
}
|
||||
record(ai, "$(P)$(R)OC3_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OC3")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)OC4")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OC4")
|
||||
field(VAL, "1.0")
|
||||
field(PREC, "2")
|
||||
}
|
||||
record(ai, "$(P)$(R)OC4_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OC4")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)FOffset")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FOFFSET")
|
||||
field(VAL, "0.0")
|
||||
field(PREC, "2")
|
||||
}
|
||||
record(ai, "$(P)$(R)FOffset_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FOFFSET")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)FScale")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FSCALE")
|
||||
field(VAL, "1.0")
|
||||
field(PREC, "2")
|
||||
}
|
||||
record(ai, "$(P)$(R)FScale_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FSCALE")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)FC1")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FC1")
|
||||
field(VAL, "1.0")
|
||||
field(PREC, "2")
|
||||
}
|
||||
record(ai, "$(P)$(R)FC1_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FC1")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)FC2")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FC2")
|
||||
field(VAL, "-1.0")
|
||||
field(PREC, "2")
|
||||
}
|
||||
record(ai, "$(P)$(R)FC2_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FC2")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
record(ao, "$(P)$(R)FC3")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FC3")
|
||||
field(VAL, "0.0")
|
||||
field(PREC, "2")
|
||||
}
|
||||
record(ai, "$(P)$(R)FC3_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FC3")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)FC4")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FC4")
|
||||
field(VAL, "1.0")
|
||||
field(PREC, "2")
|
||||
}
|
||||
record(ai, "$(P)$(R)FC4_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FC4")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
record(ao, "$(P)$(R)ROffset")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_ROFFSET")
|
||||
field(VAL, "0.0")
|
||||
field(PREC, "2")
|
||||
}
|
||||
record(ai, "$(P)$(R)ROffset_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_ROFFSET")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)RC1")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_RC1")
|
||||
field(VAL, "1.0")
|
||||
field(PREC, "2")
|
||||
}
|
||||
record(ai, "$(P)$(R)RC1_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_RC1")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)RC2")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_RC2")
|
||||
field(VAL, "1.0")
|
||||
field(PREC, "2")
|
||||
}
|
||||
record(ai, "$(P)$(R)RC2_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_RC2")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# We don't see PINI=YES for FilterType because we want to restore the actual coefficients
|
||||
# We do restore this record, but we don't process it
|
||||
record(mbbo, "$(P)$(R)FilterType")
|
||||
{
|
||||
field(ZRST, "RecursiveAve")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "Average")
|
||||
field(ONVL, "2")
|
||||
field(TWST, "Sum")
|
||||
field(TWVL, "3")
|
||||
field(THST, "Difference")
|
||||
field(THVL, "4")
|
||||
field(FRST, "RecursiveAveDiff")
|
||||
field(FRVL, "5")
|
||||
field(FVST, "CopyToFilter")
|
||||
field(FVVL, "6")
|
||||
field(FLNK, "$(P)$(R)FilterTypeSeq PP MS")
|
||||
}
|
||||
|
||||
record(seq, "$(P)$(R)FilterTypeSeq")
|
||||
{
|
||||
field(SELL, "$(P)$(R)FilterType.RVAL NPP")
|
||||
field(SELM, "Specified")
|
||||
field(DOL1, "1")
|
||||
field(LNK1, "$(P)$(R)RecursiveAveSeq.PROC PP MS")
|
||||
field(DOL2, "1")
|
||||
field(LNK2, "$(P)$(R)AverageSeq.PROC PP MS")
|
||||
field(DOL3, "1")
|
||||
field(LNK3, "$(P)$(R)SumSeq.PROC PP MS")
|
||||
field(DOL4, "1")
|
||||
field(LNK4, "$(P)$(R)DifferenceSeq.PROC PP MS")
|
||||
field(DOL5, "1")
|
||||
field(LNK5, "$(P)$(R)RecursiveAveDiffSeq.PROC PP MS")
|
||||
field(DOL6, "1")
|
||||
field(LNK6, "$(P)$(R)CopyToFilterSeq.PROC PP MS")
|
||||
}
|
||||
|
||||
record(seq, "$(P)$(R)RecursiveAveSeq")
|
||||
{
|
||||
field(DOL1, "1")
|
||||
field(LNK1, "$(P)$(R)OC1 PP MS")
|
||||
field(DOL2, "-1")
|
||||
field(LNK2, "$(P)$(R)OC2 PP MS")
|
||||
field(DOL3, "0")
|
||||
field(LNK3, "$(P)$(R)OC3 PP MS")
|
||||
field(DOL4, "1")
|
||||
field(LNK4, "$(P)$(R)OC4 PP MS")
|
||||
field(DOL5, "1")
|
||||
field(LNK5, "$(P)$(R)FC1 PP MS")
|
||||
field(DOL6, "-1")
|
||||
field(LNK6, "$(P)$(R)FC2 PP MS")
|
||||
field(DOL7, "0")
|
||||
field(LNK7, "$(P)$(R)FC3 PP MS")
|
||||
field(DOL8, "1")
|
||||
field(LNK8, "$(P)$(R)FC4 PP MS")
|
||||
field(DOL9, "0")
|
||||
field(LNK9, "$(P)$(R)RC1 PP MS")
|
||||
field(DOLA, "1")
|
||||
field(LNKA, "$(P)$(R)RC2 PP MS")
|
||||
}
|
||||
|
||||
record(seq, "$(P)$(R)AverageSeq")
|
||||
{
|
||||
field(DOL1, "1")
|
||||
field(LNK1, "$(P)$(R)OC1 PP MS")
|
||||
field(DOL2, "0")
|
||||
field(LNK2, "$(P)$(R)OC2 PP MS")
|
||||
field(DOL3, "$(P)$(R)NumFilterRecip NPP")
|
||||
field(LNK3, "$(P)$(R)OC3 PP MS")
|
||||
field(DOL4, "0")
|
||||
field(LNK4, "$(P)$(R)OC4 PP MS")
|
||||
field(DOL5, "1")
|
||||
field(LNK5, "$(P)$(R)FC1 PP MS")
|
||||
field(DOL6, "0")
|
||||
field(LNK6, "$(P)$(R)FC2 PP MS")
|
||||
field(DOL7, "$(P)$(R)NumFilterRecip NPP")
|
||||
field(LNK7, "$(P)$(R)FC3 PP MS")
|
||||
field(DOL8, "0")
|
||||
field(LNK8, "$(P)$(R)FC4 PP MS")
|
||||
field(DOL9, "0")
|
||||
field(LNK9, "$(P)$(R)RC1 PP MS")
|
||||
field(DOLA, "0")
|
||||
field(LNKA, "$(P)$(R)RC2 PP MS")
|
||||
}
|
||||
|
||||
record(seq, "$(P)$(R)SumSeq")
|
||||
{
|
||||
field(DOL1, "1")
|
||||
field(LNK1, "$(P)$(R)OC1 PP MS")
|
||||
field(DOL2, "0")
|
||||
field(LNK2, "$(P)$(R)OC2 PP MS")
|
||||
field(DOL3, "1")
|
||||
field(LNK3, "$(P)$(R)OC3 PP MS")
|
||||
field(DOL4, "0")
|
||||
field(LNK4, "$(P)$(R)OC4 PP MS")
|
||||
field(DOL5, "1")
|
||||
field(LNK5, "$(P)$(R)FC1 PP MS")
|
||||
field(DOL6, "0")
|
||||
field(LNK6, "$(P)$(R)FC2 PP MS")
|
||||
field(DOL7, "1")
|
||||
field(LNK7, "$(P)$(R)FC3 PP MS")
|
||||
field(DOL8, "0")
|
||||
field(LNK8, "$(P)$(R)FC4 PP MS")
|
||||
field(DOL9, "0")
|
||||
field(LNK9, "$(P)$(R)RC1 PP MS")
|
||||
field(DOLA, "0")
|
||||
field(LNKA, "$(P)$(R)RC2 PP MS")
|
||||
}
|
||||
|
||||
record(seq, "$(P)$(R)DifferenceSeq")
|
||||
{
|
||||
field(DOL1, "-1")
|
||||
field(LNK1, "$(P)$(R)OC1 PP MS")
|
||||
field(DOL2, "0")
|
||||
field(LNK2, "$(P)$(R)OC2 PP MS")
|
||||
field(DOL3, "1")
|
||||
field(LNK3, "$(P)$(R)OC3 PP MS")
|
||||
field(DOL4, "0")
|
||||
field(LNK4, "$(P)$(R)OC4 PP MS")
|
||||
field(DOL5, "0")
|
||||
field(LNK5, "$(P)$(R)FC1 PP MS")
|
||||
field(DOL6, "0")
|
||||
field(LNK6, "$(P)$(R)FC2 PP MS")
|
||||
field(DOL7, "1")
|
||||
field(LNK7, "$(P)$(R)FC3 PP MS")
|
||||
field(DOL8, "0")
|
||||
field(LNK8, "$(P)$(R)FC4 PP MS")
|
||||
field(DOL9, "0")
|
||||
field(LNK9, "$(P)$(R)RC1 PP MS")
|
||||
field(DOLA, "1")
|
||||
field(LNKA, "$(P)$(R)RC2 PP MS")
|
||||
}
|
||||
|
||||
record(seq, "$(P)$(R)RecursiveAveDiffSeq")
|
||||
{
|
||||
field(DOL1, "-1")
|
||||
field(LNK1, "$(P)$(R)OC1 PP MS")
|
||||
field(DOL2, "0")
|
||||
field(LNK2, "$(P)$(R)OC2 PP MS")
|
||||
field(DOL3, "1")
|
||||
field(LNK3, "$(P)$(R)OC3 PP MS")
|
||||
field(DOL4, "0")
|
||||
field(LNK4, "$(P)$(R)OC4 PP MS")
|
||||
field(DOL5, "1")
|
||||
field(LNK5, "$(P)$(R)FC1 PP MS")
|
||||
field(DOL6, "-1")
|
||||
field(LNK6, "$(P)$(R)FC2 PP MS")
|
||||
field(DOL7, "0")
|
||||
field(LNK7, "$(P)$(R)FC3 PP MS")
|
||||
field(DOL8, "1")
|
||||
field(LNK8, "$(P)$(R)FC4 PP MS")
|
||||
field(DOL9, "0")
|
||||
field(LNK9, "$(P)$(R)RC1 PP MS")
|
||||
field(DOLA, "1")
|
||||
field(LNKA, "$(P)$(R)RC2 PP MS")
|
||||
}
|
||||
|
||||
record(seq, "$(P)$(R)CopyToFilterSeq")
|
||||
{
|
||||
field(DOL1, "0")
|
||||
field(LNK1, "$(P)$(R)OC1 PP MS")
|
||||
field(DOL2, "0")
|
||||
field(LNK2, "$(P)$(R)OC2 PP MS")
|
||||
field(DOL3, "1")
|
||||
field(LNK3, "$(P)$(R)OC3 PP MS")
|
||||
field(DOL4, "0")
|
||||
field(LNK4, "$(P)$(R)OC4 PP MS")
|
||||
field(DOL5, "0")
|
||||
field(LNK5, "$(P)$(R)FC1 PP MS")
|
||||
field(DOL6, "0")
|
||||
field(LNK6, "$(P)$(R)FC2 PP MS")
|
||||
field(DOL7, "1")
|
||||
field(LNK7, "$(P)$(R)FC3 PP MS")
|
||||
field(DOL8, "0")
|
||||
field(LNK8, "$(P)$(R)FC4 PP MS")
|
||||
field(DOL9, "0")
|
||||
field(LNK9, "$(P)$(R)RC1 PP MS")
|
||||
field(DOLA, "1")
|
||||
field(LNKA, "$(P)$(R)RC2 PP MS")
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
$(P)$(R)DataTypeOut
|
||||
$(P)$(R)EnableBackground
|
||||
$(P)$(R)EnableFlatField
|
||||
$(P)$(R)ScaleFlatField
|
||||
$(P)$(R)EnableOffsetScale
|
||||
$(P)$(R)Offset
|
||||
$(P)$(R)Scale
|
||||
$(P)$(R)EnableLowClip
|
||||
$(P)$(R)LowClip
|
||||
$(P)$(R)EnableHighClip
|
||||
$(P)$(R)HighClip
|
||||
$(P)$(R)EnableFilter
|
||||
$(P)$(R)AutoResetFilter
|
||||
$(P)$(R)FilterCallbacks
|
||||
$(P)$(R)NumFilter
|
||||
$(P)$(R)FilterType
|
||||
$(P)$(R)OOffset
|
||||
$(P)$(R)OScale
|
||||
$(P)$(R)OC1
|
||||
$(P)$(R)OC2
|
||||
$(P)$(R)OC3
|
||||
$(P)$(R)OC4
|
||||
$(P)$(R)FOffset
|
||||
$(P)$(R)FScale
|
||||
$(P)$(R)FC1
|
||||
$(P)$(R)FC2
|
||||
$(P)$(R)FC3
|
||||
$(P)$(R)FC4
|
||||
$(P)$(R)ROffset
|
||||
$(P)$(R)RC1
|
||||
$(P)$(R)RC2
|
||||
@@ -1,518 +0,0 @@
|
||||
# Database for ND ROIs
|
||||
# Mark Rivers
|
||||
# April 22, 2008
|
||||
|
||||
###################################################################
|
||||
# These records control the label for the ROI #
|
||||
###################################################################
|
||||
record(stringout, "$(P)$(R)Name")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NAME")
|
||||
}
|
||||
|
||||
record(stringin, "$(P)$(R)Name_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NAME")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control the ROI definition #
|
||||
# including binning, region start and size #
|
||||
###################################################################
|
||||
|
||||
record(longout, "$(P)$(R)BinX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM0_BIN")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)BinX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM0_BIN")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)BinY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM1_BIN")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)BinY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM1_BIN")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)BinZ")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM2_BIN")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)BinZ_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM2_BIN")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)MinX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM0_MIN")
|
||||
field(LOPR, "0")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MinX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM0_MIN")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)MinY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM1_MIN")
|
||||
field(LOPR, "0")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MinY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM1_MIN")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)MinZ")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM2_MIN")
|
||||
field(LOPR, "1")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MinZ_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM2_MIN")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)SizeX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM0_SIZE")
|
||||
field(VAL, "1000000")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)SizeX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM0_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)SizeY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM1_SIZE")
|
||||
field(VAL, "1000000")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)SizeY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM1_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)SizeZ")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM2_SIZE")
|
||||
field(VAL, "1000000")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)SizeZ_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM2_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)AutoSizeX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM0_AUTO_SIZE")
|
||||
field(VAL, "0")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)AutoSizeX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM0_AUTO_SIZE")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)AutoSizeY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM1_AUTO_SIZE")
|
||||
field(VAL, "0")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)AutoSizeY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM1_AUTO_SIZE")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)AutoSizeZ")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM2_AUTO_SIZE")
|
||||
field(VAL, "0")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)AutoSizeZ_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM2_AUTO_SIZE")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MaxSizeX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM0_MAX_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MaxSizeY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM1_MAX_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MaxSizeZ_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM2_MAX_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)ReverseX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM0_REVERSE")
|
||||
field(VAL, "0")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)ReverseX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM0_REVERSE")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)ReverseY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM1_REVERSE")
|
||||
field(VAL, "0")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)ReverseY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM1_REVERSE")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)ReverseZ")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM2_REVERSE")
|
||||
field(VAL, "0")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)ReverseZ_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM2_REVERSE")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)ArraySizeX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_SIZE_X")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)ArraySizeY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_SIZE_Y")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)ArraySizeZ_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_SIZE_Z")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)EnableX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM0_ENABLE")
|
||||
field(VAL, "1")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)EnableX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM0_ENABLE")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)EnableY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM1_ENABLE")
|
||||
field(VAL, "1")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)EnableY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM1_ENABLE")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)EnableZ")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM2_ENABLE")
|
||||
field(VAL, "1")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)EnableZ_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))DIM2_ENABLE")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
###################################################################
|
||||
# These records control the scaling of the data. Useful when #
|
||||
# binning or converting data types #
|
||||
###################################################################
|
||||
|
||||
record(bo, "$(P)$(R)EnableScale")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_SCALE")
|
||||
field(VAL, "0")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)EnableScale_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_SCALE")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)Scale")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(VAL, "1")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SCALE_VALUE")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)Scale_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SCALE_VALUE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
###################################################################
|
||||
# These records control the data type of the array data #
|
||||
# The last entry is "Automatic" meaning preserve the data type #
|
||||
# of the input array. #
|
||||
###################################################################
|
||||
|
||||
record(mbbo, "$(P)$(R)DataTypeOut")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ROI_DATA_TYPE")
|
||||
field(ZRST, "Int8")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "UInt8")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Int16")
|
||||
field(TWVL, "2")
|
||||
field(THST, "UInt16")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Int32")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "UInt32")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "Float32")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "Float64")
|
||||
field(SVVL, "7")
|
||||
field(EIST, "Automatic")
|
||||
field(EIVL, "-1")
|
||||
field(VAL, "8")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)DataTypeOut_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ROI_DATA_TYPE")
|
||||
field(ZRST, "Int8")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "UInt8")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Int16")
|
||||
field(TWVL, "2")
|
||||
field(THST, "UInt16")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Int32")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "UInt32")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "Float32")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "Float64")
|
||||
field(SVVL, "7")
|
||||
field(EIST, "Automatic")
|
||||
field(EIVL, "-1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records set the HOPR and LOPR values for the position #
|
||||
# and size to the maximum for the input array #
|
||||
###################################################################
|
||||
|
||||
record(longin, "$(P)$(R)MaxX")
|
||||
{
|
||||
field(INP, "$(P)$(R)MaxSizeX_RBV CP")
|
||||
field(FLNK, "$(P)$(R)SetXHOPR.PROC PP")
|
||||
}
|
||||
|
||||
record(dfanout, "$(P)$(R)SetXHOPR")
|
||||
{
|
||||
field(DOL, "$(P)$(R)MaxX NPP")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUTA, "$(P)$(R)MinX.HOPR NPP")
|
||||
field(OUTB, "$(P)$(R)SizeX.HOPR NPP")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MaxY")
|
||||
{
|
||||
field(INP, "$(P)$(R)MaxSizeY_RBV CP")
|
||||
field(FLNK, "$(P)$(R)SetYHOPR.PROC PP")
|
||||
}
|
||||
|
||||
record(dfanout, "$(P)$(R)SetYHOPR")
|
||||
{
|
||||
field(DOL, "$(P)$(R)MaxY NPP")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUTA, "$(P)$(R)MinY.HOPR NPP")
|
||||
field(OUTB, "$(P)$(R)SizeY.HOPR NPP")
|
||||
}
|
||||
|
||||
|
||||
@@ -1,22 +0,0 @@
|
||||
$(P)$(R)Name
|
||||
$(P)$(R)DataTypeOut
|
||||
$(P)$(R)BinX
|
||||
$(P)$(R)BinY
|
||||
$(P)$(R)BinZ
|
||||
$(P)$(R)MinX
|
||||
$(P)$(R)MinY
|
||||
$(P)$(R)MinZ
|
||||
$(P)$(R)SizeX
|
||||
$(P)$(R)SizeY
|
||||
$(P)$(R)SizeZ
|
||||
$(P)$(R)ReverseX
|
||||
$(P)$(R)ReverseY
|
||||
$(P)$(R)ReverseZ
|
||||
$(P)$(R)AutoSizeX
|
||||
$(P)$(R)AutoSizeY
|
||||
$(P)$(R)AutoSizeZ
|
||||
$(P)$(R)EnableX
|
||||
$(P)$(R)EnableY
|
||||
$(P)$(R)EnableZ
|
||||
$(P)$(R)EnableScale
|
||||
$(P)$(R)Scale
|
||||
@@ -1,16 +0,0 @@
|
||||
#
|
||||
# This database syncs an ROI to be the size of the entire detector
|
||||
record(longout, "$(P)$(ROI)SizeXLink")
|
||||
{
|
||||
field(DOL, "$(P)$(CAM)ArraySizeX_RBV CP MS")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUT, "$(P)$(ROI)SizeX PP")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(ROI)SizeYLink")
|
||||
{
|
||||
field(DOL, "$(P)$(CAM)ArraySizeY_RBV CP MS")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUT, "$(P)$(ROI)SizeY PP")
|
||||
}
|
||||
|
||||
@@ -1,644 +0,0 @@
|
||||
###################################################################
|
||||
# These records contain the basic statistics #
|
||||
###################################################################
|
||||
record(bo, "$(P)$(R)ComputeStatistics")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMPUTE_STATISTICS")
|
||||
field(VAL, "1")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)ComputeStatistics_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMPUTE_STATISTICS")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)BgdWidth")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))BGD_WIDTH")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)BgdWidth_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))BGD_WIDTH")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)MinValue_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MIN_VALUE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)MaxValue_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAX_VALUE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)MeanValue_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MEAN_VALUE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)Sigma_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIGMA_VALUE")
|
||||
field(PREC, "1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)Total_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TOTAL")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)Net_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NET")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)MinX_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MIN_X")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)MinY_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MIN_Y")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)MaxX_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAX_X")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)MaxY_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAX_Y")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control whether centroid statistics are computed #
|
||||
###################################################################
|
||||
record(bo, "$(P)$(R)ComputeCentroid")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMPUTE_CENTROID")
|
||||
field(VAL, "0")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)ComputeCentroid_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMPUTE_CENTROID")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records contain the centroid statistics #
|
||||
###################################################################
|
||||
record(ao, "$(P)$(R)CentroidThreshold")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))CENTROID_THRESHOLD")
|
||||
field(VAL, "1")
|
||||
}
|
||||
record(ai, "$(P)$(R)CentroidThreshold_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))CENTROID_THRESHOLD")
|
||||
field(VAL, "0")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)CentroidX_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))CENTROIDX_VALUE")
|
||||
field(PREC, "1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)CentroidY_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))CENTROIDY_VALUE")
|
||||
field(PREC, "1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)SigmaX_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIGMAX_VALUE")
|
||||
field(PREC, "1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)SigmaY_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIGMAY_VALUE")
|
||||
field(PREC, "1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)SigmaXY_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIGMAXY_VALUE")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records control time series #
|
||||
###################################################################
|
||||
record(mbbo, "$(P)$(R)TSControl")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_CONTROL")
|
||||
field(ZRVL, "0")
|
||||
field(ZRST, "Erase/Start")
|
||||
field(ONVL, "1")
|
||||
field(ONST, "Start")
|
||||
field(TWVL, "2")
|
||||
field(TWST, "Stop")
|
||||
field(THVL, "3")
|
||||
field(THST, "Read")
|
||||
}
|
||||
|
||||
# This record periodically pokes the TSControl record with 3 to read the time series
|
||||
# but only when TSAcquiring = Acquiring
|
||||
record(longout, "$(P)$(R)TSRead")
|
||||
{
|
||||
field(SDIS, "$(P)$(R)TSAcquiring NPP NMS")
|
||||
field(DISV, "0")
|
||||
field(OUT, "$(P)$(R)TSControl PP MS")
|
||||
field(VAL, "3")
|
||||
field(SCAN, "1 second")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)TSNumPoints")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_NUM_POINTS")
|
||||
field(VAL, "$(NCHANS)")
|
||||
field(DRVH, "$(NCHANS)")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)TSCurrentPoint")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_CURRENT_POINT")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)TSAcquiring")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_ACQUIRING")
|
||||
field(ZNAM, "Done")
|
||||
field(ONAM, "Acquiring")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TSMinValue")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_MIN_VALUE")
|
||||
field(NELM, "$(NCHANS)")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TSMinX")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_MIN_X")
|
||||
field(NELM, "$(NCHANS)")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TSMinY")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_MIN_Y")
|
||||
field(NELM, "$(NCHANS)")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TSMaxValue")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_MAX_VALUE")
|
||||
field(NELM, "$(NCHANS)")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TSMaxX")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_MAX_X")
|
||||
field(NELM, "$(NCHANS)")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TSMaxY")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_MAX_Y")
|
||||
field(NELM, "$(NCHANS)")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TSMeanValue")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_MEAN_VALUE")
|
||||
field(NELM, "$(NCHANS)")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TSSigma")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_SIGMA_VALUE")
|
||||
field(NELM, "$(NCHANS)")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TSTotal")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_TOTAL")
|
||||
field(NELM, "$(NCHANS)")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TSNet")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_NET")
|
||||
field(NELM, "$(NCHANS)")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TSCentroidX")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_CENTROIDX_VALUE")
|
||||
field(NELM, "$(NCHANS)")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TSCentroidY")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_CENTROIDY_VALUE")
|
||||
field(NELM, "$(NCHANS)")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TSSigmaX")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_SIGMAX_VALUE")
|
||||
field(NELM, "$(NCHANS)")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TSSigmaY")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_SIGMAY_VALUE")
|
||||
field(NELM, "$(NCHANS)")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TSSigmaXY")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TS_SIGMAXY_VALUE")
|
||||
field(NELM, "$(NCHANS)")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
###################################################################
|
||||
# These records control profiles #
|
||||
###################################################################
|
||||
record(bo, "$(P)$(R)ComputeProfiles")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMPUTE_PROFILES")
|
||||
field(VAL, "0")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)ComputeProfiles_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMPUTE_PROFILES")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)ProfileSizeX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PROFILE_SIZE_X")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)ProfileSizeY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PROFILE_SIZE_Y")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)CursorX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))CURSOR_X")
|
||||
field(VAL, "256")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)CursorX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))CURSOR_X")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)CursorY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))CURSOR_Y")
|
||||
field(VAL, "256")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)CursorY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))CURSOR_Y")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)ProfileAverageX_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PROFILE_AVERAGE_X")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(NELM, "$(XSIZE)")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)ProfileAverageY_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PROFILE_AVERAGE_Y")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(NELM, "$(YSIZE)")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)ProfileThresholdX_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PROFILE_THRESHOLD_X")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(NELM, "$(XSIZE)")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)ProfileThresholdY_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PROFILE_THRESHOLD_Y")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(NELM, "$(YSIZE)")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)ProfileCentroidX_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PROFILE_CENTROID_X")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(NELM, "$(XSIZE)")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)ProfileCentroidY_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PROFILE_CENTROID_Y")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(NELM, "$(YSIZE)")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)ProfileCursorX_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PROFILE_CURSOR_X")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(NELM, "$(XSIZE)")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)ProfileCursorY_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PROFILE_CURSOR_Y")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(NELM, "$(YSIZE)")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
###################################################################
|
||||
# These are used to define the histogram #
|
||||
###################################################################
|
||||
record(bo, "$(P)$(R)ComputeHistogram")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMPUTE_HISTOGRAM")
|
||||
field(VAL, "0")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)ComputeHistogram_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMPUTE_HISTOGRAM")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)HistSize")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))HIST_SIZE")
|
||||
field(VAL, "256")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)HistSize_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))HIST_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)HistMin")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))HIST_MIN")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)HistMin_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))HIST_MIN")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)HistMax")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))HIST_MAX")
|
||||
field(VAL, "255")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)HistMax_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))HIST_MAX")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)HistEntropy_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))HIST_ENTROPY")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)Histogram_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))HIST_ARRAY")
|
||||
field(FTVL, "DOUBLE")
|
||||
field(NELM, "$(HIST_SIZE)")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###################################################################
|
||||
# These records set the HOPR and LOPR values for the cursor #
|
||||
# and size to the maximum for the input array #
|
||||
###################################################################
|
||||
|
||||
record(longin, "$(P)$(R)MaxSizeX")
|
||||
{
|
||||
field(INP, "$(P)$(R)ProfileSizeX_RBV CP")
|
||||
field(FLNK, "$(P)$(R)SetXHOPR.PROC PP")
|
||||
}
|
||||
|
||||
record(dfanout, "$(P)$(R)SetXHOPR")
|
||||
{
|
||||
field(DOL, "$(P)$(R)MaxSizeX NPP")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUTA, "$(P)$(R)CursorX.HOPR NPP")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MaxSizeY")
|
||||
{
|
||||
field(INP, "$(P)$(R)ProfileSizeY_RBV CP")
|
||||
field(FLNK, "$(P)$(R)SetYHOPR.PROC PP")
|
||||
}
|
||||
|
||||
record(dfanout, "$(P)$(R)SetYHOPR")
|
||||
{
|
||||
field(DOL, "$(P)$(R)MaxSizeY NPP")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUTA, "$(P)$(R)CursorY.HOPR NPP")
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,13 +0,0 @@
|
||||
$(P)$(R)BgdWidth
|
||||
$(P)$(R)ComputeStatistics
|
||||
$(P)$(R)ComputeCentroid
|
||||
$(P)$(R)CentroidThreshold
|
||||
$(P)$(R)ComputeProfiles
|
||||
$(P)$(R)CursorX
|
||||
$(P)$(R)CursorY
|
||||
$(P)$(R)ComputeHistogram
|
||||
$(P)$(R)HistSize
|
||||
$(P)$(R)HistMin
|
||||
$(P)$(R)HistMax
|
||||
$(P)$(R)TSNumPoints
|
||||
$(P)$(R)TSRead.SCAN
|
||||
@@ -1,15 +0,0 @@
|
||||
# Database for NDStdArrays asyn driver and standard asyn device support
|
||||
# Mark Rivers
|
||||
# April 14, 2008
|
||||
|
||||
###################################################################
|
||||
# This record is the array waveform data #
|
||||
###################################################################
|
||||
record(waveform, "$(P)$(R)ArrayData")
|
||||
{
|
||||
field(DTYP, "asyn$(TYPE)ArrayIn")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))STD_ARRAY_DATA")
|
||||
field(FTVL, "$(FTVL)")
|
||||
field(NELM, "$(NELEMENTS)")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
@@ -1 +0,0 @@
|
||||
# Nothing extra needed beyond NDPluginBase_settings.req for now
|
||||
@@ -1,251 +0,0 @@
|
||||
record(stringout, "$(P)$(R)Name")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NAME")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)Type1")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TYPE1")
|
||||
field(ZRST, "None")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "RotateCW90")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "RotateCCW90")
|
||||
field(TWVL, "2")
|
||||
field(THST, "Rotate180")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Flip0011")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "Flip0110")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "FlipX")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "FlipY")
|
||||
field(SVVL, "7")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)Type2")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TYPE2")
|
||||
field(ZRST, "None")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "RotateCW90")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "RotateCCW90")
|
||||
field(TWVL, "2")
|
||||
field(THST, "Rotate180")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Flip0011")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "Flip0110")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "FlipX")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "FlipY")
|
||||
field(SVVL, "7")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)Type3")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TYPE3")
|
||||
field(ZRST, "None")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "RotateCW90")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "RotateCCW90")
|
||||
field(TWVL, "2")
|
||||
field(THST, "Rotate180")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Flip0011")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "Flip0110")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "FlipX")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "FlipY")
|
||||
field(SVVL, "7")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)Type4")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))TYPE4")
|
||||
field(ZRST, "None")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "RotateCW90")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "RotateCCW90")
|
||||
field(TWVL, "2")
|
||||
field(THST, "Rotate180")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Flip0011")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "Flip0110")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "FlipX")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "FlipY")
|
||||
field(SVVL, "7")
|
||||
}
|
||||
|
||||
|
||||
record(mbbo, "$(P)$(R)OriginLocation")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ORIGIN")
|
||||
field(ZRST, "LowerLeft")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "UpperLeft")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "LowerRight")
|
||||
field(TWVL, "2")
|
||||
field(THST, "UpperRight")
|
||||
field(THVL, "3")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)OriginLocation_RBV")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ORIGIN")
|
||||
field(ZRST, "LowerLeft")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "UpperLeft")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "LowerRight")
|
||||
field(TWVL, "2")
|
||||
field(THST, "UpperRight")
|
||||
field(THVL, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)T1MaxSize0")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))T1_DIM0_MAX_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)T1MaxSize1")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))T1_DIM1_MAX_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)T1MaxSize2")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))T1_DIM2_MAX_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)T2MaxSize0")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))T2_DIM0_MAX_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)T2MaxSize1")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))T2_DIM1_MAX_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)T2MaxSize2")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))T2_DIM2_MAX_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)T3MaxSize0")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))T3_DIM0_MAX_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)T3MaxSize1")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))T3_DIM1_MAX_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)T3MaxSize2")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))T3_DIM2_MAX_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)T4MaxSize0")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))T4_DIM0_MAX_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)T4MaxSize1")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))T4_DIM1_MAX_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)T4MaxSize2")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))T4_DIM2_MAX_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
record(longin, "$(P)$(R)ArraySize0")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_SIZE_0")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)ArraySize1")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_SIZE_1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)ArraySize2")
|
||||
{
|
||||
field(PINI, "1")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ARRAY_SIZE_2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
$(P)$(R)Name
|
||||
$(P)$(R)Type1
|
||||
$(P)$(R)Type2
|
||||
$(P)$(R)Type3
|
||||
$(P)$(R)Type4
|
||||
$(P)$(R)OriginLocation
|
||||
@@ -1,110 +0,0 @@
|
||||
# Database for the records specific to the PSL driver
|
||||
# Mark Rivers
|
||||
# May 9, 2012
|
||||
|
||||
# These are the records from ADBase.template that we modify some fields for
|
||||
|
||||
# We replace the file format choices from ADBase.template.
|
||||
record(mbbo, "$(P)$(R)FileFormat")
|
||||
{
|
||||
field(ZRST, "TIFF")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "JPEG")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "BMP")
|
||||
field(TWVL, "2")
|
||||
field(THST, "GIF")
|
||||
field(THVL, "3")
|
||||
field(FRST, "PNG")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "FLF")
|
||||
field(FVVL, "5")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)FileFormat_RBV")
|
||||
{
|
||||
field(ZRST, "TIFF")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "JPEG")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "BMP")
|
||||
field(TWVL, "2")
|
||||
field(THST, "GIF")
|
||||
field(THVL, "3")
|
||||
field(FRST, "PNG")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "FLF")
|
||||
field(FVVL, "5")
|
||||
}
|
||||
# We replace the trigger mode choices from ADBase.template.
|
||||
record(mbbo, "$(P)$(R)TriggerMode")
|
||||
{
|
||||
field(ZRST, "Software")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "FreeRunning")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "External")
|
||||
field(TWVL, "2")
|
||||
field(THST, "Pipeline")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Hardware_Falling")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "Hardware_Rising")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "Pipeline_Falling")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "Pipeline_Rising")
|
||||
field(SVVL, "7")
|
||||
field(EIST, "Integration_Low")
|
||||
field(EIVL, "8")
|
||||
field(NIST, "Integration_High")
|
||||
field(NIVL, "9")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)TriggerMode_RBV")
|
||||
{
|
||||
field(ZRST, "Software")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "FreeRunning")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "External")
|
||||
field(TWVL, "2")
|
||||
field(THST, "Pipeline")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Hardware_Falling")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "Hardware_Rising")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "Pipeline_Falling")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "Pipeline_Rising")
|
||||
field(SVVL, "7")
|
||||
field(EIST, "Integration_Low")
|
||||
field(EIVL, "8")
|
||||
field(NIST, "Integration_High")
|
||||
field(NIVL, "9")
|
||||
}
|
||||
|
||||
|
||||
# These are new records for the PSL detector
|
||||
|
||||
record(waveform, "$(P)$(R)TIFFComment")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PSL_TIFF_COMMENT")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)TIFFComment_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PSL_TIFF_COMMENT")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
@@ -1 +0,0 @@
|
||||
$(P)$(R)TIFFComment
|
||||
@@ -1,406 +0,0 @@
|
||||
# Database for the records specific to the PerkinElmer driver
|
||||
# Brian Tieman
|
||||
# July 23, 2008
|
||||
|
||||
######################
|
||||
# Override ADBase to extend Trigger Mode
|
||||
######################
|
||||
record(mbbo, "$(P)$(R)TriggerMode")
|
||||
{
|
||||
field(TWST, "Free Running")
|
||||
field(TWVL, "2")
|
||||
field(THST, "Soft Trigger")
|
||||
field(THVL, "3")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)TriggerMode_RBV")
|
||||
{
|
||||
field(TWST, "Free Running")
|
||||
field(TWVL, "2")
|
||||
field(THST, "Soft Trigger")
|
||||
field(THVL, "3")
|
||||
}
|
||||
|
||||
######################
|
||||
# Override ADBase to extend Image Mode
|
||||
######################
|
||||
record(mbbo, "$(P)$(R)ImageMode")
|
||||
{
|
||||
field(THST, "Average")
|
||||
field(THVL, "3")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ImageMode_RBV")
|
||||
{
|
||||
field(THST, "Average")
|
||||
field(THVL, "3")
|
||||
}
|
||||
|
||||
######################
|
||||
# Setup records
|
||||
######################
|
||||
|
||||
record(longin, "$(P)$(R)PESystemID")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_SYSTEMID")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PEFrameBuffIndex")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_FRAME_BUFFER_INDEX")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PEImageNumber")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_IMAGE_NUMBER")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)PEInitialize")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_INITIALIZE")
|
||||
field(ZNAM, "Done")
|
||||
field(ONAM, "Initialize")
|
||||
}
|
||||
|
||||
######################
|
||||
# Corrections records
|
||||
######################
|
||||
record(waveform, "$(P)$(R)PECorrectionsDir")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_CORRECTIONS_DIRECTORY")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
|
||||
######################
|
||||
# Offset records
|
||||
######################
|
||||
record(busy, "$(P)$(R)PEAcquireOffset")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_ACQUIRE_OFFSET")
|
||||
field(ZNAM, "Done")
|
||||
field(ONAM, "Acquire")
|
||||
field(ZNAM, "Done")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(ONAM, "Acquire")
|
||||
field(OSV, "MINOR")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PENumOffsetFrames")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_NUM_OFFSET_FRAMES")
|
||||
field(LOPR, "1")
|
||||
field(HOPR, "500")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PECurrentOffsetFrame")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_CURRENT_OFFSET_FRAME")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)PEOffsetAvailable")
|
||||
{
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_OFFSET_AVAILABLE")
|
||||
field(ZNAM, "Not Available")
|
||||
field(ZSV, "MINOR")
|
||||
field(ONAM, "Available")
|
||||
field(OSV, "NO_ALARM")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)PEUseOffset")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_USE_OFFSET")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
######################
|
||||
# Gain records
|
||||
######################
|
||||
record(busy, "$(P)$(R)PEAcquireGain")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_ACQUIRE_GAIN")
|
||||
field(ZNAM, "Done")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(ONAM, "Acquire")
|
||||
field(OSV, "MINOR")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)PEGainAvailable")
|
||||
{
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_GAIN_AVAILABLE")
|
||||
field(ZNAM, "Not Available")
|
||||
field(ZSV, "MINOR")
|
||||
field(ONAM, "Available")
|
||||
field(OSV, "NO_ALARM")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PENumGainFrames")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_NUM_GAIN_FRAMES")
|
||||
field(LOPR, "1")
|
||||
field(HOPR, "500")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PECurrentGainFrame")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_CURRENT_GAIN_FRAME")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)PEUseGain")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_USE_GAIN")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)PEGainFile")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_GAIN_FILE")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)PELoadGainFile")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_LOAD_GAIN_FILE")
|
||||
field(ZNAM, "Done")
|
||||
field(ONAM, "Load")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)PESaveGainFile")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_SAVE_GAIN_FILE")
|
||||
field(ZNAM, "Done")
|
||||
field(ONAM, "Save")
|
||||
}
|
||||
|
||||
|
||||
######################
|
||||
# Pixel correction records
|
||||
######################
|
||||
record(bo, "$(P)$(R)PEUsePixelCorrection")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_USE_PIXEL_CORRECTION")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)PEPixelCorrectionAvailable")
|
||||
{
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_PIXEL_CORRECTION_AVAILABLE")
|
||||
field(ZNAM, "Not Available")
|
||||
field(ZSV, "MINOR")
|
||||
field(ONAM, "Available")
|
||||
field(OSV, "NO_ALARM")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)PEPixelCorrectionFile")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_PIXEL_CORRECTION_FILE")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)PELoadPixelCorrection")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_LOAD_PIXEL_CORRECTION_FILE")
|
||||
field(ZNAM, "Done")
|
||||
field(ONAM, "Load")
|
||||
}
|
||||
|
||||
|
||||
record(mbbo, "$(P)$(R)PEGain")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_GAIN")
|
||||
field(ZRST, "0.25pF")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "0.5pF")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "1pF")
|
||||
field(TWVL, "2")
|
||||
field(THST, "2pF")
|
||||
field(THVL, "3")
|
||||
field(FRST, "4pF")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "8pF")
|
||||
field(FVVL, "5")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)PEGain_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_GAIN")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZRST, "0.25pF")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "0.5pF")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "1pF")
|
||||
field(TWVL, "2")
|
||||
field(THST, "2pF")
|
||||
field(THVL, "3")
|
||||
field(FRST, "4pF")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "8pF")
|
||||
field(FVVL, "5")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)PEDwellTime")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_DWELL_TIME")
|
||||
field(ZRST, "66.5ms")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "79.9ms")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "99.8ms")
|
||||
field(TWVL, "2")
|
||||
field(THST, "133.2ms")
|
||||
field(THVL, "3")
|
||||
field(FRST, "199.9ms")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "400.0ms")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "999.8ms")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "1999.8ms")
|
||||
field(SVVL, "7")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)PEDwellTime_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_DWELL_TIME")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZRST, "66.5ms")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "79.9ms")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "99.8ms")
|
||||
field(TWVL, "2")
|
||||
field(THST, "133.2ms")
|
||||
field(THVL, "3")
|
||||
field(FRST, "199.9ms")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "400.0ms")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "999.8ms")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "1999.8ms")
|
||||
field(SVVL, "7")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PENumFrameBuffers")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_NUM_FRAME_BUFFERS")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "500")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PENumFrameBuffers_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_NUM_FRAME_BUFFERS")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "500")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)PETrigger")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_TRIGGER")
|
||||
field(ZNAM, "Done")
|
||||
field(ONAM, "Trigger")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PESyncTime")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_SYNC_TIME")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PESyncTime_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_SYNC_TIME")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)PESkipFrames")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_SKIP_FRAMES")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)PESkipFrames_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_SKIP_FRAMES")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZNAM, "Disable")
|
||||
field(ONAM, "Enable")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PENumFramesToSkip")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_NUM_FRAMES_TO_SKIP")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PENumFramesToSkip_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PE_NUM_FRAMES_TO_SKIP")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
$(P)$(R)PECorrectionsDir
|
||||
$(P)$(R)PENumOffsetFrames
|
||||
$(P)$(R)PEUseOffset
|
||||
$(P)$(R)PENumGainFrames
|
||||
$(P)$(R)PEUseGain
|
||||
$(P)$(R)PEGainFile
|
||||
$(P)$(R)PEUsePixelCorrection
|
||||
$(P)$(R)PEPixelCorrectionFile
|
||||
$(P)$(R)PEGain
|
||||
$(P)$(R)PESkipFrames
|
||||
$(P)$(R)PENumFramesToSkip
|
||||
$(P)$(R)PENumFrameBuffers
|
||||
@@ -1,152 +0,0 @@
|
||||
# Database for the records specific to the URL driver
|
||||
# Mark Rivers
|
||||
# October 12, 2010
|
||||
|
||||
# URL records. These are not PINI=YES because the URLSelect record is.
|
||||
record(waveform, "$(P)$(R)URL1")
|
||||
{
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))URL_NAME")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)URL2")
|
||||
{
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))URL_NAME")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)URL3")
|
||||
{
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))URL_NAME")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)URL4")
|
||||
{
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))URL_NAME")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)URL5")
|
||||
{
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))URL_NAME")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)URL6")
|
||||
{
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))URL_NAME")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)URL7")
|
||||
{
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))URL_NAME")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)URL8")
|
||||
{
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))URL_NAME")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)URL9")
|
||||
{
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))URL_NAME")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)URL10")
|
||||
{
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))URL_NAME")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)URL_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))URL_NAME")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# mbbo record to select 1 of the 8 URLs.
|
||||
# The strings can be changed at run-time and are in save/restore
|
||||
record (mbbo, "$(P)$(R)URLSelect")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(ZRST, "URL1")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "URL2")
|
||||
field(ONVL, "2")
|
||||
field(TWST, "URL3")
|
||||
field(TWVL, "3")
|
||||
field(THST, "URL4")
|
||||
field(THVL, "4")
|
||||
field(FRST, "URL5")
|
||||
field(FRVL, "5")
|
||||
field(FVST, "URL6")
|
||||
field(FVVL, "6")
|
||||
field(SXST, "URL7")
|
||||
field(SXVL, "7")
|
||||
field(SVST, "URL8")
|
||||
field(SVVL, "8")
|
||||
field(EIST, "URL9")
|
||||
field(SVVL, "8")
|
||||
field(NIST, "URL10")
|
||||
field(NIVL, "8")
|
||||
field(FLNK, "$(P)$(R)URLSeq.PROC PP MS")
|
||||
}
|
||||
|
||||
record(seq, "$(P)$(R)URLSeq")
|
||||
{
|
||||
field(SELL, "$(P)$(R)URLSelect.RVAL NPP")
|
||||
field(SELM, "Specified")
|
||||
field(DOL1, "1")
|
||||
field(LNK1, "$(P)$(R)URL1.PROC PP MS")
|
||||
field(DOL2, "1")
|
||||
field(LNK2, "$(P)$(R)URL2.PROC PP MS")
|
||||
field(DOL3, "1")
|
||||
field(LNK3, "$(P)$(R)URL3.PROC PP MS")
|
||||
field(DOL4, "1")
|
||||
field(LNK4, "$(P)$(R)URL4.PROC PP MS")
|
||||
field(DOL5, "1")
|
||||
field(LNK5, "$(P)$(R)URL5.PROC PP MS")
|
||||
field(DOL6, "1")
|
||||
field(LNK6, "$(P)$(R)URL6.PROC PP MS")
|
||||
field(DOL7, "1")
|
||||
field(LNK7, "$(P)$(R)URL7.PROC PP MS")
|
||||
field(DOL8, "1")
|
||||
field(LNK8, "$(P)$(R)URL8.PROC PP MS")
|
||||
field(DOL9, "1")
|
||||
field(LNK9, "$(P)$(R)URL9.PROC PP MS")
|
||||
field(DOLA, "1")
|
||||
field(LNKA, "$(P)$(R)URL10.PROC PP MS")
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,22 +0,0 @@
|
||||
$(P)$(R)URL1
|
||||
$(P)$(R)URL2
|
||||
$(P)$(R)URL3
|
||||
$(P)$(R)URL4
|
||||
$(P)$(R)URL5
|
||||
$(P)$(R)URL6
|
||||
$(P)$(R)URL7
|
||||
$(P)$(R)URL8
|
||||
$(P)$(R)URL9
|
||||
$(P)$(R)URL10
|
||||
$(P)$(R)URLSelect.VAL
|
||||
$(P)$(R)URLSelect.ZRST
|
||||
$(P)$(R)URLSelect.ONST
|
||||
$(P)$(R)URLSelect.TWST
|
||||
$(P)$(R)URLSelect.THST
|
||||
$(P)$(R)URLSelect.FRST
|
||||
$(P)$(R)URLSelect.FVST
|
||||
$(P)$(R)URLSelect.SXST
|
||||
$(P)$(R)URLSelect.SVST
|
||||
$(P)$(R)URLSelect.EIST
|
||||
$(P)$(R)URLSelect.NIST
|
||||
|
||||
@@ -1,493 +0,0 @@
|
||||
# Database for the records specific to the ADSC detectors
|
||||
# J. Lewis Muir (copied and modified prosilica.template by Mark Rivers)
|
||||
# April 15, 2008
|
||||
|
||||
##############################################################################
|
||||
# Controls how frequently to read the condition of the detector #
|
||||
##############################################################################
|
||||
|
||||
record(longout, "$(P)$(R)ADSCReadConditn")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_READ_CONDITION")
|
||||
field(SCAN, "5 second")
|
||||
}
|
||||
|
||||
##############################################################################
|
||||
# Detector condition properties #
|
||||
##############################################################################
|
||||
|
||||
record(mbbi, "$(P)$(R)ADSCState")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_STATE")
|
||||
# These labels should match incl/detcon_state.h in ADSC control library
|
||||
field(ZRST, "IDLE")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "EXPOSING")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "READING")
|
||||
field(TWVL, "2")
|
||||
field(THST, "ERROR")
|
||||
field(THVL, "3")
|
||||
field(FRST, "CONFIGDET")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "RETRY")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "TEMPCONTROL")
|
||||
field(SXVL, "6")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)ADSCStatus")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_STATUS")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)ADSCLastError")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_LAST_ERROR")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
##############################################################################
|
||||
# Detector error recovery parameters #
|
||||
##############################################################################
|
||||
|
||||
record(longout, "$(P)$(R)ADSCSoftReset")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_SOFTWARE_RESET")
|
||||
}
|
||||
|
||||
##############################################################################
|
||||
# Detector continuous image mode parameters #
|
||||
##############################################################################
|
||||
|
||||
record(longout, "$(P)$(R)ADSCLastImage")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_LAST_IMAGE")
|
||||
}
|
||||
|
||||
##############################################################################
|
||||
# Detector external trigger parameters #
|
||||
##############################################################################
|
||||
|
||||
record(bi, "$(P)$(R)ExSwTrOkToExp")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_OK_TO_EXPOSE")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)ExSwTrCtl")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_EXTERN_SW_TRIGGER_CTRL")
|
||||
field(ZRST, "Stop")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Start")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
record(mbbi, "$(P)$(R)ExSwTrCtlRsp")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_EXTERN_SW_TRIGGER_CTRL")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZRST, "Stop")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Start")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "OK")
|
||||
field(TWVL, "2")
|
||||
field(THST, "Again")
|
||||
field(THVL, "3")
|
||||
}
|
||||
|
||||
##############################################################################
|
||||
# Driver parameters #
|
||||
##############################################################################
|
||||
|
||||
record(mbbo, "$(P)$(R)ADSCReusDrk")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_REUSE_DARKS")
|
||||
field(ZRST, "No")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Yes")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ADSCReusDrk_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_REUSE_DARKS")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZRST, "No")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Yes")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)ADSCDezingr")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_DEZINGER")
|
||||
field(ZRST, "No")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Yes")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ADSCDezingr_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_DEZINGER")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZRST, "No")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Yes")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
##############################################################################
|
||||
# Detector hardware parameters #
|
||||
##############################################################################
|
||||
|
||||
record(mbbo, "$(P)$(R)ADSCAdc")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_ADC")
|
||||
field(ZRST, "Slow/Software")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Fast/Hardware")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ADSCAdc_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_ADC")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZRST, "Slow/Software")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Fast/Hardware")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)ADSCRaw")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_RAW")
|
||||
field(ZRST, "No")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Yes")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ADSCRaw_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_RAW")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZRST, "No")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Yes")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)ADSCImXform")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_IMAGE_TRANSFORM")
|
||||
field(ZRST, "No")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Yes")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ADSCImXform_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_IMAGE_TRANSFORM")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZRST, "No")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Yes")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)ADSCStrDrks")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_STORED_DARKS")
|
||||
field(ZRST, "No")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Yes")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ADSCStrDrks_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_STORED_DARKS")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZRST, "No")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Yes")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
##############################################################################
|
||||
# Detector file parameters #
|
||||
##############################################################################
|
||||
|
||||
record(ao, "$(P)$(R)ADSCBeamX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_BEAM_CENTER_X")
|
||||
field(PREC, "3")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)ADSCBeamX_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_BEAM_CENTER_X")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)ADSCBeamY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_BEAM_CENTER_Y")
|
||||
field(PREC, "3")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)ADSCBeamY_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_BEAM_CENTER_Y")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)ADSCDistnce")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_DISTANCE")
|
||||
field(PREC, "3")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)ADSCDistnce_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_DISTANCE")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)ADSC2Theta")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_TWO_THETA")
|
||||
field(PREC, "3")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)ADSC2Theta_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_TWO_THETA")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)ADSCAxis")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_AXIS")
|
||||
field(ZRST, "Omega")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Phi")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ADSCAxis_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_AXIS")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZRST, "Omega")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Phi")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)ADSCWavelen")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_WAVELENGTH")
|
||||
field(PREC, "7")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)ADSCWavelen_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_WAVELENGTH")
|
||||
field(PREC, "7")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)ADSCImWidth")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_IMAGE_WIDTH")
|
||||
field(PREC, "3")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)ADSCImWidth_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_IMAGE_WIDTH")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)ADSCPhi")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_PHI")
|
||||
field(PREC, "3")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)ADSCPhi_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_PHI")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)ADSCOmega")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_OMEGA")
|
||||
field(PREC, "3")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)ADSCOmega_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_OMEGA")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)ADSCKappa")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_KAPPA")
|
||||
field(PREC, "3")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)ADSCKappa_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_KAPPA")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
##############################################################################
|
||||
# Private parameters only for testing with simadsc
|
||||
##############################################################################
|
||||
|
||||
record(longout, "$(P)$(R)ADSCStpExRtryCt")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ADSC_PRVT_STOP_EXP_RTRY_CNT")
|
||||
}
|
||||
|
||||
##############################################################################
|
||||
# Note: The following are records defined in ADBase.template. #
|
||||
# We are changing some of the fields here to reflect valid values and #
|
||||
# desired behavior for the ADSC driver. #
|
||||
##############################################################################
|
||||
|
||||
record(mbbo, "$(P)$(R)TriggerMode")
|
||||
{
|
||||
field(ZRST, "Internal")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Ext. Software")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)TriggerMode_RBV")
|
||||
{
|
||||
field(ZRST, "Internal")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Ext. Software")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)BinX")
|
||||
{
|
||||
field(FLNK, "$(P)$(R)BinXChanged")
|
||||
}
|
||||
|
||||
record(calcout, "$(P)$(R)BinXChanged")
|
||||
{
|
||||
field(INPA, "$(P)$(R)BinX NPPNMS")
|
||||
field(INPB, "$(P)$(R)BinX.PACT NPPNMS")
|
||||
field(CALC, "B")
|
||||
field(OCAL, "A")
|
||||
field(OUT, "$(P)$(R)BinY PP MS")
|
||||
field(OOPT, "When Non-zero")
|
||||
field(DOPT, "Use OCAL")
|
||||
field(IVOA, "Don't drive outputs")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)BinY")
|
||||
{
|
||||
field(PINI, "NO")
|
||||
field(DTYP, "Soft Channel")
|
||||
field(OUT, "$(P)$(R)BinYChanged.PROC PP MS")
|
||||
}
|
||||
|
||||
record(calcout, "$(P)$(R)BinYChanged")
|
||||
{
|
||||
field(INPA, "$(P)$(R)BinY NPPNMS")
|
||||
field(INPB, "$(P)$(R)BinX.PACT NPPNMS")
|
||||
field(CALC, "B")
|
||||
field(OCAL, "A")
|
||||
field(OUT, "$(P)$(R)BinX PP MS")
|
||||
field(OOPT, "When Zero")
|
||||
field(DOPT, "Use OCAL")
|
||||
field(IVOA, "Don't drive outputs")
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
$(P)$(R)ADSCReadConditn.SCAN
|
||||
$(P)$(R)ADSCReusDrk
|
||||
$(P)$(R)ADSCDezingr
|
||||
$(P)$(R)ADSCAdc
|
||||
$(P)$(R)ADSCRaw
|
||||
$(P)$(R)ADSCImXform
|
||||
$(P)$(R)ADSCStrDrks
|
||||
$(P)$(R)ADSCBeamX
|
||||
$(P)$(R)ADSCBeamY
|
||||
$(P)$(R)ADSCDistnce
|
||||
$(P)$(R)ADSC2Theta
|
||||
$(P)$(R)ADSCAxis
|
||||
$(P)$(R)ADSCWavelen
|
||||
$(P)$(R)ADSCImWidth
|
||||
$(P)$(R)ADSCPhi
|
||||
$(P)$(R)ADSCOmega
|
||||
$(P)$(R)ADSCKappa
|
||||
@@ -1,342 +0,0 @@
|
||||
# Database for the records specific to the Andor SDK3 cameras
|
||||
# Phillip Sorensen
|
||||
# October 8, 2012
|
||||
|
||||
###############################################################################
|
||||
# Note: The following are records defined in ADBase.template. #
|
||||
# We are changing some of the fields here to reflect valid values for #
|
||||
# Andor SDK3 #
|
||||
###############################################################################
|
||||
|
||||
###############################################################################
|
||||
# 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, "")
|
||||
}
|
||||
|
||||
|
||||
# The following records are specific to the Andor SDK3
|
||||
# Note that we don't define the choices for mbbo and mbii records here.
|
||||
# These choices are built at iocInit by reading the list of valid choices
|
||||
# from the Andor SDK. This is very nice because they automatically change
|
||||
# depending on the capabilities of the camera.
|
||||
|
||||
###############################################################################
|
||||
# These records are additional acquisition parameters #
|
||||
###############################################################################
|
||||
|
||||
record(ao, "$(P)$(R)FrameRate")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FRAME_RATE")
|
||||
field(VAL, "10")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)FrameRate_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FRAME_RATE")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)PreAmpGain")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_PREAMP_GAIN")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)PreAmpGain_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_PREAMP_GAIN")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)ReadoutRate")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_READOUT_RATE")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ReadoutRate_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_READOUT_RATE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)Overlap")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_OVERLAP")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)Overlap_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_OVERLAP")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)NoiseFilter")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_NOISE_FILTER")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)NoiseFilter_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_NOISE_FILTER")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)PixelEncoding")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_PIXEL_ENCODING")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)PixelEncoding_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_PIXEL_ENCODING")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)ReadoutTime")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_READOUT_TIME")
|
||||
field(PREC, "4")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)TransferRate")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_TRANSFER_RATE")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)FullAOIControl")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FULL_AOI_CONTROL")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)A3Binning")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_BINNING")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)A3Binning_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_BINNING")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)A3ShutterMode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SHUTTER_MODE")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)A3ShutterMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SHUTTER_MODE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)SoftwareTrigger")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SOFTWARE_TRIGGER")
|
||||
field(ZNAM, "Done")
|
||||
field(ONAM, "Trigger")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)SensorCooling")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SENSOR_COOLING")
|
||||
field(ZNAM, "Off")
|
||||
field(ONAM, "On")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)SensorCooling_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SENSOR_COOLING")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZNAM, "Off")
|
||||
field(ONAM, "On")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)TempControl")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_TEMP_CONTROL")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)TempControl_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_TEMP_CONTROL")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)TempStatus_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_TEMP_STATUS")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)FanSpeed")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FAN_SPEED")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)FanSpeed_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FAN_SPEED")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(stringin, "$(P)$(R)SerialNumber")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SERIAL_NUMBER")
|
||||
}
|
||||
|
||||
record(stringin, "$(P)$(R)FirmwareVersion")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_FIRMWARE_VERSION")
|
||||
}
|
||||
|
||||
record(stringin, "$(P)$(R)SoftwareVersion")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_SOFTWARE_VERSION")
|
||||
}
|
||||
|
||||
record(stringin, "$(P)$(R)ControllerID")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))A3_CONTROLLER_ID")
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
$(P)$(R)FrameRate
|
||||
$(P)$(R)PreAmpGain
|
||||
$(P)$(R)ReadoutRate
|
||||
$(P)$(R)Overlap
|
||||
$(P)$(R)NoiseFilter
|
||||
$(P)$(R)PixelEncoding
|
||||
$(P)$(R)A3Binning
|
||||
$(P)$(R)A3ShutterMode
|
||||
$(P)$(R)SensorCooling
|
||||
$(P)$(R)TempControl
|
||||
$(P)$(R)FanSpeed
|
||||
@@ -1,57 +0,0 @@
|
||||
file "NDPluginBase_settings.req", P=$(P), R=netCDF1:
|
||||
file "NDFile_settings.req", P=$(P), R=netCDF1:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=TIFF1:
|
||||
file "NDFile_settings.req", P=$(P), R=TIFF1:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=JPEG1:
|
||||
file "NDFile_settings.req", P=$(P), R=JPEG1:
|
||||
file "NDFileJPEG_settings.req", P=$(P), R=JPEG1:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=Nexus1:
|
||||
file "NDFile_settings.req", P=$(P), R=Nexus1:
|
||||
file "NDFileNexus_settings.req", P=$(P), R=Nexus1:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=Magick1:
|
||||
file "NDFile_settings.req", P=$(P), R=Magick1:
|
||||
file "NDFileMagick_settings.req", P=$(P), R=Magick1:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=HDF1:
|
||||
file "NDFile_settings.req", P=$(P), R=HDF1:
|
||||
file "NDFileHDF5_settings.req", P=$(P), R=HDF1:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=ROI1:
|
||||
file "NDROI_settings.req", P=$(P), R=ROI1:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=ROI2:
|
||||
file "NDROI_settings.req", P=$(P), R=ROI2:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=ROI3:
|
||||
file "NDROI_settings.req", P=$(P), R=ROI3:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=ROI4:
|
||||
file "NDROI_settings.req", P=$(P), R=ROI4:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=Proc1:
|
||||
file "NDProcess_settings.req", P=$(P), R=Proc1:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=Stats1:
|
||||
file "NDStats_settings.req", P=$(P), R=Stats1:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=Stats2:
|
||||
file "NDStats_settings.req", P=$(P), R=Stats2:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=Stats3:
|
||||
file "NDStats_settings.req", P=$(P), R=Stats3:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=Stats4:
|
||||
file "NDStats_settings.req", P=$(P), R=Stats4:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=Stats5:
|
||||
file "NDStats_settings.req", P=$(P), R=Stats5:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=Trans1:
|
||||
file "NDTransform_settings.req", P=$(P), R=Trans1:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=Over1:
|
||||
file "NDOverlay_settings.req", P=$(P), R=Over1:
|
||||
file "NDOverlayN_settings.req", P=$(P), R=Over1:1:
|
||||
file "NDOverlayN_settings.req", P=$(P), R=Over1:2:
|
||||
file "NDOverlayN_settings.req", P=$(P), R=Over1:3:
|
||||
file "NDOverlayN_settings.req", P=$(P), R=Over1:4:
|
||||
file "NDOverlayN_settings.req", P=$(P), R=Over1:5:
|
||||
file "NDOverlayN_settings.req", P=$(P), R=Over1:6:
|
||||
file "NDOverlayN_settings.req", P=$(P), R=Over1:7:
|
||||
file "NDOverlayN_settings.req", P=$(P), R=Over1:8:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=CC1:
|
||||
file "NDColorConvert_settings.req", P=$(P), R=CC1:
|
||||
file "NDPluginBase_settings.req", P=$(P), R=CC2:
|
||||
file "NDColorConvert_settings.req", P=$(P), R=CC2:
|
||||
file "scan_settings.req", P=$(P), S=scan1
|
||||
file "scan_settings.req", P=$(P), S=scan2
|
||||
file "scan_settings.req", P=$(P), S=scan3
|
||||
file "scan_settings.req", P=$(P), S=scan4
|
||||
file "sseq_settings.req", P=$(P), S=AcquireSequence
|
||||
@@ -1,17 +0,0 @@
|
||||
## firewireColorCodes.template
|
||||
|
||||
# Valid color code strings
|
||||
record(stringin, "$(P)$(R)VALID_COLORCODE_$(N)") {
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT) $(N))FDC_VALID_COLORCODE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Has color code bi
|
||||
record(bi, "$(P)$(R)HAS_COLORCODE_$(N)") {
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT) $(N))FDC_HAS_COLORCODE")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
@@ -1,252 +0,0 @@
|
||||
## firewireDCAM.db
|
||||
## Template database file to control the features of a firewire camera.
|
||||
## See the detailled description for information about macros and how features
|
||||
## can be controlled and read out:
|
||||
##
|
||||
|
||||
## Video Format
|
||||
record(mbbo, "$(P)$(R)FORMAT") {
|
||||
field(SCAN, "Passive")
|
||||
field(PINI, "NO")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT) 0)FDC_FORMAT")
|
||||
field(ZRST, "VGA")
|
||||
field(ONST, "Super VGA 1")
|
||||
field(TWST, "Super VGA 2")
|
||||
field(THST, "Still image")
|
||||
field(FRST, "User-defined")
|
||||
field(ZRVL, "0x0")
|
||||
field(ONVL, "0x1")
|
||||
field(TWVL, "0x2")
|
||||
field(THVL, "0x6")
|
||||
field(FRVL, "0x7")
|
||||
}
|
||||
|
||||
## Read back the framerate setting when not in ROI/format7 mode.
|
||||
record(mbbi, "$(P)$(R)FORMAT_RBV") {
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT) 0)FDC_FORMAT")
|
||||
field(ZRST, "VGA")
|
||||
field(ONST, "Super VGA 1")
|
||||
field(TWST, "Super VGA 2")
|
||||
field(THST, "Still image")
|
||||
field(FRST, "User-defined")
|
||||
field(ZRVL, "0x0")
|
||||
field(ONVL, "0x1")
|
||||
field(TWVL, "0x2")
|
||||
field(THVL, "0x6")
|
||||
field(FRVL, "0x7")
|
||||
}
|
||||
|
||||
## VideoMode
|
||||
record(mbbo, "$(P)$(R)MODE") {
|
||||
field(SCAN, "Passive")
|
||||
field(PINI, "NO")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT) 0)FDC_MODE")
|
||||
field(ZRST, "0")
|
||||
field(ONST, "1")
|
||||
field(TWST, "2")
|
||||
field(THST, "3")
|
||||
field(FRST, "4")
|
||||
field(FVST, "5")
|
||||
field(SXST, "6")
|
||||
field(SVST, "7")
|
||||
field(ZRVL, "0x0")
|
||||
field(ONVL, "0x1")
|
||||
field(TWVL, "0x2")
|
||||
field(THVL, "0x3")
|
||||
field(FRVL, "0x4")
|
||||
field(FVVL, "0x5")
|
||||
field(SXVL, "0x6")
|
||||
field(SVVL, "0x7")
|
||||
}
|
||||
|
||||
## Read back the framerate setting when not in ROI/format7 mode.
|
||||
record(mbbi, "$(P)$(R)MODE_RBV") {
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT) 0)FDC_MODE")
|
||||
field(ZRST, "0")
|
||||
field(ONST, "1")
|
||||
field(TWST, "2")
|
||||
field(THST, "3")
|
||||
field(FRST, "4")
|
||||
field(FVST, "5")
|
||||
field(SXST, "6")
|
||||
field(SVST, "7")
|
||||
field(ZRVL, "0x0")
|
||||
field(ONVL, "0x1")
|
||||
field(TWVL, "0x2")
|
||||
field(THVL, "0x3")
|
||||
field(FRVL, "0x4")
|
||||
field(FVVL, "0x5")
|
||||
field(SXVL, "0x6")
|
||||
field(SVVL, "0x7")
|
||||
}
|
||||
|
||||
## Change the framerate when the camera is not in the ROI/format7 mode
|
||||
record(mbbo, "$(P)$(R)FR") {
|
||||
field(SCAN, "Passive")
|
||||
field(PINI, "NO")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT) 0)FDC_FRAMERATE")
|
||||
field(ZRST, "1.875")
|
||||
field(ONST, "3.75")
|
||||
field(TWST, "7.5")
|
||||
field(THST, "15")
|
||||
field(FRST, "30")
|
||||
field(FVST, "60")
|
||||
field(SXST, "120")
|
||||
field(SVST, "240")
|
||||
field(ZRVL, "0x0")
|
||||
field(ONVL, "0x1")
|
||||
field(TWVL, "0x2")
|
||||
field(THVL, "0x3")
|
||||
field(FRVL, "0x4")
|
||||
field(FVVL, "0x5")
|
||||
field(SXVL, "0x6")
|
||||
field(SVVL, "0x7")
|
||||
}
|
||||
|
||||
## Read back the framerate setting when not in ROI/format7 mode.
|
||||
record(mbbi, "$(P)$(R)FR_RBV") {
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT) 0)FDC_FRAMERATE")
|
||||
field(ZRST, "1.875")
|
||||
field(ONST, "3.75")
|
||||
field(TWST, "7.5")
|
||||
field(THST, "15")
|
||||
field(FRST, "30")
|
||||
field(FVST, "60")
|
||||
field(SXST, "120")
|
||||
field(SVST, "240")
|
||||
field(ZRVL, "0x0")
|
||||
field(ONVL, "0x1")
|
||||
field(TWVL, "0x2")
|
||||
field(THVL, "0x3")
|
||||
field(FRVL, "0x4")
|
||||
field(FVVL, "0x5")
|
||||
field(SXVL, "0x6")
|
||||
field(SVVL, "0x7")
|
||||
}
|
||||
|
||||
## Format 7 color code
|
||||
record(mbbo, "$(P)$(R)COLORCODE") {
|
||||
field(SCAN, "Passive")
|
||||
field(PINI, "NO")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT) 0)FDC_COLORCODE")
|
||||
field(ZRST, "0")
|
||||
field(ONST, "1")
|
||||
field(TWST, "2")
|
||||
field(THST, "3")
|
||||
field(FRST, "4")
|
||||
field(FVST, "5")
|
||||
field(SXST, "6")
|
||||
field(SVST, "7")
|
||||
field(EIST, "8")
|
||||
field(NIST, "9")
|
||||
field(TEST, "10")
|
||||
field(ZRVL, "0x0")
|
||||
field(ONVL, "0x1")
|
||||
field(TWVL, "0x2")
|
||||
field(THVL, "0x3")
|
||||
field(FRVL, "0x4")
|
||||
field(FVVL, "0x5")
|
||||
field(SXVL, "0x6")
|
||||
field(SVVL, "0x7")
|
||||
field(EIVL, "0x8")
|
||||
field(NIVL, "0x9")
|
||||
field(TEVL, "0xA")
|
||||
}
|
||||
|
||||
## Read back the framerate setting when not in ROI/format7 mode.
|
||||
record(mbbi, "$(P)$(R)COLORCODE_RBV") {
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT) 0)FDC_COLORCODE")
|
||||
field(ZRST, "0")
|
||||
field(ONST, "1")
|
||||
field(TWST, "2")
|
||||
field(THST, "3")
|
||||
field(FRST, "4")
|
||||
field(FVST, "5")
|
||||
field(SXST, "6")
|
||||
field(SVST, "7")
|
||||
field(EIST, "8")
|
||||
field(NIST, "9")
|
||||
field(TEST, "10")
|
||||
field(ZRVL, "0x0")
|
||||
field(ONVL, "0x1")
|
||||
field(TWVL, "0x2")
|
||||
field(THVL, "0x3")
|
||||
field(FRVL, "0x4")
|
||||
field(FVVL, "0x5")
|
||||
field(SXVL, "0x6")
|
||||
field(SVVL, "0x7")
|
||||
field(EIVL, "0x8")
|
||||
field(NIVL, "0x9")
|
||||
field(TEVL, "0xA")
|
||||
}
|
||||
|
||||
|
||||
# Current format string
|
||||
record(stringin, "$(P)$(R)CURRENT_FORMAT") {
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT) 0)FDC_CURRENT_FORMAT")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Current mode string
|
||||
record(stringin, "$(P)$(R)CURRENT_MODE") {
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT) 0)FDC_CURRENT_MODE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Current frame rate string
|
||||
record(stringin, "$(P)$(R)CURRENT_RATE") {
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT) 0)FDC_CURRENT_FRAMERATE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Current color mode string
|
||||
record(stringin, "$(P)$(R)CURRENT_COLORCODE") {
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT) 0)FDC_CURRENT_COLORCODE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Dropped frames
|
||||
record(longout, "$(P)$(R)DROPPED_FRAMES") {
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT) 0)FDC_DROPPED_FRAMES")
|
||||
}
|
||||
|
||||
# Dropped frames
|
||||
record(longin, "$(P)$(R)DROPPED_FRAMES_RBV") {
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT) 0)FDC_DROPPED_FRAMES")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Readout time
|
||||
record(ao, "$(P)$(R)READOUT_TIME") {
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT) 0)FDC_READOUT_TIME")
|
||||
field(PREC, "1")
|
||||
field(VAL, "1.0")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)READOUT_TIME_RBV") {
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT) 0)FDC_READOUT_TIME")
|
||||
field(PREC, "1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
@@ -1,4 +0,0 @@
|
||||
$(P)$(R)FORMAT
|
||||
$(P)$(R)MODE
|
||||
$(P)$(R)FR
|
||||
$(P)$(R)READOUT_TIME
|
||||
@@ -1,157 +0,0 @@
|
||||
## firewireFeature.db
|
||||
|
||||
# Set the value (int32)
|
||||
record(ao, "$(P)$(R)$(FEATURE)") {
|
||||
field(PINI, "$(PINI)")
|
||||
field(DTYP, "asynInt32")
|
||||
field(DESC, "$(DESC)")
|
||||
field(OUT, "@asyn($(PORT) $(N))FDC_FEAT_VAL")
|
||||
}
|
||||
|
||||
# Read the value (int32)
|
||||
record(ai, "$(P)$(R)$(FEATURE)_RBV") {
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT) $(N))FDC_FEAT_VAL")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
## Set the control mode (manual = user configured /auto = camera sets values)
|
||||
record(bo, "$(P)$(R)$(FEATURE)_CTRL") {
|
||||
field(PINI, "$(PINI)")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT) $(N))FDC_FEAT_MODE")
|
||||
field(ZNAM, "Manual")
|
||||
field(ONAM, "Auto")
|
||||
}
|
||||
|
||||
## Read back the control mode
|
||||
record(bi, "$(P)$(R)$(FEATURE)_CTRL_RBV") {
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT) $(N))FDC_FEAT_MODE")
|
||||
field(ZNAM, "Manual")
|
||||
field(ONAM, "Auto")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
## Read whether the camera supports this feature
|
||||
record(bi, "$(P)$(R)$(FEATURE)_AVL") {
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT) $(N))FDC_FEAT_AVAILABLE")
|
||||
field(ZNAM, "not available")
|
||||
field(ONAM, "available")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Read value boundaries
|
||||
record(ai, "$(P)$(R)$(FEATURE)_MIN") {
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT) $(N))FDC_FEAT_VAL_MIN")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(FLNK, "$(P)$(R)$(FEATURE)_DRVL")
|
||||
}
|
||||
|
||||
# Set DRLV field of the value PV
|
||||
record(ao, "$(P)$(R)$(FEATURE)_DRVL") {
|
||||
field(DOL, "$(P)$(R)$(FEATURE)_MIN NPP NMS")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUT, "$(P)$(R)$(FEATURE).DRVL NPP NMS")
|
||||
field(FLNK, "$(P)$(R)$(FEATURE)_LOPR")
|
||||
}
|
||||
# Set LOPR field of the value PV
|
||||
record(ao, "$(P)$(R)$(FEATURE)_LOPR") {
|
||||
field(DOL, "$(P)$(R)$(FEATURE)_MIN NPP NMS")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUT, "$(P)$(R)$(FEATURE).LOPR NPP NMS")
|
||||
}
|
||||
record(ai, "$(P)$(R)$(FEATURE)_MAX") {
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT) $(N))FDC_FEAT_VAL_MAX")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(FLNK, "$(P)$(R)$(FEATURE)_DRVH")
|
||||
}
|
||||
# Set DRLH field of the value PV
|
||||
record(ao, "$(P)$(R)$(FEATURE)_DRVH") {
|
||||
field(DOL, "$(P)$(R)$(FEATURE)_MAX NPP NMS")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUT, "$(P)$(R)$(FEATURE).DRVH NPP NMS")
|
||||
field(FLNK, "$(P)$(R)$(FEATURE)_HOPR")
|
||||
}
|
||||
# Set HOPR field of the value PV
|
||||
record(ao, "$(P)$(R)$(FEATURE)_HOPR") {
|
||||
field(DOL, "$(P)$(R)$(FEATURE)_MAX NPP NMS")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUT, "$(P)$(R)$(FEATURE).HOPR NPP NMS")
|
||||
}
|
||||
|
||||
## Read whether the camera supports absolute (floating point) control of this feature
|
||||
record(bi, "$(P)$(R)$(FEATURE)_ABS_AVL") {
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT) $(N))FDC_FEAT_ABSOLUTE")
|
||||
field(ZNAM, "not available")
|
||||
field(ONAM, "available")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Set the feature absolute value (floating point)
|
||||
record(ao, "$(P)$(R)$(FEATURE)_ABS") {
|
||||
field(PINI, "$(PINI_ABS)")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT) $(N))FDC_FEAT_VAL_ABS")
|
||||
field(PREC, "3")
|
||||
}
|
||||
|
||||
# Read the feature absolute value
|
||||
record(ai, "$(P)$(R)$(FEATURE)_ABS_RBV") {
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT) $(N))FDC_FEAT_VAL_ABS")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
# Read the feature absolute value max boundary
|
||||
record(ai, "$(P)$(R)$(FEATURE)_ABS_MAX") {
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT) $(N))FDC_FEAT_VAL_ABS_MAX")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(FLNK, "$(P)$(R)$(FEATURE)_ABS_DRVH")
|
||||
}
|
||||
# Set DRLH field of the value PV
|
||||
record(ao, "$(P)$(R)$(FEATURE)_ABS_DRVH") {
|
||||
field(DOL, "$(P)$(R)$(FEATURE)_ABS_MAX NPP NMS")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUT, "$(P)$(R)$(FEATURE)_ABS.DRVH NPP NMS")
|
||||
field(FLNK, "$(P)$(R)$(FEATURE)_ABS_HOPR")
|
||||
}
|
||||
# Set HOPR field of the value PV
|
||||
record(ao, "$(P)$(R)$(FEATURE)_ABS_HOPR") {
|
||||
field(DOL, "$(P)$(R)$(FEATURE)_ABS_MAX NPP NMS")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUT, "$(P)$(R)$(FEATURE)_ABS.HOPR NPP NMS")
|
||||
}
|
||||
|
||||
# Read the feature absolute value min boundary
|
||||
record(ai, "$(P)$(R)$(FEATURE)_ABS_MIN") {
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT) $(N))FDC_FEAT_VAL_ABS_MIN")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(FLNK, "$(P)$(R)$(FEATURE)_ABS_DRVL")
|
||||
}
|
||||
|
||||
# Set DRLV field of the value PV
|
||||
record(ao, "$(P)$(R)$(FEATURE)_ABS_DRVL") {
|
||||
field(DOL, "$(P)$(R)$(FEATURE)_ABS_MIN NPP NMS")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUT, "$(P)$(R)$(FEATURE)_ABS.DRVL NPP NMS")
|
||||
field(FLNK, "$(P)$(R)$(FEATURE)_ABS_LOPR")
|
||||
}
|
||||
# Set LOPR field of the value PV
|
||||
record(ao, "$(P)$(R)$(FEATURE)_ABS_LOPR") {
|
||||
field(DOL, "$(P)$(R)$(FEATURE)_ABS_MIN NPP NMS")
|
||||
field(OMSL, "closed_loop")
|
||||
field(OUT, "$(P)$(R)$(FEATURE)_ABS.LOPR NPP NMS")
|
||||
}
|
||||
|
||||
|
||||
@@ -1,2 +0,0 @@
|
||||
$(P)$(R)$(FEATURE)_ABS
|
||||
$(P)$(R)$(FEATURE)_CTRL
|
||||
@@ -1,2 +0,0 @@
|
||||
$(P)$(R)$(FEATURE)
|
||||
$(P)$(R)$(FEATURE)_CTRL
|
||||
@@ -1,52 +0,0 @@
|
||||
## firewireVideoModes.template
|
||||
|
||||
# Valid format strings
|
||||
record(stringin, "$(P)$(R)VALID_FORMAT_$(N)") {
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT) $(N))FDC_VALID_FORMAT")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Has format bi
|
||||
record(bi, "$(P)$(R)HAS_FORMAT_$(N)") {
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT) $(N))FDC_HAS_FORMAT")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Valid mode strings
|
||||
record(stringin, "$(P)$(R)VALID_MODE_$(N)") {
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT) $(N))FDC_VALID_MODE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
#
|
||||
|
||||
# Has mode bi
|
||||
record(bi, "$(P)$(R)HAS_MODE_$(N)") {
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT) $(N))FDC_HAS_MODE")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
# Valid frame rate strings
|
||||
record(stringin, "$(P)$(R)VALID_RATE_$(N)") {
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT) $(N))FDC_VALID_FRAMERATE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Has rate bi
|
||||
record(bi, "$(P)$(R)HAS_RATE_$(N)") {
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT) $(N))FDC_HAS_FRAMERATE")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
@@ -1,97 +0,0 @@
|
||||
# White balance. The low and high parts of the white balance register are independent.
|
||||
# Have 2 separate records and combine them into one for both output and readback
|
||||
|
||||
record(longout, "$(P)$(R)$(FEATURE)_LO") {
|
||||
field(PINI, "YES")
|
||||
field(DESC, "White bal. R/V")
|
||||
field(OUT, "$(P)$(R)$(FEATURE)_CALC.A PP MS")
|
||||
}
|
||||
|
||||
|
||||
record(longout, "$(P)$(R)$(FEATURE)_HI") {
|
||||
field(PINI, "YES")
|
||||
field(DESC, "White bal. B/U")
|
||||
field(OUT, "$(P)$(R)$(FEATURE)_CALC.B PP MS")
|
||||
}
|
||||
|
||||
record(calcout, "$(P)$(R)$(FEATURE)_CALC") {
|
||||
field(CALC, "(B<<12) | A")
|
||||
field(OUT, "$(P)$(R)$(FEATURE).VAL PP MS")
|
||||
}
|
||||
|
||||
record(calcout, "$(P)$(R)$(FEATURE)_LO_RBV_CALC") {
|
||||
field(CALC, "A & 4095")
|
||||
field(INPA, "$(P)$(R)$(FEATURE)_RBV.VAL CP MS")
|
||||
field(FLNK, "$(P)$(R)$(FEATURE)_LO_RBV")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)$(FEATURE)_LO_RBV") {
|
||||
field(INP, "$(P)$(R)$(FEATURE)_LO_RBV_CALC NPP NMS")
|
||||
}
|
||||
|
||||
record(calcout, "$(P)$(R)$(FEATURE)_HI_RBV_CALC") {
|
||||
field(CALC, "(A>>12) & 4095")
|
||||
field(INPA, "$(P)$(R)$(FEATURE)_RBV.VAL CP MS")
|
||||
field(FLNK, "$(P)$(R)$(FEATURE)_HI_RBV")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)$(FEATURE)_HI_RBV") {
|
||||
field(INP, "$(P)$(R)$(FEATURE)_HI_RBV_CALC NPP NMS")
|
||||
}
|
||||
|
||||
# Set DRLV field of the value PV
|
||||
record(calcout, "$(P)$(R)$(FEATURE)_LO_DRVL") {
|
||||
field(INPA, "$(P)$(R)$(FEATURE)_MIN CP MS")
|
||||
field(CALC, "A & 4095")
|
||||
field(OUT, "$(P)$(R)$(FEATURE)_LO.DRVL NPP NMS")
|
||||
}
|
||||
|
||||
# Set DRLV field of the value PV
|
||||
record(calcout, "$(P)$(R)$(FEATURE)_HI_DRVL") {
|
||||
field(INPA, "$(P)$(R)$(FEATURE)_MIN CP MS")
|
||||
field(CALC, "A & 4095")
|
||||
field(OUT, "$(P)$(R)$(FEATURE)_HI.DRVL NPP NMS")
|
||||
}
|
||||
|
||||
# Set LOPR field of the value PV
|
||||
record(calcout, "$(P)$(R)$(FEATURE)_LO_LOPR") {
|
||||
field(INPA, "$(P)$(R)$(FEATURE)_MIN CP MS")
|
||||
field(CALC, "A & 4095")
|
||||
field(OUT, "$(P)$(R)$(FEATURE)_LO.LOPR NPP NMS")
|
||||
}
|
||||
|
||||
# Set LOPR field of the value PV
|
||||
record(calcout, "$(P)$(R)$(FEATURE)_HI_LOPR") {
|
||||
field(INPA, "$(P)$(R)$(FEATURE)_MIN CP MS")
|
||||
field(CALC, "A & 4095")
|
||||
field(OUT, "$(P)$(R)$(FEATURE)_HI.LOPR NPP NMS")
|
||||
}
|
||||
|
||||
# Set DRLH field of the value PV
|
||||
record(calcout, "$(P)$(R)$(FEATURE)_LO_DRVH") {
|
||||
field(INPA, "$(P)$(R)$(FEATURE)_MAX CP MS")
|
||||
field(CALC, "A & 4095")
|
||||
field(OUT, "$(P)$(R)$(FEATURE)_LO.DRVH NPP NMS")
|
||||
}
|
||||
|
||||
# Set DRLH field of the value PV
|
||||
record(calcout, "$(P)$(R)$(FEATURE)_HI_DRVH") {
|
||||
field(INPA, "$(P)$(R)$(FEATURE)_MAX CP MS")
|
||||
field(CALC, "A & 4095")
|
||||
field(OUT, "$(P)$(R)$(FEATURE)_HI.DRVH NPP NMS")
|
||||
}
|
||||
# Set HOPR field of the value PV
|
||||
record(calcout, "$(P)$(R)$(FEATURE)_LO_HOPR") {
|
||||
field(INPA, "$(P)$(R)$(FEATURE)_MAX CP MS")
|
||||
field(CALC, "A & 4095")
|
||||
field(OUT, "$(P)$(R)$(FEATURE)_LO.HOPR NPP NMS")
|
||||
}
|
||||
|
||||
# Set HOPR field of the value PV
|
||||
record(calcout, "$(P)$(R)$(FEATURE)_HI_HOPR") {
|
||||
field(INPA, "$(P)$(R)$(FEATURE)_MAX CP MS")
|
||||
field(CALC, "A & 4095")
|
||||
field(OUT, "$(P)$(R)$(FEATURE)_HI.HOPR NPP NMS")
|
||||
}
|
||||
|
||||
|
||||
@@ -1,217 +0,0 @@
|
||||
# Database for the records specific to the mar345 driver
|
||||
# Mark Rivers
|
||||
# October 31, 2008
|
||||
|
||||
# Status poll. This can normally be Passive, except when ArrayCallbacks is 0 and Overlap is 1.
|
||||
# In that case the state will appear to be busy when it is idle, and this polling should be
|
||||
# turned on to avoid confusion
|
||||
|
||||
record(bo,"$(P)$(R)Abort") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_ABORT")
|
||||
field(ZNAM,"Done")
|
||||
field(ONAM,"Abort")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(bi,"$(P)$(R)Abort_RBV") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_ABORT")
|
||||
field(ZNAM,"Done")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(ONAM,"Aborting")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(busy,"$(P)$(R)Erase") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_ERASE")
|
||||
field(ZNAM,"Done")
|
||||
field(ONAM,"Erase")
|
||||
}
|
||||
|
||||
record(bi,"$(P)$(R)Erase_RBV") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_ERASE")
|
||||
field(ZNAM,"Done")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(ONAM,"Erasing")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)NumErase")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_NUM_ERASE")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NumErase_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_NUM_ERASE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NumErased_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_NUM_ERASED")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Erase mode - none, before, after
|
||||
record(mbbo,"$(P)$(R)EraseMode") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_ERASE_MODE")
|
||||
field(PINI, "YES")
|
||||
field(ZRVL,"0")
|
||||
field(ZRST,"None")
|
||||
field(ONVL,"1")
|
||||
field(ONST,"Before expose")
|
||||
field(TWVL,"2")
|
||||
field(TWST,"After scan")
|
||||
}
|
||||
# Erase mode - none, before, after
|
||||
record(mbbi,"$(P)$(R)EraseMode_RBV") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_ERASE_MODE")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZRVL,"0")
|
||||
field(ZRST,"None")
|
||||
field(ONVL,"1")
|
||||
field(ONST,"Before expose")
|
||||
field(TWVL,"2")
|
||||
field(TWST,"After scan")
|
||||
}
|
||||
|
||||
record(busy,"$(P)$(R)ChangeMode") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(PINI, "YES")
|
||||
field(VAL, "1")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_CHANGE_MODE")
|
||||
field(ZNAM,"Done")
|
||||
field(ONAM,"Change")
|
||||
}
|
||||
|
||||
record(bi,"$(P)$(R)ChangeMode_RBV") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_CHANGE_MODE")
|
||||
field(ZNAM,"Done")
|
||||
field(ZSV, "NO_ALARM")
|
||||
field(ONAM,"Changing")
|
||||
field(OSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Readout size
|
||||
record(mbbo,"$(P)$(R)ScanSize") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_SIZE")
|
||||
field(PINI, "YES")
|
||||
field(ZRVL,"0")
|
||||
field(ZRST,"180 mm")
|
||||
field(ONVL,"1")
|
||||
field(ONST,"240 mm")
|
||||
field(TWVL,"2")
|
||||
field(TWST,"300 mm")
|
||||
field(THVL,"3")
|
||||
field(THST,"345 mm")
|
||||
}
|
||||
|
||||
record(mbbi,"$(P)$(R)ScanSize_RBV") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZRVL,"0")
|
||||
field(ZRST,"180 mm")
|
||||
field(ONVL,"1")
|
||||
field(ONST,"240 mm")
|
||||
field(TWVL,"2")
|
||||
field(TWST,"300 mm")
|
||||
field(THVL,"3")
|
||||
field(THST,"345 mm")
|
||||
}
|
||||
|
||||
# Readout resolution
|
||||
record(mbbo,"$(P)$(R)ScanResolution") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_RESOLUTION")
|
||||
field(PINI, "YES")
|
||||
field(ZRVL,"0")
|
||||
field(ZRST,"0.10 mm")
|
||||
field(ONVL,"1")
|
||||
field(ONST,"0.15 mm")
|
||||
}
|
||||
|
||||
record(mbbi,"$(P)$(R)ScanResolution_RBV") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_RESOLUTION")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(ZRVL,"0")
|
||||
field(ZRST,"0.10 mm")
|
||||
field(ONVL,"1")
|
||||
field(ONST,"0.15 mm")
|
||||
}
|
||||
|
||||
|
||||
# We replace the file format choices from ADBase.template
|
||||
record(mbbo, "$(P)$(R)FileFormat")
|
||||
{
|
||||
field(ZRST, "MAR345")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Invalid")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)FileFormat_RBV")
|
||||
{
|
||||
field(ZRST, "MAR345")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Invalid")
|
||||
field(ONVL, "1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# asyn record for interactive communication with marServer
|
||||
record(asyn, "$(P)$(R)marServerAsyn")
|
||||
{
|
||||
field(PORT, "$(MARSERVER_PORT)")
|
||||
field(IMAX, "64")
|
||||
field(OMAX, "64")
|
||||
}
|
||||
|
||||
# We replace the states for DetectorState_RBV
|
||||
record(mbbi, "$(P)$(R)DetectorState_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))STATUS")
|
||||
field(ZRST, "Idle")
|
||||
field(ZRVL, "0")
|
||||
field(ZRSV, "NO_ALARM")
|
||||
field(ONST, "Exposing")
|
||||
field(ONVL, "1")
|
||||
field(ONSV, "MINOR")
|
||||
field(TWST, "Scanning")
|
||||
field(TWVL, "2")
|
||||
field(TWSV, "MINOR")
|
||||
field(THST, "Erasing")
|
||||
field(THVL, "3")
|
||||
field(THSV, "MINOR")
|
||||
field(FRST, "Changing mode")
|
||||
field(FRVL, "4")
|
||||
field(FRSV, "MINOR")
|
||||
field(FVST, "Aborting")
|
||||
field(FVVL, "5")
|
||||
field(FVSV, "MINOR")
|
||||
field(SXST, "Error")
|
||||
field(SXVL, "6")
|
||||
field(SXSV, "MAJOR")
|
||||
field(SVST, "Waiting")
|
||||
field(SVVL, "7")
|
||||
field(SVSV, "MINOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
@@ -1,4 +0,0 @@
|
||||
$(P)$(R)EraseMode
|
||||
$(P)$(R)NumErase
|
||||
$(P)$(R)ScanSize
|
||||
$(P)$(R)ScanResolution
|
||||
@@ -1,574 +0,0 @@
|
||||
# Database for the records specific to the marCCD driver
|
||||
# Mark Rivers
|
||||
# October 31, 2008
|
||||
|
||||
|
||||
###################################################
|
||||
# These are records we change from ADBase.template
|
||||
###################################################
|
||||
|
||||
|
||||
# Note: the enum choices for ImageMode and TriggerMode depend on the marCCD server mode and so
|
||||
# are set in the marCCD:readEnums method
|
||||
|
||||
record(mbbo, "$(P)$(R)FrameType")
|
||||
{
|
||||
field(ZRST, "Normal")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Background")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Raw")
|
||||
field(TWVL, "2")
|
||||
field(THST, "DblCorrelation")
|
||||
field(THVL, "3")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)FrameType_RBV")
|
||||
{
|
||||
field(ZRST, "Normal")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Background")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Raw")
|
||||
field(TWVL, "2")
|
||||
field(THST, "DblCorrelation")
|
||||
field(THVL, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
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")
|
||||
}
|
||||
|
||||
|
||||
############################################
|
||||
# These are records that are new to marCCD
|
||||
############################################
|
||||
|
||||
# Note: the enum choices for GateMode and ReadoutMode depend on the marCCD server mode and so
|
||||
# are set in the marCCD:readEnums method
|
||||
|
||||
record(mbbo, "$(P)$(R)GateMode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_GATE_MODE")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
# Note, the enum string
|
||||
record(mbbi, "$(P)$(R)GateMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_GATE_MODE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)ReadoutMode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_READOUT_MODE")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ReadoutMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_READOUT_MODE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)ServerMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_SERVER_MODE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)SeriesFileTemplate")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_SERIES_FILE_TEMPLATE")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)SeriesFileTemplate_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_SERIES_FILE_TEMPLATE")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)SeriesFileDigits")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_SERIES_FILE_DIGITS")
|
||||
field(PINI, "YES")
|
||||
field(DESC, "Series file digits")
|
||||
field(VAL, "5")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)SeriesFileDigits_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_SERIES_FILE_DIGITS")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DESC, "Series file digits")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)SeriesFileFirst")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_SERIES_FILE_FIRST")
|
||||
field(PINI, "YES")
|
||||
field(DESC, "Series file first")
|
||||
field(VAL, "1")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)SeriesFileFirst_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_SERIES_FILE_FIRST")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DESC, "Series file first")
|
||||
}
|
||||
|
||||
record(longin,"$(P)$(R)MarState_RBV") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_STATE")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DESC,"Task state")
|
||||
}
|
||||
|
||||
# State word
|
||||
record(longin,"$(P)$(R)MarState_RBV") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_STATE")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DESC,"Task state")
|
||||
}
|
||||
|
||||
# Status field for low order 4 bits (should only be IDLE, ERROR or BUSY)
|
||||
record(mbbi,"$(P)$(R)MarStatus_RBV") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_STATUS")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DESC,"Task status")
|
||||
field(ZRVL,"0")
|
||||
field(ZRST,"Idle")
|
||||
field(ZRSV,"NO_ALARM")
|
||||
field(ONVL,"1")
|
||||
field(ONST,"Unknown 1")
|
||||
field(ONSV, "INVALID")
|
||||
field(TWVL,"2")
|
||||
field(TWST,"Unknown 2")
|
||||
field(TWSV, "INVALID")
|
||||
field(THVL,"3")
|
||||
field(THST,"Undefined 3")
|
||||
field(THSV, "INVALID")
|
||||
field(FRVL,"4")
|
||||
field(FRST,"Error")
|
||||
field(FRSV, "MAJOR")
|
||||
field(FVVL,"5")
|
||||
field(FVST,"Undefined 5")
|
||||
field(FVSV, "INVALID")
|
||||
field(SXVL,"6")
|
||||
field(SXST,"Undefined 6")
|
||||
field(SXSV, "INVALID")
|
||||
field(SVVL,"7")
|
||||
field(SVST,"Undefined 7")
|
||||
field(SVSV, "INVALID")
|
||||
field(EIVL,"8")
|
||||
field(EIST,"Busy")
|
||||
field(EISV, "MINOR")
|
||||
}
|
||||
|
||||
# Individual status fields for the Acquire, Readout, Correct, Writing, and Dezinger tasks
|
||||
record(mbbi,"$(P)$(R)MarAcquireStatus_RBV") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_ACQUIRE_STATUS")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DESC,"Acquire status")
|
||||
field(ZRVL,"0")
|
||||
field(ZRST,"Idle")
|
||||
field(ZRSV,"NO_ALARM")
|
||||
field(ONVL,"1")
|
||||
field(ONST,"Queued")
|
||||
field(ONSV, "MINOR")
|
||||
field(TWVL,"2")
|
||||
field(TWST,"Executing")
|
||||
field(TWSV, "MINOR")
|
||||
field(THVL,"3")
|
||||
field(THST,"Undefined 3")
|
||||
field(THSV, "INVALID")
|
||||
field(FRVL,"4")
|
||||
field(FRST,"Error")
|
||||
field(FRSV, "MAJOR")
|
||||
field(FVVL,"5")
|
||||
field(FVST,"Undefined 5")
|
||||
field(FVSV, "INVALID")
|
||||
field(SXVL,"6")
|
||||
field(SXST,"Undefined 6")
|
||||
field(SXSV, "INVALID")
|
||||
field(SVVL,"7")
|
||||
field(SVST,"Undefined 7")
|
||||
field(SVSV, "INVALID")
|
||||
field(EIVL,"8")
|
||||
field(EIST,"Reserved")
|
||||
field(EISV, "MINOR")
|
||||
}
|
||||
|
||||
record(mbbi,"$(P)$(R)MarReadoutStatus_RBV") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_READOUT_STATUS")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DESC,"Readout status")
|
||||
field(ZRVL,"0")
|
||||
field(ZRST,"Idle")
|
||||
field(ZRSV,"NO_ALARM")
|
||||
field(ONVL,"1")
|
||||
field(ONST,"Queued")
|
||||
field(ONSV, "MINOR")
|
||||
field(TWVL,"2")
|
||||
field(TWST,"Executing")
|
||||
field(TWSV, "MINOR")
|
||||
field(THVL,"3")
|
||||
field(THST,"Undefined 3")
|
||||
field(THSV, "INVALID")
|
||||
field(FRVL,"4")
|
||||
field(FRST,"Error")
|
||||
field(FRSV, "MAJOR")
|
||||
field(FVVL,"5")
|
||||
field(FVST,"Undefined 5")
|
||||
field(FVSV, "INVALID")
|
||||
field(SXVL,"6")
|
||||
field(SXST,"Undefined 6")
|
||||
field(SXSV, "INVALID")
|
||||
field(SVVL,"7")
|
||||
field(SVST,"Undefined 7")
|
||||
field(SVSV, "INVALID")
|
||||
field(EIVL,"8")
|
||||
field(EIST,"Reserved")
|
||||
field(EISV, "MINOR")
|
||||
}
|
||||
|
||||
record(mbbi,"$(P)$(R)MarCorrectStatus_RBV") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_CORRECT_STATUS")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DESC,"Correct status")
|
||||
field(ZRVL,"0")
|
||||
field(ZRST,"Idle")
|
||||
field(ZRSV,"NO_ALARM")
|
||||
field(ONVL,"1")
|
||||
field(ONST,"Queued")
|
||||
field(ONSV, "MINOR")
|
||||
field(TWVL,"2")
|
||||
field(TWST,"Executing")
|
||||
field(TWSV, "MINOR")
|
||||
field(THVL,"3")
|
||||
field(THST,"Undefined 3")
|
||||
field(THSV, "INVALID")
|
||||
field(FRVL,"4")
|
||||
field(FRST,"Error")
|
||||
field(FRSV, "MAJOR")
|
||||
field(FVVL,"5")
|
||||
field(FVST,"Undefined 5")
|
||||
field(FVSV, "INVALID")
|
||||
field(SXVL,"6")
|
||||
field(SXST,"Undefined 6")
|
||||
field(SXSV, "INVALID")
|
||||
field(SVVL,"7")
|
||||
field(SVST,"Undefined 7")
|
||||
field(SVSV, "INVALID")
|
||||
field(EIVL,"8")
|
||||
field(EIST,"Reserved")
|
||||
field(EISV, "MINOR")
|
||||
}
|
||||
|
||||
record(mbbi,"$(P)$(R)MarWritingStatus_RBV") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_WRITING_STATUS")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DESC,"Writing status")
|
||||
field(ZRVL,"0")
|
||||
field(ZRST,"Idle")
|
||||
field(ZRSV,"NO_ALARM")
|
||||
field(ONVL,"1")
|
||||
field(ONST,"Queued")
|
||||
field(ONSV, "MINOR")
|
||||
field(TWVL,"2")
|
||||
field(TWST,"Executing")
|
||||
field(TWSV, "MINOR")
|
||||
field(THVL,"3")
|
||||
field(THST,"Undefined 3")
|
||||
field(THSV, "INVALID")
|
||||
field(FRVL,"4")
|
||||
field(FRST,"Error")
|
||||
field(FRSV, "MAJOR")
|
||||
field(FVVL,"5")
|
||||
field(FVST,"Undefined 5")
|
||||
field(FVSV, "INVALID")
|
||||
field(SXVL,"6")
|
||||
field(SXST,"Undefined 6")
|
||||
field(SXSV, "INVALID")
|
||||
field(SVVL,"7")
|
||||
field(SVST,"Undefined 7")
|
||||
field(SVSV, "INVALID")
|
||||
field(EIVL,"8")
|
||||
field(EIST,"Reserved")
|
||||
field(EISV, "MINOR")
|
||||
}
|
||||
|
||||
record(mbbi,"$(P)$(R)MarDezingerStatus_RBV") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_DEZINGER_STATUS")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DESC,"Dezinger status")
|
||||
field(ZRVL,"0")
|
||||
field(ZRST,"Idle")
|
||||
field(ZRSV,"NO_ALARM")
|
||||
field(ONVL,"1")
|
||||
field(ONST,"Queued")
|
||||
field(ONSV, "MINOR")
|
||||
field(TWVL,"2")
|
||||
field(TWST,"Executing")
|
||||
field(TWSV, "MINOR")
|
||||
field(THVL,"3")
|
||||
field(THST,"Undefined 3")
|
||||
field(THSV, "INVALID")
|
||||
field(FRVL,"4")
|
||||
field(FRST,"Error")
|
||||
field(FRSV, "MAJOR")
|
||||
field(FVVL,"5")
|
||||
field(FVST,"Undefined 5")
|
||||
field(FVSV, "INVALID")
|
||||
field(SXVL,"6")
|
||||
field(SXST,"Undefined 6")
|
||||
field(SXSV, "INVALID")
|
||||
field(SVVL,"7")
|
||||
field(SVST,"Undefined 7")
|
||||
field(SVSV, "INVALID")
|
||||
field(EIVL,"8")
|
||||
field(EIST,"Reserved")
|
||||
field(EISV, "MINOR")
|
||||
}
|
||||
|
||||
record(mbbi,"$(P)$(R)MarSeriesStatus_RBV") {
|
||||
field(DTYP,"asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_SERIES_STATUS")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DESC,"Series status")
|
||||
field(ZRVL,"0")
|
||||
field(ZRST,"Idle")
|
||||
field(ZRSV,"NO_ALARM")
|
||||
field(ONVL,"1")
|
||||
field(ONST,"Queued")
|
||||
field(ONSV, "MINOR")
|
||||
field(TWVL,"2")
|
||||
field(TWST,"Executing")
|
||||
field(TWSV, "MINOR")
|
||||
field(THVL,"3")
|
||||
field(THST,"Undefined 3")
|
||||
field(THSV, "INVALID")
|
||||
field(FRVL,"4")
|
||||
field(FRST,"Error")
|
||||
field(FRSV, "MAJOR")
|
||||
field(FVVL,"5")
|
||||
field(FVST,"Undefined 5")
|
||||
field(FVSV, "INVALID")
|
||||
field(SXVL,"6")
|
||||
field(SXST,"Undefined 6")
|
||||
field(SXSV, "INVALID")
|
||||
field(SVVL,"7")
|
||||
field(SVST,"Undefined 7")
|
||||
field(SVSV, "INVALID")
|
||||
field(EIVL,"8")
|
||||
field(EIST,"Reserved")
|
||||
field(EISV, "MINOR")
|
||||
}
|
||||
|
||||
# Timeout waiting for TIFF file.
|
||||
record(ao, "$(P)$(R)ReadTiffTimeout")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_TIFF_TIMEOUT")
|
||||
field(DESC, "Timeout for TIFF file")
|
||||
field(VAL, "30")
|
||||
field(EGU, "s")
|
||||
field(PREC, "3")
|
||||
}
|
||||
|
||||
# Overlap operation
|
||||
record(bo, "$(P)$(R)OverlapMode")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_OVERLAP")
|
||||
field(PINI, "YES")
|
||||
field(DESC, "Overlap or sequential")
|
||||
field(ZNAM, "Sequential")
|
||||
field(ONAM, "Overlap")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)OverlapMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_OVERLAP")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DESC, "Overlap or sequential")
|
||||
field(ZNAM, "Sequential")
|
||||
field(ONAM, "Overlap")
|
||||
}
|
||||
|
||||
# Frame shift
|
||||
record(longout, "$(P)$(R)FrameShift")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_FRAME_SHIFT")
|
||||
field(PINI, "YES")
|
||||
field(DESC, "Frame shift lines")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)FrameShift_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_FRAME_SHIFT")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(DESC, "Frame shift lines")
|
||||
}
|
||||
|
||||
# Baseline stability
|
||||
record(ao, "$(P)$(R)Stability")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_STABILITY")
|
||||
field(PINI, "YES")
|
||||
field(PREC, "2")
|
||||
field(DESC, "Baseline stability")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)Stability_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_STABILITY")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "2")
|
||||
field(DESC, "Baseline stability")
|
||||
}
|
||||
|
||||
## asyn record for interactive communication with marServer
|
||||
record(asyn, "$(P)$(R)marServerAsyn")
|
||||
{
|
||||
field(PORT, "$(MARSERVER_PORT)")
|
||||
field(IMAX, "64")
|
||||
field(OMAX, "64")
|
||||
}
|
||||
|
||||
# Records with auxiliary information
|
||||
record(ao, "$(P)$(R)DetectorDistance")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_DETECTOR_DISTANCE")
|
||||
field(PINI, "YES")
|
||||
field(PREC, "3")
|
||||
field(EGU, "mm")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)BeamX")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_BEAM_X")
|
||||
field(PINI, "YES")
|
||||
field(PREC, "3")
|
||||
field(EGU, "mm")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)BeamY")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_BEAM_Y")
|
||||
field(PINI, "YES")
|
||||
field(PREC, "3")
|
||||
field(EGU, "mm")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)StartPhi")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_START_PHI")
|
||||
field(PINI, "YES")
|
||||
field(PREC, "3")
|
||||
field(EGU, "deg")
|
||||
}
|
||||
|
||||
record(stringout, "$(P)$(R)RotationAxis")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_ROTATION_AXIS")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)RotationRange")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_ROTATION_RANGE")
|
||||
field(PINI, "YES")
|
||||
field(PREC, "3")
|
||||
field(EGU, "deg")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)TwoTheta")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_TWO_THETA")
|
||||
field(PINI, "YES")
|
||||
field(PREC, "3")
|
||||
field(EGU, "deg")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)Wavelength")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_WAVELENGTH")
|
||||
field(PINI, "YES")
|
||||
field(PREC, "4")
|
||||
field(EGU, "Angstrom")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)FileComments")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_FILE_COMMENTS")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)DatasetComments")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAR_DATASET_COMMENTS")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "256")
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -1,20 +0,0 @@
|
||||
$(P)$(R)ReadTiffTimeout
|
||||
$(P)$(R)OverlapMode
|
||||
$(P)$(R)AutoSave
|
||||
$(P)$(R)FrameShift
|
||||
$(P)$(R)Stability
|
||||
$(P)$(R)DetectorDistance
|
||||
$(P)$(R)BeamX
|
||||
$(P)$(R)BeamY
|
||||
$(P)$(R)StartPhi
|
||||
$(P)$(R)RotationAxis
|
||||
$(P)$(R)RotationRange
|
||||
$(P)$(R)TwoTheta
|
||||
$(P)$(R)Wavelength
|
||||
$(P)$(R)FileComments
|
||||
$(P)$(R)DatasetComments
|
||||
$(P)$(R)GateMode
|
||||
$(P)$(R)ReadoutMode
|
||||
$(P)$(R)SeriesFileTemplate
|
||||
$(P)$(R)SeriesFileDigits
|
||||
$(P)$(R)SeriesFileFirst
|
||||
@@ -1,624 +0,0 @@
|
||||
# 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")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)HeaderString")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))HEADERSTRING")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "68")
|
||||
}
|
||||
|
||||
@@ -1,30 +0,0 @@
|
||||
$(P)$(R)DelayTime
|
||||
$(P)$(R)ThresholdEnergy
|
||||
$(P)$(R)ThresholdAutoApply
|
||||
$(P)$(R)GainMenu
|
||||
$(P)$(R)ImageFileTmot
|
||||
$(P)$(R)BadPixelFile
|
||||
$(P)$(R)FlatFieldFile
|
||||
$(P)$(R)MinFlatField
|
||||
$(P)$(R)GapFill
|
||||
$(P)$(R)Wavelength
|
||||
$(P)$(R)EnergyLow
|
||||
$(P)$(R)EnergyHigh
|
||||
$(P)$(R)DetDist
|
||||
$(P)$(R)DetVOffset
|
||||
$(P)$(R)BeamX
|
||||
$(P)$(R)BeamY
|
||||
$(P)$(R)Flux
|
||||
$(P)$(R)FilterTransm
|
||||
$(P)$(R)StartAngle
|
||||
$(P)$(R)AngleIncr
|
||||
$(P)$(R)Det2theta
|
||||
$(P)$(R)Polarization
|
||||
$(P)$(R)Alpha
|
||||
$(P)$(R)Kappa
|
||||
$(P)$(R)Phi
|
||||
$(P)$(R)Chi
|
||||
$(P)$(R)OscillAxis
|
||||
$(P)$(R)NumOscill
|
||||
$(P)$(R)CbfTemplateFile
|
||||
$(P)$(R)HeaderString
|
||||
@@ -1,851 +0,0 @@
|
||||
# Database for the records specific to the Prosilica cameras
|
||||
# Mark Rivers
|
||||
# March 27, 2008
|
||||
|
||||
###############################################################################
|
||||
# Note: The following are records defined in ADBase.template. #
|
||||
# We are changing some of the fields here to reflect valid values for #
|
||||
# Prosilica #
|
||||
###############################################################################
|
||||
|
||||
###############################################################################
|
||||
# These records control the trigger mode. #
|
||||
###############################################################################
|
||||
record(mbbo, "$(P)$(R)TriggerMode")
|
||||
{
|
||||
field(ZRST, "Free Run")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Sync In 1")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Sync In 2")
|
||||
field(TWVL, "2")
|
||||
field(THST, "Sync In 3")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Sync In 4")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "Fixed Rate")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "Software")
|
||||
field(SXVL, "6")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)TriggerMode_RBV")
|
||||
{
|
||||
field(ZRST, "Free Run")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Sync In 1")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Sync In 2")
|
||||
field(TWVL, "2")
|
||||
field(THST, "Sync In 3")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Sync In 4")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "Fixed Rate")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "Software")
|
||||
field(SXVL, "6")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Only 2 data types are supported, unsigned 8 and 16 bit integers
|
||||
record(mbbo, "$(P)$(R)DataType")
|
||||
{
|
||||
field(ZRST, "UInt8")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "UInt16")
|
||||
field(ONVL, "3")
|
||||
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, "UInt8")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "UInt16")
|
||||
field(ONVL, "3")
|
||||
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, Bayer and RGB1 color modes are supported at this time
|
||||
record(mbbo, "$(P)$(R)ColorMode")
|
||||
{
|
||||
field(ZRST, "Mono")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Bayer")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "RGB1")
|
||||
field(TWVL, "2")
|
||||
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, "Bayer")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "RGB1")
|
||||
field(TWVL, "2")
|
||||
field(THST, "")
|
||||
field(THVL, "")
|
||||
field(FRST, "")
|
||||
field(FRVL, "")
|
||||
field(FVST, "")
|
||||
field(FVVL, "")
|
||||
field(SXST, "")
|
||||
field(SXVL, "")
|
||||
field(SVST, "")
|
||||
field(SVVL, "")
|
||||
}
|
||||
|
||||
# The following records are specific to the Prosilica
|
||||
|
||||
###############################################################################
|
||||
# These records are for network and frame statistics #
|
||||
###############################################################################
|
||||
record(longout, "$(P)$(R)PSReadStatistics")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_READ_STATISTICS")
|
||||
field(SCAN, "5 second")
|
||||
}
|
||||
|
||||
record(stringin, "$(P)$(R)PSDriverType_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_DRIVER_TYPE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(stringin, "$(P)$(R)PSFilterVersion_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_FILTER_VERSION")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)PSFrameRate_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_FRAME_RATE")
|
||||
field(PREC, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PSByteRate")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_BYTE_RATE")
|
||||
field(VAL, "115000000")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PSByteRate_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_BYTE_RATE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PSPacketSize_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_PACKET_SIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PSFramesCompleted_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_FRAMES_COMPLETED")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PSFramesDropped_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_FRAMES_DROPPED")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PSPacketsErroneous_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_PACKETS_ERRONEOUS")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PSPacketsMissed_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_PACKETS_MISSED")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PSPacketsReceived_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_PACKETS_RECEIVED")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PSPacketsRequested_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_PACKETS_REQUESTED")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PSPacketsResent_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_PACKETS_RESENT")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PSBadFrameCounter_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_BAD_FRAME_COUNTER")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###############################################################################
|
||||
# These records control the trigger delay. #
|
||||
###############################################################################
|
||||
record(ao, "$(P)$(R)TriggerDelay")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_TRIGGER_DELAY")
|
||||
field(PREC, "6")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)TriggerDelay_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_TRIGGER_DELAY")
|
||||
field(PREC, "6")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###############################################################################
|
||||
# These records control the trigger event. #
|
||||
###############################################################################
|
||||
record(mbbo, "$(P)$(R)TriggerEvent")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_TRIGGER_EVENT")
|
||||
field(PINI, "YES")
|
||||
field(ZRST, "Rising edge")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Falling edge")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Any edge")
|
||||
field(TWVL, "2")
|
||||
field(THST, "High level")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Low level")
|
||||
field(FRVL, "4")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)TriggerEvent_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_TRIGGER_EVENT")
|
||||
field(PINI, "YES")
|
||||
field(ZRST, "Rising edge")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Falling edge")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Any edge")
|
||||
field(TWVL, "2")
|
||||
field(THST, "High level")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Low level")
|
||||
field(FRVL, "4")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###############################################################################
|
||||
# These records control the trigger overlap. #
|
||||
###############################################################################
|
||||
record(mbbo, "$(P)$(R)TriggerOverlap")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_TRIGGER_OVERLAP")
|
||||
field(PINI, "YES")
|
||||
field(ZRST, "Off")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Previous frame")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)TriggerOverlap_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_TRIGGER_OVERLAP")
|
||||
field(ZRST, "Off")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Previous frame")
|
||||
field(ONVL, "1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###############################################################################
|
||||
# This record is a software trigger. #
|
||||
###############################################################################
|
||||
record(bo, "$(P)$(R)TriggerSoftware")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_TRIGGER_SOFTWARE")
|
||||
field(ZNAM, "Off")
|
||||
field(ONAM, "On")
|
||||
}
|
||||
|
||||
|
||||
|
||||
###############################################################################
|
||||
# These records are for hardware synchronization and digital I/O #
|
||||
###############################################################################
|
||||
|
||||
record(bi, "$(P)$(R)SyncIn1Level_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_IN_1_LEVEL")
|
||||
field(ZNAM, "Low")
|
||||
field(ONAM, "High")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)SyncIn2Level_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_IN_2_LEVEL")
|
||||
field(ZNAM, "Low")
|
||||
field(ONAM, "High")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)SyncOut1Mode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_1_MODE")
|
||||
field(ZRST, "GPO")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "AcqTrigReady")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "FrameTrigReady")
|
||||
field(TWVL, "2")
|
||||
field(THST, "FrameTrigger")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Exposing")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "FrameReadout")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "Imaging")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "Acquiring")
|
||||
field(SVVL, "7")
|
||||
field(EIST, "SyncIn1")
|
||||
field(EIVL, "8")
|
||||
field(NIST, "SyncIn2")
|
||||
field(NIVL, "9")
|
||||
field(TEST, "SyncIn3")
|
||||
field(TEVL, "10")
|
||||
field(ELST, "SyncIn4")
|
||||
field(ELVL, "11")
|
||||
field(TVST, "Strobe1")
|
||||
field(TVVL, "12")
|
||||
field(TTST, "Strobe2")
|
||||
field(TTVL, "13")
|
||||
field(FTST, "Strobe3")
|
||||
field(FTVL, "14")
|
||||
field(FFST, "Strobe4")
|
||||
field(FFVL, "15")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)SyncOut1Mode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_1_MODE")
|
||||
field(ZRST, "GPO")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "AcqTrigReady")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "FrameTrigReady")
|
||||
field(TWVL, "2")
|
||||
field(THST, "FrameTrigger")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Exposing")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "FrameReadout")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "Imaging")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "Acquiring")
|
||||
field(SVVL, "7")
|
||||
field(EIST, "SyncIn1")
|
||||
field(EIVL, "8")
|
||||
field(NIST, "SyncIn2")
|
||||
field(NIVL, "9")
|
||||
field(TEST, "SyncIn3")
|
||||
field(TEVL, "10")
|
||||
field(ELST, "SyncIn4")
|
||||
field(ELVL, "11")
|
||||
field(TVST, "Strobe1")
|
||||
field(TVVL, "12")
|
||||
field(TTST, "Strobe2")
|
||||
field(TTVL, "13")
|
||||
field(FTST, "Strobe3")
|
||||
field(FTVL, "14")
|
||||
field(FFST, "Strobe4")
|
||||
field(FFVL, "15")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)SyncOut1Level")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_1_LEVEL")
|
||||
field(ZNAM, "False")
|
||||
field(ONAM, "True")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)SyncOut1Level_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_1_LEVEL")
|
||||
field(ZNAM, "False")
|
||||
field(ONAM, "True")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)SyncOut1Invert")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_1_INVERT")
|
||||
field(ZNAM, "Off")
|
||||
field(ONAM, "On")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)SyncOut1Invert_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_1_INVERT")
|
||||
field(ZNAM, "Off")
|
||||
field(ONAM, "On")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)SyncOut2Mode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_2_MODE")
|
||||
field(ZRST, "GPO")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "AcqTrigReady")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "FrameTrigReady")
|
||||
field(TWVL, "2")
|
||||
field(THST, "FrameTrigger")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Exposing")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "FrameReadout")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "Imaging")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "Acquiring")
|
||||
field(SVVL, "7")
|
||||
field(EIST, "SyncIn1")
|
||||
field(EIVL, "8")
|
||||
field(NIST, "SyncIn2")
|
||||
field(NIVL, "9")
|
||||
field(TEST, "SyncIn3")
|
||||
field(TEVL, "10")
|
||||
field(ELST, "SyncIn4")
|
||||
field(ELVL, "11")
|
||||
field(TVST, "Strobe1")
|
||||
field(TVVL, "12")
|
||||
field(TTST, "Strobe2")
|
||||
field(TTVL, "13")
|
||||
field(FTST, "Strobe3")
|
||||
field(FTVL, "14")
|
||||
field(FFST, "Strobe4")
|
||||
field(FFVL, "15")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)SyncOut2Mode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_2_MODE")
|
||||
field(ZRST, "GPO")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "AcqTrigReady")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "FrameTrigReady")
|
||||
field(TWVL, "2")
|
||||
field(THST, "FrameTrigger")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Exposing")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "FrameReadout")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "Imaging")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "Acquiring")
|
||||
field(SVVL, "7")
|
||||
field(EIST, "SyncIn1")
|
||||
field(EIVL, "8")
|
||||
field(NIST, "SyncIn2")
|
||||
field(NIVL, "9")
|
||||
field(TEST, "SyncIn3")
|
||||
field(TEVL, "10")
|
||||
field(ELST, "SyncIn4")
|
||||
field(ELVL, "11")
|
||||
field(TVST, "Strobe1")
|
||||
field(TVVL, "12")
|
||||
field(TTST, "Strobe2")
|
||||
field(TTVL, "13")
|
||||
field(FTST, "Strobe3")
|
||||
field(FTVL, "14")
|
||||
field(FFST, "Strobe4")
|
||||
field(FFVL, "15")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)SyncOut2Level")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_2_LEVEL")
|
||||
field(ZNAM, "False")
|
||||
field(ONAM, "True")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)SyncOut2Level_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_2_LEVEL")
|
||||
field(ZNAM, "False")
|
||||
field(ONAM, "True")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)SyncOut2Invert")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_2_INVERT")
|
||||
field(ZNAM, "Off")
|
||||
field(ONAM, "On")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)SyncOut2Invert_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_2_INVERT")
|
||||
field(ZNAM, "Off")
|
||||
field(ONAM, "On")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)SyncOut3Mode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_3_MODE")
|
||||
field(ZRST, "GPO")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "AcqTrigReady")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "FrameTrigReady")
|
||||
field(TWVL, "2")
|
||||
field(THST, "FrameTrigger")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Exposing")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "FrameReadout")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "Imaging")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "Acquiring")
|
||||
field(SVVL, "7")
|
||||
field(EIST, "SyncIn1")
|
||||
field(EIVL, "8")
|
||||
field(NIST, "SyncIn2")
|
||||
field(NIVL, "9")
|
||||
field(TEST, "SyncIn3")
|
||||
field(TEVL, "10")
|
||||
field(ELST, "SyncIn4")
|
||||
field(ELVL, "11")
|
||||
field(TVST, "Strobe1")
|
||||
field(TVVL, "12")
|
||||
field(TTST, "Strobe2")
|
||||
field(TTVL, "13")
|
||||
field(FTST, "Strobe3")
|
||||
field(FTVL, "14")
|
||||
field(FFST, "Strobe4")
|
||||
field(FFVL, "15")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)SyncOut3Mode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_3_MODE")
|
||||
field(ZRST, "GPO")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "AcqTrigReady")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "FrameTrigReady")
|
||||
field(TWVL, "2")
|
||||
field(THST, "FrameTrigger")
|
||||
field(THVL, "3")
|
||||
field(FRST, "Exposing")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "FrameReadout")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "Imaging")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "Acquiring")
|
||||
field(SVVL, "7")
|
||||
field(EIST, "SyncIn1")
|
||||
field(EIVL, "8")
|
||||
field(NIST, "SyncIn2")
|
||||
field(NIVL, "9")
|
||||
field(TEST, "SyncIn3")
|
||||
field(TEVL, "10")
|
||||
field(ELST, "SyncIn4")
|
||||
field(ELVL, "11")
|
||||
field(TVST, "Strobe1")
|
||||
field(TVVL, "12")
|
||||
field(TTST, "Strobe2")
|
||||
field(TTVL, "13")
|
||||
field(FTST, "Strobe3")
|
||||
field(FTVL, "14")
|
||||
field(FFST, "Strobe4")
|
||||
field(FFVL, "15")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)SyncOut3Level")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_3_LEVEL")
|
||||
field(ZNAM, "False")
|
||||
field(ONAM, "True")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)SyncOut3Level_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_3_LEVEL")
|
||||
field(ZNAM, "False")
|
||||
field(ONAM, "True")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)SyncOut3Invert")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_3_INVERT")
|
||||
field(ZNAM, "Off")
|
||||
field(ONAM, "On")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)SyncOut3Invert_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_SYNC_OUT_3_INVERT")
|
||||
field(ZNAM, "Off")
|
||||
field(ONAM, "On")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)Strobe1Mode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_STROBE_1_MODE")
|
||||
field(ZRST, "AcqTrigReady")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "FrameTrigReady")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "FrameTrigger")
|
||||
field(TWVL, "2")
|
||||
field(THST, "Exposing")
|
||||
field(THVL, "3")
|
||||
field(FRST, "FrameReadout")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "Acquiring")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "SyncIn1")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "SyncIn2")
|
||||
field(SVVL, "7")
|
||||
field(EIST, "SyncIn3")
|
||||
field(EIVL, "8")
|
||||
field(NIST, "SyncIn4")
|
||||
field(NIVL, "9")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)Strobe1Mode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_STROBE_1_MODE")
|
||||
field(ZRST, "AcqTrigReady")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "FrameTrigReady")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "FrameTrigger")
|
||||
field(TWVL, "2")
|
||||
field(THST, "Exposing")
|
||||
field(THVL, "3")
|
||||
field(FRST, "FrameReadout")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "Acquiring")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "SyncIn1")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "SyncIn2")
|
||||
field(SVVL, "7")
|
||||
field(EIST, "SyncIn3")
|
||||
field(EIVL, "8")
|
||||
field(NIST, "SyncIn4")
|
||||
field(NIVL, "9")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(bo, "$(P)$(R)Strobe1CtlDuration")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_STROBE_1_CTL_DURATION")
|
||||
field(ZNAM, "Off")
|
||||
field(ONAM, "On")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)Strobe1CtlDuration_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_STROBE_1_CTL_DURATION")
|
||||
field(ZNAM, "Off")
|
||||
field(ONAM, "On")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)Strobe1Delay")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_STROBE_1_DELAY")
|
||||
field(PREC, "6")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)Strobe1Delay_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_STROBE_1_DELAY")
|
||||
field(PREC, "6")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)Strobe1Duration")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_STROBE_1_DURATION")
|
||||
field(PREC, "6")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)Strobe1Duration_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_STROBE_1_DURATION")
|
||||
field(PREC, "6")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
###############################################################################
|
||||
# This record controls the contents of the NDArray timestamp parameter #
|
||||
###############################################################################
|
||||
record(mbbo, "$(P)$(R)PSTimestampType")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_TIMESTAMP_TYPE")
|
||||
field(ZRST, "NativeTicks")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "NativeSeconds")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "POSIX")
|
||||
field(TWVL, "2")
|
||||
field(THST, "EPICS")
|
||||
field(THVL, "3")
|
||||
field(VAL, "0")
|
||||
field(PINI, "YES")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)PSTimestampType_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_TIMESTAMP_TYPE")
|
||||
field(ZRST, "NativeTicks")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "NativeSeconds")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "POSIX")
|
||||
field(TWVL, "2")
|
||||
field(THST, "EPICS")
|
||||
field(THVL, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
###############################################################################
|
||||
# Processing this record will reset the internal camera timer #
|
||||
###############################################################################
|
||||
record(longout, "$(P)$(R)PSResetTimer")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PS_RESET_TIMER")
|
||||
}
|
||||
|
||||
@@ -1,18 +0,0 @@
|
||||
$(P)$(R)PSReadStatistics.SCAN
|
||||
$(P)$(R)PSByteRate
|
||||
$(P)$(R)SyncOut1Mode
|
||||
$(P)$(R)SyncOut1Level
|
||||
$(P)$(R)SyncOut1Invert
|
||||
$(P)$(R)SyncOut2Mode
|
||||
$(P)$(R)SyncOut2Level
|
||||
$(P)$(R)SyncOut2Invert
|
||||
$(P)$(R)SyncOut3Mode
|
||||
$(P)$(R)SyncOut3Level
|
||||
$(P)$(R)SyncOut3Invert
|
||||
$(P)$(R)Strobe1Mode
|
||||
$(P)$(R)Strobe1CtlDuration
|
||||
$(P)$(R)Strobe1Delay
|
||||
$(P)$(R)Strobe1Duration
|
||||
$(P)$(R)TriggerEvent
|
||||
$(P)$(R)TriggerOverlap
|
||||
$(P)$(R)TriggerDelay
|
||||
@@ -1,538 +0,0 @@
|
||||
# Database for the records specific to the PVCam (PI/Acton) driver
|
||||
# Brian Tieman
|
||||
# 06/14/2009
|
||||
|
||||
record(longout, "$(P)$(R)Initialize")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_INITIALIZE_DETECTOR")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)Initialize_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_INITIALIZE_DETECTOR")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
record(stringin, "$(P)$(R)Slot1Cam_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_SLOT1")
|
||||
field(VAL, "Unknown")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
record(stringin, "$(P)$(R)Slot2Cam_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_SLOT2")
|
||||
field(VAL, "Unknown")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(stringin, "$(P)$(R)Slot3Cam_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_SLOT3")
|
||||
field(VAL, "Unknown")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)DetectorSelected")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_DETECTORSELECTED")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "500")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)DetectorSelected_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_DETECTORSELECTED")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "3")
|
||||
}
|
||||
|
||||
|
||||
record(stringin, "$(P)$(R)ChipName_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_CHIPNAME")
|
||||
field(VAL, "Unknown")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
record(longin, "$(P)$(R)NumParallelPixels_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_NUMPARALLELPIXELS")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "50000")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NumSerialPixels_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_NUMSERIALPIXELS")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "50000")
|
||||
}
|
||||
|
||||
|
||||
record(longin, "$(P)$(R)PixelParallelSize_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_PIXELPARALLELSIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "50000")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PixelSerialSize_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_PIXELSERIALSIZE")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "50000")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)ChipWidth_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_CHIPWIDTH")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "3")
|
||||
field(LOPR, "0.0")
|
||||
field(HOPR, "500.0")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)ChipHeight_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_CHIPHEIGHT")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "3")
|
||||
field(LOPR, "0.0")
|
||||
field(HOPR, "500.0")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PixelParallelDist_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_PIXELPARALLELDIST")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "50000")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PixelSerialDist_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_PIXELSERIALDIST")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "50000")
|
||||
}
|
||||
|
||||
|
||||
record(longin, "$(P)$(R)PostMask_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_POSTMASK")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "50000")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PreMask_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_PREMASK")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "50000")
|
||||
}
|
||||
|
||||
|
||||
record(longin, "$(P)$(R)PostScan_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_POSTSCAN")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "50000")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PreScan_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_PRESCAN")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "50000")
|
||||
}
|
||||
|
||||
|
||||
record(longin, "$(P)$(R)NumPorts_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_NUMPORTS")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "50000")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)FullWellCapacity_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_FULLWELLCAPACITY")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "50000")
|
||||
}
|
||||
|
||||
|
||||
record(longin, "$(P)$(R)FrameTransferCapable_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_FRAMETRANSFERCAPABLE")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "50000")
|
||||
}
|
||||
|
||||
|
||||
record(longin, "$(P)$(R)NumSpeedTableEntries_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_NUMSPEEDTABLEENTRIES")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "50000")
|
||||
}
|
||||
|
||||
|
||||
record(longout, "$(P)$(R)SpeedTableIndex")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_SPEEDTABLEINDEX")
|
||||
}
|
||||
|
||||
|
||||
record(longin, "$(P)$(R)SpeedTableIndex_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_SPEEDTABLEINDEX_RBV")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
record(longin, "$(P)$(R)BitDepth_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_BITDEPTH")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "50000")
|
||||
}
|
||||
|
||||
|
||||
record(longin, "$(P)$(R)PixelTime_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_PIXELTIME")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(LOPR, "0")
|
||||
field(HOPR, "50000")
|
||||
}
|
||||
|
||||
|
||||
record(longin, "$(P)$(R)MaxGainIndex_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_MAXGAININDEX")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)GainIndex")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_GAININDEX")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)GainIndex_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_GAININDEX_RBV")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MinShutterOpenDelay_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_MINSHUTTEROPENDELAY")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MaxShutterOpenDelay_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_MAXSHUTTEROPENDELAY")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MinShutterCloseDelay_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_MINSHUTTERCLOSEDELAY")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)MaxShutterCloseDelay_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_MAXSHUTTERCLOSEDELAY")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
record(longout, "$(P)$(R)OpenDelay")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_SHUTTEROPENDELAY")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)OpenDelay_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_SHUTTEROPENDELAY_RBV")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
record(longout, "$(P)$(R)CloseDelay")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_SHUTTERCLOSEDELAY")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)CloseDelay_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_SHUTTERCLOSEDELAY_RBV")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)MeasuredTemperature_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_MEASUREDTEMPERATURE")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "1")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)SetTemperature")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_SETTEMPERATURE")
|
||||
field(PREC, "1")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)SetTemperature_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_SETTEMPERATURE_RBV")
|
||||
field(SCAN, "I/O Intr")
|
||||
field(PREC, "1")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)MinSetTemperature")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_MINTEMPERATURE")
|
||||
field(PREC, "1")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)MaxSetTemperature")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_MAXTEMPERATURE")
|
||||
field(PREC, "1")
|
||||
}
|
||||
|
||||
|
||||
record(mbbo, "$(P)$(R)DetectorMode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_DETECTORMODE")
|
||||
field(ZRST, "NORMAL")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "FT")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "MPP")
|
||||
field(TWVL, "2")
|
||||
field(THST, "FT_MPP")
|
||||
field(THVL, "3")
|
||||
field(FRST, "ALT_NORMAL")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "ALT_FT")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "ALT_MPP")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "ALT_FT_MPP")
|
||||
field(SVVL, "7")
|
||||
field(SVST, "INTERLINE")
|
||||
field(SVVL, "8")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)DetectorMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_DETECTORMODE_RBV")
|
||||
field(ZRST, "NORMAL")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "FT")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "MPP")
|
||||
field(TWVL, "2")
|
||||
field(THST, "FT_MPP")
|
||||
field(THVL, "3")
|
||||
field(FRST, "ALT_NORMAL")
|
||||
field(FRVL, "4")
|
||||
field(FVST, "ALT_FT")
|
||||
field(FVVL, "5")
|
||||
field(SXST, "ALT_MPP")
|
||||
field(SXVL, "6")
|
||||
field(SVST, "ALT_FT_MPP")
|
||||
field(SVVL, "7")
|
||||
field(SVST, "INTERLINE")
|
||||
field(SVVL, "8")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
record(mbbo, "$(P)$(R)TriggerMode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_TRIGGERMODE")
|
||||
field(ZRST, "Free Run")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Ext Trigger")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Bulb Mode")
|
||||
field(TWVL, "2")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)TriggerMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_TRIGGERMODE_RBV")
|
||||
field(ZRST, "Free Run")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Ext Trigger")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Bulb Mode")
|
||||
field(TWVL, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
record(mbbo, "$(P)$(R)TriggerEdge")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_TRIGGEREDGE")
|
||||
field(ZRST, "None")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Positive")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Negative")
|
||||
field(TWVL, "2")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)TriggerEdge_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_TRIGGEREDGE_RBV")
|
||||
field(ZRST, "None")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Positive")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Negative")
|
||||
field(TWVL, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
record(stringin, "$(P)$(R)PVCamVers_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_PVCAMVERS_RBV")
|
||||
field(VAL, "Unknown")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
|
||||
record(stringin, "$(P)$(R)DevDrvVers_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_DEVDRVVERS_RBV")
|
||||
field(VAL, "Unknown")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
|
||||
record(stringin, "$(P)$(R)CameraFirmwareVers_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_CAMFIRMWAREVERS_RBV")
|
||||
field(VAL, "Unknown")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
|
||||
record(stringin, "$(P)$(R)HeadSerNum_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_HEADSERNUM_RBV")
|
||||
field(VAL, "Unknown")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PCIFWVers_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_PCIFWVERS_RBV")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)SerialNum_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PVCAM_SERIALNUM_RBV")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -1,3 +0,0 @@
|
||||
$(P)$(R)GainX
|
||||
$(P)$(R)GainY
|
||||
$(P)$(R)Fidget
|
||||
@@ -1,246 +0,0 @@
|
||||
# Database for the records specific to the Roper driver
|
||||
# Mark Rivers
|
||||
# December 2, 2008
|
||||
|
||||
# These are the records from ADBase.template that we modify some fields for
|
||||
|
||||
# We replace the choice fields for ImageMode from ADBase.template
|
||||
record(mbbo, "$(P)$(R)ImageMode")
|
||||
{
|
||||
field(ZRST, "Normal")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Continuous")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Focus")
|
||||
field(TWVL, "2")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ImageMode_RBV")
|
||||
{
|
||||
field(ZRST, "Normal")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Continuous")
|
||||
field(ONVL, "1")
|
||||
field(TWST, "Focus")
|
||||
field(TWVL, "2")
|
||||
}
|
||||
|
||||
# We replace the file format choices from ADBase.template.
|
||||
# The values here must be 1,2,3 because they are passed to WinView
|
||||
record(mbbo, "$(P)$(R)FileFormat")
|
||||
{
|
||||
field(ZRST, "SPE")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "TIFF")
|
||||
field(ONVL, "2")
|
||||
field(TWST, "8-bit TIFF")
|
||||
field(TWVL, "3")
|
||||
field(VAL, "0")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)FileFormat_RBV")
|
||||
{
|
||||
field(ZRST, "SPE")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "TIFF")
|
||||
field(ONVL, "2")
|
||||
field(TWST, "8-bit TIFF")
|
||||
field(TWVL, "3")
|
||||
}
|
||||
|
||||
# We replace the trigger mode choices from ADBase.template
|
||||
# Note 1=Free run and 3=External Sync is documented. 27 and 28 may be camera-specific
|
||||
record(mbbo, "$(P)$(R)TriggerMode")
|
||||
{
|
||||
field(ZRST, "Free run")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "Ext. sync")
|
||||
field(ONVL, "3")
|
||||
field(TWST, "Bulb trig.")
|
||||
field(TWVL, "28")
|
||||
field(THST, "Single trig.")
|
||||
field(THVL, "27")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)TriggerMode_RBV")
|
||||
{
|
||||
field(ZRST, "Free run")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "Ext. sync")
|
||||
field(ONVL, "3")
|
||||
field(TWST, "Bulb trig.")
|
||||
field(TWVL, "28")
|
||||
field(THST, "Single trig.")
|
||||
field(THVL, "27")
|
||||
}
|
||||
|
||||
# We change the precision on the Gain record to 0, because it is an integer on the Roper
|
||||
record(ao, "$(P)$(R)Gain")
|
||||
{
|
||||
field(PREC, "0")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)Gain_RBV")
|
||||
{
|
||||
field(PREC, "0")
|
||||
}
|
||||
|
||||
|
||||
# These are new records for the Roper detector
|
||||
|
||||
record(bo, "$(P)$(R)AutoDataType")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))AUTO_DATA_TYPE")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
}
|
||||
|
||||
record(bi, "$(P)$(R)AutoDataType_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))AUTO_DATA_TYPE")
|
||||
field(ZNAM, "No")
|
||||
field(ONAM, "Yes")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)NumAcquisitions")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ROPER_NACQUISITIONS")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NumAcquisitions_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ROPER_NACQUISITIONS")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)NumAcquisitionsCounter_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ROPER_NACQUISITIONS_COUNTER")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)RoperShutterMode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ROPER_SHUTTER_MODE")
|
||||
field(ZRST, "Normal")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "Diabled closed")
|
||||
field(ONVL, "2")
|
||||
field(TWST, "Disabled opened")
|
||||
field(TWVL, "3")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)RoperShutterMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ROPER_SHUTTER_MODE")
|
||||
field(ZRST, "Normal")
|
||||
field(ZRVL, "1")
|
||||
field(ONST, "Diabled open")
|
||||
field(ONVL, "2")
|
||||
field(TWST, "Disabled closed")
|
||||
field(TWVL, "3")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)Comment1")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMMENT1")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "80")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)Comment1_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMMENT1")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "80")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)Comment2")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMMENT2")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "80")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)Comment2_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMMENT2")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "80")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)Comment3")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMMENT3")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "80")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)Comment3_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMMENT3")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "80")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)Comment4")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMMENT4")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "80")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)Comment4_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMMENT4")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "80")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)Comment5")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynOctetWrite")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMMENT5")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "80")
|
||||
}
|
||||
|
||||
record(waveform, "$(P)$(R)Comment5_RBV")
|
||||
{
|
||||
field(DTYP, "asynOctetRead")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))COMMENT5")
|
||||
field(FTVL, "CHAR")
|
||||
field(NELM, "80")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
|
||||
@@ -1,9 +0,0 @@
|
||||
$(P)$(R)NumAcquisitions
|
||||
$(P)$(R)RoperShutterMode
|
||||
$(P)$(R)AutoDataType
|
||||
$(P)$(R)Temperature
|
||||
$(P)$(R)Comment1
|
||||
$(P)$(R)Comment2
|
||||
$(P)$(R)Comment3
|
||||
$(P)$(R)Comment4
|
||||
$(P)$(R)Comment5
|
||||
@@ -1,299 +0,0 @@
|
||||
# Database for the records specific to the simulated detector driver
|
||||
# Mark Rivers
|
||||
# March 23, 2008
|
||||
|
||||
# Redefine the color mode choices from ADBase.template to only have those that the simDetector
|
||||
# driver supports. Keep the same values (xxVL), but change the menu numbers.
|
||||
|
||||
record(mbbo, "$(P)$(R)ColorMode")
|
||||
{
|
||||
field(ZRST, "Mono")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "RGB1")
|
||||
field(ONVL, "2")
|
||||
field(TWST, "RGB2")
|
||||
field(TWVL, "3")
|
||||
field(THST, "RGB3")
|
||||
field(THVL, "4")
|
||||
field(FRST, "")
|
||||
field(FVST, "")
|
||||
field(SXST, "")
|
||||
field(SVST, "")
|
||||
field(EIST, "")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)ColorMode_RBV")
|
||||
{
|
||||
field(ZRST, "Mono")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "RGB1")
|
||||
field(ONVL, "2")
|
||||
field(TWST, "RGB2")
|
||||
field(TWVL, "3")
|
||||
field(THST, "RGB3")
|
||||
field(THVL, "4")
|
||||
field(FRST, "")
|
||||
field(FVST, "")
|
||||
field(SXST, "")
|
||||
field(SVST, "")
|
||||
field(EIST, "")
|
||||
}
|
||||
|
||||
|
||||
# New records for simulation detector
|
||||
record(ao, "$(P)$(R)GainX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_GAIN_X")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)GainX_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_GAIN_X")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)GainY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_GAIN_Y")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)GainY_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_GAIN_Y")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)GainRed")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_GAIN_RED")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)GainRed_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_GAIN_RED")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)GainGreen")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_GAIN_GREEN")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)GainGreen_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_GAIN_GREEN")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(ao, "$(P)$(R)GainBlue")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynFloat64")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_GAIN_BLUE")
|
||||
field(PREC, "2")
|
||||
}
|
||||
|
||||
record(ai, "$(P)$(R)GainBlue_RBV")
|
||||
{
|
||||
field(DTYP, "asynFloat64")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_GAIN_BLUE")
|
||||
field(PREC, "2")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)Reset")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))RESET_IMAGE")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)Reset_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))RESET_IMAGE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)Noise")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_NOISE")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)Noise_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_NOISE")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(mbbo, "$(P)$(R)SimMode")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_MODE")
|
||||
field(ZRST, "LinearRamp")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Peaks")
|
||||
field(ONVL, "1")
|
||||
}
|
||||
|
||||
record(mbbi, "$(P)$(R)SimMode_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_MODE")
|
||||
field(ZRST, "LinearRamp")
|
||||
field(ZRVL, "0")
|
||||
field(ONST, "Peaks")
|
||||
field(ONVL, "1")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
# Records for peak simulation mode
|
||||
record(longout, "$(P)$(R)PeakStartX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_START_X")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PeakStartX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_START_X")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PeakStartY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_START_Y")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PeakStartY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_START_Y")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PeakNumX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_NUM_X")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PeakNumX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_NUM_X")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PeakNumY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_NUM_Y")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PeakNumY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_NUM_Y")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PeakStepX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_STEP_X")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PeakStepX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_STEP_X")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PeakStepY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_STEP_Y")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PeakStepY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_STEP_Y")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PeakWidthX")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_WIDTH_X")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PeakWidthX_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_WIDTH_X")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PeakWidthY")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_WIDTH_Y")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PeakWidthY_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_WIDTH_Y")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
record(longout, "$(P)$(R)PeakVariation")
|
||||
{
|
||||
field(PINI, "YES")
|
||||
field(DTYP, "asynInt32")
|
||||
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_HEIGHT_VARIATION")
|
||||
}
|
||||
|
||||
record(longin, "$(P)$(R)PeakVariation_RBV")
|
||||
{
|
||||
field(DTYP, "asynInt32")
|
||||
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIM_PEAK_HEIGHT_VARIATION")
|
||||
field(SCAN, "I/O Intr")
|
||||
}
|
||||
|
||||
@@ -1,17 +0,0 @@
|
||||
$(P)$(R)GainX
|
||||
$(P)$(R)GainY
|
||||
$(P)$(R)GainRed
|
||||
$(P)$(R)GainGreen
|
||||
$(P)$(R)GainBlue
|
||||
$(P)$(R)SimMode
|
||||
$(P)$(R)PeakStartX
|
||||
$(P)$(R)PeakStartY
|
||||
$(P)$(R)PeakNumX
|
||||
$(P)$(R)PeakNumY
|
||||
$(P)$(R)PeakStepX
|
||||
$(P)$(R)PeakStepY
|
||||
$(P)$(R)PeakWidthX
|
||||
$(P)$(R)PeakWidthY
|
||||
$(P)$(R)PeakVariation
|
||||
$(P)$(R)Noise
|
||||
|
||||
Reference in New Issue
Block a user