#==================================
#----------------------------------
# cav.template:
#
# Support for a single cavity
#
# PREF - cavity name
# BIT  - RFS zone, 0 or 1 
#----------------------------------
#==================================

#==================================
# "Mailbox" PVs requested by
# Larry Doolittle to host data
# determined by external python
# scripts.
# Initial implementation: scripts write
# to '_NEW' PVs which are not used by other
# software. User must push _NEW values
# to real PVs before these values will be
# used by other software.
# 
#   Cavity loaded Q (Q_L, unitless)
#   Derived cavity calibration constant (MV)
#     (currently independent of actual applied
#      scale factor)
#   Lorentz detuning coefficient Hz/(MV/m)^2
#   State space B comples coefficient 
#     (in SI units of 1/s)
#   SSA parameters
#   Rack/cavity station self-test status
#     PVs in chas.template
#==================================

record(ao, "$(PREF)PUSH_QPROBE") {
  field(DESC, "Push calc-ed to live PV")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)QPROBE_NEW")
  field(OUT,  "$(PREF)QPROBE PP")
}

record(ao, "$(PREF)PUSH_QLOADED") {
  field(DESC, "Push calc-ed to live PV")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)QLOADED_NEW")
  field(OUT,  "$(PREF)QLOADED PP")
}

record(ao, "$(PREF)PUSH_CAV_SCALE") {
  field(DESC, "Push calc-ed to live PV")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)CAV:CAL_SCALEB_NEW")
  field(OUT,  "$(PREF)CAV:SCALER_SEL.B PP")
}

record(ao, "$(PREF)PUSH_LFDCOEF") {
  field(DESC, "Push calc-ed to live PV")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)LFDCOEF_NEW")
  field(OUT,  "$(PREF)LFDCOEF PP")
}

record(ao, "$(PREF)PUSH_SSASLOPE") {
  field(DESC, "Push calc-ed to live PV")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)SSA:SLOPE_NEW")
  field(OUT,  "$(PREF)SSA:SLOPE PP")
}

record(ao, "$(PREF)RESTORE_QPROBE") {
  field(DESC, "Push calc-ed to live PV")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)QPROBE_SAVE")
  field(OUT,  "$(PREF)QPROBE PP")
}

record(ao, "$(PREF)RESTORE_QLOADED") {
  field(DESC, "Push calc-ed to live PV")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)QLOADED_SAVE")
  field(OUT,  "$(PREF)QLOADED PP")
}

record(ao, "$(PREF)RESTORE_CAV_SCALE") {
  field(DESC, "Push calc-ed to live PV")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)CAV:CAL_SCALEB_SAVE")
  field(OUT,  "$(PREF)CAV:SCALER_SEL.B PP")
}

record(ao, "$(PREF)RESTORE_LFDCOEF") {
  field(DESC, "Push calc-ed to live PV")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)LFDCOEF_SAVE")
  field(OUT,  "$(PREF)LFDCOEF PP")
}

record(ao, "$(PREF)RESTORE_SSASLOPE") {
  field(DESC, "Push calc-ed to live PV")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)SSA:SLOPE_SAVE")
  field(OUT,  "$(PREF)SSA:SLOPE PP")
}

record(ao, "$(PREF)SAVE_QPROBE") {
  field(DESC, "Push calc-ed to live PV")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)QPROBE")
  field(OUT,  "$(PREF)QPROBE_SAVE PP")
}

record(ao, "$(PREF)SAVE_QLOADED") {
  field(DESC, "Push calc-ed to live PV")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)QLOADED")
  field(OUT,  "$(PREF)QLOADED_SAVE PP")
}

record(ao, "$(PREF)SAVE_CAV_SCALE") {
  field(DESC, "Push calc-ed to live PV")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)CAV:SCALER_SEL.B")
  field(OUT,  "$(PREF)CAV:CAL_SCALEB_SAVE PP")
}

record(ao, "$(PREF)SAVE_LFDCOEF") {
  field(DESC, "Push calc-ed to live PV")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)LFDCOEF")
  field(OUT,  "$(PREF)LFDCOEF_SAVE PP")
}

record(ao, "$(PREF)SAVE_SSASLOPE") {
  field(DESC, "Push calc-ed to live PV")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)SSA:SLOPE")
  field(OUT,  "$(PREF)SSA:SLOPE_SAVE PP")
}

record(ai, "$(PREF)QPROBE") {
  field(DESC, "Cavity probe Q")
  field(SCAN, "Passive")
  field(VAL,  "1E12")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(ai, "$(PREF)QPROBE_SAVE") {
  field(DESC, "Cavity probe Q")
  field(SCAN, "Passive")
  field(VAL,  "1E12")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(ai, "$(PREF)QPROBE_NEW") {
  field(DESC, "Cavity probe Q")
  field(SCAN, "Passive")
  field(VAL,  "1E12")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)QPROBEDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_QPROBE")
  info(feed:info:input, "$(PREF)QPROBE_NEW")
  info(feed:info:output, "$(PREF)QPROBE_NEW")
}

record(ai, "$(PREF)QLOADED") {
  field(DESC, "Loaded Q")
  field(SCAN, "Passive")
  field(VAL,  "40000000")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(ai, "$(PREF)QLOADED_SAVE") {
  field(DESC, "Loaded Q")
  field(SCAN, "Passive")
  field(VAL,  "40000000")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(ai, "$(PREF)QLOADED_NEW") {
  field(DESC, "Loaded Q")
  field(SCAN, "Passive")
  field(VAL,  "40000000")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)QLOADEDDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_QLOADED")
  info(feed:info:input, "$(PREF)QLOADED_NEW")
  info(feed:info:output, "$(PREF)QLOADED_NEW")
}

record(ai, "$(PREF)LFDCOEF") {
  field(DESC, "Lorentz detuning coeff")
  field(SCAN, "Passive")
  field(VAL,  "0")
  field(EGU,  "Hz/(MV/m)^2")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(ai, "$(PREF)LFDCOEF_SAVE") {
  field(DESC, "Lorentz detuning coeff")
  field(SCAN, "Passive")
  field(VAL,  "0")
  field(EGU,  "Hz/(MV/m)^2")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(ai, "$(PREF)LFDCOEF_NEW") {
  field(DESC, "Lorentz detuning coeff")
  field(SCAN, "Passive")
  field(VAL,  "0")
  field(EGU,  "Hz/(MV/m)^2")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)LFDCOEFDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_LFDCOEF")
  info(feed:info:input, "$(PREF)LFDCOEF_NEW")
  info(feed:info:output, "$(PREF)LFDCOEF_NEW")
}

record(ai, "$(PREF)BCOEFM") {
  field(DESC, "State space B coeff magn")
  field(SCAN, "Passive")
  field(VAL,  "0")
  field(EGU,  "1/s")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)BCOEFMDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_BCOEFM")
  info(feed:info:input, "$(PREF)BCOEFM")
  info(feed:info:output, "$(PREF)BCOEFM")
}

record(ai, "$(PREF)BCOEFP") {
  field(DESC, "State space B coeff phas")
  field(SCAN, "Passive")
  field(VAL,  "0")
  field(EGU,  "degrees")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)BCOEFPDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_BCOEFP")
  info(feed:info:input, "$(PREF)BCOEFP")
  info(feed:info:output, "$(PREF)BCOEFP")
}

record(ai, "$(PREF)CAV:CAL_SCALEB_SAVE") {
  field(DESC, "Derived cavity cal const")
  field(SCAN, "Passive")
  field(VAL,  "1")
  field(EGU,  "MV")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(ai, "$(PREF)CAV:CAL_SCALEB_NEW") {
  field(DESC, "Derived cavity cal const")
  field(SCAN, "Passive")
  field(VAL,  "1")
  field(EGU,  "MV")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)CAV:CAL_SCALEDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_CAV:CAL_SCALE_NEW")
  info(feed:info:input, "$(PREF)CAV:CAL_SCALEB_NEW")
  info(feed:info:output, "$(PREF)CAV:CAL_SCALEB_NEW")
}


#==================================
# SSA characterization parameters
# Unitless
# Used by ASETSUB
#==================================
record(ao, "$(PREF)SSA:SLOPE") {
  field(DESC, "SSA slope")
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(VAL,  "1.5")
  field(DRVL, "0")
  field(DRVH, "10")
  field(LOW,  "0.4")
  field(LSV,  "MINOR")
  field(HIGH, "4.0")
  field(HSV,  "MINOR")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(ao, "$(PREF)SSA:SLOPE_NEW") {
  field(DESC, "SSA slope")
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(VAL,  "1.5")
  field(DRVL, "0")
  field(DRVH, "10")
  field(LOW,  "0.4")
  field(LSV,  "MINOR")
  field(HIGH, "4.0")
  field(HSV,  "MINOR")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(ao, "$(PREF)SSA:SLOPE_SAVE") {
  field(DESC, "SSA slope")
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(VAL,  "1.5")
  field(DRVL, "0")
  field(DRVH, "10")
  field(LOW,  "0.4")
  field(LSV,  "MINOR")
  field(HIGH, "4.0")
  field(HSV,  "MINOR")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)SSA:SLOPEDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_SSA:SLOPE")
  info(feed:info:input, "$(PREF)SSA:SLOPE_NEW")
  info(feed:info:output, "$(PREF)SSA:SLOPE_NEW")
}

record(ao, "$(PREF)SSA:PED") {
  field(DESC, "SSA pedestal")
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(VAL,  ".04")
  field(DRVL, "0")
  field(DRVH, ".99999")
  field(LOLO, "0")
  field(LLSV, "MAJOR")
  field(HIHI, ".99999")
  field(HHSV, "MAJOR")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)SSA:PEDDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_SSA:PED")
  info(feed:info:input, "$(PREF)SSA:PED")
  info(feed:info:output, "$(PREF)SSA:PED")
}

record(ao, "$(PREF)SSA:MINX") {
  field(DESC, "SSA minx")
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(VAL,  ".05")
  field(DRVL, "0")
  field(LOLO, "0")
  field(LLSV, "MAJOR")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)SSA:MINXDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_SSA:MINX")
  info(feed:info:input, "$(PREF)SSA:MINX")
  info(feed:info:output, "$(PREF)SSA:MINX")
}

record(stringin, "$(PREF)SSA:CALMSG1") {
  field(DESC, "SSA cal summary message")
  field(SCAN, "Passive")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)SSA:CALMSG1DMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_SSA:CALMSG1")
  info(feed:info:input, "$(PREF)SSA:CALMSG1")
  info(feed:info:output, "$(PREF)SSA:CALMSG1")
}

record(stringin, "$(PREF)SSA:CALMSG2") {
  field(DESC, "SSA cal summary message")
  field(SCAN, "Passive")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)SSA:CALMSG2DMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_SSA:CALMSG2")
  info(feed:info:input, "$(PREF)SSA:CALMSG2")
  info(feed:info:output, "$(PREF)SSA:CALMSG2")
}

record(mbbi, "$(PREF)SSA:CALSTAT") {
  field(VAL,  "0")
  field(ZRVL, "0")
  field(ZRST, "Good")
  field(ONVL, "1")
  field(ONST, "Warning")
  field(ONSV, "MINOR")
  field(TWVL, "2")
  field(TWST, "Error")
  field(TWSV, "MAJOR")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)SSA:CALSTATDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_SSA:CALSTAT")
  info(feed:info:input, "$(PREF)SSA:CALSTAT")
  info(feed:info:output, "$(PREF)SSA:CALSTAT")
}

record(ai, "$(PREF)SSA:CALPWR") {
  field(DESC, "Max fwd power measured in SSA cal")
  field(SCAN, "Passive")
  field(PREC, "3")
  field(EGU,  "W")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)SSA:CALPWRDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_SSA:CALPWR")
  info(feed:info:input, "$(PREF)SSA:CALPWR")
  info(feed:info:output, "$(PREF)SSA:CALPWR")
}

#==================================
# For scanning detune frequency
# 2020-07: some parts of this are 
# decomissioned. Need to figure out 
# which and remove
#==================================

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)DFDELTADMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_DFDELTA")
  info(feed:info:input, "$(PREF)DFDELTA")
  info(feed:info:output, "$(PREF)DFDELTA")
}

record(ai, "$(PREF)DFDELTA") {
  field(DESC, "Measured detune delta")
  field(SCAN, "Passive")
  field(VAL,  "0")
  field(EGU,  "kHz")
  field(PREC, "4")
  field(PINI, "YES")
  field(FLNK, "$(PREF)DFDELTA_HZ")
  info(autosaveFields, "VAL")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)DFSCANAMPDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_DFSCANAMP")
  info(feed:info:input, "$(PREF)DFSCANAMP")
  info(feed:info:output, "$(PREF)DFSCANAMP")
}

record(ai, "$(PREF)DFSCANAMP") {
  field(DESC, "Max amplitude in DF scan")
  field(SCAN, "Passive")
  field(VAL,  "0")
  field(EGU,  "% full scale")
  field(PREC, "4")
  field(PINI, "YES")
  field(FLNK, "$(PREF)DFAMPCALC")
  info(autosaveFields, "VAL")
}

record(calc, "$(PREF)DFAMPCALC") {
  field(DESC, "Detune freq")
  field(CALC, "A*B")
  field(INPA, "$(PREF)DFSCANAMP")
  field(INPB, "$(PREF)CAV:SCALE")
  field(FLNK, "$(PREF)DFAMP")
}

record(ai, "$(PREF)DFAMP") {
  field(DESC, "Max amplitude in DF scan")
  field(SCAN, "Passive")
  field(EGU,  "MV")
  field(PREC, "2")
  field(INP,  "$(PREF)DFAMPCALC")
}

record(ai, "$(PREF)DFSCANOFFSET") {
  field(DESC, "Requested scan offset")
  field(SCAN, "Passive")
  field(VAL,  "0")
  field(EGU,  "kHz")
  field(PREC, "4")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)DFSCANOFFSETDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_DFSCANOFFSET")
  info(feed:info:input, "$(PREF)DFSCANOFFSET")
  info(feed:info:output, "$(PREF)DFSCANOFFSET")
}

# Value of 1 to prompt rf_controls.py to
# stop looping through repeat scans. 
# Different from DFSCANSTOP
# in launcher system, which kills script
record(longout, "$(PREF)DFLOOPSTOP") {
  field(DESC, "Stop detune scanning loop")
  field(SCAN, "Passive")
  field(VAL,  "0")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

# Dummy PV to allow python API to access actual PV
record(longout, "$(PREF)DFLOOPSTOPDMY") {
  field(DTYP, "FEED Register Write")
  field(OUT , "@name=$(NAME) reg=mbox_$(BIT)_DFLOOPSTOP")
  info(feed:info:input, "$(PREF)DFLOOPSTOP")
  info(feed:info:output, "$(PREF)DFLOOPSTOP")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)8PI9_FDELTADMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_8PI9_FDELTA")
  info(feed:info:input, "$(PREF)8PI9_FDELTA")
  info(feed:info:output, "$(PREF)8PI9_FDELTA")
}

record(ai, "$(PREF)8PI9_FDELTA") {
  field(DESC, "Measured 8pi/9 detune")
  field(SCAN, "Passive")
  field(VAL,  "0")
  field(EGU,  "Hz")
  field(PREC, "1")
  field(LOPR, "-900000")
  field(HOPR, "-650000")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(calc, "$(PREF)DFDELTA_HZ") {
  field(DESC, "Calc cavity ang freq")
  field(CALC, "1000*A")
  field(EGU,  "Hz")
  field(PREC, "1")
  field(INPA, "$(PREF)DFDELTA")
}

record(calcout, "$(PREF)PUSH_8PI9_FDELTA") {
  field(DESC, "Push calc-ed to live PV")
  field(CALC, "(A>B&&A<C)?0:1")
  field(INPA, "$(PREF)DFDELTA_HZ")
  field(INPB, "$(PREF)8PI9_FDELTA.LOPR")
  field(INPC, "$(PREF)8PI9_FDELTA.HOPR")
  field(OOPT, "When Zero")
  field(DOPT, "Use OCAL")
  field(OCAL, "A")
  field(OUT,  "$(PREF)8PI9_FDELTA PP")
  field(FLNK, "$(PREF)PUSH_8PI9_STAT_")
}

record(seq, "$(PREF)PUSH_8PI9_STAT_") {
  field(SELM, "All")
  field(DOL1, "$(PREF)PUSH_8PI9_FDELTA.VAL")
  field(LNK1, "$(PREF)PUSH_8PI9_STAT PP")
  field(DLY2, "3")
  field(DOL2, "0")
  field(LNK2, "$(PREF)PUSH_8PI9_STAT PP")
}

record(bo, "$(PREF)PUSH_8PI9_STAT") {
  field(DESC, "Display warning")
  field(OMSL, "supervisory")
  field(VAL,  "0")
  field(PINI, "YES")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)LOWPASS_BWDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_LOWPASS_BW")
  info(feed:info:input, "$(PREF)LOWPASS_BW")
  info(feed:info:output, "$(PREF)LOWPASS_BW")
}

record(ai, "$(PREF)LOWPASS_BW") {
  field(DESC, "Low pass filter bandwidth")
  field(SCAN, "Passive")
  field(VAL,  "150000")
  field(EGU,  "Hz")
  field(PREC, "1")
  field(LOPR, "50000")
  field(HOPR, "300000")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

#==================================
# Records used by rf_controls.py
#==================================

record(stringin, "$(PREF)RFS_URL") {
  field(VAL, "ca://$(BASE)$(RFS):")
  field(PINI, "YES")
}

record(longin, "$(PREF)RFS_ZONE") {
  field(VAL, "$(BIT)")
  field(PINI, "YES")
}

record(ai, "$(PREF)CAV_GOAL") {
  field(VAL, "5.0")
  field(EGU, "MV")
  info(autosaveFields, "VAL")
}
record(longin, "$(PREF)CAV_GOALDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_CAV_GOAL")
  info(feed:info:input, "$(PREF)CAV_GOAL")
  info(feed:info:output, "$(PREF)CAV_GOAL")
}

#==================================
# Cavity type, 1.3 or 3.9 GHz design
# frequency
# 
# Some cavity constants that vary
# based on this. Appropriate values
# are selected by <RFS>FREQ_SEL_RBV
#==================================

record(sel, "$(PREF)FREQ_SEL") {
  field(DESC, "Cavity freq selector")
  field(SELM, "Specified")
  field(NVL, "$(BASE)$(RFS):FREQ_SEL_RBV CP")
  field(INPA, "1.3e9")
  field(INPB, "3.9e9")
  field(EGU,  "Hz")
  field(PINI, "YES")
  field(FLNK, "$(PREF)L_SEL")
}

record(sel, "$(PREF)L_SEL") {
  field(DESC, "Cavity length selector")
  field(SELM, "Specified")
  field(NVL, "$(BASE)$(RFS):FREQ_SEL_RBV")
  field(INPA, "1.038")
  field(INPB, "0.34596")
  field(EGU,  "m")
  field(FLNK, "$(PREF)IMPED_SEL")
}

record(sel, "$(PREF)IMPED_SEL") {
  field(DESC, "Cavity shunt imped selector")
  field(SELM, "Specified")
  field(NVL, "$(BASE)$(RFS):FREQ_SEL_RBV")
  field(INPA, "1012")
  field(INPB, "750")
  field(EGU,  "ohms")
  field(FLNK, "$(PREF)FREQ_SEL_FO")
}

record(fanout, "$(PREF)FREQ_SEL_FO") {
  field(LNK1, "$(PREF)L")
  field(LNK2, "$(PREF)IMPED")
  field(LNK3, "$(PREF)FREQ")
}

#==================================
# Cavity constants
# Used by ASETSUB
#==================================

record(ao, "$(PREF)L") {
  field(DESC, "Cavity length")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)L_SEL")
  field(EGU,  "m")
  field(PINI, "YES")
}

record(ao, "$(PREF)IMPED") {
  field(DESC, "Cavity shunt imped")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)IMPED_SEL")
  field(EGU,  "ohms")
  field(PINI, "YES")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)IMPEDDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_IMPED")
  info(feed:info:input, "$(PREF)IMPED")
  info(feed:info:output, "$(PREF)IMPED")
}

record(ao, "$(PREF)FREQ") {
  field(DESC, "Cavity freq")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)FREQ_SEL")
  field(EGU,  "Hz")
  field(FLNK, "$(PREF)ANGFREQCALC")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)FREQDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_FREQ")
  info(feed:info:input, "$(PREF)FREQ")
  info(feed:info:output, "$(PREF)FREQ")
}

record(calc, "$(PREF)ANGFREQCALC") {
  field(DESC, "Calc cavity ang freq")
  field(CALC, "2*PI*A")
  field(INPA, "$(PREF)FREQ")
  field(FLNK, "$(PREF)ANGFREQ")
}

record(ao, "$(PREF)ANGFREQ") {
  field(DESC, "Cavity ang freq")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)ANGFREQCALC PP")
  field(EGU,  "rad*Hz")
}

#==================================
# Detune frequency scalar
# Not associated with waveform data
#==================================

record(mbbi, "$(PREF)DFVALID") {
  field(DTYP, "FEED Register Read")
  field(SCAN, "1 second")
  field(INP , "@name=$(NAME) reg=cct1_cavity$(BIT)_detune_valid")
  field(TSE , "-2")
  field(ZRVL, "0")
  field(ZRST, "Not valid")
  field(ZRSV,  "MAJOR")
  field(ONVL, "1")
  field(ONST, "Valid")
  field(FLNK, "$(PREF)DFVALID_")
  info(feed:info:setting, "$(PREF)DFVALID")
}

record(bi, "$(PREF)DFVALID_") {
  field(DESC, "Internal PV to set alarm state")
  field(INP,  "$(PREF)DFVALID")
  field(ZSV,  "INVALID")
  field(FLNK, "$(PREF)DF")
}

# NOTE: Do not use DF.ASLO directly, but
# instead DF_ASLO_FO, which gets updated with
# firmware piezo constants register 
record(ai, "$(PREF)DF") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=cavity$(BIT)_detune")
  field(TSE , "-2")
  field(ASLO, ".002")
  field(EGU,  "Hz")
  field(LOPR, "-100")
  field(HOPR, "100")
# SDIS set to inherit severity only
  field(SDIS, "$(PREF)DFVALID_ MS")
  field(DISV, "100")
  info(feed:info:setting, "$(PREF)DF")
}

# Dummy PV to allow python API to access actual PV
record(longout, "$(PREF)DFSCALEDMY") {
  field(DTYP, "FEED Register Write")
  field(OUT , "@name=$(NAME) reg=mbox_$(BIT)_DFSCALE")
  info(feed:info:input, "$(PREF)DF.ASLO")
  info(feed:info:output, "$(PREF)DF.ASLO")
}

# Add access security - no write  
record(mbbo, "$(PREF)DF_ENABLE") {
  field(DTYP, "FEED Register Write")
  field(OUT , "@name=$(NAME) reg=cct1_cavity$(BIT)_detune_en wait=false")
  field(ZRVL, "0")
  field(ONVL, "1")
  field(ZRSV, "MAJOR")
  field(ZRST, "Not enabled")
  field(ONST, "Enabled")
  info(feed:info:setting, "$(PREF)DF_ENABLE")
}

record(mbbi, "$(PREF)DF_ENABLE_RBV") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=cct1_cavity$(BIT)_detune_en")
  field(SCAN, "1 second")
  field(ZRVL, "0")
  field(ONVL, "1")
  field(ZRSV, "MAJOR")
  field(ZRST, "Not enabled")
  field(ONST, "Enabled")
  field(TSE , "-2")
  info(feed:info:setting, "$(PREF)DF_ENABLE_RBV")
}

# Attempt to select most reliable detune
# method
# If in pulse or chirp mode: Chirp
# Else if RFS calculation valid: RFS
# Else if FC calculation: Frequency Counter
# Else RFS
record(calcout, "$(PREF)DFBEST_CALC") {
  field(DESC, "Determine best DF measurement")
  field(CALC, "B=5?2:B=4?2:A?0:C?1:A")
  field(INPA, "$(PREF)DFVALID CP")
  field(INPB, "$(PREF)RFMODECTRL CP")
  field(INPC, "$(PREF)DF_FCVALID CP")
  field(OOPT, "On Change")
  field(PINI, "YES")
  field(OUT,  "$(PREF)DFBEST.SELN PP")
}

record(sel, "$(PREF)DFBEST") {
  field(DESC, "")
  field(SCAN, "1 second")
  field(SELM, "Specified")
  field(INPA, "$(PREF)DF MS")
  field(INPB, "$(PREF)DF_FC MS")
  field(INPC, "$(PREF)CHIRP:DF MS")
  field(EGU,  "Hz")
  field(LOPR, "-100")
  field(HOPR, "100")
  field(FLNK, "$(PREF)DFBEST_DESC")
}

record(mbbi, "$(PREF)DFBEST_DESC") {
  field(DESC, "")
  field(INP,  "$(PREF)DFBEST_CALC MSI")
  field(ZRVL, "0")
  field(ZRST, "RFS Cav/Fwd")
  field(ONVL, "1")
  field(ONST, "Freq Counter")
  field(TWVL, "2")
  field(TWST, "Chirp")
}

#==================================
# Detune frequency scalar as 
# measured by SEL frequency counter
# Only valid in SEL
# Not associated with waveform data
#==================================

record(mbbi, "$(PREF)DF_FCVALID") {
  field(DTYP, "FEED Register Read")
  field(SCAN, "1 second")
  field(INP , "@name=$(NAME) reg=cfreq_$(BIT)_frequency_valid")
  field(TSE , "-2")
  field(ZRVL, "0")
  field(ZRST, "Not valid")
  field(ZRSV,  "MAJOR")
  field(ONVL, "1")
  field(ONST, "Valid")
  field(FLNK, "$(PREF)DF_FCVALID_")
  info(feed:info:setting, "$(PREF)DF_FCVALID")
}

record(bi, "$(PREF)DF_FCVALID_") {
  field(DESC, "Internal PV to set alarm state")
  field(INP,  "$(PREF)DF_FCVALID")
  field(ZSV,  "INVALID")
  field(FLNK, "$(PREF)DF_FC")
}

record(ai, "$(PREF)DF_FC") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=cfreq_$(BIT)_frequency")
  field(TSE , "-2")
  field(ASLO, "1.36239")
  field(EGU,  "Hz")
  field(LOPR, "-100")
  field(HOPR, "100")
# SDIS set to inherit severity only
  field(SDIS, "$(PREF)DF_FCVALID_ MS")
  field(DISV, "100")
  field(FLNK, "$(PREF)DF_FC_AMPMAX")
  info(feed:info:setting, "$(PREF)DF_FC")
}

# Dummy PV to allow python API to access actual PV
record(longout, "$(PREF)DF_FCSCALEDMY") {
  field(DTYP, "FEED Register Write")
  field(OUT , "@name=$(NAME) reg=mbox_$(BIT)_DF_FCSCALE")
  info(feed:info:input, "$(PREF)DF_FC.ASLO")
  info(feed:info:output, "$(PREF)DF_FC.ASLO")
}

record(ai, "$(PREF)DF_FC_AMPMAX") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=cfreq_$(BIT)_amp_max")
  field(TSE , "-2")
# TODO: add scaling
#  field(ASLO, "1")
#  field(EGU,  "MV")
# SDIS set to inherit severity only
  field(SDIS, "$(PREF)DF_FCVALID_ MS")
  field(DISV, "100")
  field(FLNK, "$(PREF)DF_FC_AMPMIN")
  info(feed:info:setting, "$(PREF)DF_FC_AMPMAX")
}

record(ai, "$(PREF)DF_FC_AMPMIN") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=cfreq_$(BIT)_amp_min")
  field(TSE , "-2")
# TODO: add scaling
#  field(ASLO, "1")
#  field(EGU,  "MV")
# SDIS set to inherit severity only
  field(SDIS, "$(PREF)DF_FCVALID_ MS")
  field(DISV, "100")
  info(feed:info:setting, "$(PREF)DF_FC_AMPMIN")
}

#==================================
# Convenience G->A and A->G calculators
# Maybe change this to be built into
# displays instead
#==================================

record(ao, "$(PREF)GTOA") {
  field(DESC, "Calculator gradient input")
  field(OMSL, "supervisory")
  field(VAL,  "0")
  field(DRVL, "0")
  field(EGU,  "MV/m")
  field(PINI, "YES")
  field(FLNK, "$(PREF)GTOACALC")
}

record(calc, "$(PREF)GTOACALC") {
  field(DESC, "Convert G to A units")
  field(CALC, "A*B")
  field(INPA, "$(PREF)GTOA")
  field(INPB, "$(PREF)L")
  field(EGU,  "MV")
}

record(ao, "$(PREF)ATOG") {
  field(DESC, "Calculator amplitude input")
  field(OMSL, "supervisory")
  field(VAL,  "0")
  field(DRVL, "0")
  field(EGU,  "MV")
  field(PINI, "YES")
  field(FLNK, "$(PREF)ATOGCALC")
}

record(calc, "$(PREF)ATOGCALC") {
  field(DESC, "Convert A to G units")
  field(CALC, "A/B")
  field(INPA, "$(PREF)ATOG")
  field(INPB, "$(PREF)L")
  field(EGU,  "MV/m")
}

#==================================
# Set cavity amplitude
# Based on new amplitude setting,
# calculate new limits for AACT and push
# TODO: Alarm limits should be +/- .01% 
# based on SSA/LLRF PRD, but using looser
# tolerances for now.
#
# Convenience conversion to gradient
# for readback only
#==================================

# Dummy PV to allow python API to access actual PV
record(longout, "$(PREF)ADESDMY") {
  field(DTYP, "FEED Register Write")
  field(OUT , "@name=$(NAME) reg=mbox_$(BIT)_ADES")
  info(feed:info:input, "$(PREF)ADES")
  info(feed:info:output, "$(PREF)ADES")
}

record(ao, "$(PREF)ADES") {
  field(DESC, "Amplitude setpoint")
  field(OMSL, "supervisory")
  field(VAL,  "0")
  field(DRVL, "0")
# initial upper limit of 21 MV/m
# for LERF testing
  field(DRVH, "21.798")
  field(HIHI, "21.798")
  field(HHSV, "MAJOR")
  field(LOPR, "0")
  field(HOPR, "21.798")
  field(EGU,  "MV")
  field(PINI, "YES")
  field(OUT,  "$(PREF)AACTACALC PP")
  field(FLNK, "$(PREF)ASETSUB")
  info(autosaveFields, "VAL")
}

record(calcout, "$(PREF)AACTACALC") {
  field(DESC, "Calc AACT alarm values")
  field(CALC, "A+(A*B)")
  field(OCAL, "A-(A*B)")
  field(INPA, "$(PREF)ADES")
  field(INPB, ".1")
#  field(INPB, ".0001")
  field(OOPT, "Every Time")
  field(DOPT, "Use OCAL")
  field(FLNK, "$(PREF)AACTWCALC")
  info(autosaveFields, "INPB B")
}

record(calcout, "$(PREF)AACTWCALC") {
  field(DESC, "Calc AACT warning values")
  field(CALC, "A+(A*B)")
  field(OCAL, "A-(A*B)")
  field(INPA, "$(PREF)ADES")
  field(INPB, ".05")
#  field(INPB, ".00005")
  field(OOPT, "Every Time")
  field(DOPT, "Use OCAL")
  field(FLNK, "$(PREF)AACTASEQ")
  info(autosaveFields, "INPB B")
}

record(seq, "$(PREF)AACTASEQ") {
  field(DESC, "Push new lims to AACT")
  field(SELM, "All")
  field(DOL1, "$(PREF)AACTACALC")
  field(LNK1, "$(PREF)AACT.HIHI")
  field(DOL2, "$(PREF)AACTACALC.OVAL")
  field(LNK2, "$(PREF)AACT.LOLO")
  field(DOL3, "$(PREF)AACTWCALC")
  field(LNK3, "$(PREF)AACT.HIGH")
  field(DOL4, "$(PREF)AACTWCALC.OVAL")
  field(LNK4, "$(PREF)AACT.LOW PP")
  field(FLNK, "$(PREF)ATOGDESCALC")
}

record(calc, "$(PREF)ATOGDESCALC") {
  field(DESC, "Convert A to G units")
  field(CALC, "A/B")
  field(INPA, "$(PREF)ADES MS")
  field(INPB, "$(PREF)L")
  field(EGU,  "MV/m")
  field(FLNK, "$(PREF)GDES")
}

record(ai, "$(PREF)GDES") {
  field(DESC, "Readback amp setpoint in MV/m")
  field(INP,  "$(PREF)ATOGDESCALC MS")
  field(EGU,  "MV/m")
  field(LOPR, "0")
  field(HOPR, "22")
}

#==================================
# Read key waveform statistics
# into 'common' names. 
# Calculate gradient
#==================================

record(ai, "$(PREF)PACT") {
  field(DESC, "Cavity gradient readback")
  field(INP,  "$(PREF)CAV:PMEAN MS CP")
  field(EGU,  "degrees")
  field(LOPR, "-200")
  field(HOPR, "200")
  field(LLSV, "MAJOR")
  field(LSV,  "MINOR")
  field(HSV,  "MINOR")
  field(HHSV, "MAJOR")
  field(TSEL, "$(PREF)CAV:PMEAN.TIME")
}

record(ai, "$(PREF)AACT") {
  field(DESC, "Cavity gradient readback")
  field(INP,  "$(PREF)CAV:AMEAN MS CP")
  field(EGU,  "MV")
  field(LOPR, "0")
  field(HOPR, "22")
  field(LLSV, "MAJOR")
  field(LSV,  "MINOR")
  field(HSV,  "MINOR")
  field(HHSV, "MAJOR")
  field(FLNK, "$(PREF)ATOGACTCALC")
  field(TSEL, "$(PREF)CAV:AMEAN.TIME")
}

record(calc, "$(PREF)ATOGACTCALC") {
  field(DESC, "Convert A to G units")
  field(CALC, "A/B")
  field(INPA, "$(PREF)AACT MS")
  field(INPB, "$(PREF)L")
  field(EGU,  "MV/m")
  field(FLNK, "$(PREF)GACT")
}

record(ai, "$(PREF)GACT") {
  field(DESC, "Cavity gradient readback")
  field(INP,  "$(PREF)ATOGACTCALC MS")
  field(EGU,  "MV/m")
  field(LOPR, "0")
  field(HOPR, "22")
  field(TSEL, "$(PREF)CAV:AMEAN.TIME")
}

#==================================
# On reconnect, set cavity on/off/mode
# control to match current
# register values. Plus push: 
# -feedback gains
# -interlock active/bypass
# -interlock resets
#==================================
record(longin, "$(PREF)INIT1_") {
  field(DTYP, "FEED On Connect")
  field(INP , "@name=$(NAME)")
  field(SCAN, "I/O Intr")
  field(PHAS, "0")
  field(FLNK, "$(PREF)INIT2_")
}

record(seq, "$(PREF)INIT2_") {
  field(PINI, "YES")
  field(SELM, "All")
# Wait for input records to process
  field(DLY1, "2")
  field(DOL1, "$(PREF)RFSTATE MS")
  field(LNK1, "$(PREF)RFCTRL PP")
  field(DOL2, "$(PREF)RFMODEINIT_ PP MS")
  field(LNK2, "$(PREF)RFMODECTRL PP")
  field(FLNK, "$(PREF)INIT3_")
}

record(fanout, "$(PREF)INIT3_") {
  field(LNK1, "$(PREF)AMPFB_GAIN_I")
  field(LNK2, "$(PREF)AMPFB_GAIN_P")
  field(LNK3, "$(PREF)PHAFB_GAIN_I")
  field(LNK4, "$(PREF)PHAFB_GAIN_P")
  field(FLNK, "$(PREF)INIT4_")
}

record(fanout, "$(PREF)INIT4_") {
  field(LNK1, "$(PREF)PLL_BYP")
  field(LNK2, "$(PREF)IOCWDOG_BYP")
  field(LNK3, "$(PREF)RESINTLK_BYP")
  field(LNK4, "$(PREF)RESLINK_BYP")
  field(LNK5, "$(PREF)SSA_BYP")
  field(LNK6, "$(PREF)QUENCH_BYP")
  field(FLNK, "$(PREF)INIT5_")
}

record(fanout, "$(PREF)INIT5_") {
  field(LNK1, "$(PREF)IOCWDOG_TIME")
  field(LNK2, "$(PREF)RFS:INTLK_RESET_ALL")
  field(LNK3, "$(PREF)FREQ_SEL")
  field(FLNK, "$(PREF)INIT6_")
}

record(fanout, "$(PREF)INIT6_") {
  field(LNK1, "$(PREF)CONST_QUENCH")
  field(LNK2, "$(PREF)CONST_PZT")
  field(FLNK, "$(PREF)INIT7_")
}

record(fanout, "$(PREF)INIT7_") {
  field(LNK1, "$(PREF)CHIRP:AMP_MAX")
  field(LNK2, "$(PREF)CHIRP:AMP_SLOPE")
  field(LNK3, "$(PREF)CHIRP:FREQ_INIT")
  field(LNK4, "$(PREF)CHIRP:FREQ_SLOPE")
  field(LNK5, "$(PREF)CHIRP:ACQ_PER_WF")
  field(LNK6, "$(PREF)CHIRP:TIME")
}


#==================================
# Set cavity mode: SELAP, SELA, SEL
# (Currently sets informational
# AMPFB/PHAFB PVs but these could 
# potentially be removed and change
# ASETSUB to use RFMODECTRL directly.)
# Causes ASETSUB to process, which
# will recalculate and set cavity
# control registers based on current
# version of ADES.
#==================================

# Dummy PV to allow python API to access actual PV
record(longout, "$(PREF)RFMODECTRLDMY") {
  field(DTYP, "FEED Register Write")
  field(OUT , "@name=$(NAME) reg=mbox_$(BIT)_RFMODECTRL")
  info(feed:info:input, "$(PREF)RFMODECTRL")
  info(feed:info:output, "$(PREF)RFMODECTRL")
}

record(mbbo, "$(PREF)RFMODECTRL") {
  field(DESC, "Set cavity mode")
  field(OMSL, "supervisory")
  field(VAL,  "0")
  field(ZRST, "SELAP")
  field(ONST, "SELA")
  field(TWST, "SEL")
  field(THST, "SEL Raw")
  field(FRST, "Pulse")
  field(FVST, "Chirp")
  field(PINI, "YES")
  field(FLNK, "$(PREF)RFMODECTRLCALC")
  info(autosaveFields, "VAL")
}

record(calc, "$(PREF)RFMODECTRLCALC") {
  field(DESC, "Calc seq mask")
  field(CALC, "A=0?12:A=1?6:3")
  field(INPA, "$(PREF)RFMODECTRL")
  field(FLNK, "$(PREF)RFMODECTRLSEQ")
}

# SELAP: set A/P to close
# SELA:  set A to close, P to open
# SEL/Pulse/Chirp:   set A/P to open
record(seq, "$(PREF)RFMODECTRLSEQ") {
  field(SELM, "Mask")
  field(SELL, "$(PREF)RFMODECTRLCALC")
  field(DOL1, "0")
  field(LNK1, "$(PREF)AMPFB PP")
  field(DOL2, "0")
  field(LNK2, "$(PREF)PHAFB PP")
  field(DOL3, "1")
  field(LNK3, "$(PREF)AMPFB PP")
  field(DOL4, "1")
  field(LNK4, "$(PREF)PHAFB PP")
  field(FLNK, "$(PREF)RFMODECTRLCALC2")
}

# If exiting pulsed mode and entering other mode, exit
#   pulsed mode by turning off TGEN, wait, then process
#   ASETSUB
# Otherwise, just process ASETSUB
record(calc, "$(PREF)RFMODECTRLCALC2") {
  field(DESC, "Calc seq mask")
  field(CALC, "(A#4)&&(B=2)?3:4")
  field(INPA, "$(PREF)RFMODECTRL")
  field(INPB, "$(PREF)PULSE_STATUS")
  field(FLNK, "$(PREF)RFMODECTRLSEQ2")
}

record(seq, "$(PREF)RFMODECTRLSEQ2") {
  field(SELM, "Mask")
  field(SELL, "$(PREF)RFMODECTRLCALC2")
  field(DOL1, "1")
  field(LNK1, "$(PREF)TGENOFFSTRT CA")
  field(DLY2, "1")
  field(DOL2, "1")
  field(LNK2, "$(PREF)ASETSUB.PROC")
  field(DOL3, "1")
  field(LNK3, "$(PREF)ASETSUB.PROC")
}

record(bi, "$(PREF)AMPFB") {
  field(DESC, "Cavity amplitude feedback")
  field(ZNAM, "Open")
  field(ONAM, "Close")
  field(ZSV,  "MINOR")
  field(OSV,  "NO_ALARM")
}

record(bi, "$(PREF)PHAFB") {
  field(DESC, "Cavity phase feedback")
  field(ZNAM, "Open")
  field(ONAM, "Close")
  field(ZSV,  "MINOR")
  field(OSV,  "NO_ALARM")
}

#==================================
# Determine current cavity mode
# If chirp enabled, limit registers 
# are ignored by firmware
# Amp feedback closed if X hi != X lo
# Pha feedback closed if Y hi != Y lo
# When RF is off, all 4 are set to 0.
# In that case, to avoid interpreting
# that as SEL when RFMODECTRL is not SEL
# (and confusing people), set readback
# to value of RFMODECTRL (desired mode)
#==================================

record(calc, "$(PREF)RFLIMSUM_") {
  field(DESC, "Used in mode set/read")
  field(CALC, "A+B+C+D")
  field(INPA, "$(PREF)REGLIM0_RBV") # X hi
  field(INPB, "$(PREF)REGLIM1_RBV") # Y hi
  field(INPC, "$(PREF)REGLIM2_RBV") # X lo
  field(INPD, "$(PREF)REGLIM3_RBV") # Y lo
}

# RFMODEINIT_ used to set RFMODECTRL
# to appropriate value on boot/reconnect.
# Processed by INIT2_ 
record(calc, "$(PREF)RFMODEINIT_") {
  field(DESC, "Calc desired RF mode")
  field(CALC, "F=1?5:(A#C)&&(B#D)?0:(A#C)?1:(G=0)?E:(A=C)&&(B=D)?2:0")
  field(INPA, "$(PREF)REGLIM0_RBV") # X hi
  field(INPB, "$(PREF)REGLIM1_RBV") # Y hi
  field(INPC, "$(PREF)REGLIM2_RBV") # X lo
  field(INPD, "$(PREF)REGLIM3_RBV") # Y lo
  field(INPE, "$(PREF)RFMODECTRL") 
  field(INPF, "$(PREF)CHIRP:ENABLE_RBV") 
  field(INPG, "$(PREF)RFLIMSUM_ PP") 
}

record(calc, "$(PREF)RFLIMSEL_") {
  field(DESC, "Used in mode set/read")
  field(CALC, "(A=C)&&(B=D)")
  field(INPA, "$(PREF)REGLIM0_RBV") # X hi
  field(INPB, "$(PREF)REGLIM1_RBV") # Y hi
  field(INPC, "$(PREF)REGLIM2_RBV") # X lo
  field(INPD, "$(PREF)REGLIM3_RBV") # Y lo
}

# If chirp enabled or modectrl=chirp -> chirp
# Else if modectrl=pulse -> pulse
# Else use x and y lim register pairs both not equal -> SELAP
# Else if x lim registers not equal -> SELA
# Else if lim registers all 0 -> modectrl
# Else if x and y lim register pairs both equal and modectrl=SEL -> SEL    
# Else if x and y lim register pairs both equal and modectrl=SEL Raw -> SEL Raw
# Else unknown    
record(calc, "$(PREF)RFMODECALC_") {
  field(DESC, "Calc actual RF mode")
  field(CALC, "(E=5)|(G=1)?5:E=4?4:(A#C)&&(B#D)?0:(A#C)?1:F=0?E:I&(E=2)?2:I&(E=3)?3:6")
  field(INPA, "$(PREF)REGLIM0_RBV MSI") # X hi
  field(INPB, "$(PREF)REGLIM1_RBV MSI") # Y hi
  field(INPC, "$(PREF)REGLIM2_RBV MSI") # X lo
  field(INPD, "$(PREF)REGLIM3_RBV MSI") # Y lo
  field(INPE, "$(PREF)RFMODECTRL MSI") 
  field(INPF, "$(PREF)RFLIMSUM_ PP") 
# chirp on if G == 1 
  field(INPG, "$(PREF)CHIRP:ENABLE_RBV") 
# pulsing on if H == 2 
  field(INPH, "$(PREF)PULSE_STATUS")
  field(INPI, "$(PREF)RFLIMSEL_ PP") 
  field(FLNK, "$(PREF)RFMODE")
  field(PINI, "YES")
}

record(mbbi, "$(PREF)RFMODE") {
  field(DESC, "Read cavity mode")
  field(INP,  "$(PREF)RFMODECALC_")
  field(ZRST, "SELAP")
  field(ONST, "SELA")
  field(ONSV, "MINOR")
  field(TWST, "SEL")
  field(TWSV, "MINOR")
  field(THST, "SEL Raw")
  field(THSV, "MINOR")
  field(FRST, "Pulse")
  field(FRSV, "MINOR")
  field(FVST, "Chirp")
  field(FVSV, "MINOR")
  field(SXST, "Unknown")
  field(SXSV, "INVALID")
  field(FLNK, "$(PREF)RFREADYFORBEAM_")
}

record(calc, "$(PREF)RFREADYFORBEAM_") {
  field(DESC, "Calc actual RF mode")
  field(CALC, "(A=0)&(B=1)?1:0")
  field(INPA, "$(PREF)RFMODE MSI")
  field(INPB, "$(PREF)RFSTATE MSI")
  field(FLNK, "$(PREF)RFREADYFORBEAM")
}

record(mbbi, "$(PREF)RFREADYFORBEAM") {
  field(DESC, "RF state ready for beam")
  field(INP,  "$(PREF)RFREADYFORBEAM_ MS")
  field(ZRST, "Not ready")
  field(ZRSV, "MINOR")
  field(ONST, "Ready")
}

# WARNING: If we add additional control/readback
#          mode options (like SELP), need to update CALC 
record(calc, "$(PREF)RFMODESTATCALC") {
  field(DESC, "Calc seq mask")
  field(CALC, "A=B?1:0")
  field(INPA, "$(PREF)RFMODE CPP") # actual RF state
  field(INPB, "$(PREF)RFMODECTRL CPP")  # desired RF state
  field(FLNK, "$(PREF)RFMODESTAT")
  field(PINI, "YES")
}

record(bi, "$(PREF)RFMODESTAT") {
  field(DESC, "Desired mode matches actual")
  field(INP,  "$(PREF)RFMODESTATCALC")
  field(ZNAM, "Inconsistent")
  field(ZSV,  "MAJOR")
  field(ONAM, "Consistent")
}

#==================================
# Feedback output limits
# Used by ASETSUB
#==================================

record(ao, "$(PREF)SSA:DRV_MAX") {
  field(DESC, "SSA drive magnitude maximum")
  field(OMSL, "supervisory")
  field(VAL,  "0.8")
  field(LOPR, "0")
  field(HOPR, "1")
  field(DRVL, "0")
  field(DRVH, "1")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}
record(longin, "$(PREF)SSA:DRV_MAXDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_SSA:DRV_MAX")
  info(feed:info:input, "$(PREF)SSA:DRV_MAX")
  info(feed:info:output, "$(PREF)SSA:DRV_MAX")
}

# SSA drive power allocated for phase feedback
record(ao, "$(PREF)SSA:REACTIVE") {
  field(DESC, "SSA drive reactive power fraction")
  field(OMSL, "supervisory")
  field(VAL,  "0.2")
  field(LOPR, "0")
  field(HOPR, "1")
  field(DRVL, "0")
  field(DRVH, "1")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}
record(longin, "$(PREF)SSA:REACTIVEDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_SSA:REACTIVE")
  info(feed:info:input, "$(PREF)SSA:REACTIVE")
  info(feed:info:output, "$(PREF)SSA:REACTIVE")
}

#==================================
# Based on ADES and various inputs/constants,
# set new values for cavity control registers
#==================================

record(aSub, "$(PREF)ASETSUB") {
  field(INAM, "")
  field(SNAM, "asub_setamp")
# Inputs
  field(FTA, "DOUBLE") # amplitude setpoint
  field(INPA, "$(PREF)ADES")
  field(FTB, "DOUBLE") # shunt impedance
  field(INPB, "$(PREF)IMPED")
  field(FTC, "DOUBLE") # cav frequency
  field(INPC, "$(PREF)FREQ")
  field(FTD, "DOUBLE") # cav loaded Q
  field(INPD, "$(PREF)QLOADED")
  field(FTE, "DOUBLE") # forward full-scale [sqrt(W)]
  field(INPE, "$(PREF)FWD:SCALE")
  field(FTF, "DOUBLE") # cavity full-scale [MV]
  field(INPF, "$(PREF)CAV:SCALE")
  field(FTG, "SHORT") # amp feedback open/close
  field(INPG, "$(PREF)AMPFB")
  field(FTH, "SHORT") # pha feedback open/close
  field(INPH, "$(PREF)PHAFB")
  field(FTI, "DOUBLE") # SSA slope
  field(INPI, "$(PREF)SSA:SLOPE")
  field(FTJ, "DOUBLE") # SSA minx
  field(INPJ, "$(PREF)SSA:MINX")
  field(FTK, "DOUBLE") # SSA pedestal
  field(INPK, "$(PREF)SSA:PED")
  field(FTL, "DOUBLE") # policy max r
  field(INPL, "$(PREF)SSA:DRV_MAX")
  field(FTM, "DOUBLE") # policy sin(theta)
  field(INPM, "$(PREF)SSA:REACTIVE")
  field(FTN, "SHORT") # desired RF on/off
  field(INPN, "$(PREF)RFCTRL")
  field(FTO, "SHORT") # desired RF mode
  field(INPO, "$(PREF)RFMODECTRL")
  field(FTP, "DOUBLE") # raw SEL amplitude setting
  field(INPP, "$(PREF)SEL_ASET CPP")
  field(FTR, "SHORT") # previous RF mode
  field(INPR, "$(PREF)RFMODEPREV")
  field(FTS, "LONG") # current decimation setting
  field(INPS, "$(PREF)ACQ_DECIM")
  field(FTT, "LONG") # decimation setting stored when last entered chirp mode
  field(INPT, "$(PREF)CHIRP:DECIM_SAVE")

# Intermediate results
  field(FTVA, "DOUBLE") # sqrt(U)
  field(FTVB, "DOUBLE") # SSA target
  field(FTVC, "DOUBLE") # SSA target normalized
  field(FTVD, "DOUBLE") # Cav ADC setpoint normalized
  field(FTVF, "DOUBLE") # policy X
  field(FTVG, "DOUBLE") # policy y
  field(FTVH, "DOUBLE") # lowslope

# Outputs
  field(FTVI, "SHORT")  # chirp enable 
  field(FTVJ, "LONG")   # restore to original decimation when exiting chirp mode 
  field(FTVM, "DOUBLE") # x lo before policy clip  
  field(FTVN, "DOUBLE") # x hi before policy clip
  field(FTVE, "LONG")   # setmp element 0, magnitude
  field(FTVK, "LONG")   # lim_x_lo
  field(FTVL, "LONG")   # lim_x_hi
  field(FTVO, "LONG")   # lim_y_lo
  field(FTVP, "LONG")   # lim_y_hi
  field(FTVQ, "SHORT")  # too_high
  field(FTVR, "USHORT") # mask for ASETSUBGO
  field(OUTR, "$(PREF)ASETSUBGO PP") 
  field(FTVS, "CHAR")  # index for status message
  field(NOVS, "40")
  field(FTVT, "SHORT")  # indicate error message
  field(FTVU, "SHORT")  # current RF mode for use on next iteration
  field(OUTU, "$(PREF)RFMODEPREV PP") 
  field(PINI, "NO")
  field(FLNK, "$(PREF)ASETDIAGSUB")
  info(autosaveFields, "R T")
}

record(aSub, "$(PREF)ASETDIAGSUB") {
  field(DESC, "Graphical diagnostic")
  field(SNAM, "asub_setamp_diag")
# Inputs
  field(FTA, "DOUBLE") # amplitude setpoint
  field(INPA, "$(PREF)ADES CP")
  field(FTB, "DOUBLE") # shunt impedance
  field(INPB, "$(PREF)IMPED CP")
  field(FTC, "DOUBLE") # cav frequency
  field(INPC, "$(PREF)FREQ CP")
  field(FTD, "DOUBLE") # cav loaded Q
  field(INPD, "$(PREF)QLOADED CP")
  field(FTE, "DOUBLE") # forward full-scale [sqrt(W)]
  field(INPE, "$(PREF)FWD:SCALE CP")
  field(FTI, "DOUBLE") # SSA slope
  field(INPI, "$(PREF)SSA:SLOPE CP")
  field(FTJ, "DOUBLE") # SSA minx
  field(INPJ, "$(PREF)SSA:MINX CP")
  field(FTK, "DOUBLE") # SSA pedestal
  field(INPK, "$(PREF)SSA:PED CP")
  field(FTL, "DOUBLE") # policy max r
  field(INPL, "$(PREF)SSA:DRV_MAX CP")
  field(FTM, "DOUBLE") # policy reactive power 
  field(INPM, "$(PREF)SSA:REACTIVE CP")
# Outputs
  field(NOVA, "2") # Policy x low limit 					 
  field(NOVB, "2") # Policy x high limit 					 
  field(NOVC, "2") # Policy y low limit 					 
  field(NOVD, "2") # Policy y high limit 					 
  field(NOVE, "2") # Policy x low and high limits 			 
  field(NOVF, "2") # Policy y low and high limits 			 
  field(NOVG, "2") # SELA(P) x low limit 					 
  field(NOVH, "2") # SELA(P) x high limit 					 
  field(NOVI, "2") # SELA(P) x low and limits 				 
  field(NOVJ, "2") # Zero, two elements 					 
  field(NOVK, "2") # Graph x axis 							 
  field(NOVL, "2") # Graph y axis                           
  field(NOVM, "100") # Unit semi-circle x                          
  field(NOVN, "100") # Unit semi-circle y                          
}

record(longin, "$(PREF)RFMODEPREV") {
# val written by ASETSUB
  field(VAL, "-1")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(longin, "$(PREF)CHIRP:DECIM_SAVE") {
# val written by ASETSUBGO when entering chirp mode
  field(VAL, "-1")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(seq, "$(PREF)ASETSUBGO") {
  field(SELM, "Mask")
  field(SELL, "$(PREF)ASETSUB.VALR")
  field(DOL1, "$(PREF)ASETSUB.VALE")
  field(LNK1, "$(PREF)REGMAG PP")
  field(DOL2, "$(PREF)ASETSUB.VALL")
  field(LNK2, "$(PREF)REGLIM0 PP")
  field(DOL3, "$(PREF)ASETSUB.VALP")
  field(LNK3, "$(PREF)REGLIM1 PP")
  field(DOL4, "$(PREF)ASETSUB.VALK")
  field(LNK4, "$(PREF)REGLIM2 PP")
  field(DOL5, "$(PREF)ASETSUB.VALO")
  field(LNK5, "$(PREF)REGLIM3 PP")
  field(DOL6, "$(PREF)ASETSUB.S")
  field(LNK6, "$(PREF)CHIRP:DECIM_SAVE PP")
  field(DOL7, "1")
  field(LNK7, "$(PREF)CHIRP:SETUP.PROC")
# delay?
  field(DOL8, "$(PREF)ASETSUB.VALI")
  field(LNK8, "$(PREF)CHIRP:ENABLE PP")
  field(DOL9, "$(PREF)ASETSUB.T")
  field(LNK9, "$(PREF)ACQ_DECIM PP")
}

#==================================
# User RF on/off control.
# Separate ON/OFF seq records
# so that RF interlock inhibit
# can use these directly.
#==================================

# Dummy PV to allow python API to access actual PV
record(longout, "$(PREF)RFCTRLDMY") {
  field(DTYP, "FEED Register Write")
  field(OUT , "@name=$(NAME) reg=mbox_$(BIT)_RFCTRL")
  info(feed:info:input, "$(PREF)RFCTRL")
  info(feed:info:output, "$(PREF)RFCTRL")
}

record(bo, "$(PREF)RFCTRL") {
  field(DESC, "Turn RF on/off")
  field(OMSL, "supervisory")
  field(ZNAM, "Off")
  field(ONAM, "On")
  field(VAL,  "0")
  field(FLNK, "$(PREF)RFCTRLCALC")
}

record(calc, "$(PREF)RFCTRLCALC") {
  field(DESC, "Calc seq mask")
  field(CALC, "A=0?1:2")
  field(INPA, "$(PREF)RFCTRL")
  field(FLNK, "$(PREF)RFCTRLSEQ")
}

record(seq, "$(PREF)RFCTRLSEQ") {
  field(SELM, "Mask")
  field(SELL, "$(PREF)RFCTRLCALC")
  field(SCAN, "Passive")
  field(LNK1, "$(PREF)RFOFFSEQ PP")
  field(LNK2, "$(PREF)RFONSEQ PP")
}

record(seq, "$(PREF)RFOFFSEQ") {
  field(SELM, "All")
  field(SCAN, "Passive")
# To turn RF off, process first 5 links 
# and disable chirp
# Turns off RF drive without changing amplitude setpoint
  field(DOL1, "0")
  field(LNK1, "$(PREF)REGMAG PP")
  field(DOL2, "0")
  field(LNK2, "$(PREF)REGLIM0 PP")
  field(DOL3, "0")
  field(LNK3, "$(PREF)REGLIM1 PP")
  field(DOL4, "0")
  field(LNK4, "$(PREF)REGLIM2 PP")
  field(DOL5, "0")
  field(LNK5, "$(PREF)REGLIM3 PP")
  field(DOL6, "0")
  field(LNK6, "$(PREF)CHIRP:ENABLE PP")
  field(FLNK, "$(PREF)RFOFFSEQ2")
}

record(calcout, "$(PREF)RFOFFSEQ2") {
  field(DESC, "Calc seq mask")
  field(CALC, "(A#1)&&(B=2)?0:1")
  field(OCAL, "1")
  field(OOPT, "When Zero")
  field(DOPT, "Use OCAL")
  field(INPA, "$(PREF)RFCTRL")
  field(INPB, "$(PREF)PULSE_STATUS")
  field(OUT,  "$(PREF)TGENOFFSTRT CA")
  field(FLNK, "$(PREF)ASETSUB")
}

record(calc, "$(PREF)RFONSEQ") {
  field(DESC, "Calc seq mask")
  field(CALC, "A=5?2:1")
  field(INPA, "$(PREF)RFCTRL")
  field(FLNK, "$(PREF)RFONSEQ2")
}

record(seq, "$(PREF)RFONSEQ2") {
  field(SELM, "All")
  field(SCAN, "Passive")
# To turn RF back on, process link 1
# Forces ASETSUB to re-calculate and set registers 
# based on current ADES and desired mode
  field(LNK1, "$(PREF)ASETSUB PP")
}

#==================================
# Determine current RF on/off state from
# limit registers, TGEN status, and
# interlock permit
#==================================

record(calc, "$(PREF)RFSTATECALC") {
  field(DESC, "Calc seq mask")
  field(SCAN, "1 second")
  field(CALC, "F=0?0:((A+B+C+D)=0)&E=1&G=0?0:1")
  field(INPA, "$(PREF)REGLIM0_RBV PP MSI") # X hi
  field(INPB, "$(PREF)REGLIM1_RBV PP MSI") # Y hi
  field(INPC, "$(PREF)REGLIM2_RBV PP MSI") # X lo
  field(INPD, "$(PREF)REGLIM3_RBV PP MSI") # Y lo
  field(INPE, "$(PREF)TGEN_STAT NPP MSI")
  field(INPF, "$(PREF)RFPERMIT CP MSI")
  field(INPG, "$(PREF)CHIRP:ENABLE_RBV PP MSI")
  field(FLNK, "$(PREF)RFSTATE")
  field(PINI, "YES")
}

record(bi, "$(PREF)RFSTATE") {
  field(DESC, "Read drive on/off state")
  field(INP,  "$(PREF)RFSTATECALC")
  field(ZNAM, "Off")
  field(ZSV,  "MAJOR")
  field(ONAM, "On")
  field(FLNK, "$(PREF)RFMODECALC_")
}

record(calc, "$(PREF)RFSTATCALC") {
  field(DESC, "Calc seq mask")
  field(CALC, "A=B?1:0")
  field(INPA, "$(PREF)RFSTATE CPP") # actual RF state
  field(INPB, "$(PREF)RFCTRL CPP")  # desired RF state
  field(FLNK, "$(PREF)RFSTAT")
  field(PINI, "YES")
}

record(bi, "$(PREF)RFSTAT") {
  field(DESC, "Desired on/off matches actual")
  field(INP,  "$(PREF)RFSTATCALC")
  field(ZNAM, "Inconsistent")
  field(ZSV,  "MAJOR")
  field(ONAM, "Consistent")
}

#==================================
# Set cavity phase
# Based on new phase setting,
# calculate new limits for PACT and push
# Alarm limits +/- .01 degree 
# based on SSA/LLRF PRD
#==================================

record(ao, "$(PREF)PREF") {
  field(DESC, "Gold phase offset")
  field(OMSL, "supervisory")
  field(VAL,  "0")
  field(EGU,  "degrees")
  field(DRVL, "-180")
  field(DRVH, "180")
  field(LOPR, "-180")
  field(HOPR, "180")
  field(FLNK, "$(PREF)PDESAOFF")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

# PDESAOFF is subtracted from PDES
record(calcout, "$(PREF)PDESAOFF") {
  field(DESC, "PDES offset")
  field(CALC, "A+B+C+D")
  field(INPA, "$(PREF)PREF")
# Compensate for observed 90 degree offset 
  field(INPB, "90")
# Reserve for possible future offsets:
  field(INPC, "")
  field(INPD, "")
  field(OOPT, "Every Time")
  field(OUT, "$(PREF)PDES.AOFF NPP")
#  info(autosaveFields, "B C D")
}

record(calcout, "$(PREF)PDESASLO") {
  field(DESC, "PDES scale")
  field(CALC, "A*(360/2^18)")
# Negative sign from Fermi 3/2018
# Needs revisiting
  field(INPA, "-1")
  field(OOPT, "Every Time")
  field(OUT, "$(PREF)PDES.ASLO NPP")
  field(PINI, "YES")
#  info(autosaveFields, "A")
}

# Dummy PV to allow python API to access actual PV
record(longout, "$(PREF)PDESDMY") {
  field(DTYP, "FEED Register Write")
  field(OUT , "@name=$(NAME) reg=mbox_$(BIT)_PDES")
  info(feed:info:input, "$(PREF)PDES")
  info(feed:info:output, "$(PREF)PDES")
}

record(ao, "$(PREF)PDES") {
  field(DESC, "Phase setpoint")
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(VAL,  "0")
  field(EGU,  "degrees")
  field(DRVL, "-180")
  field(DRVH, "180")
  field(LOPR, "-180")
  field(HOPR, "180")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_setmp_1 wait=false")
  field(FLNK, "$(PREF)PACTACALC PP")
  info(feed:info:setting, "$(PREF)PDES")
  info(autosaveFields, "VAL")
}

record(longin, "$(PREF)REGPHA_RBV") {
  field(DESC,  "PDES raw register readback")
  field(DTYP, "FEED Register Read")
  field(SCAN, "1 second")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_setmp_1")
  field(TSE , "-2")
  info(feed:info:setting, "$(PREF)REGPHA_RBV")
}

record(calcout, "$(PREF)PACTACALC") {
  field(DESC, "Calc PACT alarm values")
  field(CALC, "A+B")
  field(OCAL, "A-B")
  field(INPA, "$(PREF)PDES")
  field(INPB, ".01")
  field(OOPT, "Every Time")
  field(DOPT, "Use OCAL")
  field(FLNK, "$(PREF)PACTWCALC")
  info(autosaveFields, "INPB B")
}

record(calcout, "$(PREF)PACTWCALC") {
  field(DESC, "Calc PACT warning values")
  field(CALC, "A+B")
  field(OCAL, "A-B")
  field(INPA, "$(PREF)PDES")
  field(INPB, ".005")
  field(OOPT, "Every Time")
  field(DOPT, "Use OCAL")
  field(FLNK, "$(PREF)PACTASEQ")
  info(autosaveFields, "INPB B")
}

record(seq, "$(PREF)PACTASEQ") {
  field(DESC, "Push new lims to PACT")
  field(SELM, "All")
  field(DOL1, "$(PREF)PACTACALC")
  field(LNK1, "$(PREF)PACT.HIHI")
  field(DOL2, "$(PREF)PACTACALC.OVAL")
  field(LNK2, "$(PREF)PACT.LOLO")
  field(DOL3, "$(PREF)PACTWCALC")
  field(LNK3, "$(PREF)PACT.HIGH")
  field(DOL4, "$(PREF)PACTWCALC.OVAL")
  field(LNK4, "$(PREF)PACT.LOW PP")
}

#==================================
# Cavity amplitude/limit registers. 
# Set by ASET*/RFCTRL* PVs
# Not to be used directly to control amplitude
#
# setmp_0 - magnitude
# lim_2   - ampl fdbck low limit
# lim_0   - ampl fdbck high limit
# lim_3   - phase fdbck low limit
# lim_1   - phase fdbck high limit
#
# Notes about register scan:
# The LIM registers are processed by RFSTATE.
# TODO: revisit names, set limits
#==================================
record(longout, "$(PREF)REGMAG") {
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_setmp_0 wait=false")
  field(DRVL, "-131072")
  field(DRVH, "131071")
  field(LOPR, "-131072")
  field(HOPR, "131071")
  info(feed:info:setting, "$(PREF)REGMAG")
}

record(longin, "$(PREF)REGMAG_RBV") {
  field(DTYP, "FEED Register Read")
  field(SCAN, "1 second")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_setmp_0")
  field(TSE , "-2")
  field(LOPR, "-131072")
  field(HOPR, "131071")
  info(feed:info:setting, "$(PREF)REGMAG_RBV")
}

record(longout, "$(PREF)REGLIM0") {
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_lim_0 wait=false")
  field(DRVL, "-131072")
  field(DRVH, "131071")
  field(LOPR, "-131072")
  field(HOPR, "131071")
  info(feed:info:setting, "$(PREF)REGLIM0")
}

record(longin, "$(PREF)REGLIM0_RBV") {
  field(DTYP, "FEED Register Read")
  field(SCAN, "Passive")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_lim_0")
  field(TSE , "-2")
  field(LOPR, "-131072")
  field(HOPR, "131071")
  info(feed:info:setting, "$(PREF)REGLIM0_RBV")
}

record(longout, "$(PREF)REGLIM1") {
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_lim_1 wait=false")
  field(DRVL, "-131072")
  field(DRVH, "131071")
  field(LOPR, "-131072")
  field(HOPR, "131071")
  info(feed:info:setting, "$(PREF)REGLIM1")
}

record(longin, "$(PREF)REGLIM1_RBV") {
  field(DTYP, "FEED Register Read")
  field(SCAN, "Passive")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_lim_1")
  field(TSE , "-2")
  field(LOPR, "-131072")
  field(HOPR, "131071")
  info(feed:info:setting, "$(PREF)REGLIM1_RBV")
}

record(longout, "$(PREF)REGLIM2") {
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_lim_2 wait=false")
  field(DRVL, "-131072")
  field(DRVH, "131071")
  field(LOPR, "-131072")
  field(HOPR, "131071")
  info(feed:info:setting, "$(PREF)REGLIM2")
}

record(longin, "$(PREF)REGLIM2_RBV") {
  field(DTYP, "FEED Register Read")
  field(SCAN, "Passive")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_lim_2")
  field(TSE , "-2")
  field(LOPR, "-131072")
  field(HOPR, "131071")
  info(feed:info:setting, "$(PREF)REGLIM2_RBV")
}

record(longout, "$(PREF)REGLIM3") {
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_lim_3 wait=false")
  field(DRVL, "-131072")
  field(DRVH, "131071")
  field(LOPR, "-131072")
  field(HOPR, "131071")
  info(feed:info:setting, "$(PREF)REGLIM3")
}

record(longin, "$(PREF)REGLIM3_RBV") {
  field(DTYP, "FEED Register Read")
  field(SCAN, "Passive")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_lim_3")
  field(TSE , "-2")
  field(LOPR, "-131072")
  field(HOPR, "131071")
  info(feed:info:setting, "$(PREF)REGLIM3_RBV")
}

#==================================
# SEL controls: 
# raw amplitude control and 
# SEL phase offset
#==================================

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)SEL_ASETDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_SEL_ASET")
  info(feed:info:input, "$(PREF)SEL_ASET")
  info(feed:info:output, "$(PREF)SEL_ASET")
}

record(ao, "$(PREF)SEL_ASET") {
  field(DESC, "SEL raw amplitude control")
  field(OMSL, "supervisory")
  field(VAL,  "0")
  field(EGU,  "%")
  field(DRVL, "0")
  field(DRVH, "100")
  field(LOPR, "0")
  field(HOPR, "100")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(calc, "$(PREF)SEL_ALIMCALC") {
  field(CALC, "A*100")
  field(INPA, "$(PREF)SSA:DRV_MAX CPP")
  field(PINI, "YES")
  field(FLNK, "$(PREF)SEL_ALIMFO")
}

record(dfanout, "$(PREF)SEL_ALIMFO") {
  field(DOL,  "$(PREF)SEL_ALIMCALC")
  field(OMSL, "closed_loop")
  field(OUTA, "$(PREF)SEL_ASET.DRVH NPP")
  field(OUTB, "$(PREF)SEL_ASET.HOPR NPP")
}

# SEL_POFFAOFF is subtracted from SEL_POFF
# Placeholder offset in case needed in future
record(calcout, "$(PREF)SEL_PAOFF") {
  field(DESC, "SEL_POFF offset")
  field(CALC, "A+B+C+D")
  field(INPA, "")
  field(INPB, "")
  field(INPC, "")
  field(INPD, "")
  field(OOPT, "Every Time")
  field(OUT, "$(PREF)SEL_PAOFFFO PP")
#  info(autosaveFields, "A B C D")
}

record(dfanout, "$(PREF)SEL_PAOFFFO") {
  field(DOL,  "$(PREF)SEL_PAOFF")
  field(OMSL, "closed_loop")
  field(OUTA, "$(PREF)SEL_POFF.AOFF NPP")
  field(OUTB, "$(PREF)SEL_POFF_RBV.AOFF NPP")
}

record(calcout, "$(PREF)SEL_PASLO") {
  field(DESC, "SEL_POFF scale")
  field(CALC, "360/2^18")
  field(OOPT, "Every Time")
  field(OUT, "$(PREF)SEL_PASLOFO PP")
  field(PINI, "YES")
}

record(dfanout, "$(PREF)SEL_PASLOFO") {
  field(DOL,  "$(PREF)SEL_PASLO")
  field(OMSL, "closed_loop")
  field(OUTA, "$(PREF)SEL_POFF.ASLO NPP")
  field(OUTB, "$(PREF)SEL_POFF_RBV.ASLO NPP")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)SEL_POFFDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_SEL_POFF")
  info(feed:info:input, "$(PREF)SEL_POFF")
  info(feed:info:output, "$(PREF)SEL_POFF")
}

record(calc, "$(PREF)SEL_POFF_INUSE") {
  field(DESC, "SEL POFF used by RF controller")
  field(CALC, "B=1?A:0")
  field(INPA, "$(PREF)SEL_POFF CP")
  field(INPB, "$(PREF)SEL_ENABLE_RBV CP MSI")
  field(PINI, "YES")
}

record(ao, "$(PREF)SEL_POFF") {
  field(DESC, "SEL phase offset")
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(VAL,  "0")
  field(EGU,  "degrees")
  field(DRVL, "-180")
  field(DRVH, "180")
  field(LOPR, "-180")
  field(HOPR, "180")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_ph_offset wait=false")
  info(feed:info:setting, "$(PREF)SEL_POFF")
  info(autosaveFields, "VAL")
# update readback when setpoint changes
  field(FLNK, "$(PREF)SEL_POFF_RBV")
}

record(ai, "$(PREF)SEL_POFF_RBV") {
  field(DESC, "SEL phase offset")
  field(DTYP, "FEED Register Read")
# Processed by SEL_POFF or fixed scan SEL_ENABLE_RBV
# Latter is for regular updates. 
# Former is for more responsive updates.
  field(SCAN, "Passive")
  field(EGU,  "degrees")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_ph_offset")
  field(TSE , "-2")
  field(LOPR, "-200")
  field(HOPR, "200")
  info(feed:info:setting, "$(PREF)SEL_POFF_RBV")
}

#==================================
# RF controller alarms/diagnostics
#==================================

record(calc, "$(PREF)CTRL_SUM") {
  field(SCAN, "1 second")
  field(CALC, "A")
  field(INPA, "$(PREF)SEL_ENABLE_RBV MS")
  field(INPB, "$(PREF)SEL_THRESH_RBV MS")
  field(INPC, "$(PREF)FB_SOURCE_RBV MS")
  field(INPD, "$(BASE)$(RFS):CLK_STATUS MS")
  field(INPE, "$(PREF)DF_ENABLE_RBV MS")
  field(INPF, "$(BASE)$(RFS):DF_FC_SRC_RBV MS")
}

record(mbbo, "$(PREF)SEL_ENABLE") {
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(VAL,  "1")
  field(ZRVL, "0")
  field(ONVL, "1")
  field(ZRST, "Disable")
  field(ONST, "Enable")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_sel_en wait=false")
  field(DISV, "2")
  field(PINI, "YES")
  info(feed:info:setting, "$(PREF)SEL_ENABLE")
}

record(mbbi, "$(PREF)SEL_ENABLE_RBV") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_sel_en")
  field(SCAN, "1 second")
  field(ZRVL, "0")
  field(ONVL, "1")
  field(ZRSV, "MAJOR")
  field(ZRST, "Not enabled")
  field(ONST, "Enabled")
  field(TSE , "-2")
  info(feed:info:setting, "$(PREF)SEL_ENABLE_RBV")
  field(FLNK, "$(PREF)SEL_POFF_RBV")
}

record(longout, "$(PREF)SEL_THRESH") {
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_sel_thresh wait=false")
  field(DISV, "2")
  info(feed:info:setting, "$(PREF)SEL_THRESH")
}

record(longin, "$(PREF)SEL_THRESH_RBV") {
  field(DTYP, "FEED Register Read")
  field(SCAN, "1 second")
  field(LOLO, "0")
  field(LLSV, "MAJOR")
  field(HIHI, "1000000")
  field(HHSV, "MAJOR")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_sel_thresh")
  field(TSE , "-2")
  info(feed:info:setting, "$(PREF)SEL_THRESH_RBV")
}

record(mbbo, "$(PREF)FB_SOURCE") {
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(VAL,  "1")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_use_fiber_iq wait=false")
  field(ZRVL, "0")
  field(ONVL, "1")
  field(ZRST, "Use loopback")
  field(ONST, "Use cavity")
  field(DISV, "2")
  field(PINI, "YES")
  info(feed:info:setting, "$(PREF)FB_SOURCE")
}

record(mbbi, "$(PREF)FB_SOURCE_RBV") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_use_fiber_iq")
  field(SCAN, "1 second")
  field(ZRVL, "0")
  field(ONVL, "1")
  field(ZRSV, "MAJOR")
  field(ZRST, "Loopback")
  field(ONST, "Cavity")
  field(TSE , "-2")
  info(feed:info:setting, "$(PREF)FB_SOURCE_RBV")
}

#==================================
# TGEN status
#==================================

record(longin, "$(PREF)REGTGEN_STAT") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=tgen_$(BIT)_status")
  field(TSE , "-2")
  field(FLNK, "$(PREF)TGEN_STAT_CALC")
  info(feed:info:setting, "$(PREF)REGTGEN_STAT")
}

record(calc, "$(PREF)TGEN_STAT_CALC") {
  field(CALC, "(A&B)=C?1:(A&B)=D?1:0")
  field(INPA, "$(PREF)REGTGEN_STAT PP MS")
  field(INPB, "0xF")
  field(INPC, "0")
  field(INPD, "0x7")
  field(FLNK, "$(PREF)TGEN_STAT")
}

# Scan more frequently than
# TGEN check sleep in rf_pulse.py
record(bi, "$(PREF)TGEN_STAT") {
  field(DESC, "TGEN status")
  field(SCAN, ".1 second")
  field(INP,  "$(PREF)TGEN_STAT_CALC PP MS")
  field(ZNAM, "Not off")
  field(ZSV,  "MINOR")
  field(ONAM, "Off")
}

#==================================
# Feedback gains
# Until we have calibrated units:
# values should always be negative,
# set DRVL/DRVH appropriately
#==================================

record(longout, "$(PREF)AMPFB_GAIN_I") {
  field(DESC, "Amp fbck integral gain (Ki)")
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(DRVL, "-131072")
  field(DRVH, "0")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_coeff_0 wait=false")
  info(feed:info:setting, "$(PREF)AMPFB_GAIN_I")
  info(autosaveFields, "VAL")
}

record(longin, "$(PREF)AMPFB_GAIN_I_RBV") {
  field(DESC, "Amp fbck integral gain (Ki)")
  field(DTYP, "FEED Register Read")
  field(SCAN, "1 second")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_coeff_0")
  field(TSE , "-2")
  info(feed:info:setting, "$(PREF)AMPFB_GAIN_I_RBV")
}

record(longout, "$(PREF)AMPFB_GAIN_P") {
  field(DESC, "Amp fbck proportional gain (Kp)")
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(DRVL, "-131072")
  field(DRVH, "0")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_coeff_2 wait=false")
  info(feed:info:setting, "$(PREF)AMPFB_GAIN_P")
  info(autosaveFields, "VAL")
}

record(longin, "$(PREF)AMPFB_GAIN_P_RBV") {
  field(DESC, "Amp fbck proportional gain (Kp)")
  field(DTYP, "FEED Register Read")
  field(SCAN, "1 second")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_coeff_2")
  field(TSE , "-2")
  info(feed:info:setting, "$(PREF)AMPFB_GAIN_P_RBV")
}

record(longout, "$(PREF)PHAFB_GAIN_I") {
  field(DESC, "Pha fbck integral gain (Ki)")
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(DRVL, "-131072")
  field(DRVH, "0")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_coeff_1 wait=false")
  info(feed:info:setting, "$(PREF)PHAFB_GAIN_I")
  info(autosaveFields, "VAL")
}

record(longin, "$(PREF)PHAFB_GAIN_I_RBV") {
  field(DESC, "Pha fbck integral gain (Ki)")
  field(DTYP, "FEED Register Read")
  field(SCAN, "1 second")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_coeff_1")
#  field(EGU,  "1/s")
  field(TSE , "-2")
  info(feed:info:setting, "$(PREF)PHAFB_GAIN_I_RBV")
}

record(longout, "$(PREF)PHAFB_GAIN_P") {
  field(DESC, "Pha fbck proportional gain (Kp)")
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(DRVL, "-131072")
  field(DRVH, "0")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_coeff_3 wait=false")
  info(feed:info:setting, "$(PREF)PHAFB_KP")
  info(autosaveFields, "VAL")
}

record(longin, "$(PREF)PHAFB_GAIN_P_RBV") {
  field(DESC, "Pha fbck proportional gain (Kp)")
  field(DTYP, "FEED Register Read")
  field(SCAN, "1 second")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_fdbk_core_mp_proc_coeff_3")
  field(TSE , "-2")
  info(feed:info:setting, "$(PREF)PHAFB_GAIN_P_RBV")
}

record(ao, "$(PREF)PLANT_GAIN") {
  field(DESC, "RF controller plant gain")
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(VAL,  "0")
  field(PREC, "4")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)PLANT_GAINDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_PLANT_GAIN")
  info(feed:info:input, "$(PREF)PLANT_GAIN")
  info(feed:info:output, "$(PREF)PLANT_GAIN")
}

#==================================
# From Larry Doolittle, 29 Jul 2019
# The EPICS timeout feature is managed by a single write-only
# 16-bit register, "epics_wdog_timeout".  Writing N to that register
# will keep the system from watchdogging for between (N-1)/24 seconds
# and N/24 seconds.  That is, it sets a counter that is decremented
# with a 24 Hz pulse (actually 23.842 Hz), and when the counter hits
# zero, bam!  No more RF.
# Longest achievable timeout is therefore 2^16 ticks or 45.8 minutes.
#==================================

record(ao, "$(PREF)IOCWDOG_TIME") {
  field(DESC, "EPICS watchdog")
  field(SCAN, "Passive")
  field(DTYP, "FEED Register Write")
  field(EGU,  "s")
  field(ASLO, ".0416667")
  field(PREC, "1")
  field(OMSL, "supervisory")
  field(VAL,  "10")
  field(DRVL, "0")
  field(DRVH, "2730")
  field(OUT , "@name=$(NAME) reg=epics_wdog_$(BIT)_timeout")
  field(PINI, "YES")
  info(feed:info:setting, "$(PREF)IOCWDOG_TIME")
  info(autosaveFields, "VAL")
}

record(ai, "$(PREF)IOCWDOG_TIME_RBV") {
  field(DESC, "EPICS watchdog")
  field(SCAN, "10 second")
  field(DTYP, "FEED Register Read")
  field(EGU,  "s")
  field(ASLO, ".0416667")
  field(PREC, "1")
  field(VAL,  "10")
  field(INP , "@name=$(NAME) reg=epics_wdog_$(BIT)_timeout")
  info(feed:info:setting, "$(PREF)IOCWDOG_TIME_RBV")
  info(autosaveFields, "SCAN")
}

#==================================
# Interlock status on RFS side
# TODO: Add MS
#==================================

record(calc, "$(PREF)RFPERMIT_CALC") {
  field(DESC, "Final RF permit status on RFS")
  field(SCAN, "1 second")
  field(CALC, "A=0?1:0")
  field(INPA, "$(PREF)RFS:INTLK_LTCH")
  field(FLNK, "$(PREF)RFPERMIT")
}

record(bi, "$(PREF)RFPERMIT") {
  field(DESC, "Final RF permit status on RFS")
  field(INP,  "$(PREF)RFPERMIT_CALC")
  field(ZNAM, "RF inhibit")
  field(ZSV,  "MAJOR")
  field(ONAM, "RF allow")
}

record(calc, "$(PREF)SSA:RFPERMIT_CALC") {
  field(CALC, "A&(~15|(1<<B))>>B?0:1")
  field(INPA, "$(BASE)$(RFS):J18_RBV CP")
  field(INPB, "$(BIT)")
  field(FLNK, "$(PREF)SSA:RFPERMIT")
}

record(bi, "$(PREF)SSA:RFPERMIT") {
  field(DESC, "SSA permit status read by RFS")
  field(INP,  "$(PREF)SSA:RFPERMIT_CALC")
  field(ZNAM, "Fault")
  field(ZSV,  "MAJOR")
  field(ONAM, "Ok")
}

#==================================
# Break out diagnostic status bits
#==================================

record(calc, "$(PREF)OFLW_ERR_STAT") {
  field(DESC, "Calc pha/mag error mask")
  field(CALC, "A&B")
  field(INPA, "$(PREF)OFLW_STAT CPP MSI")
  field(INPB, "0xFF")
  field(PINI, "YES")
}

record(calc, "$(PREF)OFLW_DRV_CALC") {
  field(DESC, "Calc drive clip mask")
  field(CALC, "A&B>>C")
  field(INPA, "$(PREF)OFLW_STAT CPP MSI")
  field(INPB, "0xF00")
  field(INPC, "8")
# INPD just to force processing chain
  field(INPD, "$(PREF)RFMODECTRL CPP")
  field(PINI, "YES")
  field(FLNK, "$(PREF)OFLW_DRV_STAT")
}

record(mbbiDirect, "$(PREF)OFLW_DRV_STAT") {
  field(INP, "$(PREF)OFLW_DRV_CALC MSI")
  field(FLNK, "$(PREF)AMPFB_HLIM")
}

record(bi, "$(PREF)AMPFB_HLIM") {
  field(DESC, "Ampl fbck low lim state")
  field(INP,  "$(PREF)OFLW_DRV_STAT.B0")
  field(ZNAM, "Not clipped")
  field(ONAM, "Clipped")
  field(FLNK, "$(PREF)AMPFB_LLIM")
}

record(bi, "$(PREF)AMPFB_LLIM") {
  field(DESC, "Ampl fbck low lim state")
  field(INP,  "$(PREF)OFLW_DRV_STAT.B2")
  field(ZNAM, "Not clipped")
  field(ONAM, "Clipped")
  field(FLNK, "$(PREF)AMPFB_LSUM")
}

record(calc, "$(PREF)AMPFB_LSUM") {
  field(DESC, "Ampl fbck low lim status")
  field(CALC, "((A>0)&&((B=0)||(B=1)))?0:1")
  field(INPA, "$(PREF)AMPFB_LLIM MS")
  field(INPB, "$(PREF)RFMODECTRL")
  field(LOLO, "0")
  field(LLSV, "MAJOR")
  field(HIHI, "2")
  field(FLNK, "$(PREF)AMPFB_HSUM")
}

record(calc, "$(PREF)AMPFB_HSUM") {
  field(DESC, "Ampl fbck high lim status")
  field(CALC, "((A>0)&&((B=0)||(B=1)))?0:1")
  field(INPA, "$(PREF)AMPFB_HLIM MS")
  field(INPB, "$(PREF)RFMODECTRL")
  field(LOLO, "0")
  field(LLSV, "MAJOR")
  field(HIHI, "2")
  field(FLNK, "$(PREF)AMPFB_SUM")
}

record(calc, "$(PREF)AMPFB_SUM") {
  field(DESC, "Ampl fbck summary status")
  field(CALC, "A+B=2?1:0")
  field(INPA, "$(PREF)AMPFB_HSUM MS")
  field(INPB, "$(PREF)AMPFB_LSUM MS")
  field(LOLO, "0")
  field(LLSV, "MAJOR")
  field(HIHI, "2")
  field(FLNK, "$(PREF)PHAFB_HLIM")
}

record(bi, "$(PREF)PHAFB_HLIM") {
  field(DESC, "Phase fbck high lim state")
  field(INP,  "$(PREF)OFLW_DRV_STAT.B1")
  field(ZNAM, "Not clipped")
  field(ONAM, "Clipped")
  field(FLNK, "$(PREF)PHAFB_LLIM")
}

record(bi, "$(PREF)PHAFB_LLIM") {
  field(DESC, "Phase fbck low lim state")
  field(INP,  "$(PREF)OFLW_DRV_STAT.B3")
  field(ZNAM, "Not clipped")
  field(ONAM, "Clipped")
  field(FLNK, "$(PREF)PHAFB_LSUM")
}

record(calc, "$(PREF)PHAFB_LSUM") {
  field(DESC, "Phase fbck low lim status")
  field(CALC, "((A>0)&&(B=0))?0:1")
  field(INPA, "$(PREF)PHAFB_LLIM MS")
  field(INPB, "$(PREF)RFMODECTRL")
  field(LOLO, "0")
  field(LLSV, "MAJOR")
  field(HIHI, "2")
  field(FLNK, "$(PREF)PHAFB_HSUM")
}

record(calc, "$(PREF)PHAFB_HSUM") {
  field(DESC, "Phase fbck high lim status")
  field(CALC, "((A>0)&&(B=0))?0:1")
  field(INPA, "$(PREF)PHAFB_HLIM MS")
  field(INPB, "$(PREF)RFMODECTRL")
  field(LOLO, "0")
  field(LLSV, "MAJOR")
  field(HIHI, "2")
  field(FLNK, "$(PREF)PHAFB_SUM")
}

record(calc, "$(PREF)PHAFB_SUM") {
  field(DESC, "Phase fbck summary status")
  field(CALC, "A+B=2?1:0")
  field(INPA, "$(PREF)PHAFB_HSUM MS")
  field(INPB, "$(PREF)PHAFB_LSUM MS")
  field(LOLO, "0")
  field(LLSV, "MAJOR")
  field(HIHI, "2")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)RACK_OTHERS_OFFDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_RACK_OTHERS_OFF")
  info(feed:info:input, "$(PREF)RACK_OTHERS_OFF")
  info(feed:info:output, "$(PREF)RACK_OTHERS_OFF")
}

#==================================
# Gradient calculated from forward power
# Only valid in SEL
#==================================

record(calc, "$(PREF)GCALC2_") {
  field(DESC, "G calc from fwd power")
  field(CALC, "((A+1)*B)/(4*A*C*D)")
  field(INPA, "400") # beta
  field(INPB, "$(PREF)L")
  field(INPC, "$(PREF)QLOADED")
  field(INPD, "1040") # R/Q
}

record(calc, "$(PREF)GCALC1") {
  field(DESC, "G calc from fwd power")
  field(CALC, "SQR(A/B)/1000000")
  field(INPA, "$(PREF)FWD:PWRMEAN CP MSI")
  field(INPB, "$(PREF)GCALC2_ PP")
  field(LOPR, "0")
  field(HOPR, "22")
  field(FLNK, "$(PREF)GCALC_")
}

record(calc, "$(PREF)GCALC_") {
  field(DESC, "G calc from fwd power")
  field(CALC, "B=0?0.0:B=4?0.0:A")
  field(INPA, "$(PREF)GCALC1")
  field(INPB, "$(PREF)RFMODE")
  field(LOLO, "0")
  field(LLSV, "INVALID")
  field(HIHI, "100")
  field(FLNK, "$(PREF)GCALC")
}

record(ai, "$(PREF)GCALC") {
  field(DESC, "G calc from fwd power")
  field(SCAN, "Passive")
  field(EGU,  "MV/m")
  field(PREC, "3")
  field(INP,  "$(PREF)GCALC_ MS")
  field(LOPR, "0")
  field(HOPR, "22")
}


#==================================
# Cavity probe is special case, calibration-wise
# We have 2 methods of calibration:
# A: using losses, ADC full scale, probe Q
# B: using reverse decay waveform
# Users select which should be active
#==================================

record(bo, "$(PREF)CAVSCALE_SEL") {
  field(DESC, "Active calibration")
  field(OMSL, "supervisory")
  field(ZNAM, "QProbe")
  field(ONAM, "RevCal")
  field(VAL,  "1")
  info(autosaveFields, "VAL")
}

# Calculate Qprobe from measured scale factor
# (rev waveform), losses etc
record(calcout, "$(PREF)QPROBE_CALC1") {
  field(CALC, "(1E6*A/B)^2/C")
  field(INPA, "$(PREF)CAV:SCALER_SEL.B")
  field(INPB, "$(PREF)CAV:CAL_SCALE_SQRTW")
  field(INPC, "$(PREF)IMPED")
# scale by beam-based fudge as well?
# $(PREF)CAV:FUDGE_SEL.B
  field(OOPT, "Every Time")
  field(PINI, "NO")
  field(OUT, "$(PREF)QPROBE_CALC2 PP")
}

record(ao, "$(PREF)QPROBE_CALC2") {
  field(DESC, "Calculated Q probe")
  field(OMSL, "supervisory")
  field(PREC, "5")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(ao, "$(PREF)PUSH_QPROBECALC") {
  field(DESC, "Push calc-ed to live PV")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)QPROBE_CALC2")
  field(OUT,  "$(PREF)QPROBE PP")
}

# Dummy PV to allow python API to access actual PV
record(longin, "$(PREF)CAV_SCALE_SQRTWDMY") {
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_CAV_SCALE_SQRTW")
  info(feed:info:input, "$(PREF)CAV:CAL_SCALE_SQRTW")
}

#==================================
# Dummy scale factor to support
# feed_wf_acquire_signal_fault.template
# Value is always 1
#==================================

record(ao, "$(PREF)FLTSCALE_") {
  field(DESC, "Unused scale")
  field(OMSL, "closed_loop")
  field(DOL, "1.0")
  field(PINI, "YES")
}

#==================================
# Support for P/I controller diagnostic
# waveform graphic
#==================================

alias("$(PREF)FLTSCALE_", "$(PREF)CTRL:ISCALE")
alias("$(PREF)FLTSCALE_", "$(PREF)CTRL:QSCALE")
alias("$(PREF)FLTSCALE_", "$(PREF)CTRL:ASCALE")
alias("$(PREF)FLTSCALE_", "$(PREF)CTRL:PSCALE")

record(ai, "$(PREF)CTRL:SCALE") {
  field(DESC, "Gain adjustment")
  field(VAL, "1.0")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(aSub, "$(PREF)CTRL:CALC") {
  field(SNAM, "Controller Output")
  field(INPA, "$(PREF)SEL_POFF_INUSE")
# Process when DAC waveform updates
# DAC updates after CAV, so should have
# synchronous data
  field(INPB, "$(PREF)DAC:IWF MSI CP")
  field(INPC, "$(PREF)DAC:QWF MSI NPP")
  field(INPD, "$(PREF)CAV:PWF MSI NPP")
  field(INPE, "$(PREF)CTRL:SCALE")
  field(NOA , "1")
  field(NOB , "16384")
  field(NOC , "16384")
  field(NOD , "16384")
  field(NOE , "1")
  field(NOVA, "16384") # PI control output I
  field(NOVB, "16384") # PI control output Q
  field(NOVC, "16384") # PI control output phase
  field(NOVD, "16384") # PI control output amplitude
  field(NOVE, "16384") # unrotated DAC phase
  field(NOVF, "16384") # rotations
  field(OUTA, "$(PREF)CTRL:IWF MSI PP")
  field(OUTB, "$(PREF)CTRL:QWF MSI PP")
  field(OUTC, "$(PREF)CTRL:PWF MSI PP")
  field(OUTD, "$(PREF)CTRL:AWF MSI PP")
  field(TSEL, "$(PREF)DAC:IWF.TIME")
}

record(aai, "$(PREF)CTRL:IWF") {
  field(DESC, "PI controller output")
  field(FTVL, "DOUBLE")
  field(NELM, "16384")
  field(TSEL, "$(PREF)DAC:IWF.TIME")
}

record(aai, "$(PREF)CTRL:QWF") {
  field(DESC, "PI controller output")
  field(FTVL, "DOUBLE")
  field(NELM, "16384")
  field(TSEL, "$(PREF)DAC:IWF.TIME")
}

record(aai, "$(PREF)CTRL:PWF") {
  field(DESC, "PI controller output")
  field(FTVL, "DOUBLE")
  field(NELM, "16384")
  field(TSEL, "$(PREF)DAC:IWF.TIME")
}

record(aai, "$(PREF)CTRL:AWF") {
  field(DESC, "PI controller output")
  field(FTVL, "DOUBLE")
  field(NELM, "16384")
  field(TSEL, "$(PREF)DAC:IWF.TIME")
  field(FLNK, "$(CTRLFLNK=)")
}

record(aSub, "$(PREF)CTRL:LIMS") {
  field(SNAM, "Controller Limits")
# lim amplitude (x) low
  field(INPA, "$(PREF)REGLIM2_RBV CP MSI")
# lim amplitude (x) high
  field(INPB, "$(PREF)REGLIM0_RBV CP MSI")
# lim phase (y) low
  field(INPC, "$(PREF)REGLIM3_RBV CP MSI")
# lim phase (y) high
  field(INPD, "$(PREF)REGLIM1_RBV CP MSI")
  field(INPE, "$(PREF)DAC:TWF MSI CP")
  field(NOA , "1")
  field(NOB , "1")
  field(NOC , "1")
  field(NOD , "1")
  field(NOE , "16384")
  field(FTA,  "LONG")
  field(FTB,  "LONG")
  field(FTC,  "LONG")
  field(FTD,  "LONG")
  field(FTE,  "DOUBLE")
# Normalized limits
  field(NOVA, "5") # i lims array for graphic
  field(NOVB, "5") # q lims array for graphic
  field(NOVC, "1") # i low lim
  field(NOVD, "1") # i high lim
  field(NOVE, "1") # q low lim
  field(NOVF, "1") # q high lim
  field(NOVG, "16384") # i low lim horizontal line graphic
  field(NOVH, "16384") # i high lim horizontal line graphic
  field(NOVI, "16384") # q low lim horizontal line graphic
  field(NOVJ, "16384") # q high lim horizontal line graphic
  field(FTVA, "DOUBLE")
  field(FTVB, "DOUBLE")
  field(FTVC, "DOUBLE")
  field(FTVD, "DOUBLE")
  field(FTVE, "DOUBLE")
  field(FTVF, "DOUBLE")
  field(FTVG, "DOUBLE")
  field(FTVH, "DOUBLE")
  field(FTVI, "DOUBLE")
  field(FTVJ, "DOUBLE")
}

#==================================
# Test tone and DAC mode control
#==================================

# Only modes 1, 2 are standard operating modes
# 0 - off/disabled
# 1 - primary controller (nominal)
# 2 - test source
# 3 - reserved 
record(mbbo, "$(PREF)TONE") {
  field(DESC, "Test tone output")
  field(DTYP, "Raw Soft Channel")
  field(OMSL, "supervisory")
  field(ZRST, "Off")
  field(ZRVL, "1")
  field(ONST, "On")
  field(ONVL, "2")
  field(VAL,  "0")
  field(OUT,  "$(PREF)REG_DACMODE PP")
  info(autosaveFields, "VAL")
}

record(longin, "$(PREF)TONEDMY") {  
field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=mbox_$(BIT)_TONE")
  info(feed:info:input, "$(PREF)TONE") 
  info(feed:info:output, "$(PREF)TONE")
}

record(longout, "$(PREF)REG_DACMODE") {
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(OUT , "@name=$(NAME) reg=dac_$(BIT)_sel")
  info(feed:info:setting, "$(PREF)REG_DACMODE")
}

record(mbbi, "$(PREF)DACMODE_RBV") {
  field(DESC, "DAC output control")
  field(SCAN, "1 second")
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=dac_$(BIT)_sel")
  field(ZRST, "Channel disabled")
  field(ZRVL, "0")
  field(ZRSV, "MAJOR")
  field(ONST, "Tone off")
  field(ONVL, "1")
  field(TWST, "Tone on")
  field(TWVL, "2")
  field(TWSV, "MINOR")
  field(THST, "Channel disabled")
  field(THVL, "3")
  field(THSV, "MAJOR")
  info(feed:info:setting, "$(PREF)DACMODE_RBV")
}

#==================================
# Calculate detune frequency
# and cavity bandwidth waveforms
# from cavity and forward
#==================================

alias("$(PREF)FLTSCALE_", "$(PREF)DF:SCALE")
alias("$(PREF)FLTSCALE_", "$(PREF)BW:SCALE")

# Quick and preliminary wf-calculated detune validity
# Need to add QA to subroutine and to 
# set wf stats status/severity
record(calc, "$(PREF)DF:WFVALID") {
  field(DESC, "Determine if DF valid")
  field(CALC, "(A=1)&(B<4)?1:0")
  field(INPA, "$(PREF)RFSTATE CP")
  field(INPB, "$(PREF)RFMODE CP")
  field(LOLO, "0")
  field(LLSV, "INVALID")
}

record(aSub, "$(PREF)DF:CALC") {
  field(SNAM, "Calculate Detune")
# CAV Q updates last in the set, so
# should have synchronous data
  field(INPA, "$(PREF)CAV:IWF MSI NPP")
  field(INPB, "$(PREF)CAV:QWF MSI CP")
  field(INPC, "$(PREF)FWD:IWF MSI NPP")
  field(INPD, "$(PREF)FWD:QWF MSI NPP")
  field(INPE, "$(PREF)BCOEFM NPP")
  field(INPF, "$(PREF)BCOEFP NPP")
  field(INPG, "$(PREF)CAV:SCALE NPP")
  field(INPH, "$(PREF)FWD:SCALE NPP")
  field(INPI, "$(PREF)ACQ_SAMP_PERIOD NPP")
  field(NOA , "16384")
  field(NOB , "16384")
  field(NOC , "16384")
  field(NOD , "16384")
  field(NOE , "1")
  field(NOF , "1")
  field(NOG , "1")
  field(NOH , "1")
  field(NOI , "1")
  field(NOVA, "16384") # Detune frequency
  field(NOVB, "16384") # Cavity bandwidth
  field(NOVC, "16384") # dvdt I
  field(NOVD, "16384") # dvdt Q
  field(OUTA, "$(PREF)DF:WF PP")
  field(OUTB, "$(PREF)BW:WF PP")
  field(TSEL, "$(PREF)CAV:QWF.TIME")
  field(FLNK, "$(DFFLNK=)")
}

record(aai, "$(PREF)DF:WF") {
  field(DESC, "Detune from cav/fwd wfs")
  field(FTVL, "DOUBLE")
  field(NELM, "16384")
# FLNK to wf stats here
# All other WFs fed from normal RFS WF
# support and wf stats processing chain
# defined in rfs_logic database
  field(FLNK, "$(PREF)DF:STAT_CALC_")
}
record(aai, "$(PREF)BW:WF") {
  field(DESC, "Cavity bandwidth")
  field(FTVL, "DOUBLE")
  field(NELM, "16384")
}
# Use CAV timebase waveform for detune displays
# Must dbLoad these aliases after WF databases
alias("$(PREF)CH6:TWF", "$(PREF)DF:TWF")
alias("$(PREF)CH6:TWF", "$(PREF)BW:TWF")

#==================================
# Constants used in firmware:
# piezo coefficients
# quench detect algorithm
#==================================

record(aao, "$(PREF)CONST_PZT") {
    field(DTYP, "FEED Register Write")
    field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_piezo_sf_consts")
    field(FTVL, "LONG")
    field(NELM, "4")
    field(PINI, "YES")
    field(FLNK, "$(PREF)DF_ASLO_FO")
    info(autosaveFields, "VAL")
    info(feed:info:output, "$(PREF)CONST_PZT")
}
# Push detune scaling to affected software
# at the same time as updating firmware (CONST_PZT)
# for consistent data
record(ao, "$(PREF)DF_ASLO_FO") {
  field(DESC, "Propagate detune quantum")
  field(OMSL, "closed_loop")
  field(DOL,  "$(PREF)DF.ASLO")
}

record(aai, "$(PREF)CONST_PZT_RBV") {
    field(DTYP, "FEED Register Read")
    field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_piezo_sf_consts")
    field(FTVL, "LONG")
    field(NELM, "4")
    field(SCAN, "10 second")
    field(TSE , "-2")
    field(FLNK, "$(PREF)CONST_QUENCH_RBV")
    info(feed:info:input, "$(PREF)CONST_PZT_RBV")
}

# array is [rev_mul, fwd_mul, cav_mul, treshold]
# trip occurs when:
# fwd_mul * fwd_data**2 - rev_mul * rev_data**2 - cav_mul * d cav^2 / dt > threshold
record(aao, "$(PREF)CONST_QUENCH") {
  field(DESC, "Quench detection constants")
    field(DTYP, "FEED Register Write")
    field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_quench_sf_consts")
    field(FTVL, "LONG")
    field(NELM, "4")
    field(PINI, "YES")
    field(FLNK, "$(PREF)CONST_QUENCH_RBV")
    info(autosaveFields, "VAL")
    info(feed:info:output, "$(PREF)CONST_QUENCH")
}

record(aai, "$(PREF)CONST_QUENCH_RBV") {
  field(DESC, "Quench detection constants")
    field(DTYP, "FEED Register Read")
    field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_quench_sf_consts")
    field(FTVL, "LONG")
    field(NELM, "4")
    field(TSE , "-2")
    field(FLNK, "$(PREF)CONST_QUENCH_REV_RBV")
    info(feed:info:input, "$(PREF)CONST_QUENCH_RBV")
}

record(subArray, "$(PREF)CONST_QUENCH_REV_RBV") {
  field(DESC, "Quench detection constants")
  field(PINI, "YES")
  field(FTVL, "LONG")
  field(INP,  "$(PREF)CONST_QUENCH_RBV CP MSI")
  field(MALM, "4")
  field(NELM, "1")
  field(INDX, "0")
  field(FLNK, "$(PREF)CONST_QUENCH_FWD_RBV")
}

record(subArray, "$(PREF)CONST_QUENCH_FWD_RBV") {
  field(DESC, "Quench detection constants")
  field(PINI, "YES")
  field(FTVL, "LONG")
  field(INP,  "$(PREF)CONST_QUENCH_RBV MSI")
  field(MALM, "4")
  field(NELM, "1")
  field(INDX, "1")
  field(FLNK, "$(PREF)CONST_QUENCH_CAV_RBV")
}

record(subArray, "$(PREF)CONST_QUENCH_CAV_RBV") {
  field(DESC, "Quench detection constants")
  field(PINI, "YES")
  field(FTVL, "LONG")
  field(INP,  "$(PREF)CONST_QUENCH_RBV MSI")
  field(MALM, "4")
  field(NELM, "1")
  field(INDX, "2")
  field(FLNK, "$(PREF)CONST_QUENCH_THRESH_RBV")
}

record(subArray, "$(PREF)CONST_QUENCH_THRESH_RBV") {
  field(DESC, "Quench detection constants")
  field(PINI, "YES")
  field(FTVL, "LONG")
  field(INP,  "$(PREF)CONST_QUENCH_RBV MSI")
  field(MALM, "4")
  field(NELM, "1")
  field(INDX, "3")
}

record(ai, "$(PREF)CONST_QUENCH_FSW") {
  field(DESC, "Full scale power used in coef calc")
  field(VAL, "0")
  field(EGU, "W")
  field(PINI, "YES")
  field(FLNK, "$(PREF)CONST_QUENCH_CALC")
  info(autosaveFields, "VAL")
}

record(ai, "$(PREF)QUENCH_THRESH") {
  field(DESC, "Quench trip threshold")
  field(VAL, "800")
  field(EGU, "W")
  field(PINI, "YES")
  field(FLNK, "$(PREF)CONST_QUENCH_CALC")
  info(autosaveFields, "VAL")
}

record(aSub, "$(PREF)CONST_QUENCH_CALC") {
  field(SNAM, "asub_quench_coef")
  field(INPA, "$(PREF)CAV:SCALE CP MSI")
  field(INPB, "$(PREF)FWD:SCALE CP MSI")
  field(INPC, "$(PREF)REV:SCALE CP MSI")
  field(INPD, "$(PREF)CONST_QUENCH_FSW MSI")
  field(INPE, "$(PREF)FREQ MSI")
# When frequency changes, IMPED is processed after FREQ	
  field(INPF, "$(PREF)IMPED CP MSI")
  field(INPG, "$(PREF)QUENCH_THRESH MSI")
  field(NOVA, "4")
  field(OUTA, "$(PREF)CONST_QUENCH PP")
  field(FTVB, "SHORT")  # override input full-scale value
  field(FTVC, "DOUBLE") # full-scale value used
}

#==================================
# Chirp method of detune frequency
# measurement
#==================================

#chirp_0_count - Debug output relaying how many chirps have been generated
#shell_0_dsp_chirp_acq_per - Periodicity of chirp generation w.r.t waveforms
#read out by the host
#shell_0_dsp_chirp_amp_max - Max amplitude of the chirp envelope. Shouldn't
#exceed 666636658
#shell_0_dsp_chirp_amp_slope - Slope of amplitude ramp up -
#(amp_max/ramp_time)
#shell_0_dsp_chirp_ddphase - 'Chirpyness', or how quickly the frequency
#sweep takes place
#shell_0_dsp_chirp_dphase - Initial frequency
#shell_0_dsp_chirp_en - Enables chirp mode
#shell_0_dsp_chirp_len - Total duration of chirp/sweep (sweep time / dt)

record(ai, "$(PREF)CHIRP:CNT") {
  field(DTYP, "FEED Register Read")
  field(SCAN, "10 second")
  field(INP , "@name=$(NAME) reg=chirp_$(BIT)_count")
  field(TSE , "-2")
  info(feed:info:setting, "$(PREF)CHIRP:CNT")
}

record(ao, "$(PREF)CHIRP:ACQ_PER_WF") {
  field(DTYP, "FEED Register Write")
  field(DOL,  "1")
  field(OMSL, "closed_loop")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_chirp_acq_per wait=false")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
  info(feed:info:setting, "$(PREF)CHIRP:ACQ_PER_WF")
}

record(ai, "$(PREF)CHIRP:ACQ_PER_WF_RBV") {
  field(DTYP, "FEED Register Read")
  field(SCAN, "10 second")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_chirp_acq_per")
  field(TSE , "-2")
  info(feed:info:setting, "$(PREF)CHIRP:ACQ_PER_WF_RBV")
}

record(ao, "$(PREF)CHIRP:AMP_MAX") {
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_chirp_amp_max wait=false")
  field(DRVH, "666636658")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
  info(feed:info:setting, "$(PREF)CHIRP:AMP_MAX")
}

record(ai, "$(PREF)CHIRP:AMP_MAX_RBV") {
  field(DTYP, "FEED Register Read")
  field(SCAN, "10 second")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_chirp_amp_max")
  field(TSE , "-2")
  info(feed:info:setting, "$(PREF)CHIRP:AMP_MAX_RBV")
}

record(ao, "$(PREF)CHIRP:AMP_SLOPE") {
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_chirp_amp_slope wait=false")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
  info(feed:info:setting, "$(PREF)CHIRP:AMP_SLOPE")
}

record(ai, "$(PREF)CHIRP:AMP_SLOPE_RBV") {
  field(DTYP, "FEED Register Read")
  field(SCAN, "10 second")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_chirp_amp_slope")
  field(TSE , "-2")
  info(feed:info:setting, "$(PREF)CHIRP:AMP_SLOPE_RBV")
}

record(ao, "$(PREF)CHIRP:FREQ_SLOPE") {
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_chirp_ddphase wait=false")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
  info(feed:info:setting, "$(PREF)CHIRP:FREQ_SLOPE")
}

record(ai, "$(PREF)CHIRP:FREQ_SLOPE_RBV") {
  field(DTYP, "FEED Register Read")
  field(SCAN, "10 second")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_chirp_ddphase")
  field(TSE , "-2")
  info(feed:info:setting, "$(PREF)CHIRP:FREQ_SLOPE_RBV")
}

record(ao, "$(PREF)CHIRP:FREQ_INIT") {
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_chirp_dphase wait=false")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
  info(feed:info:setting, "$(PREF)CHIRP:FREQ_INIT")
}

record(ai, "$(PREF)CHIRP:FREQ_INIT_RBV") {
  field(DTYP, "FEED Register Read")
  field(SCAN, "10 second")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_chirp_dphase")
  field(TSE , "-2")
  info(feed:info:setting, "$(PREF)CHIRP:FREQ_INIT_RBV")
}

record(ao, "$(PREF)CHIRP:TIME") {
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_chirp_len wait=false")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
  info(feed:info:setting, "$(PREF)CHIRP:TIME")
}

record(ai, "$(PREF)CHIRP:TIME_RBV") {
  field(DTYP, "FEED Register Read")
  field(SCAN, "10 second")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_chirp_len")
  field(TSE , "-2")
  info(feed:info:setting, "$(PREF)CHIRP:TIME_RBV")
}

record(mbbo, "$(PREF)CHIRP:ENABLE") {
  field(DESC, "Enable chirp mode")
  field(DTYP, "FEED Register Write")
  field(OMSL, "supervisory")
  field(VAL,  "0")
  field(ZRVL, "0")
  field(ONVL, "1")
  field(ZRST, "Disable")
  field(ONST, "Enable")
  field(ONSV, "MINOR")
  field(OUT , "@name=$(NAME) reg=shell_$(BIT)_dsp_chirp_en wait=false")
  field(DISV, "2")
  info(feed:info:setting, "$(PREF)CHIRP:ENABLE")
}

# Processed by RFSTATECALC
record(mbbi, "$(PREF)CHIRP:ENABLE_RBV") {
  field(DESC, "Enable chirp mode")
  field(DTYP, "FEED Register Read")
  field(INP , "@name=$(NAME) reg=shell_$(BIT)_dsp_chirp_en")
  field(ZRVL, "0")
  field(ONVL, "1")
  field(ONSV, "MINOR")
  field(ZRST, "Not enabled")
  field(ONST, "Enabled")
  field(TSE , "-2")
  info(feed:info:setting, "$(PREF)CHIRP:ENABLE_RBV")
}

record(ai, "$(PREF)CHIRP:CAVTHRESH") {
  field(DESC, "Cavity ampl to measure df")
  field(VAL,  "0.01")
  field(EGU,  "MV")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(ai, "$(PREF)CHIRP:FWDTHRESH") {
  field(DESC, "Fwd pwr to measure df")
  field(VAL,  "2.0")
  field(EGU,  "W")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(aSub, "$(PREF)CHIRP:DF_CALC") {
  field(SNAM, "Calculate Detune Chirp")
# If subroutine returns -1, set to INVALID
# Downstream records inherit this severity 
  field(BRSV, "INVALID")
# CAV Q updates last in the set, so
# should have synchronous data
  field(INPA, "$(PREF)CAV:IWF MSI NPP")
  field(INPB, "$(PREF)CAV:QWF MSI CP")
  field(INPC, "$(PREF)FWD:IWF MSI NPP")
  field(INPD, "$(PREF)FWD:QWF MSI NPP")
  field(INPE, "$(PREF)CHIRP:ENABLE_RBV NPP")
  field(INPF, "$(PREF)ACQ_SAMP_PERIOD NPP")
  field(INPG, "$(PREF)PULSE_STATUS NPP")
  field(INPH, "$(PREF)CHIRP:CAVTHRESH NPP")
  field(INPI, "$(PREF)CHIRP:FWDTHRESH NPP")
  field(INPJ, "$(PREF)CAV:AMAX NPP")
  field(INPK, "$(PREF)FWD:PWRMAX NPP")
  field(FTE,  "SHORT")
  field(FTG,  "SHORT")
  field(NOA , "16384")
  field(NOB , "16384")
  field(NOC , "16384")
  field(NOD , "16384")
  field(NOE , "1")
  field(NOF , "1")
  field(NOG , "1")
  field(NOH , "1")
  field(NOI , "1")
  field(NOVA, "1") # Detune frequency [Hz]
  field(NOVB, "1") # Cavity bandwidth [Hz]
  field(NOVC, "16384") # dvdt I
  field(NOVD, "16384") # dvdt Q
  field(NOVE, "1") # Fit RMS [MV/s]
  field(NOVF, "1") # Detune frequency and bandwidth RMS [Hz]
  field(FLNK, "$(PREF)CHIRP:DF")
  field(TSEL, "$(PREF)CAV:QWF.TIME")
}

record(ai, "$(PREF)CHIRP:DF") {
  field(EGU,  "Hz")
  field(INP, "$(PREF)CHIRP:DF_CALC.VALA MSI")
  field(LOPR, "-100")
  field(HOPR, "100")
  field(FLNK, "$(PREF)CHIRP:BW")
  field(TSEL, "$(PREF)CAV:QWF.TIME")
}

record(ai, "$(PREF)CHIRP:BW") {
  field(EGU,  "Hz")
  field(INP, "$(PREF)CHIRP:DF_CALC.VALB MSI")
  field(FLNK, "$(PREF)CHIRP:FITRMS")
  field(TSEL, "$(PREF)CAV:QWF.TIME")
}

record(ai, "$(PREF)CHIRP:FITRMS") {
  field(EGU,  "MV/s")
  field(INP,  "$(PREF)CHIRP:DF_CALC.VALE MSI")
  field(FLNK, "$(PREF)CHIRP:RMS")
  field(TSEL, "$(PREF)CAV:QWF.TIME")
}

record(ai, "$(PREF)CHIRP:RMS") {
  field(EGU,  "Hz")
  field(INP,  "$(PREF)CHIRP:DF_CALC.VALF MSI")
  field(TSEL, "$(PREF)CAV:QWF.TIME")
}

record(aSub, "$(PREF)CHIRP:SETUP") {
  field(SNAM, "Setup Chirp")
  field(INPA, "$(PREF)RFMODECTRL")
  field(INPB, "$(PREF)SEL_ASET CP")
  field(INPC, "$(PREF)ACQ_NORD CP")
  field(INPD, "$(PREF)CHIRP:FREQ_START CP")
  field(INPE, "$(PREF)CHIRP:FREQ_STOP CP")
  field(FTA,  "SHORT")
  field(FTC,  "LONG")
  field(FTD,  "LONG")
  field(FTE,  "LONG")
  field(OUTA, "$(PREF)CHIRP:ACQ_PER_WF PP")
  field(OUTB, "$(PREF)CHIRP:AMP_MAX PP")
  field(OUTC, "$(PREF)CHIRP:AMP_SLOPE PP")
  field(OUTD, "$(PREF)CHIRP:FREQ_SLOPE PP")
  field(OUTE, "$(PREF)CHIRP:FREQ_INIT PP")
  field(OUTF, "$(PREF)CHIRP:TIME PP")
  field(OUTG, "$(PREF)CHIRP:DECIM_REC PP")
  field(OUTH, "$(PREF)CHIRP:STATUS PP")
  field(OUTI, "$(PREF)ACQ_DECIM PP")
  field(FTVA,  "LONG")
  field(FTVB,  "LONG")
  field(FTVC,  "LONG")
  field(FTVD,  "LONG")
  field(FTVE,  "LONG")
  field(FTVF,  "LONG")
  field(FTVG,  "LONG")
  field(FTVH,  "LONG")
  field(FTVI,  "LONG")
}

record(longout, "$(PREF)CHIRP:FREQ_START") {
  field(DESC, "Chirp mode frequency range start")
  field(VAL, "-50000")
  field(EGU, "Hz")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(longout, "$(PREF)CHIRP:FREQ_STOP") {
  field(DESC, "Chirp mode frequency range stop")
  field(VAL, "50000")
  field(EGU, "Hz")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}

record(mbbi, "$(PREF)CHIRP:STATUS") {
  field(VAL,  "0")
  field(ZRVL, "0")
  field(ZRST, "")
  field(ONVL, "1")
  field(ONST, "Out of range")
  field(ONSV, "MAJOR")
  field(TWVL, "1")
  field(TWST, "Set start < stop")
  field(TWSV, "MAJOR")
  field(INP, "$(PREF)CHIRP:SETUP.VALH")
  info(autosaveFields, "VAL")
}

# Push recommended chirp decimation to 
# actual chirp decimation
# on cavity state/setpoint change
# User can choose to override actual if desired
record(longout, "$(PREF)CHIRP:DECIM_REC") {
  field(DESC, "Recommended decimation for chirp mode")
  field(VAL, "8")
  field(DRVL, "1")
  field(DRVL, "255")
  field(OUT,  "$(PREF)CHIRP:DECIM PP")
  info(autosaveFields, "VAL")
}

record(longout, "$(PREF)CHIRP:DECIM") {
  field(DESC, "Decimation for chirp mode")
  field(VAL, "8")
  field(DRVL, "1")
  field(DRVL, "255")
  info(autosaveFields, "VAL")
}

# First write to avg_power_<bit>_read
# Then read shell_<bit>_dsp_avg_power_samp 
record(longout, "$(PREF)AACT_SQR_READ") {
  field(DTYP, "FEED Register Write")
  field(SCAN, "1 second")
  field(OMSL, "supervisory")
  field(OUT,  "@name=$(NAME) reg=shell_$(BIT)_dsp_avg_power_samp wait=false")
  field(VAL,  "1")
  field(FLNK, "$(PREF)AACT_SQR_RAW")
  info(feed:info:setting, "$(PREF)AACT_SQR_READ")
}

record(ai, "$(PREF)AACT_SQR_RAW") {
  field(DESC, "Cav ampl ^2 unscaled")
  field(DTYP, "FEED Register Read")
  field(EGU,  "")
  field(INP , "@name=$(NAME) reg=avg_power_$(BIT)_read")
  field(TSE , "-2")
  field(FLNK, "$(PREF)AACT_SQR")
  info(feed:info:setting, "$(PREF)AACT_SQR_RAW")
}

record(calcout, "$(PREF)AACT_SQR") {
  field(DESC, "")
  field(CALC, "E*E*(A>>8)/(A&C)/(2**12)")
  field(INPA, "$(PREF)AACT_SQR_RAW MSI")
  field(INPB, "$(PREF)AACT_SQR_RAW.SEVR")
  field(INPC, "0xFF")
  field(INPD, "0xFFFF00")
  field(INPE, "$(PREF)CAV:SCALE")
  field(OOPT, "When Zero")
  field(DOPT, "Use OCAL")
  field(OCAL, "B=3?1:A&C=0?1:A&C=255?1:0")
  field(EGU,  "MV^2")
  field(FLNK, "$(PREF)PWRDISS")
}

record(calc, "$(PREF)PWRDISS") {
  field(DESC, "")
  field(CALC, "1e12*A/B/C")
  field(INPA, "$(PREF)AACT_SQR MSI")
  field(INPB, "$(PREF)Q0 MSI")
  field(INPC, "$(PREF)IMPED MSI")
  field(EGU,  "W")
# Keep-alive for IOC->FW watchdog
  field(FLNK, "$(PREF)IOCWDOG_TIME")
}

record(ai, "$(PREF)Q0") {
  field(DESC, "Cavity Q0")
# Don't provide default
# Want to use real measured value
  field(VAL,  "0")
# unitless
# field(ASG, "")
  field(PINI, "YES")
  info(autosaveFields, "VAL")
}
