#================================================================================#
# LCLS-II MPS PV template for read-only registers                                #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - PORT  : Asyn port name                                                     #
#   - ADDR  : Asyn parameter list number (0: AppBay0, 1: AppBay1, 2: MpsBase)    #
#   - PARAM : Asyn parameter name                                                #
#================================================================================#

record(longin, "$(P):L_THR_CH") {
    field(DESC, "Bay $(BAY) Threshold channel")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRNUM_0")
    field(HIHI, "")
    field(HHSV, "")
    field(LOLO, "")
    field(LLSV, "")
}

#================================================================================#
# LCLS-II MPS PV template for read-only registers                                #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - PORT  : Asyn port name                                                     #
#   - ADDR  : Asyn parameter list number (0: AppBay0, 1: AppBay1, 2: MpsBase)    #
#   - PARAM : Asyn parameter name                                                #
#================================================================================#

record(longin, "$(P):L_THR_CNT") {
    field(DESC, "Bay $(BAY) Threshold count")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRCNT_0")
    field(HIHI, "")
    field(HHSV, "")
    field(LOLO, "")
    field(LLSV, "")
}

#================================================================================#
# LCLS-II MPS PV template for read-only registers                                #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - PORT  : Asyn port name                                                     #
#   - ADDR  : Asyn parameter list number (0: AppBay0, 1: AppBay1, 2: MpsBase)    #
#   - PARAM : Asyn parameter name                                                #
#================================================================================#

record(longin, "$(P):L_THR_BYTEMAP") {
    field(DESC, "Bay $(BAY) Threshold byte map")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_BYTEMAP_0")
    field(HIHI, "")
    field(HHSV, "")
    field(LOLO, "")
    field(LLSV, "")
}

#================================================================================#
# LCLS-II MPS PV template for read-only registers                                #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - PORT  : Asyn port name                                                     #
#   - ADDR  : Asyn parameter list number (0: AppBay0, 1: AppBay1, 2: MpsBase)    #
#   - PARAM : Asyn parameter name                                                #
#================================================================================#

record(longin, "$(P):L_LATCHED_RAW") {
    field(DESC, "Bay $(BAY) Latched Value")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_TRIP_VALUER_0")
    field(HIHI, "")
    field(HHSV, "")
    field(LOLO, "")
    field(LLSV, "")
}

#================================================================================#
# LCLS-II MPS PV template for read-only registers                                #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - PORT  : Asyn port name                                                     #
#   - ADDR  : Asyn parameter list number (0: AppBay0, 1: AppBay1, 2: MpsBase)    #
#   - PARAM : Asyn parameter name                                                #
#================================================================================#

record(ai, "$(P):L_LATCHED") {
    field(DESC, "Bay $(BAY) Latched Value")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_TRIP_VALUE_0")
}

#================================================================================#
# LCLS-II MPS PV template for read-only registers                                #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - PORT  : Asyn port name                                                     #
#   - ADDR  : Asyn parameter list number (0: AppBay0, 1: AppBay1, 2: MpsBase)    #
#   - PARAM : Asyn parameter name                                                #
#================================================================================#

record(int64in, "$(P):L_LATCHED_PID") {
    field(DESC, "Bay $(BAY) Latched PID")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt64")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_TRIP_PID_0")
}

#================================================================================#
# LCLS-II MPS PV template for 1-bit read-write registers                         #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - PORT  : Asyn port name                                                     #
#   - ADDR  : Asyn parameter list number (0: AppBay0, 1: AppBay1, 2: MpsBase)    #
#   - PARAM : Asyn parameter name                                                #
#   - ZNAM  : Label for the "0" state                                            #
#   - ONAM  : Label for the "1" state                                            #
#   - ZSV   : Label for the "0" severity, default none                           #
#   - OSV   : Label for the "1" severity, default none                           #
#================================================================================#

record(bo, "$(P):L_IDL_EN") {
    field(DESC, "Bay $(BAY) IDLE table enabled")
    field(SCAN, "Passive")
    field(PINI, "YES")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_IDLEEN_0")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
    field(ZSV,  "")
    field(OSV,  "")
    field(DOL,  "")
    field(OMSL, "")
}

record(bi, "$(P):L_IDL_EN_RBV") {
    field(DESC, "Bay $(BAY) IDLE table enabled")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_IDLEEN_0")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
    field(ZSV,  "")
    field(OSV,  "")
}

#================================================================================#
# LCLS-II MPS PV template for 1-bit read-only registers                          #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - PORT  : Asyn port name                                                     #
#   - ADDR  : Asyn parameter list number (0: AppBay0, 1: AppBay1, 2: MpsBase)    #
#   - PARAM : Asyn parameter name                                                #
#   - ZNAM  : Label for the "0" state                                            #
#   - ONAM  : Label for the "1" state                                            #
#================================================================================#

record(bi, "$(P):L_ALT_EN") {
    field(DESC, "Bay $(BAY) ALT table enabled")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_ALTEN_0")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS PV template for 1-bit read-only registers                          #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - PORT  : Asyn port name                                                     #
#   - ADDR  : Asyn parameter list number (0: AppBay0, 1: AppBay1, 2: MpsBase)    #
#   - PARAM : Asyn parameter name                                                #
#   - ZNAM  : Label for the "0" state                                            #
#   - ONAM  : Label for the "1" state                                            #
#================================================================================#

record(bi, "$(P):L_LC1_EN") {
    field(DESC, "Bay $(BAY) LCLS1 table enabled")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_LCLS1EN_0")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T0_LC1_L") {
    field(DESC, "BLEN, Bay $(BAY), LCLS1, Threshold")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_000")
    field(FLNK, "$(P):L_T0_LC1_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T0_LC1_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), LCLS1, Threshold Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T0_LC1_L")
    field(OUT,  "$(P):L_T0_LC1_L_MGR")
    field(FLNK, "$(P):L_T0_LC1_L_MGR.PROC")
}
record(ai,  "$(P):L_T0_LC1_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), LCLS1, Threshold")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_000")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T0_LC1_H") {
    field(DESC, "BLEN, Bay $(BAY), LCLS1, Threshold")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_000")
    field(FLNK, "$(P):L_T0_LC1_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T0_LC1_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), LCLS1, Threshold Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T0_LC1_H")
    field(OUT,  "$(P):L_T0_LC1_H_MGR")
    field(FLNK, "$(P):L_T0_LC1_H_MGR.PROC")
}
record(ai,  "$(P):L_T0_LC1_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), LCLS1, Threshold")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_000")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T0_LC1_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), LCLS1, Threshold")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_000")
}

# Maximum

record(longin,  "$(P):L_T0_LC1_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), LCLS1, Threshold")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_000")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T0_LC1_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), LCLS1, Threshold")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_000")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T0_LC1_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T0_LC1_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), LCLS1, Threshold Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T0_LC1_L_EN")
    field(OUT,  "$(P):L_T0_LC1_L_EN_MGR")
    field(FLNK, "$(P):L_T0_LC1_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T0_LC1_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), LCLS1, Threshold")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_000")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T0_LC1_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), LCLS1, Threshold")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_000")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T0_LC1_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T0_LC1_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), LCLS1, Threshold Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T0_LC1_H_EN")
    field(OUT,  "$(P):L_T0_LC1_H_EN_MGR")
    field(FLNK, "$(P):L_T0_LC1_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T0_LC1_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), LCLS1, Threshold")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_000")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T0_IDL_L") {
    field(DESC, "BLEN, Bay $(BAY), IDLE, Threshold")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_010")
    field(FLNK, "$(P):L_T0_IDL_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T0_IDL_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), IDLE, Threshold Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T0_IDL_L")
    field(OUT,  "$(P):L_T0_IDL_L_MGR")
    field(FLNK, "$(P):L_T0_IDL_L_MGR.PROC")
}
record(ai,  "$(P):L_T0_IDL_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), IDLE, Threshold")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_010")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T0_IDL_H") {
    field(DESC, "BLEN, Bay $(BAY), IDLE, Threshold")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_010")
    field(FLNK, "$(P):L_T0_IDL_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T0_IDL_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), IDLE, Threshold Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T0_IDL_H")
    field(OUT,  "$(P):L_T0_IDL_H_MGR")
    field(FLNK, "$(P):L_T0_IDL_H_MGR.PROC")
}
record(ai,  "$(P):L_T0_IDL_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), IDLE, Threshold")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_010")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T0_IDL_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), IDLE, Threshold")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_010")
}

# Maximum

record(longin,  "$(P):L_T0_IDL_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), IDLE, Threshold")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_010")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T0_IDL_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), IDLE, Threshold")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_010")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T0_IDL_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T0_IDL_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), IDLE, Threshold Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T0_IDL_L_EN")
    field(OUT,  "$(P):L_T0_IDL_L_EN_MGR")
    field(FLNK, "$(P):L_T0_IDL_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T0_IDL_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), IDLE, Threshold")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_010")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T0_IDL_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), IDLE, Threshold")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_010")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T0_IDL_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T0_IDL_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), IDLE, Threshold Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T0_IDL_H_EN")
    field(OUT,  "$(P):L_T0_IDL_H_EN_MGR")
    field(FLNK, "$(P):L_T0_IDL_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T0_IDL_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), IDLE, Threshold")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_010")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T0_L") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 0")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_020")
    field(FLNK, "$(P):L_T0_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T0_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 0 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T0_L")
    field(OUT,  "$(P):L_T0_L_MGR")
    field(FLNK, "$(P):L_T0_L_MGR.PROC")
}
record(ai,  "$(P):L_T0_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 0")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_020")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T0_H") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 0")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_020")
    field(FLNK, "$(P):L_T0_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T0_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 0 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T0_H")
    field(OUT,  "$(P):L_T0_H_MGR")
    field(FLNK, "$(P):L_T0_H_MGR.PROC")
}
record(ai,  "$(P):L_T0_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 0")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_020")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T0_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 0")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_020")
}

# Maximum

record(longin,  "$(P):L_T0_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 0")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_020")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T0_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 0")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_020")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T0_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T0_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 0 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T0_L_EN")
    field(OUT,  "$(P):L_T0_L_EN_MGR")
    field(FLNK, "$(P):L_T0_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T0_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 0")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_020")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T0_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 0")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_020")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T0_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T0_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 0 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T0_H_EN")
    field(OUT,  "$(P):L_T0_H_EN_MGR")
    field(FLNK, "$(P):L_T0_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T0_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 0")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_020")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T1_L") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 1")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_021")
    field(FLNK, "$(P):L_T1_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T1_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 1 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T1_L")
    field(OUT,  "$(P):L_T1_L_MGR")
    field(FLNK, "$(P):L_T1_L_MGR.PROC")
}
record(ai,  "$(P):L_T1_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 1")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_021")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T1_H") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 1")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_021")
    field(FLNK, "$(P):L_T1_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T1_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 1 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T1_H")
    field(OUT,  "$(P):L_T1_H_MGR")
    field(FLNK, "$(P):L_T1_H_MGR.PROC")
}
record(ai,  "$(P):L_T1_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 1")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_021")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T1_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 1")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_021")
}

# Maximum

record(longin,  "$(P):L_T1_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 1")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_021")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T1_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 1")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_021")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T1_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T1_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 1 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T1_L_EN")
    field(OUT,  "$(P):L_T1_L_EN_MGR")
    field(FLNK, "$(P):L_T1_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T1_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 1")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_021")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T1_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 1")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_021")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T1_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T1_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 1 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T1_H_EN")
    field(OUT,  "$(P):L_T1_H_EN_MGR")
    field(FLNK, "$(P):L_T1_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T1_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 1")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_021")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T2_L") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 2")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_022")
    field(FLNK, "$(P):L_T2_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T2_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 2 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T2_L")
    field(OUT,  "$(P):L_T2_L_MGR")
    field(FLNK, "$(P):L_T2_L_MGR.PROC")
}
record(ai,  "$(P):L_T2_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 2")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_022")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T2_H") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 2")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_022")
    field(FLNK, "$(P):L_T2_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T2_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 2 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T2_H")
    field(OUT,  "$(P):L_T2_H_MGR")
    field(FLNK, "$(P):L_T2_H_MGR.PROC")
}
record(ai,  "$(P):L_T2_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 2")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_022")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T2_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 2")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_022")
}

# Maximum

record(longin,  "$(P):L_T2_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 2")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_022")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T2_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 2")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_022")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T2_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T2_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 2 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T2_L_EN")
    field(OUT,  "$(P):L_T2_L_EN_MGR")
    field(FLNK, "$(P):L_T2_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T2_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 2")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_022")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T2_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 2")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_022")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T2_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T2_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 2 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T2_H_EN")
    field(OUT,  "$(P):L_T2_H_EN_MGR")
    field(FLNK, "$(P):L_T2_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T2_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 2")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_022")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T3_L") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 3")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_023")
    field(FLNK, "$(P):L_T3_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T3_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 3 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T3_L")
    field(OUT,  "$(P):L_T3_L_MGR")
    field(FLNK, "$(P):L_T3_L_MGR.PROC")
}
record(ai,  "$(P):L_T3_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 3")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_023")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T3_H") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 3")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_023")
    field(FLNK, "$(P):L_T3_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T3_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 3 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T3_H")
    field(OUT,  "$(P):L_T3_H_MGR")
    field(FLNK, "$(P):L_T3_H_MGR.PROC")
}
record(ai,  "$(P):L_T3_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 3")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_023")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T3_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 3")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_023")
}

# Maximum

record(longin,  "$(P):L_T3_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 3")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_023")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T3_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 3")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_023")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T3_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T3_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 3 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T3_L_EN")
    field(OUT,  "$(P):L_T3_L_EN_MGR")
    field(FLNK, "$(P):L_T3_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T3_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 3")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_023")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T3_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 3")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_023")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T3_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T3_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 3 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T3_H_EN")
    field(OUT,  "$(P):L_T3_H_EN_MGR")
    field(FLNK, "$(P):L_T3_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T3_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 3")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_023")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T4_L") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 4")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_024")
    field(FLNK, "$(P):L_T4_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T4_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 4 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T4_L")
    field(OUT,  "$(P):L_T4_L_MGR")
    field(FLNK, "$(P):L_T4_L_MGR.PROC")
}
record(ai,  "$(P):L_T4_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 4")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_024")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T4_H") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 4")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_024")
    field(FLNK, "$(P):L_T4_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T4_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 4 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T4_H")
    field(OUT,  "$(P):L_T4_H_MGR")
    field(FLNK, "$(P):L_T4_H_MGR.PROC")
}
record(ai,  "$(P):L_T4_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 4")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_024")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T4_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 4")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_024")
}

# Maximum

record(longin,  "$(P):L_T4_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 4")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_024")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T4_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 4")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_024")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T4_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T4_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 4 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T4_L_EN")
    field(OUT,  "$(P):L_T4_L_EN_MGR")
    field(FLNK, "$(P):L_T4_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T4_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 4")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_024")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T4_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 4")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_024")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T4_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T4_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 4 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T4_H_EN")
    field(OUT,  "$(P):L_T4_H_EN_MGR")
    field(FLNK, "$(P):L_T4_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T4_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 4")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_024")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T5_L") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 5")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_025")
    field(FLNK, "$(P):L_T5_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T5_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 5 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T5_L")
    field(OUT,  "$(P):L_T5_L_MGR")
    field(FLNK, "$(P):L_T5_L_MGR.PROC")
}
record(ai,  "$(P):L_T5_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 5")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_025")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T5_H") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 5")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_025")
    field(FLNK, "$(P):L_T5_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T5_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 5 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T5_H")
    field(OUT,  "$(P):L_T5_H_MGR")
    field(FLNK, "$(P):L_T5_H_MGR.PROC")
}
record(ai,  "$(P):L_T5_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 5")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_025")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T5_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 5")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_025")
}

# Maximum

record(longin,  "$(P):L_T5_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 5")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_025")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T5_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 5")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_025")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T5_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T5_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 5 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T5_L_EN")
    field(OUT,  "$(P):L_T5_L_EN_MGR")
    field(FLNK, "$(P):L_T5_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T5_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 5")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_025")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T5_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 5")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_025")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T5_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T5_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 5 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T5_H_EN")
    field(OUT,  "$(P):L_T5_H_EN_MGR")
    field(FLNK, "$(P):L_T5_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T5_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 5")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_025")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T6_L") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 6")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_026")
    field(FLNK, "$(P):L_T6_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T6_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 6 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T6_L")
    field(OUT,  "$(P):L_T6_L_MGR")
    field(FLNK, "$(P):L_T6_L_MGR.PROC")
}
record(ai,  "$(P):L_T6_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 6")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_026")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T6_H") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 6")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_026")
    field(FLNK, "$(P):L_T6_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T6_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 6 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T6_H")
    field(OUT,  "$(P):L_T6_H_MGR")
    field(FLNK, "$(P):L_T6_H_MGR.PROC")
}
record(ai,  "$(P):L_T6_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 6")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_026")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T6_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 6")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_026")
}

# Maximum

record(longin,  "$(P):L_T6_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 6")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_026")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T6_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 6")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_026")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T6_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T6_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 6 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T6_L_EN")
    field(OUT,  "$(P):L_T6_L_EN_MGR")
    field(FLNK, "$(P):L_T6_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T6_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 6")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_026")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T6_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 6")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_026")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T6_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T6_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 6 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T6_H_EN")
    field(OUT,  "$(P):L_T6_H_EN_MGR")
    field(FLNK, "$(P):L_T6_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T6_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 6")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_026")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T7_L") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 7")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_027")
    field(FLNK, "$(P):L_T7_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T7_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 7 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T7_L")
    field(OUT,  "$(P):L_T7_L_MGR")
    field(FLNK, "$(P):L_T7_L_MGR.PROC")
}
record(ai,  "$(P):L_T7_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 7")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_027")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T7_H") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 7")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_027")
    field(FLNK, "$(P):L_T7_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T7_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 7 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T7_H")
    field(OUT,  "$(P):L_T7_H_MGR")
    field(FLNK, "$(P):L_T7_H_MGR.PROC")
}
record(ai,  "$(P):L_T7_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 7")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_027")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T7_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 7")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_027")
}

# Maximum

record(longin,  "$(P):L_T7_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 7")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_027")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T7_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 7")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_027")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T7_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T7_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 7 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T7_L_EN")
    field(OUT,  "$(P):L_T7_L_EN_MGR")
    field(FLNK, "$(P):L_T7_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T7_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 7")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_027")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T7_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 7")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_027")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T7_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T7_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 7 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T7_H_EN")
    field(OUT,  "$(P):L_T7_H_EN_MGR")
    field(FLNK, "$(P):L_T7_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T7_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), STD, Threshold 7")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_027")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T0_ALT_L") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 0")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_030")
    field(FLNK, "$(P):L_T0_ALT_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T0_ALT_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 0 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T0_ALT_L")
    field(OUT,  "$(P):L_T0_ALT_L_MGR")
    field(FLNK, "$(P):L_T0_ALT_L_MGR.PROC")
}
record(ai,  "$(P):L_T0_ALT_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 0")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_030")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T0_ALT_H") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 0")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_030")
    field(FLNK, "$(P):L_T0_ALT_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T0_ALT_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 0 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T0_ALT_H")
    field(OUT,  "$(P):L_T0_ALT_H_MGR")
    field(FLNK, "$(P):L_T0_ALT_H_MGR.PROC")
}
record(ai,  "$(P):L_T0_ALT_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 0")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_030")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T0_ALT_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 0")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_030")
}

# Maximum

record(longin,  "$(P):L_T0_ALT_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 0")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_030")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T0_ALT_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 0")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_030")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T0_ALT_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T0_ALT_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 0 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T0_ALT_L_EN")
    field(OUT,  "$(P):L_T0_ALT_L_EN_MGR")
    field(FLNK, "$(P):L_T0_ALT_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T0_ALT_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 0")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_030")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T0_ALT_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 0")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_030")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T0_ALT_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T0_ALT_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 0 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T0_ALT_H_EN")
    field(OUT,  "$(P):L_T0_ALT_H_EN_MGR")
    field(FLNK, "$(P):L_T0_ALT_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T0_ALT_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 0")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_030")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T1_ALT_L") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 1")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_031")
    field(FLNK, "$(P):L_T1_ALT_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T1_ALT_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 1 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T1_ALT_L")
    field(OUT,  "$(P):L_T1_ALT_L_MGR")
    field(FLNK, "$(P):L_T1_ALT_L_MGR.PROC")
}
record(ai,  "$(P):L_T1_ALT_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 1")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_031")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T1_ALT_H") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 1")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_031")
    field(FLNK, "$(P):L_T1_ALT_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T1_ALT_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 1 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T1_ALT_H")
    field(OUT,  "$(P):L_T1_ALT_H_MGR")
    field(FLNK, "$(P):L_T1_ALT_H_MGR.PROC")
}
record(ai,  "$(P):L_T1_ALT_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 1")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_031")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T1_ALT_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 1")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_031")
}

# Maximum

record(longin,  "$(P):L_T1_ALT_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 1")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_031")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T1_ALT_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 1")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_031")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T1_ALT_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T1_ALT_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 1 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T1_ALT_L_EN")
    field(OUT,  "$(P):L_T1_ALT_L_EN_MGR")
    field(FLNK, "$(P):L_T1_ALT_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T1_ALT_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 1")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_031")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T1_ALT_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 1")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_031")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T1_ALT_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T1_ALT_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 1 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T1_ALT_H_EN")
    field(OUT,  "$(P):L_T1_ALT_H_EN_MGR")
    field(FLNK, "$(P):L_T1_ALT_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T1_ALT_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 1")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_031")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T2_ALT_L") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 2")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_032")
    field(FLNK, "$(P):L_T2_ALT_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T2_ALT_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 2 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T2_ALT_L")
    field(OUT,  "$(P):L_T2_ALT_L_MGR")
    field(FLNK, "$(P):L_T2_ALT_L_MGR.PROC")
}
record(ai,  "$(P):L_T2_ALT_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 2")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_032")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T2_ALT_H") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 2")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_032")
    field(FLNK, "$(P):L_T2_ALT_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T2_ALT_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 2 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T2_ALT_H")
    field(OUT,  "$(P):L_T2_ALT_H_MGR")
    field(FLNK, "$(P):L_T2_ALT_H_MGR.PROC")
}
record(ai,  "$(P):L_T2_ALT_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 2")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_032")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T2_ALT_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 2")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_032")
}

# Maximum

record(longin,  "$(P):L_T2_ALT_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 2")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_032")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T2_ALT_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 2")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_032")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T2_ALT_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T2_ALT_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 2 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T2_ALT_L_EN")
    field(OUT,  "$(P):L_T2_ALT_L_EN_MGR")
    field(FLNK, "$(P):L_T2_ALT_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T2_ALT_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 2")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_032")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T2_ALT_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 2")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_032")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T2_ALT_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T2_ALT_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 2 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T2_ALT_H_EN")
    field(OUT,  "$(P):L_T2_ALT_H_EN_MGR")
    field(FLNK, "$(P):L_T2_ALT_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T2_ALT_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 2")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_032")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T3_ALT_L") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 3")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_033")
    field(FLNK, "$(P):L_T3_ALT_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T3_ALT_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 3 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T3_ALT_L")
    field(OUT,  "$(P):L_T3_ALT_L_MGR")
    field(FLNK, "$(P):L_T3_ALT_L_MGR.PROC")
}
record(ai,  "$(P):L_T3_ALT_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 3")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_033")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T3_ALT_H") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 3")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_033")
    field(FLNK, "$(P):L_T3_ALT_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T3_ALT_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 3 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T3_ALT_H")
    field(OUT,  "$(P):L_T3_ALT_H_MGR")
    field(FLNK, "$(P):L_T3_ALT_H_MGR.PROC")
}
record(ai,  "$(P):L_T3_ALT_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 3")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_033")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T3_ALT_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 3")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_033")
}

# Maximum

record(longin,  "$(P):L_T3_ALT_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 3")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_033")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T3_ALT_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 3")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_033")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T3_ALT_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T3_ALT_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 3 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T3_ALT_L_EN")
    field(OUT,  "$(P):L_T3_ALT_L_EN_MGR")
    field(FLNK, "$(P):L_T3_ALT_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T3_ALT_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 3")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_033")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T3_ALT_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 3")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_033")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T3_ALT_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T3_ALT_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 3 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T3_ALT_H_EN")
    field(OUT,  "$(P):L_T3_ALT_H_EN_MGR")
    field(FLNK, "$(P):L_T3_ALT_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T3_ALT_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 3")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_033")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T4_ALT_L") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 4")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_034")
    field(FLNK, "$(P):L_T4_ALT_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T4_ALT_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 4 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T4_ALT_L")
    field(OUT,  "$(P):L_T4_ALT_L_MGR")
    field(FLNK, "$(P):L_T4_ALT_L_MGR.PROC")
}
record(ai,  "$(P):L_T4_ALT_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 4")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_034")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T4_ALT_H") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 4")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_034")
    field(FLNK, "$(P):L_T4_ALT_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T4_ALT_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 4 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T4_ALT_H")
    field(OUT,  "$(P):L_T4_ALT_H_MGR")
    field(FLNK, "$(P):L_T4_ALT_H_MGR.PROC")
}
record(ai,  "$(P):L_T4_ALT_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 4")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_034")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T4_ALT_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 4")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_034")
}

# Maximum

record(longin,  "$(P):L_T4_ALT_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 4")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_034")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T4_ALT_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 4")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_034")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T4_ALT_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T4_ALT_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 4 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T4_ALT_L_EN")
    field(OUT,  "$(P):L_T4_ALT_L_EN_MGR")
    field(FLNK, "$(P):L_T4_ALT_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T4_ALT_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 4")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_034")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T4_ALT_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 4")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_034")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T4_ALT_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T4_ALT_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 4 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T4_ALT_H_EN")
    field(OUT,  "$(P):L_T4_ALT_H_EN_MGR")
    field(FLNK, "$(P):L_T4_ALT_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T4_ALT_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 4")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_034")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T5_ALT_L") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 5")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_035")
    field(FLNK, "$(P):L_T5_ALT_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T5_ALT_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 5 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T5_ALT_L")
    field(OUT,  "$(P):L_T5_ALT_L_MGR")
    field(FLNK, "$(P):L_T5_ALT_L_MGR.PROC")
}
record(ai,  "$(P):L_T5_ALT_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 5")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_035")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T5_ALT_H") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 5")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_035")
    field(FLNK, "$(P):L_T5_ALT_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T5_ALT_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 5 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T5_ALT_H")
    field(OUT,  "$(P):L_T5_ALT_H_MGR")
    field(FLNK, "$(P):L_T5_ALT_H_MGR.PROC")
}
record(ai,  "$(P):L_T5_ALT_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 5")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_035")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T5_ALT_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 5")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_035")
}

# Maximum

record(longin,  "$(P):L_T5_ALT_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 5")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_035")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T5_ALT_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 5")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_035")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T5_ALT_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T5_ALT_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 5 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T5_ALT_L_EN")
    field(OUT,  "$(P):L_T5_ALT_L_EN_MGR")
    field(FLNK, "$(P):L_T5_ALT_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T5_ALT_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 5")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_035")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T5_ALT_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 5")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_035")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T5_ALT_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T5_ALT_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 5 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T5_ALT_H_EN")
    field(OUT,  "$(P):L_T5_ALT_H_EN_MGR")
    field(FLNK, "$(P):L_T5_ALT_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T5_ALT_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 5")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_035")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T6_ALT_L") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 6")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_036")
    field(FLNK, "$(P):L_T6_ALT_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T6_ALT_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 6 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T6_ALT_L")
    field(OUT,  "$(P):L_T6_ALT_L_MGR")
    field(FLNK, "$(P):L_T6_ALT_L_MGR.PROC")
}
record(ai,  "$(P):L_T6_ALT_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 6")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_036")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T6_ALT_H") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 6")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_036")
    field(FLNK, "$(P):L_T6_ALT_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T6_ALT_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 6 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T6_ALT_H")
    field(OUT,  "$(P):L_T6_ALT_H_MGR")
    field(FLNK, "$(P):L_T6_ALT_H_MGR.PROC")
}
record(ai,  "$(P):L_T6_ALT_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 6")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_036")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T6_ALT_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 6")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_036")
}

# Maximum

record(longin,  "$(P):L_T6_ALT_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 6")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_036")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T6_ALT_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 6")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_036")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T6_ALT_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T6_ALT_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 6 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T6_ALT_L_EN")
    field(OUT,  "$(P):L_T6_ALT_L_EN_MGR")
    field(FLNK, "$(P):L_T6_ALT_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T6_ALT_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 6")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_036")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T6_ALT_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 6")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_036")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T6_ALT_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T6_ALT_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 6 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T6_ALT_H_EN")
    field(OUT,  "$(P):L_T6_ALT_H_EN_MGR")
    field(FLNK, "$(P):L_T6_ALT_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T6_ALT_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 6")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_036")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold PV template                                              #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#   - DESC  : Description                                                        #
#   - EGU   : Engineering units                                                  #
#   - PREC  : Precision                                                          #
#   - PORT  : Asyn port name                                                     #
#   - BAY   : Bay number (0 or 1)                                                #
#   - APP   : Application name (BLM, BPM, BCM, BLEN)                             #
#   - TABLE : Threhold table (0: LCLS1, 1: No-beam, 2: Standard, 3: Alternative) #
#   - THR   : Threshold index (0-7)                                              #
#   - CH    : Threhold channel (application specific)                            #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

#### VALUES ####

# MINIMUM (Set and RBV)

record(ao, "$(P):L_T7_ALT_L") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 7")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_037")
    field(FLNK, "$(P):L_T7_ALT_L_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T7_ALT_L_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 7 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T7_ALT_L")
    field(OUT,  "$(P):L_T7_ALT_L_MGR")
    field(FLNK, "$(P):L_T7_ALT_L_MGR.PROC")
}
record(ai,  "$(P):L_T7_ALT_L_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 7")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMIN_037")
}
# MAXIMUM (Set and RBV)
record(ao, "$(P):L_T7_ALT_H") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 7")
    field(SCAN, "Passive")
    field(PHAS, "2")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_037")
    field(FLNK, "$(P):L_T7_ALT_H_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T7_ALT_H_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 7 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T7_ALT_H")
    field(OUT,  "$(P):L_T7_ALT_H_MGR")
    field(FLNK, "$(P):L_T7_ALT_H_MGR.PROC")
}
record(ai,  "$(P):L_T7_ALT_H_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 7")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynFloat64")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAX_037")
}
#### RAW VALUES ####

# Minimum

record(longin,  "$(P):L_T7_ALT_L_RAW") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 7")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMINR_037")
}

# Maximum

record(longin,  "$(P):L_T7_ALT_H_RAW") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 7")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynInt32")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_THRMAXR_037")
}

#### ENABLES ####

# MINIMUM (Set and RBV)

record(bo, "$(P):L_T7_ALT_L_EN") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 7")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_037")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T7_ALT_L_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T7_ALT_L_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 7 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T7_ALT_L_EN")
    field(OUT,  "$(P):L_T7_ALT_L_EN_MGR")
    field(FLNK, "$(P):L_T7_ALT_L_EN_MGR.PROC")
}
record(bi, "$(P):L_T7_ALT_L_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 7")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMINEN_037")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}


# MAXIMUM (Set and RBV)

record(bo,      "$(P):L_T7_ALT_H_EN") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 7")
    field(SCAN, "Passive")
    field(DTYP, "asynUInt32Digital")
    field(OUT,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_037")
    field(ZNAM, "Disable")
    field(ONAM, "Enable")
    field(FLNK, "$(P):L_T7_ALT_H_EN_OUT")
    #info(autosaveFields, "VAL")
}
record(ao, "$(P):L_T7_ALT_H_EN_OUT") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 7 Out")
    field(SCAN, "Passive")
    field(DTYP, "Soft Channel")
    field(EGU,  "$(EGU)")
    field(PREC, "$(PREC)")
    field(OMSL, "closed_loop")
    field(DOL,  "$(P):L_T7_ALT_H_EN")
    field(OUT,  "$(P):L_T7_ALT_H_EN_MGR")
    field(FLNK, "$(P):L_T7_ALT_H_EN_MGR.PROC")
}
record(bi,      "$(P):L_T7_ALT_H_EN_RBV") {
    field(DESC, "BLEN, Bay $(BAY), ALT, Threshold 7")
    field(SCAN, "I/O Intr")
    field(PINI, "NO")
    field(DTYP, "asynUInt32Digital")
    field(INP,  "@asynMask($(PORT),$(BAY),0x01)BLEN_THRMAXEN_037")
    field(ZNAM, "Disabled")
    field(ONAM, "Enabled")
}

#================================================================================#
# LCLS-II MPS Threshold scale factor and offset PV template                      #
# Macro description:                                                             #
#   - P               : Record name prefix                                       #
#   - R               : Channel name.                                            #
#   - DESC            : Description                                              #
#   - SCAN            : Scan period                                              #
#   - SCALE_SLOPE_PV  : Name of the PV with the scale slope value                #
#   - SCALE_OFFSET_PV : Name of the PV with the scale offset value               #
#   - EGU             : Engineering units                                        #
#   - PREC            : Precision                                                #
#   - PORT            : Asyn port name                                           #
#   - BAY             : Bay number (0 or 1)                                      #
#   - APP             : Application name (BLM, BPM, BCM, BLEN)                   #
#   - CH              : Threhold channel (application specific)                  #
#     * BLM  => (X)(Y), X=input channel(0-2), Y=Integration channel (0-3)        #
#     * BPM  => (X),    X=Channel (0:X, 1:Y, 2, TIMIT)                           #
#     * BCM  => (X),    X=Channel (0:Charge, 1:Difference)                       #
#     * BLEN => 0                                                                #
#================================================================================#

# Scale Factor PVs
record(calcout, "$(P):L_SS") {
    field(DESC, "Bay $(BAY) Scale factor slope")
    field(SCAN, "1 second")
    field(PHAS, "1")
    field(PINI, "NO")
    field(EGU,  "/raw")
    field(PREC, "4")
    field(INPA, "$(P):L_FWSLO")
    field(CALC, "A")
    field(DTYP, "Soft Channel")
    field(OUT,  "$(P):L_SS_OUT PP")
    field(OOPT, "On Change")
}
record(ao,      "$(P):L_SS_OUT") {
    field(DESC, "Bay $(BAY) Scale factor slope")
    field(SCAN, "Passive")
    field(PHAS, "1")
    field(PINI, "NO")
    field(EGU,  "/raw")
    field(PREC, "4")
    field(OMSL, "closed_loop")
    field(OIF,  "Full")
    field(DOL,  "$(P):L_SS")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_SCALESLOPE_0")
}
record(ai,      "$(P):L_SS_RBV") {
    field(DESC, "Bay $(BAY) Scale factor slope")
    field(SCAN, "I/O Intr")
    field(EGU,  "/raw")
    field(PREC, "4")
    field(DTYP, "asynFloat64")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_SCALESLOPE_0")
}
# Scale Offset PVs
record(calcout, "$(P):L_SO") {
    field(DESC, "Bay $(BAY) Scale factor slope")
    field(SCAN, "1 second")
    field(PHAS, "1")
    field(PINI, "NO")
    field(EGU,  "raw")
    field(PREC, "4")
    field(INPA, "$(P):L_FWOFF")
    field(CALC, "A")
    field(DTYP, "Soft Channel")
    field(OUT,  "$(P):L_SO_OUT PP")
    field(OOPT, "On Change")
}
record(ao,      "$(P):L_SO_OUT") {
    field(DESC, "Bay $(BAY) Scale factor offset")
    field(SCAN, "Passive")
    field(PHAS, "1")
    field(PINI, "NO")
    field(EGU,  "raw")
    field(PREC, "0")
    field(OMSL, "closed_loop")
    field(OIF,  "Full")
    field(DOL,  "$(P):L_FWOFF")
    field(DTYP, "asynFloat64")
    field(OUT,  "@asyn($(PORT),$(BAY))BLEN_SCALEOFFSET_0")
}
record(ai,      "$(P):L_SO_RBV") {
    field(DESC, "Bay $(BAY) Scale factor")
    field(SCAN, "I/O Intr")
    field(EGU,  "raw")
    field(PREC, "0")
    field(DTYP, "asynFloat64")
    field(INP,  "@asyn($(PORT),$(BAY))BLEN_SCALEOFFSET_0")
}

#================================================================================#
# LCLS-II MPS PV template to store fault name and register with manager          #
# Macro description:                                                             #
#   - P     : Record name prefix                                                 #
#   - R     : Record name                                                        #
#================================================================================#

record(stringout, "$(P):L_NAME") {
    field(DESC,    "Channel name")
    field(PINI,    "YES")
    field(SCAN,    "Passive")
    field(DTYP,    "asynOctetWrite")
    field(VAL,     "$(P):L")
    field(OUT,     "@asyn($(PORT),$(BAY))BLEN_NAME_0")
}

