# 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                        #
#  about the detector                                             # 
###################################################################

record(stringin, "$(P)$(D)PortName_RBV")
{
   field(VAL,  "$(PORT)")
}

###################################################################
#  These records control basic information                        #
#  about the detector                                             # 
###################################################################

record(stringin, "$(P)$(D)Manufacturer_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynOctetRead")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))MANUFACTURER")
}

record(stringin, "$(P)$(D)Model_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynOctetRead")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))MODEL")
}

record(longin, "$(P)$(D)MaxSizeX_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))MAX_SIZE_X")
   field(SCAN, "I/O Intr")
}

record(longin, "$(P)$(D)MaxSizeY_RBV")
{
   field(PINI, "1")
   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)$(D)DataType")
{
   field(PINI, "1")
   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)$(D)DataType_RBV")
{
   field(PINI, "1")
   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 detector readout                     #
#  including binning, region start and size                       # 
###################################################################

record(longout, "$(P)$(D)BinX")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))BIN_X")
}

record(longin, "$(P)$(D)BinX_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))BIN_X")
   field(SCAN, "I/O Intr")
}

record(longout, "$(P)$(D)BinY")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))BIN_Y")
}

record(longin, "$(P)$(D)BinY_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))BIN_Y")
   field(SCAN, "I/O Intr")
}

record(longout, "$(P)$(D)MinX")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))MIN_X")
}

record(longin, "$(P)$(D)MinX_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))MIN_X")
   field(SCAN, "I/O Intr")
}

record(longout, "$(P)$(D)MinY")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))MIN_Y")
}

record(longin, "$(P)$(D)MinY_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))MIN_Y")
   field(SCAN, "I/O Intr")
}

record(longout, "$(P)$(D)SizeX")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIZE_X")
}

record(longin, "$(P)$(D)SizeX_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIZE_X")
   field(SCAN, "I/O Intr")
}

record(longout, "$(P)$(D)SizeY")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIZE_Y")
}

record(longin, "$(P)$(D)SizeY_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))SIZE_Y")
   field(SCAN, "I/O Intr")
}

record(longin, "$(P)$(D)ImageSizeX_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))IMAGE_SIZE_X")
   field(SCAN, "I/O Intr")
}

record(longin, "$(P)$(D)ImageSizeY_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))IMAGE_SIZE_Y")
   field(SCAN, "I/O Intr")
}

record(longin, "$(P)$(D)ImageSize_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))IMAGE_SIZE")
   field(SCAN, "I/O Intr")
}

###################################################################
#  These records control the acquisition time and                 #
#  period                                                         # 
###################################################################
record(ao, "$(P)$(D)AcquireTime")
{
   field(PINI, "1")
   field(DTYP, "asynFloat64")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))ACQ_TIME")
   field(PREC, "3")
}

record(ai, "$(P)$(D)AcquireTime_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))ACQ_TIME")
   field(PREC, "3")
   field(SCAN, "I/O Intr")
}

record(ao, "$(P)$(D)AcquirePeriod")
{
   field(PINI, "1")
   field(DTYP, "asynFloat64")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))ACQ_PERIOD")
   field(PREC, "3")
}

record(ai, "$(P)$(D)AcquirePeriod_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))ACQ_PERIOD")
   field(PREC, "3")
   field(SCAN, "I/O Intr")
}



###################################################################
#  These records control the gain                                 # 
###################################################################
record(ao, "$(P)$(D)Gain")
{
   field(PINI, "1")
   field(DTYP, "asynFloat64")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))GAIN")
   field(PREC, "3")
}

record(ai, "$(P)$(D)Gain_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))GAIN")
   field(PREC, "3")
   field(SCAN, "I/O Intr")
}

###################################################################
#  These records control the acquisition mode                     # 
###################################################################
record(mbbo, "$(P)$(D)ImageMode")
{
   field(PINI, "1")
   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")
}

record(mbbi, "$(P)$(D)ImageMode_RBV")
{
   field(PINI, "1")
   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)$(D)TriggerMode")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))TRIGGER_MODE")
   field(ZRST, "Internal")
   field(ZRVL, "0")
   field(ONST, "External")
   field(ONVL, "1")
}

record(mbbi, "$(P)$(D)TriggerMode_RBV")
{
   field(PINI, "1")
   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)$(D)NumExposures")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))NEXPOSURES")
}

record(longin, "$(P)$(D)NumExposures_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))NEXPOSURES")
   field(SCAN, "I/O Intr")
}

record(longout, "$(P)$(D)NumImages")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))NIMAGES")
}

record(longin, "$(P)$(D)NumImages_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))NIMAGES")
   field(SCAN, "I/O Intr")
}

###################################################################
#  These records control  acquisition start and                   # 
#  and stop                                                       #
###################################################################

record(bo, "$(P)$(D)Acquire")
{
   field(ZNAM, "Done")
   field(ONAM, "Acquire")
   field(OUT,  "$(P)$(D)AcquireFanout PP MS")
}

record(dfanout, "$(P)$(D)AcquireFanout")
{
   field(OUTA, "$(P)$(D)StartAcquireCalc.PROC PP MS")
   field(OUTB, "$(P)$(D)DoAcquire PP MS")
}

record(calcout, "$(P)$(D)StartAcquireCalc")
{
    field(INPA, "$(P)$(D)Acquire")
    field(CALC, "A")
    field(OUT,  "$(P)$(D)AcquireBusy PP MS")
    field(OOPT, "Transition To Non-zero")
}

record(busy, "$(P)$(D)AcquireBusy")
{
}

record(longout, "$(P)$(D)DoAcquire")
{
   field(DTYP, "asynInt32")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))ACQUIRE")
}

record(longin, "$(P)$(D)Acquire_RBV")
{
    field(PINI, "1")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))ACQUIRE")
    field(SCAN, "I/O Intr")
    field(FLNK, "$(P)$(D)AcquireDoneCalc")
}

record(calcout, "$(P)$(D)AcquireDoneCalc")
{
    field(INPA, "$(P)$(D)Acquire_RBV")
    field(CALC, "A")
    field(OUT,  "$(P)$(D)AcquireDoneFanout PP MS")
    field(OOPT, "Transition To Zero")
}

record(dfanout, "$(P)$(D)AcquireDoneFanout")
{
   field(VAL, "0")
   field(OUTA, "$(P)$(D)Acquire CA MS")
   field(OUTB, "$(P)$(D)AcquireBusy CA MS")
}

###################################################################
#  These records provide statistics on image callbacks and        #
#  image callback rates                                           # 
###################################################################
record(longout, "$(P)$(D)ImageCounter")
{
    field(DTYP, "asynInt32")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))IMAGE_COUNTER")
}

record(longin, "$(P)$(D)ImageCounter_RBV")
{
    field(PINI, "1")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))IMAGE_COUNTER")
    field(SCAN, "I/O Intr")
}

# This record needs work, because .B should reflect the time since last processed
record(calc, "$(P)$(D)ImageRate_RBV")
{
    field(INPA, "$(P)$(D)ImageRate_RBV.B NPP NMS")  # Previous counter value
    field(INPB, "$(P)$(D)ImageCounter_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)$(D)DetectorState_RBV")
{
    field(PINI, "1")
    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, "MINOR")
    field(TWST, "Readout")
    field(TWVL, "2")
    field(TWSV, "MINOR")
    field(THST, "Correct")
    field(THVL, "3")
    field(THSV, "MINOR")
    field(FRST, "Saving")
    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(SCAN, "I/O Intr")
}


###################################################################
#  These records control file I/O                                 # 
###################################################################

# File path.
record(waveform, "$(P)$(D)FilePath")
{
    field(PINI, "1")
    field(DTYP, "asynOctetWrite")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_PATH")
    field(FTVL, "UCHAR")
    field(NELM, "256")
}

record(waveform, "$(P)$(D)FilePath_RBV")
{
    field(PINI, "1")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_PATH")
    field(FTVL, "UCHAR")
    field(NELM, "256")
    field(SCAN, "I/O Intr")
}

# Filename
record(waveform, "$(P)$(D)FileName")
{
    field(PINI, "1")
    field(DTYP, "asynOctetWrite")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_NAME")
    field(FTVL, "UCHAR")
    field(NELM, "256")
}

record(waveform, "$(P)$(D)FileName_RBV")
{
    field(PINI, "1")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_NAME")
    field(FTVL, "UCHAR")
    field(NELM, "256")
    field(SCAN, "I/O Intr")
}

# File number
record(longout, "$(P)$(D)FileNumber")
{
    field(PINI, "1")
    field(VAL,  "1")
    field(DTYP, "asynInt32")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_NUMBER")
}

record(longin, "$(P)$(D)FileNumber_RBV")
{
    field(PINI, "1")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_NUMBER")
    field(SCAN, "I/O Intr")
}

record(calcout, "$(P)$(D)FileNumber_Sync")
{
    field(INPA, "$(P)$(D)FileNumber_RBV CP")
    field(CALC, "A")
    field(OUT,  "$(P)$(D)FileNumber PP")
}

# Autoincrement flag
record(mbbo, "$(P)$(D)AutoIncrement")
{
    field(PINI,  "1")
    field(DTYP, "asynInt32")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))AUTO_INCREMENT")
    field(ZRST, "No")
    field(ZRVL, "0")
    field(ONST, "Yes")
    field(ONVL, "1")
}

record(mbbo, "$(P)$(D)AutoIncrement_RBV")
{
    field(DTYP, "asynInt32")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))AUTO_INCREMENT")
    field(ZRST, "No")
    field(ZRVL, "0")
    field(ONST, "Yes")
    field(ONVL, "1")
    field(SCAN, "I/O Intr")
}

# File template
record(waveform, "$(P)$(D)FileTemplate")
{
    field(PINI,  "1")
    field(DTYP, "asynOctetWrite")
    field(INP,   "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_TEMPLATE")
    field(FTVL, "UCHAR")
    field(NELM, "256")
}

record(waveform, "$(P)$(D)FileTemplate_RBV")
{
    field(PINI,  "1")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_TEMPLATE")
    field(FTVL, "UCHAR")
    field(NELM, "256")
    field(SCAN, "I/O Intr")
}

# Full filename, including path
record(waveform, "$(P)$(D)FullFileName_RBV")
{
    field(PINI,  "1")
    field(DTYP, "asynOctetRead")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))FULL_FILE_NAME")
    field(FTVL, "UCHAR")
    field(NELM, "256")
    field(SCAN, "I/O Intr")
}

# Autosave flag
record(mbbo, "$(P)$(D)AutoSave")
{
    field(PINI,  "1")
    field(DTYP, "asynInt32")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))AUTO_SAVE")
    field(ZRST, "No")
    field(ZRVL, "0")
    field(ONST, "Yes")
    field(ONVL, "1")
}

record(mbbi, "$(P)$(D)AutoSave_RBV")
{
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))AUTO_SAVE")
    field(ZRST, "No")
    field(ZRVL, "0")
    field(ONST, "Yes")
    field(ONVL, "1")
    field(SCAN, "I/O Intr")
}

# NOTE: These should be busy records, but wait till we get asynBusy record
# Write file
record(longout, "$(P)$(D)WriteFile")
{
    field(DTYP, "asynInt32")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))WRITE_FILE")
}

# Read file
record(longout, "$(P)$(D)ReadFile")
{
    field(DTYP, "asynInt32")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))READ_FILE")
}

# File data format 
record(mbbo, "$(P)$(D)FileFormat")
{
    field(PINI, "1")
    field(DTYP, "asynInt32")
    field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_FORMAT")
    field(ZRST, "Default")
    field(ZRVL, "0")
    field(ONST, "Invalid")
    field(ONVL, "1")
}

record(mbbi, "$(P)$(D)FileFormat_RBV")
{
    field(PINI, "1")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILE_FORMAT")
    field(ZRST, "Default")
    field(ZRVL, "0")
    field(ONST, "Invalid")
    field(ONVL, "1")
    field(SCAN, "I/O Intr")
}

###################################################################
#  The asynRecord is used for mainly for trace mask               # 
###################################################################
 
# Set ASYN_TRACEIO_HEX bit by default
record(asyn,"$(P)$(D)AsynIO")
{
    field(PORT, $(PORT))
    field(TIB2,"1")
}

###################################################################
#  Records past here need work!!!!                                # 
###################################################################

# Needs works past here
record(mbbo, "$(P)$(D)Compression")
{
   field(ZRST,  "None")
   field(ONST,  "LZW")
   field(TWST, "Skip-Huff")
   field(THST, "RL Encoding")
}

record(bi, "$(P)$(D)CorrectBackground")
{
   field(VAL, "0")
   field(ZNAM, "No")
   field(ONAM, "Yes")
}

record(bi, "$(P)$(D)CorrectFlatfield")
{
   field(VAL, "0")
   field(ZNAM, "No")
   field(ONAM, "Yes")
}

record(bi, "$(P)$(D)CorrectSpatial")
{
   field(VAL, "0")
   field(ZNAM, "No")
   field(ONAM, "Yes")
}

record(mbbo, "$(P)$(D)ImageType")
{
   field(VAL, "0")
   field(ZRST, "Normal")
   field(ONST, "Dbl correlation")
   field(TWST, "Background")
   field(THST, "Flatfield")
}

record(ao, "$(P)$(D)TimeRemaining")
{
   field(VAL, "0")
   field(PREC, "1")
}

record(stringout, "$(P)$(D)OpenShutterStr")
{
   field(VAL, "1")
}

record(bo, "$(P)$(D)OpenShutter")
{
}

record(stringout, "$(P)$(D)CloseShutterStr")
{
   field(VAL, "0")
}

record(bo, "$(P)$(D)CloseShutter")
{
}

record(ao, "$(P)$(D)OpenShutterDly")
{
   field(VAL, ".05")
   field(PREC, "3")
}

record(ao, "$(P)$(D)CloseShutterDly")
{
   field(VAL, ".05")
   field(PREC, "3")
}

record(mbbo, "$(P)$(D)ShutterMode")
{
   field(VAL, "2")
   field(ZRST, "None")
   field(ONST, "Camera output")
   field(TWST, "EPICS PV")
}

record(bo, "$(P)$(D)Shutter")
{
   field(PINI, "YES")
   field(VAL, "0")
   field(ZNAM, "Closed")
   field(ZSV, "MAJOR")
   field(ONAM, "Open")
   field(OSV, "NO_ALARM")
}

record(stringin, "$(P)$(D)ShutterStatus")
{
   field(PINI, "YES")
   field(INP, "$(P)$(D)Shutter CP MS")
}

record(stringout, "$(P)$(D)DetInStr")
{
}

record(stringout, "$(P)$(D)DetOutStr")
{
}

record(stringin, "$(P)$(D)Comment1")
{
   field(DESC, "Comment 1")
}

record(stringin, "$(P)$(D)Comment2")
{
   field(DESC, "Comment 2")
}

record(stringin, "$(P)$(D)Comment3")
{
   field(DESC, "Comment 3")
}

record(stringin, "$(P)$(D)Comment4")
{
   field(DESC, "Comment 4")
}

record(stringin, "$(P)$(D)Comment5")
{
   field(DESC, "Comment 5")
}

record(stringin, "$(P)$(D)Comment6")
{
   field(DESC, "Comment 6")
}