#==================================
#----------------------------------
# intlkCountCmCommon.template:
#
# Interlock fault counters
#----------------------------------
#==================================

record(stringin,"$(CM,recursive)00:INTLK_CNTROT") {
  field(DTYP,"Soft Timestamp")
  field(INP,"@%H%M%S")
  field(SCAN,"5 second")
  field(FLNK,"$(CM,recursive)00:INTLK_CNTROC")
}

record(calcout,"$(CM,recursive)00:INTLK_CNTROC") {
  field(INPA,"$(CM,recursive)00:INTLK_CNTROT")
  field(CALC,"A>235950?1:0")
  field(OOPT,"Transition To Zero")
  field(OUT,"$(CM,recursive)00:INTLK_CNTRO1 PP")
}

record(fanout, "$(CM,recursive)00:INTLK_CNTRO1") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(LNK0, "$(CM,recursive)10:INTLK_CNTRO")
  field(LNK1, "$(CM,recursive)20:INTLK_CNTRO")
  field(LNK2, "$(CM,recursive)30:INTLK_CNTRO")
  field(LNK3, "$(CM,recursive)40:INTLK_CNTRO")
  field(LNK4, "$(CM,recursive)50:INTLK_CNTRO")
  field(LNK5, "$(CM,recursive)60:INTLK_CNTRO")
  field(LNK6, "$(CM,recursive)70:INTLK_CNTRO")
  field(LNK7, "$(CM,recursive)80:INTLK_CNTRO")
  field(LNK8, "$(CM,recursive)00:RESA:INTLK_CNTRO")
  field(LNK9, "$(CM,recursive)00:RESB:INTLK_CNTRO")
}

#==================================
# Reset user fault counters
# for cryomodule
#==================================

# Reset single fault type for all 8 cavities 
record(fanout, "$(CM,recursive)00:SSA_CNTUCLR") {
  field(DESC, "Clear intlk counts for cm")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,recursive)10:SSA_CNTUCLR")
  field(LNK1, "$(CM,recursive)20:SSA_CNTUCLR")
  field(LNK2, "$(CM,recursive)30:SSA_CNTUCLR")
  field(LNK3, "$(CM,recursive)40:SSA_CNTUCLR")
  field(LNK4, "$(CM,recursive)50:SSA_CNTUCLR")
  field(LNK5, "$(CM,recursive)60:SSA_CNTUCLR")
  field(LNK6, "$(CM,recursive)70:SSA_CNTUCLR")
  field(LNK7, "$(CM,recursive)80:SSA_CNTUCLR")
}

record(fanout, "$(CM,recursive)00:QUENCH_CNTUCLR") {
  field(DESC, "Clear intlk counts for cm")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,recursive)10:QUENCH_CNTUCLR")
  field(LNK1, "$(CM,recursive)20:QUENCH_CNTUCLR")
  field(LNK2, "$(CM,recursive)30:QUENCH_CNTUCLR")
  field(LNK3, "$(CM,recursive)40:QUENCH_CNTUCLR")
  field(LNK4, "$(CM,recursive)50:QUENCH_CNTUCLR")
  field(LNK5, "$(CM,recursive)60:QUENCH_CNTUCLR")
  field(LNK6, "$(CM,recursive)70:QUENCH_CNTUCLR")
  field(LNK7, "$(CM,recursive)80:QUENCH_CNTUCLR")
}

record(fanout, "$(CM,recursive)00:CRYO_CNTUCLR") {
  field(DESC, "Clear intlk counts for cm")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,recursive)10:CRYO_CNTUCLR")
  field(LNK1, "$(CM,recursive)20:CRYO_CNTUCLR")
  field(LNK2, "$(CM,recursive)30:CRYO_CNTUCLR")
  field(LNK3, "$(CM,recursive)40:CRYO_CNTUCLR")
  field(LNK4, "$(CM,recursive)50:CRYO_CNTUCLR")
  field(LNK5, "$(CM,recursive)60:CRYO_CNTUCLR")
  field(LNK6, "$(CM,recursive)70:CRYO_CNTUCLR")
  field(LNK7, "$(CM,recursive)80:CRYO_CNTUCLR")
}

record(fanout, "$(CM,recursive)00:STEPTEMP_CNTUCLR") {
  field(DESC, "Clear intlk counts for cm")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,recursive)10:STEPTEMP_CNTUCLR")
  field(LNK1, "$(CM,recursive)20:STEPTEMP_CNTUCLR")
  field(LNK2, "$(CM,recursive)30:STEPTEMP_CNTUCLR")
  field(LNK3, "$(CM,recursive)40:STEPTEMP_CNTUCLR")
  field(LNK4, "$(CM,recursive)50:STEPTEMP_CNTUCLR")
  field(LNK5, "$(CM,recursive)60:STEPTEMP_CNTUCLR")
  field(LNK6, "$(CM,recursive)70:STEPTEMP_CNTUCLR")
  field(LNK7, "$(CM,recursive)80:STEPTEMP_CNTUCLR")
}

record(fanout, "$(CM,recursive)00:CPLRTEMP1_CNTUCLR") {
  field(DESC, "Clear intlk counts for cm")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,recursive)10:CPLRTEMP1_CNTUCLR")
  field(LNK1, "$(CM,recursive)20:CPLRTEMP1_CNTUCLR")
  field(LNK2, "$(CM,recursive)30:CPLRTEMP1_CNTUCLR")
  field(LNK3, "$(CM,recursive)40:CPLRTEMP1_CNTUCLR")
  field(LNK4, "$(CM,recursive)50:CPLRTEMP1_CNTUCLR")
  field(LNK5, "$(CM,recursive)60:CPLRTEMP1_CNTUCLR")
  field(LNK6, "$(CM,recursive)70:CPLRTEMP1_CNTUCLR")
  field(LNK7, "$(CM,recursive)80:CPLRTEMP1_CNTUCLR")
}

record(fanout, "$(CM,recursive)00:CPLRTEMP2_CNTUCLR") {
  field(DESC, "Clear intlk counts for cm")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,recursive)10:CPLRTEMP2_CNTUCLR")
  field(LNK1, "$(CM,recursive)20:CPLRTEMP2_CNTUCLR")
  field(LNK2, "$(CM,recursive)30:CPLRTEMP2_CNTUCLR")
  field(LNK3, "$(CM,recursive)40:CPLRTEMP2_CNTUCLR")
  field(LNK4, "$(CM,recursive)50:CPLRTEMP2_CNTUCLR")
  field(LNK5, "$(CM,recursive)60:CPLRTEMP2_CNTUCLR")
  field(LNK6, "$(CM,recursive)70:CPLRTEMP2_CNTUCLR")
  field(LNK7, "$(CM,recursive)80:CPLRTEMP2_CNTUCLR")
}

record(fanout, "$(CM,recursive)00:RESLINK_CNTUCLR") {
  field(DESC, "Clear intlk counts for cm")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,recursive)10:RESLINK_CNTUCLR")
  field(LNK1, "$(CM,recursive)20:RESLINK_CNTUCLR")
  field(LNK2, "$(CM,recursive)30:RESLINK_CNTUCLR")
  field(LNK3, "$(CM,recursive)40:RESLINK_CNTUCLR")
  field(LNK4, "$(CM,recursive)50:RESLINK_CNTUCLR")
  field(LNK5, "$(CM,recursive)60:RESLINK_CNTUCLR")
  field(LNK6, "$(CM,recursive)70:RESLINK_CNTUCLR")
  field(LNK7, "$(CM,recursive)80:RESLINK_CNTUCLR")
}

record(fanout, "$(CM,recursive)00:RESINTLK_CNTUCLR") {
  field(DESC, "Clear intlk counts for cm")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,recursive)10:RESINTLK_CNTUCLR")
  field(LNK1, "$(CM,recursive)20:RESINTLK_CNTUCLR")
  field(LNK2, "$(CM,recursive)30:RESINTLK_CNTUCLR")
  field(LNK3, "$(CM,recursive)40:RESINTLK_CNTUCLR")
  field(LNK4, "$(CM,recursive)50:RESINTLK_CNTUCLR")
  field(LNK5, "$(CM,recursive)60:RESINTLK_CNTUCLR")
  field(LNK6, "$(CM,recursive)70:RESINTLK_CNTUCLR")
  field(LNK7, "$(CM,recursive)80:RESINTLK_CNTUCLR")
}

record(fanout, "$(CM,recursive)00:PLL_CNTUCLR") {
  field(DESC, "Clear intlk counts for cm")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,recursive)10:PLL_CNTUCLR")
  field(LNK1, "$(CM,recursive)20:PLL_CNTUCLR")
  field(LNK2, "$(CM,recursive)30:PLL_CNTUCLR")
  field(LNK3, "$(CM,recursive)40:PLL_CNTUCLR")
  field(LNK4, "$(CM,recursive)50:PLL_CNTUCLR")
  field(LNK5, "$(CM,recursive)60:PLL_CNTUCLR")
  field(LNK6, "$(CM,recursive)70:PLL_CNTUCLR")
  field(LNK7, "$(CM,recursive)80:PLL_CNTUCLR")
}

record(fanout, "$(CM,recursive)00:IOCWDOG_CNTUCLR") {
  field(DESC, "Clear intlk counts for cm")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,recursive)10:IOCWDOG_CNTUCLR")
  field(LNK1, "$(CM,recursive)20:IOCWDOG_CNTUCLR")
  field(LNK2, "$(CM,recursive)30:IOCWDOG_CNTUCLR")
  field(LNK3, "$(CM,recursive)40:IOCWDOG_CNTUCLR")
  field(LNK4, "$(CM,recursive)50:IOCWDOG_CNTUCLR")
  field(LNK5, "$(CM,recursive)60:IOCWDOG_CNTUCLR")
  field(LNK6, "$(CM,recursive)70:IOCWDOG_CNTUCLR")
  field(LNK7, "$(CM,recursive)80:IOCWDOG_CNTUCLR")
}

record(fanout, "$(CM,recursive)00:LO_CNTUCLR") {
  field(DESC, "Clear intlk counts for cm")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,recursive)10:LO_CNTUCLR")
  field(LNK1, "$(CM,recursive)20:LO_CNTUCLR")
  field(LNK2, "$(CM,recursive)30:LO_CNTUCLR")
  field(LNK3, "$(CM,recursive)40:LO_CNTUCLR")
  field(LNK4, "$(CM,recursive)50:LO_CNTUCLR")
  field(LNK5, "$(CM,recursive)60:LO_CNTUCLR")
  field(LNK6, "$(CM,recursive)70:LO_CNTUCLR")
  field(LNK7, "$(CM,recursive)80:LO_CNTUCLR")
}

record(fanout, "$(CM,recursive)00:ADMIN_CNTUCLR") {
  field(DESC, "Clear intlk counts for cm")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,recursive)10:ADMIN_CNTUCLR")
  field(LNK1, "$(CM,recursive)20:ADMIN_CNTUCLR")
  field(LNK2, "$(CM,recursive)30:ADMIN_CNTUCLR")
  field(LNK3, "$(CM,recursive)40:ADMIN_CNTUCLR")
  field(LNK4, "$(CM,recursive)50:ADMIN_CNTUCLR")
  field(LNK5, "$(CM,recursive)60:ADMIN_CNTUCLR")
  field(LNK6, "$(CM,recursive)70:ADMIN_CNTUCLR")
  field(LNK7, "$(CM,recursive)80:ADMIN_CNTUCLR")
}

record(fanout, "$(CM,recursive)00:FB_SUM_CNTUCLR") {
  field(DESC, "Clear intlk counts for cm")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,recursive)10:FB_SUM_CNTUCLR")
  field(LNK1, "$(CM,recursive)20:FB_SUM_CNTUCLR")
  field(LNK2, "$(CM,recursive)30:FB_SUM_CNTUCLR")
  field(LNK3, "$(CM,recursive)40:FB_SUM_CNTUCLR")
  field(LNK4, "$(CM,recursive)50:FB_SUM_CNTUCLR")
  field(LNK5, "$(CM,recursive)60:FB_SUM_CNTUCLR")
  field(LNK6, "$(CM,recursive)70:FB_SUM_CNTUCLR")
  field(LNK7, "$(CM,recursive)80:FB_SUM_CNTUCLR")
}

# Reset single fault type for both racks 
record(fanout, "$(CM,recursive)00:BMLNVAC_CNTUCLR") {
  field(DESC, "Clear intlk counts for cm")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,recursive)00:BMLNVACA_CNTUCLR")
  field(LNK1, "$(CM,recursive)00:BMLNVACB_CNTUCLR")
}

record(fanout, "$(CM,recursive)10:CPLRVAC_CNTUCLR") {
  field(DESC, "Clear intlk counts for cm")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,recursive)10:CPLRVACA_CNTUCLR")
  field(LNK1, "$(CM,recursive)10:CPLRVACB_CNTUCLR")
}

# Reset all counts for cryomodule
record(fanout, "$(CM,recursive)00:INTLK_CNTUCLR") {
  field(DESC, "Clear intlk counts for cm")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,recursive)10:INTLK_CNTUCLR_ALL")
  field(LNK1, "$(CM,recursive)20:INTLK_CNTUCLR_ALL")
  field(LNK2, "$(CM,recursive)30:INTLK_CNTUCLR_ALL")
  field(LNK3, "$(CM,recursive)40:INTLK_CNTUCLR_ALL")
  field(LNK4, "$(CM,recursive)50:INTLK_CNTUCLR_ALL")
  field(LNK5, "$(CM,recursive)60:INTLK_CNTUCLR_ALL")
  field(LNK6, "$(CM,recursive)70:INTLK_CNTUCLR_ALL")
  field(LNK7, "$(CM,recursive)80:INTLK_CNTUCLR_ALL")
  field(LNK8, "$(CM,recursive)00:RESA:INTLK_CNTUCLR_ALL")
  field(LNK9, "$(CM,recursive)00:RESB:INTLK_CNTUCLR_ALL")
}

record(fanout, "$(CM,undefined)10:INTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(LNK0, "$(CM,undefined)10:SSA_CNTRO")
  field(LNK1, "$(CM,undefined)10:STEPTEMP_CNTRO")
  field(LNK2, "$(CM,undefined)10:CPLRTEMP1_CNTRO")
  field(LNK3, "$(CM,undefined)10:CPLRTEMP2_CNTRO")
  field(LNK4, "$(CM,undefined)10:QUENCH_CNTRO")
  field(LNK5, "$(CM,undefined)10:RESINTLK_CNTRO")
  field(LNK6, "$(CM,undefined)10:RESLINK_CNTRO")
  field(LNK7, "$(CM,undefined)10:PLL_CNTRO")
  field(LNK8, "$(CM,undefined)10:IOCWDOG_CNTRO")
  field(LNK9, "$(CM,undefined)10:CRYO_CNTRO")
  field(LNKA, "$(CM,undefined)10:LO_CNTRO")
  field(LNKB, "$(CM,undefined)10:ADMIN_CNTRO")
  field(LNKC, "$(CM,undefined)10:FB_SUM_CNTRO")
}

record(fanout, "$(CM,undefined)10:INTLK_CNTUCLR_ALL") {
  field(DESC, "Clear all intlk counts for cavity")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,undefined)10:SSA_CNTUCLR")
  field(LNK1, "$(CM,undefined)10:STEPTEMP_CNTUCLR")
  field(LNK2, "$(CM,undefined)10:CPLRTEMP1_CNTUCLR")
  field(LNK3, "$(CM,undefined)10:CPLRTEMP2_CNTUCLR")
  field(LNK4, "$(CM,undefined)10:QUENCH_CNTUCLR")
  field(LNK5, "$(CM,undefined)10:RESINTLK_CNTUCLR")
  field(LNK6, "$(CM,undefined)10:RESLINK_CNTUCLR")
  field(LNK7, "$(CM,undefined)10:PLL_CNTUCLR")
  field(LNK8, "$(CM,undefined)10:IOCWDOG_CNTUCLR")
  field(LNK9, "$(CM,undefined)10:CRYO_CNTUCLR")
  field(LNKA, "$(CM,undefined)10:LO_CNTUCLR")
  field(LNKB, "$(CM,undefined)10:ADMIN_CNTUCLR")
  field(LNKC, "$(CM,undefined)10:FB_SUM_CNTUCLR")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)10:STEPTEMP_CNTPV") {
  field(DESC, "STEPTEMP previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:STEPTEMP_CNTP") {
  field(DESC, "STEPTEMP previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:STEPTEMP_FLTV") {
  field(DESC, "STEPTEMP value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:STEPTEMP_BYPV") {
  field(DESC, "STEPTEMP value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:STEPTEMP_CNTET") {
  field(DESC, "STEPTEMP increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)10:STEPTEMP_CNTSUB") {
  field(DESC, "STEPTEMP fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)10:STEPTEMP_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)10:STEPTEMP_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)10:STEPTEMP_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)10:STEPTEMP_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)10:STEPTEMP_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)10:STEPTEMP_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)10:STEPTEMP_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)10:STEPTEMP_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)10:STEPTEMP_CNTFO PP")
}

record(fanout, "$(CM,undefined)10:STEPTEMP_CNTFO") {
  field(DESC, "STEPTEMP fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)10:STEPTEMP_CNT")
  field(LNK2, "$(CM,undefined)10:STEPTEMP_CNTTC")
  field(LNK3, "$(CM,undefined)10:STEPTEMP_CNTUC")
}

record(calc, "$(CM,undefined)10:STEPTEMP_CNT") {
  field(DESC, "STEPTEMP total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:STEPTEMP_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:STEPTEMP_CNTTC") {
  field(DESC, "STEPTEMP today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:STEPTEMP_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)10:STEPTEMP_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)10:STEPTEMP_CNTT") {
  field(DESC, "STEPTEMP today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)10:STEPTEMP_CNTY") {
  field(DESC, "STEPTEMP yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:STEPTEMP_CNTUC") {
  field(DESC, "STEPTEMP user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:STEPTEMP_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)10:STEPTEMP_CNTU PP")
}

record(longin, "$(CM,undefined)10:STEPTEMP_CNTU") {
  field(DESC, "STEPTEMP user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)10:STEPTEMP_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)10:STEPTEMP_CNTU PP")
}

record(seq, "$(CM,undefined)10:STEPTEMP_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)10:STEPTEMP_CNTT")
  field(LNK1, "$(CM,undefined)10:STEPTEMP_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)10:STEPTEMP_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)10:CPLRTEMP1_CNTPV") {
  field(DESC, "CPLRTEMP1 previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:CPLRTEMP1_CNTP") {
  field(DESC, "CPLRTEMP1 previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:CPLRTEMP1_FLTV") {
  field(DESC, "CPLRTEMP1 value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:CPLRTEMP1_BYPV") {
  field(DESC, "CPLRTEMP1 value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:CPLRTEMP1_CNTET") {
  field(DESC, "CPLRTEMP1 increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)10:CPLRTEMP1_CNTSUB") {
  field(DESC, "CPLRTEMP1 fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)10:CPLRTEMP1_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)10:CPLRTEMP1_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)10:CPLRTEMP1_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)10:CPLRTEMP1_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)10:CPLRTEMP1_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)10:CPLRTEMP1_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)10:CPLRTEMP1_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)10:CPLRTEMP1_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)10:CPLRTEMP1_CNTFO PP")
}

record(fanout, "$(CM,undefined)10:CPLRTEMP1_CNTFO") {
  field(DESC, "CPLRTEMP1 fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)10:CPLRTEMP1_CNT")
  field(LNK2, "$(CM,undefined)10:CPLRTEMP1_CNTTC")
  field(LNK3, "$(CM,undefined)10:CPLRTEMP1_CNTUC")
}

record(calc, "$(CM,undefined)10:CPLRTEMP1_CNT") {
  field(DESC, "CPLRTEMP1 total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:CPLRTEMP1_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:CPLRTEMP1_CNTTC") {
  field(DESC, "CPLRTEMP1 today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:CPLRTEMP1_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)10:CPLRTEMP1_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)10:CPLRTEMP1_CNTT") {
  field(DESC, "CPLRTEMP1 today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)10:CPLRTEMP1_CNTY") {
  field(DESC, "CPLRTEMP1 yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:CPLRTEMP1_CNTUC") {
  field(DESC, "CPLRTEMP1 user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:CPLRTEMP1_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)10:CPLRTEMP1_CNTU PP")
}

record(longin, "$(CM,undefined)10:CPLRTEMP1_CNTU") {
  field(DESC, "CPLRTEMP1 user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)10:CPLRTEMP1_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)10:CPLRTEMP1_CNTU PP")
}

record(seq, "$(CM,undefined)10:CPLRTEMP1_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)10:CPLRTEMP1_CNTT")
  field(LNK1, "$(CM,undefined)10:CPLRTEMP1_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)10:CPLRTEMP1_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)10:CPLRTEMP2_CNTPV") {
  field(DESC, "CPLRTEMP2 previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:CPLRTEMP2_CNTP") {
  field(DESC, "CPLRTEMP2 previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:CPLRTEMP2_FLTV") {
  field(DESC, "CPLRTEMP2 value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:CPLRTEMP2_BYPV") {
  field(DESC, "CPLRTEMP2 value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:CPLRTEMP2_CNTET") {
  field(DESC, "CPLRTEMP2 increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)10:CPLRTEMP2_CNTSUB") {
  field(DESC, "CPLRTEMP2 fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)10:CPLRTEMP2_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)10:CPLRTEMP2_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)10:CPLRTEMP2_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)10:CPLRTEMP2_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)10:CPLRTEMP2_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)10:CPLRTEMP2_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)10:CPLRTEMP2_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)10:CPLRTEMP2_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)10:CPLRTEMP2_CNTFO PP")
}

record(fanout, "$(CM,undefined)10:CPLRTEMP2_CNTFO") {
  field(DESC, "CPLRTEMP2 fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)10:CPLRTEMP2_CNT")
  field(LNK2, "$(CM,undefined)10:CPLRTEMP2_CNTTC")
  field(LNK3, "$(CM,undefined)10:CPLRTEMP2_CNTUC")
}

record(calc, "$(CM,undefined)10:CPLRTEMP2_CNT") {
  field(DESC, "CPLRTEMP2 total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:CPLRTEMP2_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:CPLRTEMP2_CNTTC") {
  field(DESC, "CPLRTEMP2 today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:CPLRTEMP2_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)10:CPLRTEMP2_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)10:CPLRTEMP2_CNTT") {
  field(DESC, "CPLRTEMP2 today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)10:CPLRTEMP2_CNTY") {
  field(DESC, "CPLRTEMP2 yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:CPLRTEMP2_CNTUC") {
  field(DESC, "CPLRTEMP2 user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:CPLRTEMP2_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)10:CPLRTEMP2_CNTU PP")
}

record(longin, "$(CM,undefined)10:CPLRTEMP2_CNTU") {
  field(DESC, "CPLRTEMP2 user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)10:CPLRTEMP2_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)10:CPLRTEMP2_CNTU PP")
}

record(seq, "$(CM,undefined)10:CPLRTEMP2_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)10:CPLRTEMP2_CNTT")
  field(LNK1, "$(CM,undefined)10:CPLRTEMP2_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)10:CPLRTEMP2_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)10:QUENCH_CNTPV") {
  field(DESC, "QUENCH previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:QUENCH_CNTP") {
  field(DESC, "QUENCH previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:QUENCH_FLTV") {
  field(DESC, "QUENCH value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:QUENCH_BYPV") {
  field(DESC, "QUENCH value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:QUENCH_CNTET") {
  field(DESC, "QUENCH increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)10:QUENCH_CNTSUB") {
  field(DESC, "QUENCH fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)10:QUENCH_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)10:QUENCH_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)10:QUENCH_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)10:QUENCH_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)10:QUENCH_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)10:QUENCH_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)10:QUENCH_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)10:QUENCH_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)10:QUENCH_CNTFO PP")
}

record(fanout, "$(CM,undefined)10:QUENCH_CNTFO") {
  field(DESC, "QUENCH fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)10:QUENCH_CNT")
  field(LNK2, "$(CM,undefined)10:QUENCH_CNTTC")
  field(LNK3, "$(CM,undefined)10:QUENCH_CNTUC")
}

record(calc, "$(CM,undefined)10:QUENCH_CNT") {
  field(DESC, "QUENCH total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:QUENCH_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:QUENCH_CNTTC") {
  field(DESC, "QUENCH today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:QUENCH_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)10:QUENCH_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)10:QUENCH_CNTT") {
  field(DESC, "QUENCH today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)10:QUENCH_CNTY") {
  field(DESC, "QUENCH yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:QUENCH_CNTUC") {
  field(DESC, "QUENCH user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:QUENCH_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)10:QUENCH_CNTU PP")
}

record(longin, "$(CM,undefined)10:QUENCH_CNTU") {
  field(DESC, "QUENCH user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)10:QUENCH_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)10:QUENCH_CNTU PP")
}

record(seq, "$(CM,undefined)10:QUENCH_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)10:QUENCH_CNTT")
  field(LNK1, "$(CM,undefined)10:QUENCH_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)10:QUENCH_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)10:RESINTLK_CNTPV") {
  field(DESC, "RESINTLK previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:RESINTLK_CNTP") {
  field(DESC, "RESINTLK previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:RESINTLK_FLTV") {
  field(DESC, "RESINTLK value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:RESINTLK_BYPV") {
  field(DESC, "RESINTLK value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:RESINTLK_CNTET") {
  field(DESC, "RESINTLK increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)10:RESINTLK_CNTSUB") {
  field(DESC, "RESINTLK fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)10:RESINTLK_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)10:RESINTLK_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)10:RESINTLK_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)10:RESINTLK_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)10:RESINTLK_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)10:RESINTLK_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)10:RESINTLK_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)10:RESINTLK_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)10:RESINTLK_CNTFO PP")
}

record(fanout, "$(CM,undefined)10:RESINTLK_CNTFO") {
  field(DESC, "RESINTLK fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)10:RESINTLK_CNT")
  field(LNK2, "$(CM,undefined)10:RESINTLK_CNTTC")
  field(LNK3, "$(CM,undefined)10:RESINTLK_CNTUC")
}

record(calc, "$(CM,undefined)10:RESINTLK_CNT") {
  field(DESC, "RESINTLK total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:RESINTLK_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:RESINTLK_CNTTC") {
  field(DESC, "RESINTLK today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:RESINTLK_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)10:RESINTLK_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)10:RESINTLK_CNTT") {
  field(DESC, "RESINTLK today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)10:RESINTLK_CNTY") {
  field(DESC, "RESINTLK yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:RESINTLK_CNTUC") {
  field(DESC, "RESINTLK user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:RESINTLK_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)10:RESINTLK_CNTU PP")
}

record(longin, "$(CM,undefined)10:RESINTLK_CNTU") {
  field(DESC, "RESINTLK user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)10:RESINTLK_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)10:RESINTLK_CNTU PP")
}

record(seq, "$(CM,undefined)10:RESINTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)10:RESINTLK_CNTT")
  field(LNK1, "$(CM,undefined)10:RESINTLK_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)10:RESINTLK_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)10:RESLINK_CNTPV") {
  field(DESC, "RESLINK previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:RESLINK_CNTP") {
  field(DESC, "RESLINK previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:RESLINK_FLTV") {
  field(DESC, "RESLINK value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:RESLINK_BYPV") {
  field(DESC, "RESLINK value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:RESLINK_CNTET") {
  field(DESC, "RESLINK increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)10:RESLINK_CNTSUB") {
  field(DESC, "RESLINK fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)10:RESLINK_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)10:RESLINK_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)10:RESLINK_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)10:RESLINK_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)10:RESLINK_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)10:RESLINK_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)10:RESLINK_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)10:RESLINK_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)10:RESLINK_CNTFO PP")
}

record(fanout, "$(CM,undefined)10:RESLINK_CNTFO") {
  field(DESC, "RESLINK fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)10:RESLINK_CNT")
  field(LNK2, "$(CM,undefined)10:RESLINK_CNTTC")
  field(LNK3, "$(CM,undefined)10:RESLINK_CNTUC")
}

record(calc, "$(CM,undefined)10:RESLINK_CNT") {
  field(DESC, "RESLINK total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:RESLINK_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:RESLINK_CNTTC") {
  field(DESC, "RESLINK today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:RESLINK_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)10:RESLINK_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)10:RESLINK_CNTT") {
  field(DESC, "RESLINK today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)10:RESLINK_CNTY") {
  field(DESC, "RESLINK yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:RESLINK_CNTUC") {
  field(DESC, "RESLINK user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:RESLINK_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)10:RESLINK_CNTU PP")
}

record(longin, "$(CM,undefined)10:RESLINK_CNTU") {
  field(DESC, "RESLINK user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)10:RESLINK_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)10:RESLINK_CNTU PP")
}

record(seq, "$(CM,undefined)10:RESLINK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)10:RESLINK_CNTT")
  field(LNK1, "$(CM,undefined)10:RESLINK_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)10:RESLINK_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)10:PLL_CNTPV") {
  field(DESC, "PLL previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:PLL_CNTP") {
  field(DESC, "PLL previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:PLL_FLTV") {
  field(DESC, "PLL value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:PLL_BYPV") {
  field(DESC, "PLL value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:PLL_CNTET") {
  field(DESC, "PLL increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)10:PLL_CNTSUB") {
  field(DESC, "PLL fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)10:PLL_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)10:PLL_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)10:PLL_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)10:PLL_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)10:PLL_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)10:PLL_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)10:PLL_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)10:PLL_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)10:PLL_CNTFO PP")
}

record(fanout, "$(CM,undefined)10:PLL_CNTFO") {
  field(DESC, "PLL fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)10:PLL_CNT")
  field(LNK2, "$(CM,undefined)10:PLL_CNTTC")
  field(LNK3, "$(CM,undefined)10:PLL_CNTUC")
}

record(calc, "$(CM,undefined)10:PLL_CNT") {
  field(DESC, "PLL total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:PLL_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:PLL_CNTTC") {
  field(DESC, "PLL today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:PLL_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)10:PLL_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)10:PLL_CNTT") {
  field(DESC, "PLL today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)10:PLL_CNTY") {
  field(DESC, "PLL yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:PLL_CNTUC") {
  field(DESC, "PLL user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:PLL_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)10:PLL_CNTU PP")
}

record(longin, "$(CM,undefined)10:PLL_CNTU") {
  field(DESC, "PLL user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)10:PLL_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)10:PLL_CNTU PP")
}

record(seq, "$(CM,undefined)10:PLL_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)10:PLL_CNTT")
  field(LNK1, "$(CM,undefined)10:PLL_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)10:PLL_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)10:IOCWDOG_CNTPV") {
  field(DESC, "IOCWDOG previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:IOCWDOG_CNTP") {
  field(DESC, "IOCWDOG previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:IOCWDOG_FLTV") {
  field(DESC, "IOCWDOG value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:IOCWDOG_BYPV") {
  field(DESC, "IOCWDOG value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:IOCWDOG_CNTET") {
  field(DESC, "IOCWDOG increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)10:IOCWDOG_CNTSUB") {
  field(DESC, "IOCWDOG fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)10:IOCWDOG_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)10:IOCWDOG_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)10:IOCWDOG_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)10:IOCWDOG_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)10:IOCWDOG_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)10:IOCWDOG_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)10:IOCWDOG_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)10:IOCWDOG_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)10:IOCWDOG_CNTFO PP")
}

record(fanout, "$(CM,undefined)10:IOCWDOG_CNTFO") {
  field(DESC, "IOCWDOG fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)10:IOCWDOG_CNT")
  field(LNK2, "$(CM,undefined)10:IOCWDOG_CNTTC")
  field(LNK3, "$(CM,undefined)10:IOCWDOG_CNTUC")
}

record(calc, "$(CM,undefined)10:IOCWDOG_CNT") {
  field(DESC, "IOCWDOG total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:IOCWDOG_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:IOCWDOG_CNTTC") {
  field(DESC, "IOCWDOG today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:IOCWDOG_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)10:IOCWDOG_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)10:IOCWDOG_CNTT") {
  field(DESC, "IOCWDOG today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)10:IOCWDOG_CNTY") {
  field(DESC, "IOCWDOG yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:IOCWDOG_CNTUC") {
  field(DESC, "IOCWDOG user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:IOCWDOG_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)10:IOCWDOG_CNTU PP")
}

record(longin, "$(CM,undefined)10:IOCWDOG_CNTU") {
  field(DESC, "IOCWDOG user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)10:IOCWDOG_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)10:IOCWDOG_CNTU PP")
}

record(seq, "$(CM,undefined)10:IOCWDOG_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)10:IOCWDOG_CNTT")
  field(LNK1, "$(CM,undefined)10:IOCWDOG_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)10:IOCWDOG_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)10:SSA_CNTPV") {
  field(DESC, "SSA previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:SSA_CNTP") {
  field(DESC, "SSA previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:SSA_FLTV") {
  field(DESC, "SSA value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:SSA_BYPV") {
  field(DESC, "SSA value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:SSA_CNTET") {
  field(DESC, "SSA increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)10:SSA_CNTSUB") {
  field(DESC, "SSA fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)10:SSA_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)10:SSA_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)10:SSA_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)10:SSA_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)10:SSA_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)10:SSA_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)10:SSA_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)10:SSA_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)10:SSA_CNTFO PP")
}

record(fanout, "$(CM,undefined)10:SSA_CNTFO") {
  field(DESC, "SSA fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)10:SSA_CNT")
  field(LNK2, "$(CM,undefined)10:SSA_CNTTC")
  field(LNK3, "$(CM,undefined)10:SSA_CNTUC")
}

record(calc, "$(CM,undefined)10:SSA_CNT") {
  field(DESC, "SSA total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:SSA_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:SSA_CNTTC") {
  field(DESC, "SSA today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:SSA_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)10:SSA_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)10:SSA_CNTT") {
  field(DESC, "SSA today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)10:SSA_CNTY") {
  field(DESC, "SSA yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:SSA_CNTUC") {
  field(DESC, "SSA user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:SSA_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)10:SSA_CNTU PP")
}

record(longin, "$(CM,undefined)10:SSA_CNTU") {
  field(DESC, "SSA user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)10:SSA_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)10:SSA_CNTU PP")
}

record(seq, "$(CM,undefined)10:SSA_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)10:SSA_CNTT")
  field(LNK1, "$(CM,undefined)10:SSA_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)10:SSA_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)10:CRYO_CNTPV") {
  field(DESC, "CRYO previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:CRYO_CNTP") {
  field(DESC, "CRYO previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:CRYO_FLTV") {
  field(DESC, "CRYO value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:CRYO_BYPV") {
  field(DESC, "CRYO value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:CRYO_CNTET") {
  field(DESC, "CRYO increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)10:CRYO_CNTSUB") {
  field(DESC, "CRYO fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)10:CRYO_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)10:CRYO_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)10:CRYO_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)10:CRYO_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)10:CRYO_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)10:CRYO_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)10:CRYO_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)10:CRYO_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)10:CRYO_CNTFO PP")
}

record(fanout, "$(CM,undefined)10:CRYO_CNTFO") {
  field(DESC, "CRYO fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)10:CRYO_CNT")
  field(LNK2, "$(CM,undefined)10:CRYO_CNTTC")
  field(LNK3, "$(CM,undefined)10:CRYO_CNTUC")
}

record(calc, "$(CM,undefined)10:CRYO_CNT") {
  field(DESC, "CRYO total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:CRYO_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:CRYO_CNTTC") {
  field(DESC, "CRYO today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:CRYO_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)10:CRYO_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)10:CRYO_CNTT") {
  field(DESC, "CRYO today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)10:CRYO_CNTY") {
  field(DESC, "CRYO yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:CRYO_CNTUC") {
  field(DESC, "CRYO user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:CRYO_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)10:CRYO_CNTU PP")
}

record(longin, "$(CM,undefined)10:CRYO_CNTU") {
  field(DESC, "CRYO user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)10:CRYO_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)10:CRYO_CNTU PP")
}

record(seq, "$(CM,undefined)10:CRYO_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)10:CRYO_CNTT")
  field(LNK1, "$(CM,undefined)10:CRYO_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)10:CRYO_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)10:LO_CNTPV") {
  field(DESC, "LO previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:LO_CNTP") {
  field(DESC, "LO previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:LO_FLTV") {
  field(DESC, "LO value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:LO_BYPV") {
  field(DESC, "LO value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:LO_CNTET") {
  field(DESC, "LO increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)10:LO_CNTSUB") {
  field(DESC, "LO fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)10:LO_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)10:LO_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)10:LO_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)10:LO_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)10:LO_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)10:LO_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)10:LO_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)10:LO_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)10:LO_CNTFO PP")
}

record(fanout, "$(CM,undefined)10:LO_CNTFO") {
  field(DESC, "LO fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)10:LO_CNT")
  field(LNK2, "$(CM,undefined)10:LO_CNTTC")
  field(LNK3, "$(CM,undefined)10:LO_CNTUC")
}

record(calc, "$(CM,undefined)10:LO_CNT") {
  field(DESC, "LO total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:LO_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:LO_CNTTC") {
  field(DESC, "LO today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:LO_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)10:LO_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)10:LO_CNTT") {
  field(DESC, "LO today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)10:LO_CNTY") {
  field(DESC, "LO yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:LO_CNTUC") {
  field(DESC, "LO user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:LO_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)10:LO_CNTU PP")
}

record(longin, "$(CM,undefined)10:LO_CNTU") {
  field(DESC, "LO user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)10:LO_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)10:LO_CNTU PP")
}

record(seq, "$(CM,undefined)10:LO_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)10:LO_CNTT")
  field(LNK1, "$(CM,undefined)10:LO_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)10:LO_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)10:ADMIN_CNTPV") {
  field(DESC, "ADMIN previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:ADMIN_CNTP") {
  field(DESC, "ADMIN previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:ADMIN_FLTV") {
  field(DESC, "ADMIN value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:ADMIN_BYPV") {
  field(DESC, "ADMIN value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:ADMIN_CNTET") {
  field(DESC, "ADMIN increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)10:ADMIN_CNTSUB") {
  field(DESC, "ADMIN fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)10:ADMIN_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)10:ADMIN_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)10:ADMIN_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)10:ADMIN_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)10:ADMIN_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)10:ADMIN_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)10:ADMIN_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)10:ADMIN_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)10:ADMIN_CNTFO PP")
}

record(fanout, "$(CM,undefined)10:ADMIN_CNTFO") {
  field(DESC, "ADMIN fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)10:ADMIN_CNT")
  field(LNK2, "$(CM,undefined)10:ADMIN_CNTTC")
  field(LNK3, "$(CM,undefined)10:ADMIN_CNTUC")
}

record(calc, "$(CM,undefined)10:ADMIN_CNT") {
  field(DESC, "ADMIN total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:ADMIN_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:ADMIN_CNTTC") {
  field(DESC, "ADMIN today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:ADMIN_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)10:ADMIN_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)10:ADMIN_CNTT") {
  field(DESC, "ADMIN today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)10:ADMIN_CNTY") {
  field(DESC, "ADMIN yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:ADMIN_CNTUC") {
  field(DESC, "ADMIN user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:ADMIN_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)10:ADMIN_CNTU PP")
}

record(longin, "$(CM,undefined)10:ADMIN_CNTU") {
  field(DESC, "ADMIN user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)10:ADMIN_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)10:ADMIN_CNTU PP")
}

record(seq, "$(CM,undefined)10:ADMIN_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)10:ADMIN_CNTT")
  field(LNK1, "$(CM,undefined)10:ADMIN_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)10:ADMIN_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)10:FB_SUM_CNTPV") {
  field(DESC, "FB_SUM previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:FB_SUM_CNTP") {
  field(DESC, "FB_SUM previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:FB_SUM_FLTV") {
  field(DESC, "FB_SUM value indicating fault")
  field(PINI, "YES")
  field(VAL, "2")
}

record(bi, "$(CM,undefined)10:FB_SUM_BYPV") {
  field(DESC, "FB_SUM value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "0")
}

record(bi, "$(CM,undefined)10:FB_SUM_CNTET") {
  field(DESC, "FB_SUM increment counter every time")
  field(PINI, "YES")
  field(VAL, "1")
}

record(aSub, "$(CM,undefined)10:FB_SUM_CNTSUB") {
  field(DESC, "FB_SUM fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)10:FB_SUM")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "$(CM,undefined)10:RFREADYFORBEAM CP")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)10:FB_SUM_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)10:FB_SUM_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)10:FB_SUM_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)10:FB_SUM_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)10:FB_SUM_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)10:FB_SUM_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)10:FB_SUM_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)10:FB_SUM_CNTFO PP")
}

record(fanout, "$(CM,undefined)10:FB_SUM_CNTFO") {
  field(DESC, "FB_SUM fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)10:FB_SUM_CNT")
  field(LNK2, "$(CM,undefined)10:FB_SUM_CNTTC")
  field(LNK3, "$(CM,undefined)10:FB_SUM_CNTUC")
}

record(calc, "$(CM,undefined)10:FB_SUM_CNT") {
  field(DESC, "FB_SUM total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:FB_SUM_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:FB_SUM_CNTTC") {
  field(DESC, "FB_SUM today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:FB_SUM_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)10:FB_SUM_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)10:FB_SUM_CNTT") {
  field(DESC, "FB_SUM today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)10:FB_SUM_CNTY") {
  field(DESC, "FB_SUM yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:FB_SUM_CNTUC") {
  field(DESC, "FB_SUM user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:FB_SUM_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)10:FB_SUM_CNTU PP")
}

record(longin, "$(CM,undefined)10:FB_SUM_CNTU") {
  field(DESC, "FB_SUM user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)10:FB_SUM_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)10:FB_SUM_CNTU PP")
}

record(seq, "$(CM,undefined)10:FB_SUM_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)10:FB_SUM_CNTT")
  field(LNK1, "$(CM,undefined)10:FB_SUM_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)10:FB_SUM_CNTT PP")
}
record(fanout, "$(CM,undefined)20:INTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(LNK0, "$(CM,undefined)20:SSA_CNTRO")
  field(LNK1, "$(CM,undefined)20:STEPTEMP_CNTRO")
  field(LNK2, "$(CM,undefined)20:CPLRTEMP1_CNTRO")
  field(LNK3, "$(CM,undefined)20:CPLRTEMP2_CNTRO")
  field(LNK4, "$(CM,undefined)20:QUENCH_CNTRO")
  field(LNK5, "$(CM,undefined)20:RESINTLK_CNTRO")
  field(LNK6, "$(CM,undefined)20:RESLINK_CNTRO")
  field(LNK7, "$(CM,undefined)20:PLL_CNTRO")
  field(LNK8, "$(CM,undefined)20:IOCWDOG_CNTRO")
  field(LNK9, "$(CM,undefined)20:CRYO_CNTRO")
  field(LNKA, "$(CM,undefined)20:LO_CNTRO")
  field(LNKB, "$(CM,undefined)20:ADMIN_CNTRO")
  field(LNKC, "$(CM,undefined)20:FB_SUM_CNTRO")
}

record(fanout, "$(CM,undefined)20:INTLK_CNTUCLR_ALL") {
  field(DESC, "Clear all intlk counts for cavity")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,undefined)20:SSA_CNTUCLR")
  field(LNK1, "$(CM,undefined)20:STEPTEMP_CNTUCLR")
  field(LNK2, "$(CM,undefined)20:CPLRTEMP1_CNTUCLR")
  field(LNK3, "$(CM,undefined)20:CPLRTEMP2_CNTUCLR")
  field(LNK4, "$(CM,undefined)20:QUENCH_CNTUCLR")
  field(LNK5, "$(CM,undefined)20:RESINTLK_CNTUCLR")
  field(LNK6, "$(CM,undefined)20:RESLINK_CNTUCLR")
  field(LNK7, "$(CM,undefined)20:PLL_CNTUCLR")
  field(LNK8, "$(CM,undefined)20:IOCWDOG_CNTUCLR")
  field(LNK9, "$(CM,undefined)20:CRYO_CNTUCLR")
  field(LNKA, "$(CM,undefined)20:LO_CNTUCLR")
  field(LNKB, "$(CM,undefined)20:ADMIN_CNTUCLR")
  field(LNKC, "$(CM,undefined)20:FB_SUM_CNTUCLR")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)20:STEPTEMP_CNTPV") {
  field(DESC, "STEPTEMP previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:STEPTEMP_CNTP") {
  field(DESC, "STEPTEMP previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:STEPTEMP_FLTV") {
  field(DESC, "STEPTEMP value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:STEPTEMP_BYPV") {
  field(DESC, "STEPTEMP value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:STEPTEMP_CNTET") {
  field(DESC, "STEPTEMP increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)20:STEPTEMP_CNTSUB") {
  field(DESC, "STEPTEMP fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)20:STEPTEMP_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)20:STEPTEMP_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)20:STEPTEMP_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)20:STEPTEMP_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)20:STEPTEMP_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)20:STEPTEMP_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)20:STEPTEMP_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)20:STEPTEMP_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)20:STEPTEMP_CNTFO PP")
}

record(fanout, "$(CM,undefined)20:STEPTEMP_CNTFO") {
  field(DESC, "STEPTEMP fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)20:STEPTEMP_CNT")
  field(LNK2, "$(CM,undefined)20:STEPTEMP_CNTTC")
  field(LNK3, "$(CM,undefined)20:STEPTEMP_CNTUC")
}

record(calc, "$(CM,undefined)20:STEPTEMP_CNT") {
  field(DESC, "STEPTEMP total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:STEPTEMP_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:STEPTEMP_CNTTC") {
  field(DESC, "STEPTEMP today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:STEPTEMP_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)20:STEPTEMP_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)20:STEPTEMP_CNTT") {
  field(DESC, "STEPTEMP today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)20:STEPTEMP_CNTY") {
  field(DESC, "STEPTEMP yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:STEPTEMP_CNTUC") {
  field(DESC, "STEPTEMP user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:STEPTEMP_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)20:STEPTEMP_CNTU PP")
}

record(longin, "$(CM,undefined)20:STEPTEMP_CNTU") {
  field(DESC, "STEPTEMP user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)20:STEPTEMP_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)20:STEPTEMP_CNTU PP")
}

record(seq, "$(CM,undefined)20:STEPTEMP_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)20:STEPTEMP_CNTT")
  field(LNK1, "$(CM,undefined)20:STEPTEMP_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)20:STEPTEMP_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)20:CPLRTEMP1_CNTPV") {
  field(DESC, "CPLRTEMP1 previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:CPLRTEMP1_CNTP") {
  field(DESC, "CPLRTEMP1 previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:CPLRTEMP1_FLTV") {
  field(DESC, "CPLRTEMP1 value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:CPLRTEMP1_BYPV") {
  field(DESC, "CPLRTEMP1 value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:CPLRTEMP1_CNTET") {
  field(DESC, "CPLRTEMP1 increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)20:CPLRTEMP1_CNTSUB") {
  field(DESC, "CPLRTEMP1 fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)20:CPLRTEMP1_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)20:CPLRTEMP1_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)20:CPLRTEMP1_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)20:CPLRTEMP1_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)20:CPLRTEMP1_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)20:CPLRTEMP1_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)20:CPLRTEMP1_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)20:CPLRTEMP1_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)20:CPLRTEMP1_CNTFO PP")
}

record(fanout, "$(CM,undefined)20:CPLRTEMP1_CNTFO") {
  field(DESC, "CPLRTEMP1 fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)20:CPLRTEMP1_CNT")
  field(LNK2, "$(CM,undefined)20:CPLRTEMP1_CNTTC")
  field(LNK3, "$(CM,undefined)20:CPLRTEMP1_CNTUC")
}

record(calc, "$(CM,undefined)20:CPLRTEMP1_CNT") {
  field(DESC, "CPLRTEMP1 total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:CPLRTEMP1_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:CPLRTEMP1_CNTTC") {
  field(DESC, "CPLRTEMP1 today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:CPLRTEMP1_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)20:CPLRTEMP1_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)20:CPLRTEMP1_CNTT") {
  field(DESC, "CPLRTEMP1 today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)20:CPLRTEMP1_CNTY") {
  field(DESC, "CPLRTEMP1 yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:CPLRTEMP1_CNTUC") {
  field(DESC, "CPLRTEMP1 user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:CPLRTEMP1_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)20:CPLRTEMP1_CNTU PP")
}

record(longin, "$(CM,undefined)20:CPLRTEMP1_CNTU") {
  field(DESC, "CPLRTEMP1 user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)20:CPLRTEMP1_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)20:CPLRTEMP1_CNTU PP")
}

record(seq, "$(CM,undefined)20:CPLRTEMP1_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)20:CPLRTEMP1_CNTT")
  field(LNK1, "$(CM,undefined)20:CPLRTEMP1_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)20:CPLRTEMP1_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)20:CPLRTEMP2_CNTPV") {
  field(DESC, "CPLRTEMP2 previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:CPLRTEMP2_CNTP") {
  field(DESC, "CPLRTEMP2 previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:CPLRTEMP2_FLTV") {
  field(DESC, "CPLRTEMP2 value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:CPLRTEMP2_BYPV") {
  field(DESC, "CPLRTEMP2 value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:CPLRTEMP2_CNTET") {
  field(DESC, "CPLRTEMP2 increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)20:CPLRTEMP2_CNTSUB") {
  field(DESC, "CPLRTEMP2 fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)20:CPLRTEMP2_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)20:CPLRTEMP2_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)20:CPLRTEMP2_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)20:CPLRTEMP2_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)20:CPLRTEMP2_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)20:CPLRTEMP2_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)20:CPLRTEMP2_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)20:CPLRTEMP2_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)20:CPLRTEMP2_CNTFO PP")
}

record(fanout, "$(CM,undefined)20:CPLRTEMP2_CNTFO") {
  field(DESC, "CPLRTEMP2 fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)20:CPLRTEMP2_CNT")
  field(LNK2, "$(CM,undefined)20:CPLRTEMP2_CNTTC")
  field(LNK3, "$(CM,undefined)20:CPLRTEMP2_CNTUC")
}

record(calc, "$(CM,undefined)20:CPLRTEMP2_CNT") {
  field(DESC, "CPLRTEMP2 total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:CPLRTEMP2_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:CPLRTEMP2_CNTTC") {
  field(DESC, "CPLRTEMP2 today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:CPLRTEMP2_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)20:CPLRTEMP2_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)20:CPLRTEMP2_CNTT") {
  field(DESC, "CPLRTEMP2 today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)20:CPLRTEMP2_CNTY") {
  field(DESC, "CPLRTEMP2 yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:CPLRTEMP2_CNTUC") {
  field(DESC, "CPLRTEMP2 user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:CPLRTEMP2_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)20:CPLRTEMP2_CNTU PP")
}

record(longin, "$(CM,undefined)20:CPLRTEMP2_CNTU") {
  field(DESC, "CPLRTEMP2 user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)20:CPLRTEMP2_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)20:CPLRTEMP2_CNTU PP")
}

record(seq, "$(CM,undefined)20:CPLRTEMP2_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)20:CPLRTEMP2_CNTT")
  field(LNK1, "$(CM,undefined)20:CPLRTEMP2_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)20:CPLRTEMP2_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)20:QUENCH_CNTPV") {
  field(DESC, "QUENCH previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:QUENCH_CNTP") {
  field(DESC, "QUENCH previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:QUENCH_FLTV") {
  field(DESC, "QUENCH value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:QUENCH_BYPV") {
  field(DESC, "QUENCH value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:QUENCH_CNTET") {
  field(DESC, "QUENCH increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)20:QUENCH_CNTSUB") {
  field(DESC, "QUENCH fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)20:QUENCH_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)20:QUENCH_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)20:QUENCH_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)20:QUENCH_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)20:QUENCH_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)20:QUENCH_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)20:QUENCH_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)20:QUENCH_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)20:QUENCH_CNTFO PP")
}

record(fanout, "$(CM,undefined)20:QUENCH_CNTFO") {
  field(DESC, "QUENCH fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)20:QUENCH_CNT")
  field(LNK2, "$(CM,undefined)20:QUENCH_CNTTC")
  field(LNK3, "$(CM,undefined)20:QUENCH_CNTUC")
}

record(calc, "$(CM,undefined)20:QUENCH_CNT") {
  field(DESC, "QUENCH total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:QUENCH_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:QUENCH_CNTTC") {
  field(DESC, "QUENCH today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:QUENCH_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)20:QUENCH_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)20:QUENCH_CNTT") {
  field(DESC, "QUENCH today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)20:QUENCH_CNTY") {
  field(DESC, "QUENCH yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:QUENCH_CNTUC") {
  field(DESC, "QUENCH user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:QUENCH_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)20:QUENCH_CNTU PP")
}

record(longin, "$(CM,undefined)20:QUENCH_CNTU") {
  field(DESC, "QUENCH user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)20:QUENCH_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)20:QUENCH_CNTU PP")
}

record(seq, "$(CM,undefined)20:QUENCH_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)20:QUENCH_CNTT")
  field(LNK1, "$(CM,undefined)20:QUENCH_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)20:QUENCH_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)20:RESINTLK_CNTPV") {
  field(DESC, "RESINTLK previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:RESINTLK_CNTP") {
  field(DESC, "RESINTLK previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:RESINTLK_FLTV") {
  field(DESC, "RESINTLK value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:RESINTLK_BYPV") {
  field(DESC, "RESINTLK value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:RESINTLK_CNTET") {
  field(DESC, "RESINTLK increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)20:RESINTLK_CNTSUB") {
  field(DESC, "RESINTLK fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)20:RESINTLK_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)20:RESINTLK_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)20:RESINTLK_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)20:RESINTLK_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)20:RESINTLK_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)20:RESINTLK_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)20:RESINTLK_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)20:RESINTLK_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)20:RESINTLK_CNTFO PP")
}

record(fanout, "$(CM,undefined)20:RESINTLK_CNTFO") {
  field(DESC, "RESINTLK fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)20:RESINTLK_CNT")
  field(LNK2, "$(CM,undefined)20:RESINTLK_CNTTC")
  field(LNK3, "$(CM,undefined)20:RESINTLK_CNTUC")
}

record(calc, "$(CM,undefined)20:RESINTLK_CNT") {
  field(DESC, "RESINTLK total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:RESINTLK_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:RESINTLK_CNTTC") {
  field(DESC, "RESINTLK today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:RESINTLK_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)20:RESINTLK_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)20:RESINTLK_CNTT") {
  field(DESC, "RESINTLK today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)20:RESINTLK_CNTY") {
  field(DESC, "RESINTLK yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:RESINTLK_CNTUC") {
  field(DESC, "RESINTLK user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:RESINTLK_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)20:RESINTLK_CNTU PP")
}

record(longin, "$(CM,undefined)20:RESINTLK_CNTU") {
  field(DESC, "RESINTLK user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)20:RESINTLK_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)20:RESINTLK_CNTU PP")
}

record(seq, "$(CM,undefined)20:RESINTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)20:RESINTLK_CNTT")
  field(LNK1, "$(CM,undefined)20:RESINTLK_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)20:RESINTLK_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)20:RESLINK_CNTPV") {
  field(DESC, "RESLINK previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:RESLINK_CNTP") {
  field(DESC, "RESLINK previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:RESLINK_FLTV") {
  field(DESC, "RESLINK value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:RESLINK_BYPV") {
  field(DESC, "RESLINK value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:RESLINK_CNTET") {
  field(DESC, "RESLINK increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)20:RESLINK_CNTSUB") {
  field(DESC, "RESLINK fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)20:RESLINK_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)20:RESLINK_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)20:RESLINK_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)20:RESLINK_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)20:RESLINK_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)20:RESLINK_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)20:RESLINK_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)20:RESLINK_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)20:RESLINK_CNTFO PP")
}

record(fanout, "$(CM,undefined)20:RESLINK_CNTFO") {
  field(DESC, "RESLINK fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)20:RESLINK_CNT")
  field(LNK2, "$(CM,undefined)20:RESLINK_CNTTC")
  field(LNK3, "$(CM,undefined)20:RESLINK_CNTUC")
}

record(calc, "$(CM,undefined)20:RESLINK_CNT") {
  field(DESC, "RESLINK total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:RESLINK_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:RESLINK_CNTTC") {
  field(DESC, "RESLINK today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:RESLINK_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)20:RESLINK_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)20:RESLINK_CNTT") {
  field(DESC, "RESLINK today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)20:RESLINK_CNTY") {
  field(DESC, "RESLINK yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:RESLINK_CNTUC") {
  field(DESC, "RESLINK user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:RESLINK_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)20:RESLINK_CNTU PP")
}

record(longin, "$(CM,undefined)20:RESLINK_CNTU") {
  field(DESC, "RESLINK user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)20:RESLINK_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)20:RESLINK_CNTU PP")
}

record(seq, "$(CM,undefined)20:RESLINK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)20:RESLINK_CNTT")
  field(LNK1, "$(CM,undefined)20:RESLINK_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)20:RESLINK_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)20:PLL_CNTPV") {
  field(DESC, "PLL previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:PLL_CNTP") {
  field(DESC, "PLL previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:PLL_FLTV") {
  field(DESC, "PLL value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:PLL_BYPV") {
  field(DESC, "PLL value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:PLL_CNTET") {
  field(DESC, "PLL increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)20:PLL_CNTSUB") {
  field(DESC, "PLL fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)20:PLL_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)20:PLL_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)20:PLL_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)20:PLL_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)20:PLL_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)20:PLL_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)20:PLL_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)20:PLL_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)20:PLL_CNTFO PP")
}

record(fanout, "$(CM,undefined)20:PLL_CNTFO") {
  field(DESC, "PLL fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)20:PLL_CNT")
  field(LNK2, "$(CM,undefined)20:PLL_CNTTC")
  field(LNK3, "$(CM,undefined)20:PLL_CNTUC")
}

record(calc, "$(CM,undefined)20:PLL_CNT") {
  field(DESC, "PLL total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:PLL_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:PLL_CNTTC") {
  field(DESC, "PLL today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:PLL_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)20:PLL_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)20:PLL_CNTT") {
  field(DESC, "PLL today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)20:PLL_CNTY") {
  field(DESC, "PLL yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:PLL_CNTUC") {
  field(DESC, "PLL user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:PLL_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)20:PLL_CNTU PP")
}

record(longin, "$(CM,undefined)20:PLL_CNTU") {
  field(DESC, "PLL user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)20:PLL_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)20:PLL_CNTU PP")
}

record(seq, "$(CM,undefined)20:PLL_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)20:PLL_CNTT")
  field(LNK1, "$(CM,undefined)20:PLL_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)20:PLL_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)20:IOCWDOG_CNTPV") {
  field(DESC, "IOCWDOG previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:IOCWDOG_CNTP") {
  field(DESC, "IOCWDOG previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:IOCWDOG_FLTV") {
  field(DESC, "IOCWDOG value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:IOCWDOG_BYPV") {
  field(DESC, "IOCWDOG value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:IOCWDOG_CNTET") {
  field(DESC, "IOCWDOG increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)20:IOCWDOG_CNTSUB") {
  field(DESC, "IOCWDOG fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)20:IOCWDOG_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)20:IOCWDOG_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)20:IOCWDOG_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)20:IOCWDOG_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)20:IOCWDOG_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)20:IOCWDOG_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)20:IOCWDOG_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)20:IOCWDOG_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)20:IOCWDOG_CNTFO PP")
}

record(fanout, "$(CM,undefined)20:IOCWDOG_CNTFO") {
  field(DESC, "IOCWDOG fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)20:IOCWDOG_CNT")
  field(LNK2, "$(CM,undefined)20:IOCWDOG_CNTTC")
  field(LNK3, "$(CM,undefined)20:IOCWDOG_CNTUC")
}

record(calc, "$(CM,undefined)20:IOCWDOG_CNT") {
  field(DESC, "IOCWDOG total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:IOCWDOG_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:IOCWDOG_CNTTC") {
  field(DESC, "IOCWDOG today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:IOCWDOG_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)20:IOCWDOG_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)20:IOCWDOG_CNTT") {
  field(DESC, "IOCWDOG today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)20:IOCWDOG_CNTY") {
  field(DESC, "IOCWDOG yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:IOCWDOG_CNTUC") {
  field(DESC, "IOCWDOG user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:IOCWDOG_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)20:IOCWDOG_CNTU PP")
}

record(longin, "$(CM,undefined)20:IOCWDOG_CNTU") {
  field(DESC, "IOCWDOG user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)20:IOCWDOG_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)20:IOCWDOG_CNTU PP")
}

record(seq, "$(CM,undefined)20:IOCWDOG_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)20:IOCWDOG_CNTT")
  field(LNK1, "$(CM,undefined)20:IOCWDOG_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)20:IOCWDOG_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)20:SSA_CNTPV") {
  field(DESC, "SSA previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:SSA_CNTP") {
  field(DESC, "SSA previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:SSA_FLTV") {
  field(DESC, "SSA value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:SSA_BYPV") {
  field(DESC, "SSA value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:SSA_CNTET") {
  field(DESC, "SSA increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)20:SSA_CNTSUB") {
  field(DESC, "SSA fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)20:SSA_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)20:SSA_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)20:SSA_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)20:SSA_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)20:SSA_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)20:SSA_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)20:SSA_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)20:SSA_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)20:SSA_CNTFO PP")
}

record(fanout, "$(CM,undefined)20:SSA_CNTFO") {
  field(DESC, "SSA fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)20:SSA_CNT")
  field(LNK2, "$(CM,undefined)20:SSA_CNTTC")
  field(LNK3, "$(CM,undefined)20:SSA_CNTUC")
}

record(calc, "$(CM,undefined)20:SSA_CNT") {
  field(DESC, "SSA total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:SSA_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:SSA_CNTTC") {
  field(DESC, "SSA today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:SSA_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)20:SSA_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)20:SSA_CNTT") {
  field(DESC, "SSA today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)20:SSA_CNTY") {
  field(DESC, "SSA yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:SSA_CNTUC") {
  field(DESC, "SSA user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:SSA_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)20:SSA_CNTU PP")
}

record(longin, "$(CM,undefined)20:SSA_CNTU") {
  field(DESC, "SSA user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)20:SSA_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)20:SSA_CNTU PP")
}

record(seq, "$(CM,undefined)20:SSA_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)20:SSA_CNTT")
  field(LNK1, "$(CM,undefined)20:SSA_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)20:SSA_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)20:CRYO_CNTPV") {
  field(DESC, "CRYO previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:CRYO_CNTP") {
  field(DESC, "CRYO previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:CRYO_FLTV") {
  field(DESC, "CRYO value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:CRYO_BYPV") {
  field(DESC, "CRYO value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:CRYO_CNTET") {
  field(DESC, "CRYO increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)20:CRYO_CNTSUB") {
  field(DESC, "CRYO fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)20:CRYO_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)20:CRYO_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)20:CRYO_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)20:CRYO_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)20:CRYO_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)20:CRYO_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)20:CRYO_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)20:CRYO_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)20:CRYO_CNTFO PP")
}

record(fanout, "$(CM,undefined)20:CRYO_CNTFO") {
  field(DESC, "CRYO fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)20:CRYO_CNT")
  field(LNK2, "$(CM,undefined)20:CRYO_CNTTC")
  field(LNK3, "$(CM,undefined)20:CRYO_CNTUC")
}

record(calc, "$(CM,undefined)20:CRYO_CNT") {
  field(DESC, "CRYO total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:CRYO_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:CRYO_CNTTC") {
  field(DESC, "CRYO today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:CRYO_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)20:CRYO_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)20:CRYO_CNTT") {
  field(DESC, "CRYO today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)20:CRYO_CNTY") {
  field(DESC, "CRYO yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:CRYO_CNTUC") {
  field(DESC, "CRYO user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:CRYO_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)20:CRYO_CNTU PP")
}

record(longin, "$(CM,undefined)20:CRYO_CNTU") {
  field(DESC, "CRYO user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)20:CRYO_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)20:CRYO_CNTU PP")
}

record(seq, "$(CM,undefined)20:CRYO_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)20:CRYO_CNTT")
  field(LNK1, "$(CM,undefined)20:CRYO_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)20:CRYO_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)20:LO_CNTPV") {
  field(DESC, "LO previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:LO_CNTP") {
  field(DESC, "LO previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:LO_FLTV") {
  field(DESC, "LO value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:LO_BYPV") {
  field(DESC, "LO value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:LO_CNTET") {
  field(DESC, "LO increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)20:LO_CNTSUB") {
  field(DESC, "LO fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)20:LO_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)20:LO_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)20:LO_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)20:LO_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)20:LO_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)20:LO_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)20:LO_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)20:LO_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)20:LO_CNTFO PP")
}

record(fanout, "$(CM,undefined)20:LO_CNTFO") {
  field(DESC, "LO fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)20:LO_CNT")
  field(LNK2, "$(CM,undefined)20:LO_CNTTC")
  field(LNK3, "$(CM,undefined)20:LO_CNTUC")
}

record(calc, "$(CM,undefined)20:LO_CNT") {
  field(DESC, "LO total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:LO_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:LO_CNTTC") {
  field(DESC, "LO today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:LO_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)20:LO_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)20:LO_CNTT") {
  field(DESC, "LO today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)20:LO_CNTY") {
  field(DESC, "LO yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:LO_CNTUC") {
  field(DESC, "LO user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:LO_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)20:LO_CNTU PP")
}

record(longin, "$(CM,undefined)20:LO_CNTU") {
  field(DESC, "LO user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)20:LO_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)20:LO_CNTU PP")
}

record(seq, "$(CM,undefined)20:LO_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)20:LO_CNTT")
  field(LNK1, "$(CM,undefined)20:LO_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)20:LO_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)20:ADMIN_CNTPV") {
  field(DESC, "ADMIN previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:ADMIN_CNTP") {
  field(DESC, "ADMIN previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:ADMIN_FLTV") {
  field(DESC, "ADMIN value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:ADMIN_BYPV") {
  field(DESC, "ADMIN value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)20:ADMIN_CNTET") {
  field(DESC, "ADMIN increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)20:ADMIN_CNTSUB") {
  field(DESC, "ADMIN fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)20:ADMIN_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)20:ADMIN_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)20:ADMIN_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)20:ADMIN_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)20:ADMIN_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)20:ADMIN_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)20:ADMIN_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)20:ADMIN_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)20:ADMIN_CNTFO PP")
}

record(fanout, "$(CM,undefined)20:ADMIN_CNTFO") {
  field(DESC, "ADMIN fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)20:ADMIN_CNT")
  field(LNK2, "$(CM,undefined)20:ADMIN_CNTTC")
  field(LNK3, "$(CM,undefined)20:ADMIN_CNTUC")
}

record(calc, "$(CM,undefined)20:ADMIN_CNT") {
  field(DESC, "ADMIN total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:ADMIN_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:ADMIN_CNTTC") {
  field(DESC, "ADMIN today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:ADMIN_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)20:ADMIN_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)20:ADMIN_CNTT") {
  field(DESC, "ADMIN today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)20:ADMIN_CNTY") {
  field(DESC, "ADMIN yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:ADMIN_CNTUC") {
  field(DESC, "ADMIN user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:ADMIN_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)20:ADMIN_CNTU PP")
}

record(longin, "$(CM,undefined)20:ADMIN_CNTU") {
  field(DESC, "ADMIN user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)20:ADMIN_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)20:ADMIN_CNTU PP")
}

record(seq, "$(CM,undefined)20:ADMIN_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)20:ADMIN_CNTT")
  field(LNK1, "$(CM,undefined)20:ADMIN_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)20:ADMIN_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)20:FB_SUM_CNTPV") {
  field(DESC, "FB_SUM previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:FB_SUM_CNTP") {
  field(DESC, "FB_SUM previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)20:FB_SUM_FLTV") {
  field(DESC, "FB_SUM value indicating fault")
  field(PINI, "YES")
  field(VAL, "2")
}

record(bi, "$(CM,undefined)20:FB_SUM_BYPV") {
  field(DESC, "FB_SUM value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "0")
}

record(bi, "$(CM,undefined)20:FB_SUM_CNTET") {
  field(DESC, "FB_SUM increment counter every time")
  field(PINI, "YES")
  field(VAL, "1")
}

record(aSub, "$(CM,undefined)20:FB_SUM_CNTSUB") {
  field(DESC, "FB_SUM fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)20:FB_SUM")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "$(CM,undefined)20:RFREADYFORBEAM CP")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)20:FB_SUM_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)20:FB_SUM_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)20:FB_SUM_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)20:FB_SUM_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)20:FB_SUM_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)20:FB_SUM_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)20:FB_SUM_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)20:FB_SUM_CNTFO PP")
}

record(fanout, "$(CM,undefined)20:FB_SUM_CNTFO") {
  field(DESC, "FB_SUM fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)20:FB_SUM_CNT")
  field(LNK2, "$(CM,undefined)20:FB_SUM_CNTTC")
  field(LNK3, "$(CM,undefined)20:FB_SUM_CNTUC")
}

record(calc, "$(CM,undefined)20:FB_SUM_CNT") {
  field(DESC, "FB_SUM total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:FB_SUM_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:FB_SUM_CNTTC") {
  field(DESC, "FB_SUM today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:FB_SUM_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)20:FB_SUM_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)20:FB_SUM_CNTT") {
  field(DESC, "FB_SUM today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)20:FB_SUM_CNTY") {
  field(DESC, "FB_SUM yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)20:FB_SUM_CNTUC") {
  field(DESC, "FB_SUM user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)20:FB_SUM_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)20:FB_SUM_CNTU PP")
}

record(longin, "$(CM,undefined)20:FB_SUM_CNTU") {
  field(DESC, "FB_SUM user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)20:FB_SUM_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)20:FB_SUM_CNTU PP")
}

record(seq, "$(CM,undefined)20:FB_SUM_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)20:FB_SUM_CNTT")
  field(LNK1, "$(CM,undefined)20:FB_SUM_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)20:FB_SUM_CNTT PP")
}
record(fanout, "$(CM,undefined)30:INTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(LNK0, "$(CM,undefined)30:SSA_CNTRO")
  field(LNK1, "$(CM,undefined)30:STEPTEMP_CNTRO")
  field(LNK2, "$(CM,undefined)30:CPLRTEMP1_CNTRO")
  field(LNK3, "$(CM,undefined)30:CPLRTEMP2_CNTRO")
  field(LNK4, "$(CM,undefined)30:QUENCH_CNTRO")
  field(LNK5, "$(CM,undefined)30:RESINTLK_CNTRO")
  field(LNK6, "$(CM,undefined)30:RESLINK_CNTRO")
  field(LNK7, "$(CM,undefined)30:PLL_CNTRO")
  field(LNK8, "$(CM,undefined)30:IOCWDOG_CNTRO")
  field(LNK9, "$(CM,undefined)30:CRYO_CNTRO")
  field(LNKA, "$(CM,undefined)30:LO_CNTRO")
  field(LNKB, "$(CM,undefined)30:ADMIN_CNTRO")
  field(LNKC, "$(CM,undefined)30:FB_SUM_CNTRO")
}

record(fanout, "$(CM,undefined)30:INTLK_CNTUCLR_ALL") {
  field(DESC, "Clear all intlk counts for cavity")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,undefined)30:SSA_CNTUCLR")
  field(LNK1, "$(CM,undefined)30:STEPTEMP_CNTUCLR")
  field(LNK2, "$(CM,undefined)30:CPLRTEMP1_CNTUCLR")
  field(LNK3, "$(CM,undefined)30:CPLRTEMP2_CNTUCLR")
  field(LNK4, "$(CM,undefined)30:QUENCH_CNTUCLR")
  field(LNK5, "$(CM,undefined)30:RESINTLK_CNTUCLR")
  field(LNK6, "$(CM,undefined)30:RESLINK_CNTUCLR")
  field(LNK7, "$(CM,undefined)30:PLL_CNTUCLR")
  field(LNK8, "$(CM,undefined)30:IOCWDOG_CNTUCLR")
  field(LNK9, "$(CM,undefined)30:CRYO_CNTUCLR")
  field(LNKA, "$(CM,undefined)30:LO_CNTUCLR")
  field(LNKB, "$(CM,undefined)30:ADMIN_CNTUCLR")
  field(LNKC, "$(CM,undefined)30:FB_SUM_CNTUCLR")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)30:STEPTEMP_CNTPV") {
  field(DESC, "STEPTEMP previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:STEPTEMP_CNTP") {
  field(DESC, "STEPTEMP previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:STEPTEMP_FLTV") {
  field(DESC, "STEPTEMP value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:STEPTEMP_BYPV") {
  field(DESC, "STEPTEMP value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:STEPTEMP_CNTET") {
  field(DESC, "STEPTEMP increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)30:STEPTEMP_CNTSUB") {
  field(DESC, "STEPTEMP fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)30:STEPTEMP_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)30:STEPTEMP_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)30:STEPTEMP_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)30:STEPTEMP_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)30:STEPTEMP_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)30:STEPTEMP_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)30:STEPTEMP_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)30:STEPTEMP_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)30:STEPTEMP_CNTFO PP")
}

record(fanout, "$(CM,undefined)30:STEPTEMP_CNTFO") {
  field(DESC, "STEPTEMP fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)30:STEPTEMP_CNT")
  field(LNK2, "$(CM,undefined)30:STEPTEMP_CNTTC")
  field(LNK3, "$(CM,undefined)30:STEPTEMP_CNTUC")
}

record(calc, "$(CM,undefined)30:STEPTEMP_CNT") {
  field(DESC, "STEPTEMP total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:STEPTEMP_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:STEPTEMP_CNTTC") {
  field(DESC, "STEPTEMP today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:STEPTEMP_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)30:STEPTEMP_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)30:STEPTEMP_CNTT") {
  field(DESC, "STEPTEMP today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)30:STEPTEMP_CNTY") {
  field(DESC, "STEPTEMP yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:STEPTEMP_CNTUC") {
  field(DESC, "STEPTEMP user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:STEPTEMP_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)30:STEPTEMP_CNTU PP")
}

record(longin, "$(CM,undefined)30:STEPTEMP_CNTU") {
  field(DESC, "STEPTEMP user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)30:STEPTEMP_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)30:STEPTEMP_CNTU PP")
}

record(seq, "$(CM,undefined)30:STEPTEMP_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)30:STEPTEMP_CNTT")
  field(LNK1, "$(CM,undefined)30:STEPTEMP_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)30:STEPTEMP_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)30:CPLRTEMP1_CNTPV") {
  field(DESC, "CPLRTEMP1 previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:CPLRTEMP1_CNTP") {
  field(DESC, "CPLRTEMP1 previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:CPLRTEMP1_FLTV") {
  field(DESC, "CPLRTEMP1 value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:CPLRTEMP1_BYPV") {
  field(DESC, "CPLRTEMP1 value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:CPLRTEMP1_CNTET") {
  field(DESC, "CPLRTEMP1 increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)30:CPLRTEMP1_CNTSUB") {
  field(DESC, "CPLRTEMP1 fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)30:CPLRTEMP1_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)30:CPLRTEMP1_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)30:CPLRTEMP1_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)30:CPLRTEMP1_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)30:CPLRTEMP1_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)30:CPLRTEMP1_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)30:CPLRTEMP1_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)30:CPLRTEMP1_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)30:CPLRTEMP1_CNTFO PP")
}

record(fanout, "$(CM,undefined)30:CPLRTEMP1_CNTFO") {
  field(DESC, "CPLRTEMP1 fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)30:CPLRTEMP1_CNT")
  field(LNK2, "$(CM,undefined)30:CPLRTEMP1_CNTTC")
  field(LNK3, "$(CM,undefined)30:CPLRTEMP1_CNTUC")
}

record(calc, "$(CM,undefined)30:CPLRTEMP1_CNT") {
  field(DESC, "CPLRTEMP1 total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:CPLRTEMP1_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:CPLRTEMP1_CNTTC") {
  field(DESC, "CPLRTEMP1 today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:CPLRTEMP1_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)30:CPLRTEMP1_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)30:CPLRTEMP1_CNTT") {
  field(DESC, "CPLRTEMP1 today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)30:CPLRTEMP1_CNTY") {
  field(DESC, "CPLRTEMP1 yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:CPLRTEMP1_CNTUC") {
  field(DESC, "CPLRTEMP1 user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:CPLRTEMP1_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)30:CPLRTEMP1_CNTU PP")
}

record(longin, "$(CM,undefined)30:CPLRTEMP1_CNTU") {
  field(DESC, "CPLRTEMP1 user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)30:CPLRTEMP1_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)30:CPLRTEMP1_CNTU PP")
}

record(seq, "$(CM,undefined)30:CPLRTEMP1_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)30:CPLRTEMP1_CNTT")
  field(LNK1, "$(CM,undefined)30:CPLRTEMP1_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)30:CPLRTEMP1_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)30:CPLRTEMP2_CNTPV") {
  field(DESC, "CPLRTEMP2 previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:CPLRTEMP2_CNTP") {
  field(DESC, "CPLRTEMP2 previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:CPLRTEMP2_FLTV") {
  field(DESC, "CPLRTEMP2 value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:CPLRTEMP2_BYPV") {
  field(DESC, "CPLRTEMP2 value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:CPLRTEMP2_CNTET") {
  field(DESC, "CPLRTEMP2 increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)30:CPLRTEMP2_CNTSUB") {
  field(DESC, "CPLRTEMP2 fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)30:CPLRTEMP2_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)30:CPLRTEMP2_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)30:CPLRTEMP2_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)30:CPLRTEMP2_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)30:CPLRTEMP2_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)30:CPLRTEMP2_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)30:CPLRTEMP2_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)30:CPLRTEMP2_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)30:CPLRTEMP2_CNTFO PP")
}

record(fanout, "$(CM,undefined)30:CPLRTEMP2_CNTFO") {
  field(DESC, "CPLRTEMP2 fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)30:CPLRTEMP2_CNT")
  field(LNK2, "$(CM,undefined)30:CPLRTEMP2_CNTTC")
  field(LNK3, "$(CM,undefined)30:CPLRTEMP2_CNTUC")
}

record(calc, "$(CM,undefined)30:CPLRTEMP2_CNT") {
  field(DESC, "CPLRTEMP2 total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:CPLRTEMP2_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:CPLRTEMP2_CNTTC") {
  field(DESC, "CPLRTEMP2 today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:CPLRTEMP2_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)30:CPLRTEMP2_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)30:CPLRTEMP2_CNTT") {
  field(DESC, "CPLRTEMP2 today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)30:CPLRTEMP2_CNTY") {
  field(DESC, "CPLRTEMP2 yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:CPLRTEMP2_CNTUC") {
  field(DESC, "CPLRTEMP2 user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:CPLRTEMP2_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)30:CPLRTEMP2_CNTU PP")
}

record(longin, "$(CM,undefined)30:CPLRTEMP2_CNTU") {
  field(DESC, "CPLRTEMP2 user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)30:CPLRTEMP2_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)30:CPLRTEMP2_CNTU PP")
}

record(seq, "$(CM,undefined)30:CPLRTEMP2_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)30:CPLRTEMP2_CNTT")
  field(LNK1, "$(CM,undefined)30:CPLRTEMP2_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)30:CPLRTEMP2_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)30:QUENCH_CNTPV") {
  field(DESC, "QUENCH previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:QUENCH_CNTP") {
  field(DESC, "QUENCH previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:QUENCH_FLTV") {
  field(DESC, "QUENCH value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:QUENCH_BYPV") {
  field(DESC, "QUENCH value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:QUENCH_CNTET") {
  field(DESC, "QUENCH increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)30:QUENCH_CNTSUB") {
  field(DESC, "QUENCH fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)30:QUENCH_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)30:QUENCH_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)30:QUENCH_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)30:QUENCH_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)30:QUENCH_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)30:QUENCH_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)30:QUENCH_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)30:QUENCH_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)30:QUENCH_CNTFO PP")
}

record(fanout, "$(CM,undefined)30:QUENCH_CNTFO") {
  field(DESC, "QUENCH fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)30:QUENCH_CNT")
  field(LNK2, "$(CM,undefined)30:QUENCH_CNTTC")
  field(LNK3, "$(CM,undefined)30:QUENCH_CNTUC")
}

record(calc, "$(CM,undefined)30:QUENCH_CNT") {
  field(DESC, "QUENCH total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:QUENCH_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:QUENCH_CNTTC") {
  field(DESC, "QUENCH today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:QUENCH_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)30:QUENCH_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)30:QUENCH_CNTT") {
  field(DESC, "QUENCH today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)30:QUENCH_CNTY") {
  field(DESC, "QUENCH yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:QUENCH_CNTUC") {
  field(DESC, "QUENCH user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:QUENCH_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)30:QUENCH_CNTU PP")
}

record(longin, "$(CM,undefined)30:QUENCH_CNTU") {
  field(DESC, "QUENCH user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)30:QUENCH_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)30:QUENCH_CNTU PP")
}

record(seq, "$(CM,undefined)30:QUENCH_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)30:QUENCH_CNTT")
  field(LNK1, "$(CM,undefined)30:QUENCH_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)30:QUENCH_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)30:RESINTLK_CNTPV") {
  field(DESC, "RESINTLK previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:RESINTLK_CNTP") {
  field(DESC, "RESINTLK previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:RESINTLK_FLTV") {
  field(DESC, "RESINTLK value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:RESINTLK_BYPV") {
  field(DESC, "RESINTLK value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:RESINTLK_CNTET") {
  field(DESC, "RESINTLK increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)30:RESINTLK_CNTSUB") {
  field(DESC, "RESINTLK fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)30:RESINTLK_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)30:RESINTLK_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)30:RESINTLK_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)30:RESINTLK_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)30:RESINTLK_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)30:RESINTLK_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)30:RESINTLK_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)30:RESINTLK_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)30:RESINTLK_CNTFO PP")
}

record(fanout, "$(CM,undefined)30:RESINTLK_CNTFO") {
  field(DESC, "RESINTLK fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)30:RESINTLK_CNT")
  field(LNK2, "$(CM,undefined)30:RESINTLK_CNTTC")
  field(LNK3, "$(CM,undefined)30:RESINTLK_CNTUC")
}

record(calc, "$(CM,undefined)30:RESINTLK_CNT") {
  field(DESC, "RESINTLK total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:RESINTLK_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:RESINTLK_CNTTC") {
  field(DESC, "RESINTLK today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:RESINTLK_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)30:RESINTLK_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)30:RESINTLK_CNTT") {
  field(DESC, "RESINTLK today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)30:RESINTLK_CNTY") {
  field(DESC, "RESINTLK yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:RESINTLK_CNTUC") {
  field(DESC, "RESINTLK user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:RESINTLK_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)30:RESINTLK_CNTU PP")
}

record(longin, "$(CM,undefined)30:RESINTLK_CNTU") {
  field(DESC, "RESINTLK user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)30:RESINTLK_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)30:RESINTLK_CNTU PP")
}

record(seq, "$(CM,undefined)30:RESINTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)30:RESINTLK_CNTT")
  field(LNK1, "$(CM,undefined)30:RESINTLK_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)30:RESINTLK_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)30:RESLINK_CNTPV") {
  field(DESC, "RESLINK previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:RESLINK_CNTP") {
  field(DESC, "RESLINK previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:RESLINK_FLTV") {
  field(DESC, "RESLINK value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:RESLINK_BYPV") {
  field(DESC, "RESLINK value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:RESLINK_CNTET") {
  field(DESC, "RESLINK increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)30:RESLINK_CNTSUB") {
  field(DESC, "RESLINK fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)30:RESLINK_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)30:RESLINK_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)30:RESLINK_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)30:RESLINK_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)30:RESLINK_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)30:RESLINK_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)30:RESLINK_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)30:RESLINK_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)30:RESLINK_CNTFO PP")
}

record(fanout, "$(CM,undefined)30:RESLINK_CNTFO") {
  field(DESC, "RESLINK fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)30:RESLINK_CNT")
  field(LNK2, "$(CM,undefined)30:RESLINK_CNTTC")
  field(LNK3, "$(CM,undefined)30:RESLINK_CNTUC")
}

record(calc, "$(CM,undefined)30:RESLINK_CNT") {
  field(DESC, "RESLINK total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:RESLINK_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:RESLINK_CNTTC") {
  field(DESC, "RESLINK today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:RESLINK_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)30:RESLINK_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)30:RESLINK_CNTT") {
  field(DESC, "RESLINK today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)30:RESLINK_CNTY") {
  field(DESC, "RESLINK yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:RESLINK_CNTUC") {
  field(DESC, "RESLINK user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:RESLINK_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)30:RESLINK_CNTU PP")
}

record(longin, "$(CM,undefined)30:RESLINK_CNTU") {
  field(DESC, "RESLINK user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)30:RESLINK_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)30:RESLINK_CNTU PP")
}

record(seq, "$(CM,undefined)30:RESLINK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)30:RESLINK_CNTT")
  field(LNK1, "$(CM,undefined)30:RESLINK_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)30:RESLINK_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)30:PLL_CNTPV") {
  field(DESC, "PLL previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:PLL_CNTP") {
  field(DESC, "PLL previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:PLL_FLTV") {
  field(DESC, "PLL value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:PLL_BYPV") {
  field(DESC, "PLL value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:PLL_CNTET") {
  field(DESC, "PLL increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)30:PLL_CNTSUB") {
  field(DESC, "PLL fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)30:PLL_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)30:PLL_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)30:PLL_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)30:PLL_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)30:PLL_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)30:PLL_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)30:PLL_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)30:PLL_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)30:PLL_CNTFO PP")
}

record(fanout, "$(CM,undefined)30:PLL_CNTFO") {
  field(DESC, "PLL fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)30:PLL_CNT")
  field(LNK2, "$(CM,undefined)30:PLL_CNTTC")
  field(LNK3, "$(CM,undefined)30:PLL_CNTUC")
}

record(calc, "$(CM,undefined)30:PLL_CNT") {
  field(DESC, "PLL total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:PLL_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:PLL_CNTTC") {
  field(DESC, "PLL today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:PLL_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)30:PLL_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)30:PLL_CNTT") {
  field(DESC, "PLL today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)30:PLL_CNTY") {
  field(DESC, "PLL yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:PLL_CNTUC") {
  field(DESC, "PLL user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:PLL_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)30:PLL_CNTU PP")
}

record(longin, "$(CM,undefined)30:PLL_CNTU") {
  field(DESC, "PLL user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)30:PLL_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)30:PLL_CNTU PP")
}

record(seq, "$(CM,undefined)30:PLL_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)30:PLL_CNTT")
  field(LNK1, "$(CM,undefined)30:PLL_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)30:PLL_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)30:IOCWDOG_CNTPV") {
  field(DESC, "IOCWDOG previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:IOCWDOG_CNTP") {
  field(DESC, "IOCWDOG previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:IOCWDOG_FLTV") {
  field(DESC, "IOCWDOG value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:IOCWDOG_BYPV") {
  field(DESC, "IOCWDOG value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:IOCWDOG_CNTET") {
  field(DESC, "IOCWDOG increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)30:IOCWDOG_CNTSUB") {
  field(DESC, "IOCWDOG fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)30:IOCWDOG_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)30:IOCWDOG_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)30:IOCWDOG_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)30:IOCWDOG_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)30:IOCWDOG_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)30:IOCWDOG_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)30:IOCWDOG_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)30:IOCWDOG_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)30:IOCWDOG_CNTFO PP")
}

record(fanout, "$(CM,undefined)30:IOCWDOG_CNTFO") {
  field(DESC, "IOCWDOG fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)30:IOCWDOG_CNT")
  field(LNK2, "$(CM,undefined)30:IOCWDOG_CNTTC")
  field(LNK3, "$(CM,undefined)30:IOCWDOG_CNTUC")
}

record(calc, "$(CM,undefined)30:IOCWDOG_CNT") {
  field(DESC, "IOCWDOG total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:IOCWDOG_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:IOCWDOG_CNTTC") {
  field(DESC, "IOCWDOG today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:IOCWDOG_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)30:IOCWDOG_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)30:IOCWDOG_CNTT") {
  field(DESC, "IOCWDOG today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)30:IOCWDOG_CNTY") {
  field(DESC, "IOCWDOG yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:IOCWDOG_CNTUC") {
  field(DESC, "IOCWDOG user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:IOCWDOG_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)30:IOCWDOG_CNTU PP")
}

record(longin, "$(CM,undefined)30:IOCWDOG_CNTU") {
  field(DESC, "IOCWDOG user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)30:IOCWDOG_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)30:IOCWDOG_CNTU PP")
}

record(seq, "$(CM,undefined)30:IOCWDOG_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)30:IOCWDOG_CNTT")
  field(LNK1, "$(CM,undefined)30:IOCWDOG_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)30:IOCWDOG_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)30:SSA_CNTPV") {
  field(DESC, "SSA previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:SSA_CNTP") {
  field(DESC, "SSA previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:SSA_FLTV") {
  field(DESC, "SSA value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:SSA_BYPV") {
  field(DESC, "SSA value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:SSA_CNTET") {
  field(DESC, "SSA increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)30:SSA_CNTSUB") {
  field(DESC, "SSA fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)30:SSA_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)30:SSA_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)30:SSA_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)30:SSA_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)30:SSA_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)30:SSA_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)30:SSA_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)30:SSA_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)30:SSA_CNTFO PP")
}

record(fanout, "$(CM,undefined)30:SSA_CNTFO") {
  field(DESC, "SSA fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)30:SSA_CNT")
  field(LNK2, "$(CM,undefined)30:SSA_CNTTC")
  field(LNK3, "$(CM,undefined)30:SSA_CNTUC")
}

record(calc, "$(CM,undefined)30:SSA_CNT") {
  field(DESC, "SSA total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:SSA_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:SSA_CNTTC") {
  field(DESC, "SSA today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:SSA_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)30:SSA_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)30:SSA_CNTT") {
  field(DESC, "SSA today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)30:SSA_CNTY") {
  field(DESC, "SSA yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:SSA_CNTUC") {
  field(DESC, "SSA user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:SSA_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)30:SSA_CNTU PP")
}

record(longin, "$(CM,undefined)30:SSA_CNTU") {
  field(DESC, "SSA user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)30:SSA_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)30:SSA_CNTU PP")
}

record(seq, "$(CM,undefined)30:SSA_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)30:SSA_CNTT")
  field(LNK1, "$(CM,undefined)30:SSA_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)30:SSA_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)30:CRYO_CNTPV") {
  field(DESC, "CRYO previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:CRYO_CNTP") {
  field(DESC, "CRYO previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:CRYO_FLTV") {
  field(DESC, "CRYO value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:CRYO_BYPV") {
  field(DESC, "CRYO value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:CRYO_CNTET") {
  field(DESC, "CRYO increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)30:CRYO_CNTSUB") {
  field(DESC, "CRYO fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)30:CRYO_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)30:CRYO_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)30:CRYO_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)30:CRYO_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)30:CRYO_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)30:CRYO_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)30:CRYO_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)30:CRYO_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)30:CRYO_CNTFO PP")
}

record(fanout, "$(CM,undefined)30:CRYO_CNTFO") {
  field(DESC, "CRYO fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)30:CRYO_CNT")
  field(LNK2, "$(CM,undefined)30:CRYO_CNTTC")
  field(LNK3, "$(CM,undefined)30:CRYO_CNTUC")
}

record(calc, "$(CM,undefined)30:CRYO_CNT") {
  field(DESC, "CRYO total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:CRYO_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:CRYO_CNTTC") {
  field(DESC, "CRYO today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:CRYO_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)30:CRYO_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)30:CRYO_CNTT") {
  field(DESC, "CRYO today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)30:CRYO_CNTY") {
  field(DESC, "CRYO yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:CRYO_CNTUC") {
  field(DESC, "CRYO user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:CRYO_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)30:CRYO_CNTU PP")
}

record(longin, "$(CM,undefined)30:CRYO_CNTU") {
  field(DESC, "CRYO user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)30:CRYO_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)30:CRYO_CNTU PP")
}

record(seq, "$(CM,undefined)30:CRYO_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)30:CRYO_CNTT")
  field(LNK1, "$(CM,undefined)30:CRYO_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)30:CRYO_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)30:LO_CNTPV") {
  field(DESC, "LO previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:LO_CNTP") {
  field(DESC, "LO previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:LO_FLTV") {
  field(DESC, "LO value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:LO_BYPV") {
  field(DESC, "LO value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:LO_CNTET") {
  field(DESC, "LO increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)30:LO_CNTSUB") {
  field(DESC, "LO fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)30:LO_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)30:LO_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)30:LO_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)30:LO_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)30:LO_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)30:LO_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)30:LO_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)30:LO_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)30:LO_CNTFO PP")
}

record(fanout, "$(CM,undefined)30:LO_CNTFO") {
  field(DESC, "LO fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)30:LO_CNT")
  field(LNK2, "$(CM,undefined)30:LO_CNTTC")
  field(LNK3, "$(CM,undefined)30:LO_CNTUC")
}

record(calc, "$(CM,undefined)30:LO_CNT") {
  field(DESC, "LO total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:LO_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:LO_CNTTC") {
  field(DESC, "LO today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:LO_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)30:LO_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)30:LO_CNTT") {
  field(DESC, "LO today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)30:LO_CNTY") {
  field(DESC, "LO yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:LO_CNTUC") {
  field(DESC, "LO user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:LO_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)30:LO_CNTU PP")
}

record(longin, "$(CM,undefined)30:LO_CNTU") {
  field(DESC, "LO user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)30:LO_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)30:LO_CNTU PP")
}

record(seq, "$(CM,undefined)30:LO_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)30:LO_CNTT")
  field(LNK1, "$(CM,undefined)30:LO_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)30:LO_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)30:ADMIN_CNTPV") {
  field(DESC, "ADMIN previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:ADMIN_CNTP") {
  field(DESC, "ADMIN previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:ADMIN_FLTV") {
  field(DESC, "ADMIN value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:ADMIN_BYPV") {
  field(DESC, "ADMIN value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)30:ADMIN_CNTET") {
  field(DESC, "ADMIN increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)30:ADMIN_CNTSUB") {
  field(DESC, "ADMIN fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)30:ADMIN_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)30:ADMIN_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)30:ADMIN_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)30:ADMIN_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)30:ADMIN_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)30:ADMIN_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)30:ADMIN_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)30:ADMIN_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)30:ADMIN_CNTFO PP")
}

record(fanout, "$(CM,undefined)30:ADMIN_CNTFO") {
  field(DESC, "ADMIN fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)30:ADMIN_CNT")
  field(LNK2, "$(CM,undefined)30:ADMIN_CNTTC")
  field(LNK3, "$(CM,undefined)30:ADMIN_CNTUC")
}

record(calc, "$(CM,undefined)30:ADMIN_CNT") {
  field(DESC, "ADMIN total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:ADMIN_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:ADMIN_CNTTC") {
  field(DESC, "ADMIN today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:ADMIN_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)30:ADMIN_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)30:ADMIN_CNTT") {
  field(DESC, "ADMIN today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)30:ADMIN_CNTY") {
  field(DESC, "ADMIN yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:ADMIN_CNTUC") {
  field(DESC, "ADMIN user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:ADMIN_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)30:ADMIN_CNTU PP")
}

record(longin, "$(CM,undefined)30:ADMIN_CNTU") {
  field(DESC, "ADMIN user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)30:ADMIN_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)30:ADMIN_CNTU PP")
}

record(seq, "$(CM,undefined)30:ADMIN_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)30:ADMIN_CNTT")
  field(LNK1, "$(CM,undefined)30:ADMIN_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)30:ADMIN_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)30:FB_SUM_CNTPV") {
  field(DESC, "FB_SUM previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:FB_SUM_CNTP") {
  field(DESC, "FB_SUM previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)30:FB_SUM_FLTV") {
  field(DESC, "FB_SUM value indicating fault")
  field(PINI, "YES")
  field(VAL, "2")
}

record(bi, "$(CM,undefined)30:FB_SUM_BYPV") {
  field(DESC, "FB_SUM value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "0")
}

record(bi, "$(CM,undefined)30:FB_SUM_CNTET") {
  field(DESC, "FB_SUM increment counter every time")
  field(PINI, "YES")
  field(VAL, "1")
}

record(aSub, "$(CM,undefined)30:FB_SUM_CNTSUB") {
  field(DESC, "FB_SUM fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)30:FB_SUM")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "$(CM,undefined)30:RFREADYFORBEAM CP")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)30:FB_SUM_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)30:FB_SUM_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)30:FB_SUM_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)30:FB_SUM_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)30:FB_SUM_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)30:FB_SUM_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)30:FB_SUM_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)30:FB_SUM_CNTFO PP")
}

record(fanout, "$(CM,undefined)30:FB_SUM_CNTFO") {
  field(DESC, "FB_SUM fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)30:FB_SUM_CNT")
  field(LNK2, "$(CM,undefined)30:FB_SUM_CNTTC")
  field(LNK3, "$(CM,undefined)30:FB_SUM_CNTUC")
}

record(calc, "$(CM,undefined)30:FB_SUM_CNT") {
  field(DESC, "FB_SUM total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:FB_SUM_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:FB_SUM_CNTTC") {
  field(DESC, "FB_SUM today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:FB_SUM_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)30:FB_SUM_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)30:FB_SUM_CNTT") {
  field(DESC, "FB_SUM today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)30:FB_SUM_CNTY") {
  field(DESC, "FB_SUM yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)30:FB_SUM_CNTUC") {
  field(DESC, "FB_SUM user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)30:FB_SUM_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)30:FB_SUM_CNTU PP")
}

record(longin, "$(CM,undefined)30:FB_SUM_CNTU") {
  field(DESC, "FB_SUM user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)30:FB_SUM_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)30:FB_SUM_CNTU PP")
}

record(seq, "$(CM,undefined)30:FB_SUM_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)30:FB_SUM_CNTT")
  field(LNK1, "$(CM,undefined)30:FB_SUM_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)30:FB_SUM_CNTT PP")
}
record(fanout, "$(CM,undefined)40:INTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(LNK0, "$(CM,undefined)40:SSA_CNTRO")
  field(LNK1, "$(CM,undefined)40:STEPTEMP_CNTRO")
  field(LNK2, "$(CM,undefined)40:CPLRTEMP1_CNTRO")
  field(LNK3, "$(CM,undefined)40:CPLRTEMP2_CNTRO")
  field(LNK4, "$(CM,undefined)40:QUENCH_CNTRO")
  field(LNK5, "$(CM,undefined)40:RESINTLK_CNTRO")
  field(LNK6, "$(CM,undefined)40:RESLINK_CNTRO")
  field(LNK7, "$(CM,undefined)40:PLL_CNTRO")
  field(LNK8, "$(CM,undefined)40:IOCWDOG_CNTRO")
  field(LNK9, "$(CM,undefined)40:CRYO_CNTRO")
  field(LNKA, "$(CM,undefined)40:LO_CNTRO")
  field(LNKB, "$(CM,undefined)40:ADMIN_CNTRO")
  field(LNKC, "$(CM,undefined)40:FB_SUM_CNTRO")
}

record(fanout, "$(CM,undefined)40:INTLK_CNTUCLR_ALL") {
  field(DESC, "Clear all intlk counts for cavity")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,undefined)40:SSA_CNTUCLR")
  field(LNK1, "$(CM,undefined)40:STEPTEMP_CNTUCLR")
  field(LNK2, "$(CM,undefined)40:CPLRTEMP1_CNTUCLR")
  field(LNK3, "$(CM,undefined)40:CPLRTEMP2_CNTUCLR")
  field(LNK4, "$(CM,undefined)40:QUENCH_CNTUCLR")
  field(LNK5, "$(CM,undefined)40:RESINTLK_CNTUCLR")
  field(LNK6, "$(CM,undefined)40:RESLINK_CNTUCLR")
  field(LNK7, "$(CM,undefined)40:PLL_CNTUCLR")
  field(LNK8, "$(CM,undefined)40:IOCWDOG_CNTUCLR")
  field(LNK9, "$(CM,undefined)40:CRYO_CNTUCLR")
  field(LNKA, "$(CM,undefined)40:LO_CNTUCLR")
  field(LNKB, "$(CM,undefined)40:ADMIN_CNTUCLR")
  field(LNKC, "$(CM,undefined)40:FB_SUM_CNTUCLR")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)40:STEPTEMP_CNTPV") {
  field(DESC, "STEPTEMP previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:STEPTEMP_CNTP") {
  field(DESC, "STEPTEMP previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:STEPTEMP_FLTV") {
  field(DESC, "STEPTEMP value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:STEPTEMP_BYPV") {
  field(DESC, "STEPTEMP value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:STEPTEMP_CNTET") {
  field(DESC, "STEPTEMP increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)40:STEPTEMP_CNTSUB") {
  field(DESC, "STEPTEMP fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)40:STEPTEMP_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)40:STEPTEMP_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)40:STEPTEMP_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)40:STEPTEMP_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)40:STEPTEMP_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)40:STEPTEMP_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)40:STEPTEMP_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)40:STEPTEMP_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)40:STEPTEMP_CNTFO PP")
}

record(fanout, "$(CM,undefined)40:STEPTEMP_CNTFO") {
  field(DESC, "STEPTEMP fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)40:STEPTEMP_CNT")
  field(LNK2, "$(CM,undefined)40:STEPTEMP_CNTTC")
  field(LNK3, "$(CM,undefined)40:STEPTEMP_CNTUC")
}

record(calc, "$(CM,undefined)40:STEPTEMP_CNT") {
  field(DESC, "STEPTEMP total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:STEPTEMP_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:STEPTEMP_CNTTC") {
  field(DESC, "STEPTEMP today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:STEPTEMP_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)40:STEPTEMP_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)40:STEPTEMP_CNTT") {
  field(DESC, "STEPTEMP today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)40:STEPTEMP_CNTY") {
  field(DESC, "STEPTEMP yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:STEPTEMP_CNTUC") {
  field(DESC, "STEPTEMP user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:STEPTEMP_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)40:STEPTEMP_CNTU PP")
}

record(longin, "$(CM,undefined)40:STEPTEMP_CNTU") {
  field(DESC, "STEPTEMP user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)40:STEPTEMP_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)40:STEPTEMP_CNTU PP")
}

record(seq, "$(CM,undefined)40:STEPTEMP_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)40:STEPTEMP_CNTT")
  field(LNK1, "$(CM,undefined)40:STEPTEMP_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)40:STEPTEMP_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)40:CPLRTEMP1_CNTPV") {
  field(DESC, "CPLRTEMP1 previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:CPLRTEMP1_CNTP") {
  field(DESC, "CPLRTEMP1 previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:CPLRTEMP1_FLTV") {
  field(DESC, "CPLRTEMP1 value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:CPLRTEMP1_BYPV") {
  field(DESC, "CPLRTEMP1 value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:CPLRTEMP1_CNTET") {
  field(DESC, "CPLRTEMP1 increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)40:CPLRTEMP1_CNTSUB") {
  field(DESC, "CPLRTEMP1 fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)40:CPLRTEMP1_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)40:CPLRTEMP1_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)40:CPLRTEMP1_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)40:CPLRTEMP1_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)40:CPLRTEMP1_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)40:CPLRTEMP1_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)40:CPLRTEMP1_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)40:CPLRTEMP1_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)40:CPLRTEMP1_CNTFO PP")
}

record(fanout, "$(CM,undefined)40:CPLRTEMP1_CNTFO") {
  field(DESC, "CPLRTEMP1 fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)40:CPLRTEMP1_CNT")
  field(LNK2, "$(CM,undefined)40:CPLRTEMP1_CNTTC")
  field(LNK3, "$(CM,undefined)40:CPLRTEMP1_CNTUC")
}

record(calc, "$(CM,undefined)40:CPLRTEMP1_CNT") {
  field(DESC, "CPLRTEMP1 total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:CPLRTEMP1_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:CPLRTEMP1_CNTTC") {
  field(DESC, "CPLRTEMP1 today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:CPLRTEMP1_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)40:CPLRTEMP1_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)40:CPLRTEMP1_CNTT") {
  field(DESC, "CPLRTEMP1 today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)40:CPLRTEMP1_CNTY") {
  field(DESC, "CPLRTEMP1 yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:CPLRTEMP1_CNTUC") {
  field(DESC, "CPLRTEMP1 user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:CPLRTEMP1_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)40:CPLRTEMP1_CNTU PP")
}

record(longin, "$(CM,undefined)40:CPLRTEMP1_CNTU") {
  field(DESC, "CPLRTEMP1 user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)40:CPLRTEMP1_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)40:CPLRTEMP1_CNTU PP")
}

record(seq, "$(CM,undefined)40:CPLRTEMP1_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)40:CPLRTEMP1_CNTT")
  field(LNK1, "$(CM,undefined)40:CPLRTEMP1_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)40:CPLRTEMP1_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)40:CPLRTEMP2_CNTPV") {
  field(DESC, "CPLRTEMP2 previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:CPLRTEMP2_CNTP") {
  field(DESC, "CPLRTEMP2 previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:CPLRTEMP2_FLTV") {
  field(DESC, "CPLRTEMP2 value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:CPLRTEMP2_BYPV") {
  field(DESC, "CPLRTEMP2 value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:CPLRTEMP2_CNTET") {
  field(DESC, "CPLRTEMP2 increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)40:CPLRTEMP2_CNTSUB") {
  field(DESC, "CPLRTEMP2 fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)40:CPLRTEMP2_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)40:CPLRTEMP2_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)40:CPLRTEMP2_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)40:CPLRTEMP2_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)40:CPLRTEMP2_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)40:CPLRTEMP2_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)40:CPLRTEMP2_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)40:CPLRTEMP2_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)40:CPLRTEMP2_CNTFO PP")
}

record(fanout, "$(CM,undefined)40:CPLRTEMP2_CNTFO") {
  field(DESC, "CPLRTEMP2 fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)40:CPLRTEMP2_CNT")
  field(LNK2, "$(CM,undefined)40:CPLRTEMP2_CNTTC")
  field(LNK3, "$(CM,undefined)40:CPLRTEMP2_CNTUC")
}

record(calc, "$(CM,undefined)40:CPLRTEMP2_CNT") {
  field(DESC, "CPLRTEMP2 total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:CPLRTEMP2_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:CPLRTEMP2_CNTTC") {
  field(DESC, "CPLRTEMP2 today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:CPLRTEMP2_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)40:CPLRTEMP2_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)40:CPLRTEMP2_CNTT") {
  field(DESC, "CPLRTEMP2 today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)40:CPLRTEMP2_CNTY") {
  field(DESC, "CPLRTEMP2 yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:CPLRTEMP2_CNTUC") {
  field(DESC, "CPLRTEMP2 user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:CPLRTEMP2_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)40:CPLRTEMP2_CNTU PP")
}

record(longin, "$(CM,undefined)40:CPLRTEMP2_CNTU") {
  field(DESC, "CPLRTEMP2 user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)40:CPLRTEMP2_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)40:CPLRTEMP2_CNTU PP")
}

record(seq, "$(CM,undefined)40:CPLRTEMP2_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)40:CPLRTEMP2_CNTT")
  field(LNK1, "$(CM,undefined)40:CPLRTEMP2_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)40:CPLRTEMP2_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)40:QUENCH_CNTPV") {
  field(DESC, "QUENCH previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:QUENCH_CNTP") {
  field(DESC, "QUENCH previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:QUENCH_FLTV") {
  field(DESC, "QUENCH value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:QUENCH_BYPV") {
  field(DESC, "QUENCH value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:QUENCH_CNTET") {
  field(DESC, "QUENCH increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)40:QUENCH_CNTSUB") {
  field(DESC, "QUENCH fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)40:QUENCH_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)40:QUENCH_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)40:QUENCH_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)40:QUENCH_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)40:QUENCH_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)40:QUENCH_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)40:QUENCH_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)40:QUENCH_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)40:QUENCH_CNTFO PP")
}

record(fanout, "$(CM,undefined)40:QUENCH_CNTFO") {
  field(DESC, "QUENCH fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)40:QUENCH_CNT")
  field(LNK2, "$(CM,undefined)40:QUENCH_CNTTC")
  field(LNK3, "$(CM,undefined)40:QUENCH_CNTUC")
}

record(calc, "$(CM,undefined)40:QUENCH_CNT") {
  field(DESC, "QUENCH total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:QUENCH_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:QUENCH_CNTTC") {
  field(DESC, "QUENCH today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:QUENCH_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)40:QUENCH_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)40:QUENCH_CNTT") {
  field(DESC, "QUENCH today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)40:QUENCH_CNTY") {
  field(DESC, "QUENCH yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:QUENCH_CNTUC") {
  field(DESC, "QUENCH user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:QUENCH_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)40:QUENCH_CNTU PP")
}

record(longin, "$(CM,undefined)40:QUENCH_CNTU") {
  field(DESC, "QUENCH user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)40:QUENCH_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)40:QUENCH_CNTU PP")
}

record(seq, "$(CM,undefined)40:QUENCH_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)40:QUENCH_CNTT")
  field(LNK1, "$(CM,undefined)40:QUENCH_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)40:QUENCH_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)40:RESINTLK_CNTPV") {
  field(DESC, "RESINTLK previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:RESINTLK_CNTP") {
  field(DESC, "RESINTLK previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:RESINTLK_FLTV") {
  field(DESC, "RESINTLK value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:RESINTLK_BYPV") {
  field(DESC, "RESINTLK value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:RESINTLK_CNTET") {
  field(DESC, "RESINTLK increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)40:RESINTLK_CNTSUB") {
  field(DESC, "RESINTLK fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)40:RESINTLK_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)40:RESINTLK_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)40:RESINTLK_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)40:RESINTLK_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)40:RESINTLK_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)40:RESINTLK_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)40:RESINTLK_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)40:RESINTLK_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)40:RESINTLK_CNTFO PP")
}

record(fanout, "$(CM,undefined)40:RESINTLK_CNTFO") {
  field(DESC, "RESINTLK fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)40:RESINTLK_CNT")
  field(LNK2, "$(CM,undefined)40:RESINTLK_CNTTC")
  field(LNK3, "$(CM,undefined)40:RESINTLK_CNTUC")
}

record(calc, "$(CM,undefined)40:RESINTLK_CNT") {
  field(DESC, "RESINTLK total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:RESINTLK_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:RESINTLK_CNTTC") {
  field(DESC, "RESINTLK today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:RESINTLK_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)40:RESINTLK_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)40:RESINTLK_CNTT") {
  field(DESC, "RESINTLK today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)40:RESINTLK_CNTY") {
  field(DESC, "RESINTLK yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:RESINTLK_CNTUC") {
  field(DESC, "RESINTLK user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:RESINTLK_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)40:RESINTLK_CNTU PP")
}

record(longin, "$(CM,undefined)40:RESINTLK_CNTU") {
  field(DESC, "RESINTLK user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)40:RESINTLK_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)40:RESINTLK_CNTU PP")
}

record(seq, "$(CM,undefined)40:RESINTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)40:RESINTLK_CNTT")
  field(LNK1, "$(CM,undefined)40:RESINTLK_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)40:RESINTLK_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)40:RESLINK_CNTPV") {
  field(DESC, "RESLINK previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:RESLINK_CNTP") {
  field(DESC, "RESLINK previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:RESLINK_FLTV") {
  field(DESC, "RESLINK value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:RESLINK_BYPV") {
  field(DESC, "RESLINK value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:RESLINK_CNTET") {
  field(DESC, "RESLINK increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)40:RESLINK_CNTSUB") {
  field(DESC, "RESLINK fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)40:RESLINK_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)40:RESLINK_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)40:RESLINK_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)40:RESLINK_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)40:RESLINK_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)40:RESLINK_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)40:RESLINK_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)40:RESLINK_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)40:RESLINK_CNTFO PP")
}

record(fanout, "$(CM,undefined)40:RESLINK_CNTFO") {
  field(DESC, "RESLINK fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)40:RESLINK_CNT")
  field(LNK2, "$(CM,undefined)40:RESLINK_CNTTC")
  field(LNK3, "$(CM,undefined)40:RESLINK_CNTUC")
}

record(calc, "$(CM,undefined)40:RESLINK_CNT") {
  field(DESC, "RESLINK total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:RESLINK_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:RESLINK_CNTTC") {
  field(DESC, "RESLINK today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:RESLINK_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)40:RESLINK_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)40:RESLINK_CNTT") {
  field(DESC, "RESLINK today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)40:RESLINK_CNTY") {
  field(DESC, "RESLINK yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:RESLINK_CNTUC") {
  field(DESC, "RESLINK user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:RESLINK_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)40:RESLINK_CNTU PP")
}

record(longin, "$(CM,undefined)40:RESLINK_CNTU") {
  field(DESC, "RESLINK user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)40:RESLINK_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)40:RESLINK_CNTU PP")
}

record(seq, "$(CM,undefined)40:RESLINK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)40:RESLINK_CNTT")
  field(LNK1, "$(CM,undefined)40:RESLINK_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)40:RESLINK_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)40:PLL_CNTPV") {
  field(DESC, "PLL previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:PLL_CNTP") {
  field(DESC, "PLL previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:PLL_FLTV") {
  field(DESC, "PLL value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:PLL_BYPV") {
  field(DESC, "PLL value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:PLL_CNTET") {
  field(DESC, "PLL increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)40:PLL_CNTSUB") {
  field(DESC, "PLL fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)40:PLL_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)40:PLL_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)40:PLL_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)40:PLL_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)40:PLL_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)40:PLL_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)40:PLL_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)40:PLL_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)40:PLL_CNTFO PP")
}

record(fanout, "$(CM,undefined)40:PLL_CNTFO") {
  field(DESC, "PLL fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)40:PLL_CNT")
  field(LNK2, "$(CM,undefined)40:PLL_CNTTC")
  field(LNK3, "$(CM,undefined)40:PLL_CNTUC")
}

record(calc, "$(CM,undefined)40:PLL_CNT") {
  field(DESC, "PLL total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:PLL_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:PLL_CNTTC") {
  field(DESC, "PLL today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:PLL_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)40:PLL_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)40:PLL_CNTT") {
  field(DESC, "PLL today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)40:PLL_CNTY") {
  field(DESC, "PLL yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:PLL_CNTUC") {
  field(DESC, "PLL user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:PLL_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)40:PLL_CNTU PP")
}

record(longin, "$(CM,undefined)40:PLL_CNTU") {
  field(DESC, "PLL user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)40:PLL_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)40:PLL_CNTU PP")
}

record(seq, "$(CM,undefined)40:PLL_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)40:PLL_CNTT")
  field(LNK1, "$(CM,undefined)40:PLL_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)40:PLL_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)40:IOCWDOG_CNTPV") {
  field(DESC, "IOCWDOG previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:IOCWDOG_CNTP") {
  field(DESC, "IOCWDOG previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:IOCWDOG_FLTV") {
  field(DESC, "IOCWDOG value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:IOCWDOG_BYPV") {
  field(DESC, "IOCWDOG value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:IOCWDOG_CNTET") {
  field(DESC, "IOCWDOG increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)40:IOCWDOG_CNTSUB") {
  field(DESC, "IOCWDOG fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)40:IOCWDOG_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)40:IOCWDOG_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)40:IOCWDOG_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)40:IOCWDOG_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)40:IOCWDOG_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)40:IOCWDOG_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)40:IOCWDOG_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)40:IOCWDOG_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)40:IOCWDOG_CNTFO PP")
}

record(fanout, "$(CM,undefined)40:IOCWDOG_CNTFO") {
  field(DESC, "IOCWDOG fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)40:IOCWDOG_CNT")
  field(LNK2, "$(CM,undefined)40:IOCWDOG_CNTTC")
  field(LNK3, "$(CM,undefined)40:IOCWDOG_CNTUC")
}

record(calc, "$(CM,undefined)40:IOCWDOG_CNT") {
  field(DESC, "IOCWDOG total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:IOCWDOG_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:IOCWDOG_CNTTC") {
  field(DESC, "IOCWDOG today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:IOCWDOG_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)40:IOCWDOG_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)40:IOCWDOG_CNTT") {
  field(DESC, "IOCWDOG today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)40:IOCWDOG_CNTY") {
  field(DESC, "IOCWDOG yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:IOCWDOG_CNTUC") {
  field(DESC, "IOCWDOG user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:IOCWDOG_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)40:IOCWDOG_CNTU PP")
}

record(longin, "$(CM,undefined)40:IOCWDOG_CNTU") {
  field(DESC, "IOCWDOG user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)40:IOCWDOG_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)40:IOCWDOG_CNTU PP")
}

record(seq, "$(CM,undefined)40:IOCWDOG_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)40:IOCWDOG_CNTT")
  field(LNK1, "$(CM,undefined)40:IOCWDOG_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)40:IOCWDOG_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)40:SSA_CNTPV") {
  field(DESC, "SSA previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:SSA_CNTP") {
  field(DESC, "SSA previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:SSA_FLTV") {
  field(DESC, "SSA value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:SSA_BYPV") {
  field(DESC, "SSA value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:SSA_CNTET") {
  field(DESC, "SSA increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)40:SSA_CNTSUB") {
  field(DESC, "SSA fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)40:SSA_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)40:SSA_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)40:SSA_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)40:SSA_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)40:SSA_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)40:SSA_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)40:SSA_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)40:SSA_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)40:SSA_CNTFO PP")
}

record(fanout, "$(CM,undefined)40:SSA_CNTFO") {
  field(DESC, "SSA fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)40:SSA_CNT")
  field(LNK2, "$(CM,undefined)40:SSA_CNTTC")
  field(LNK3, "$(CM,undefined)40:SSA_CNTUC")
}

record(calc, "$(CM,undefined)40:SSA_CNT") {
  field(DESC, "SSA total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:SSA_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:SSA_CNTTC") {
  field(DESC, "SSA today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:SSA_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)40:SSA_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)40:SSA_CNTT") {
  field(DESC, "SSA today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)40:SSA_CNTY") {
  field(DESC, "SSA yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:SSA_CNTUC") {
  field(DESC, "SSA user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:SSA_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)40:SSA_CNTU PP")
}

record(longin, "$(CM,undefined)40:SSA_CNTU") {
  field(DESC, "SSA user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)40:SSA_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)40:SSA_CNTU PP")
}

record(seq, "$(CM,undefined)40:SSA_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)40:SSA_CNTT")
  field(LNK1, "$(CM,undefined)40:SSA_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)40:SSA_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)40:CRYO_CNTPV") {
  field(DESC, "CRYO previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:CRYO_CNTP") {
  field(DESC, "CRYO previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:CRYO_FLTV") {
  field(DESC, "CRYO value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:CRYO_BYPV") {
  field(DESC, "CRYO value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:CRYO_CNTET") {
  field(DESC, "CRYO increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)40:CRYO_CNTSUB") {
  field(DESC, "CRYO fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)40:CRYO_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)40:CRYO_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)40:CRYO_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)40:CRYO_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)40:CRYO_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)40:CRYO_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)40:CRYO_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)40:CRYO_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)40:CRYO_CNTFO PP")
}

record(fanout, "$(CM,undefined)40:CRYO_CNTFO") {
  field(DESC, "CRYO fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)40:CRYO_CNT")
  field(LNK2, "$(CM,undefined)40:CRYO_CNTTC")
  field(LNK3, "$(CM,undefined)40:CRYO_CNTUC")
}

record(calc, "$(CM,undefined)40:CRYO_CNT") {
  field(DESC, "CRYO total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:CRYO_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:CRYO_CNTTC") {
  field(DESC, "CRYO today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:CRYO_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)40:CRYO_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)40:CRYO_CNTT") {
  field(DESC, "CRYO today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)40:CRYO_CNTY") {
  field(DESC, "CRYO yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:CRYO_CNTUC") {
  field(DESC, "CRYO user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:CRYO_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)40:CRYO_CNTU PP")
}

record(longin, "$(CM,undefined)40:CRYO_CNTU") {
  field(DESC, "CRYO user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)40:CRYO_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)40:CRYO_CNTU PP")
}

record(seq, "$(CM,undefined)40:CRYO_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)40:CRYO_CNTT")
  field(LNK1, "$(CM,undefined)40:CRYO_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)40:CRYO_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)40:LO_CNTPV") {
  field(DESC, "LO previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:LO_CNTP") {
  field(DESC, "LO previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:LO_FLTV") {
  field(DESC, "LO value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:LO_BYPV") {
  field(DESC, "LO value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:LO_CNTET") {
  field(DESC, "LO increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)40:LO_CNTSUB") {
  field(DESC, "LO fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)40:LO_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)40:LO_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)40:LO_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)40:LO_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)40:LO_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)40:LO_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)40:LO_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)40:LO_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)40:LO_CNTFO PP")
}

record(fanout, "$(CM,undefined)40:LO_CNTFO") {
  field(DESC, "LO fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)40:LO_CNT")
  field(LNK2, "$(CM,undefined)40:LO_CNTTC")
  field(LNK3, "$(CM,undefined)40:LO_CNTUC")
}

record(calc, "$(CM,undefined)40:LO_CNT") {
  field(DESC, "LO total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:LO_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:LO_CNTTC") {
  field(DESC, "LO today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:LO_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)40:LO_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)40:LO_CNTT") {
  field(DESC, "LO today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)40:LO_CNTY") {
  field(DESC, "LO yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:LO_CNTUC") {
  field(DESC, "LO user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:LO_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)40:LO_CNTU PP")
}

record(longin, "$(CM,undefined)40:LO_CNTU") {
  field(DESC, "LO user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)40:LO_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)40:LO_CNTU PP")
}

record(seq, "$(CM,undefined)40:LO_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)40:LO_CNTT")
  field(LNK1, "$(CM,undefined)40:LO_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)40:LO_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)40:ADMIN_CNTPV") {
  field(DESC, "ADMIN previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:ADMIN_CNTP") {
  field(DESC, "ADMIN previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:ADMIN_FLTV") {
  field(DESC, "ADMIN value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:ADMIN_BYPV") {
  field(DESC, "ADMIN value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)40:ADMIN_CNTET") {
  field(DESC, "ADMIN increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)40:ADMIN_CNTSUB") {
  field(DESC, "ADMIN fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)40:ADMIN_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)40:ADMIN_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)40:ADMIN_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)40:ADMIN_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)40:ADMIN_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)40:ADMIN_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)40:ADMIN_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)40:ADMIN_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)40:ADMIN_CNTFO PP")
}

record(fanout, "$(CM,undefined)40:ADMIN_CNTFO") {
  field(DESC, "ADMIN fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)40:ADMIN_CNT")
  field(LNK2, "$(CM,undefined)40:ADMIN_CNTTC")
  field(LNK3, "$(CM,undefined)40:ADMIN_CNTUC")
}

record(calc, "$(CM,undefined)40:ADMIN_CNT") {
  field(DESC, "ADMIN total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:ADMIN_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:ADMIN_CNTTC") {
  field(DESC, "ADMIN today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:ADMIN_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)40:ADMIN_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)40:ADMIN_CNTT") {
  field(DESC, "ADMIN today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)40:ADMIN_CNTY") {
  field(DESC, "ADMIN yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:ADMIN_CNTUC") {
  field(DESC, "ADMIN user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:ADMIN_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)40:ADMIN_CNTU PP")
}

record(longin, "$(CM,undefined)40:ADMIN_CNTU") {
  field(DESC, "ADMIN user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)40:ADMIN_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)40:ADMIN_CNTU PP")
}

record(seq, "$(CM,undefined)40:ADMIN_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)40:ADMIN_CNTT")
  field(LNK1, "$(CM,undefined)40:ADMIN_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)40:ADMIN_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)40:FB_SUM_CNTPV") {
  field(DESC, "FB_SUM previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:FB_SUM_CNTP") {
  field(DESC, "FB_SUM previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)40:FB_SUM_FLTV") {
  field(DESC, "FB_SUM value indicating fault")
  field(PINI, "YES")
  field(VAL, "2")
}

record(bi, "$(CM,undefined)40:FB_SUM_BYPV") {
  field(DESC, "FB_SUM value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "0")
}

record(bi, "$(CM,undefined)40:FB_SUM_CNTET") {
  field(DESC, "FB_SUM increment counter every time")
  field(PINI, "YES")
  field(VAL, "1")
}

record(aSub, "$(CM,undefined)40:FB_SUM_CNTSUB") {
  field(DESC, "FB_SUM fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)40:FB_SUM")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "$(CM,undefined)40:RFREADYFORBEAM CP")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)40:FB_SUM_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)40:FB_SUM_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)40:FB_SUM_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)40:FB_SUM_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)40:FB_SUM_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)40:FB_SUM_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)40:FB_SUM_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)40:FB_SUM_CNTFO PP")
}

record(fanout, "$(CM,undefined)40:FB_SUM_CNTFO") {
  field(DESC, "FB_SUM fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)40:FB_SUM_CNT")
  field(LNK2, "$(CM,undefined)40:FB_SUM_CNTTC")
  field(LNK3, "$(CM,undefined)40:FB_SUM_CNTUC")
}

record(calc, "$(CM,undefined)40:FB_SUM_CNT") {
  field(DESC, "FB_SUM total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:FB_SUM_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:FB_SUM_CNTTC") {
  field(DESC, "FB_SUM today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:FB_SUM_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)40:FB_SUM_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)40:FB_SUM_CNTT") {
  field(DESC, "FB_SUM today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)40:FB_SUM_CNTY") {
  field(DESC, "FB_SUM yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)40:FB_SUM_CNTUC") {
  field(DESC, "FB_SUM user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)40:FB_SUM_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)40:FB_SUM_CNTU PP")
}

record(longin, "$(CM,undefined)40:FB_SUM_CNTU") {
  field(DESC, "FB_SUM user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)40:FB_SUM_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)40:FB_SUM_CNTU PP")
}

record(seq, "$(CM,undefined)40:FB_SUM_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)40:FB_SUM_CNTT")
  field(LNK1, "$(CM,undefined)40:FB_SUM_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)40:FB_SUM_CNTT PP")
}
record(fanout, "$(CM,undefined)50:INTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(LNK0, "$(CM,undefined)50:SSA_CNTRO")
  field(LNK1, "$(CM,undefined)50:STEPTEMP_CNTRO")
  field(LNK2, "$(CM,undefined)50:CPLRTEMP1_CNTRO")
  field(LNK3, "$(CM,undefined)50:CPLRTEMP2_CNTRO")
  field(LNK4, "$(CM,undefined)50:QUENCH_CNTRO")
  field(LNK5, "$(CM,undefined)50:RESINTLK_CNTRO")
  field(LNK6, "$(CM,undefined)50:RESLINK_CNTRO")
  field(LNK7, "$(CM,undefined)50:PLL_CNTRO")
  field(LNK8, "$(CM,undefined)50:IOCWDOG_CNTRO")
  field(LNK9, "$(CM,undefined)50:CRYO_CNTRO")
  field(LNKA, "$(CM,undefined)50:LO_CNTRO")
  field(LNKB, "$(CM,undefined)50:ADMIN_CNTRO")
  field(LNKC, "$(CM,undefined)50:FB_SUM_CNTRO")
}

record(fanout, "$(CM,undefined)50:INTLK_CNTUCLR_ALL") {
  field(DESC, "Clear all intlk counts for cavity")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,undefined)50:SSA_CNTUCLR")
  field(LNK1, "$(CM,undefined)50:STEPTEMP_CNTUCLR")
  field(LNK2, "$(CM,undefined)50:CPLRTEMP1_CNTUCLR")
  field(LNK3, "$(CM,undefined)50:CPLRTEMP2_CNTUCLR")
  field(LNK4, "$(CM,undefined)50:QUENCH_CNTUCLR")
  field(LNK5, "$(CM,undefined)50:RESINTLK_CNTUCLR")
  field(LNK6, "$(CM,undefined)50:RESLINK_CNTUCLR")
  field(LNK7, "$(CM,undefined)50:PLL_CNTUCLR")
  field(LNK8, "$(CM,undefined)50:IOCWDOG_CNTUCLR")
  field(LNK9, "$(CM,undefined)50:CRYO_CNTUCLR")
  field(LNKA, "$(CM,undefined)50:LO_CNTUCLR")
  field(LNKB, "$(CM,undefined)50:ADMIN_CNTUCLR")
  field(LNKC, "$(CM,undefined)50:FB_SUM_CNTUCLR")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)50:STEPTEMP_CNTPV") {
  field(DESC, "STEPTEMP previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:STEPTEMP_CNTP") {
  field(DESC, "STEPTEMP previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:STEPTEMP_FLTV") {
  field(DESC, "STEPTEMP value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:STEPTEMP_BYPV") {
  field(DESC, "STEPTEMP value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:STEPTEMP_CNTET") {
  field(DESC, "STEPTEMP increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)50:STEPTEMP_CNTSUB") {
  field(DESC, "STEPTEMP fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)50:STEPTEMP_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)50:STEPTEMP_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)50:STEPTEMP_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)50:STEPTEMP_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)50:STEPTEMP_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)50:STEPTEMP_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)50:STEPTEMP_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)50:STEPTEMP_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)50:STEPTEMP_CNTFO PP")
}

record(fanout, "$(CM,undefined)50:STEPTEMP_CNTFO") {
  field(DESC, "STEPTEMP fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)50:STEPTEMP_CNT")
  field(LNK2, "$(CM,undefined)50:STEPTEMP_CNTTC")
  field(LNK3, "$(CM,undefined)50:STEPTEMP_CNTUC")
}

record(calc, "$(CM,undefined)50:STEPTEMP_CNT") {
  field(DESC, "STEPTEMP total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:STEPTEMP_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:STEPTEMP_CNTTC") {
  field(DESC, "STEPTEMP today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:STEPTEMP_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)50:STEPTEMP_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)50:STEPTEMP_CNTT") {
  field(DESC, "STEPTEMP today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)50:STEPTEMP_CNTY") {
  field(DESC, "STEPTEMP yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:STEPTEMP_CNTUC") {
  field(DESC, "STEPTEMP user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:STEPTEMP_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)50:STEPTEMP_CNTU PP")
}

record(longin, "$(CM,undefined)50:STEPTEMP_CNTU") {
  field(DESC, "STEPTEMP user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)50:STEPTEMP_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)50:STEPTEMP_CNTU PP")
}

record(seq, "$(CM,undefined)50:STEPTEMP_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)50:STEPTEMP_CNTT")
  field(LNK1, "$(CM,undefined)50:STEPTEMP_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)50:STEPTEMP_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)50:CPLRTEMP1_CNTPV") {
  field(DESC, "CPLRTEMP1 previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:CPLRTEMP1_CNTP") {
  field(DESC, "CPLRTEMP1 previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:CPLRTEMP1_FLTV") {
  field(DESC, "CPLRTEMP1 value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:CPLRTEMP1_BYPV") {
  field(DESC, "CPLRTEMP1 value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:CPLRTEMP1_CNTET") {
  field(DESC, "CPLRTEMP1 increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)50:CPLRTEMP1_CNTSUB") {
  field(DESC, "CPLRTEMP1 fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)50:CPLRTEMP1_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)50:CPLRTEMP1_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)50:CPLRTEMP1_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)50:CPLRTEMP1_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)50:CPLRTEMP1_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)50:CPLRTEMP1_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)50:CPLRTEMP1_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)50:CPLRTEMP1_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)50:CPLRTEMP1_CNTFO PP")
}

record(fanout, "$(CM,undefined)50:CPLRTEMP1_CNTFO") {
  field(DESC, "CPLRTEMP1 fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)50:CPLRTEMP1_CNT")
  field(LNK2, "$(CM,undefined)50:CPLRTEMP1_CNTTC")
  field(LNK3, "$(CM,undefined)50:CPLRTEMP1_CNTUC")
}

record(calc, "$(CM,undefined)50:CPLRTEMP1_CNT") {
  field(DESC, "CPLRTEMP1 total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:CPLRTEMP1_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:CPLRTEMP1_CNTTC") {
  field(DESC, "CPLRTEMP1 today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:CPLRTEMP1_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)50:CPLRTEMP1_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)50:CPLRTEMP1_CNTT") {
  field(DESC, "CPLRTEMP1 today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)50:CPLRTEMP1_CNTY") {
  field(DESC, "CPLRTEMP1 yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:CPLRTEMP1_CNTUC") {
  field(DESC, "CPLRTEMP1 user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:CPLRTEMP1_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)50:CPLRTEMP1_CNTU PP")
}

record(longin, "$(CM,undefined)50:CPLRTEMP1_CNTU") {
  field(DESC, "CPLRTEMP1 user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)50:CPLRTEMP1_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)50:CPLRTEMP1_CNTU PP")
}

record(seq, "$(CM,undefined)50:CPLRTEMP1_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)50:CPLRTEMP1_CNTT")
  field(LNK1, "$(CM,undefined)50:CPLRTEMP1_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)50:CPLRTEMP1_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)50:CPLRTEMP2_CNTPV") {
  field(DESC, "CPLRTEMP2 previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:CPLRTEMP2_CNTP") {
  field(DESC, "CPLRTEMP2 previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:CPLRTEMP2_FLTV") {
  field(DESC, "CPLRTEMP2 value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:CPLRTEMP2_BYPV") {
  field(DESC, "CPLRTEMP2 value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:CPLRTEMP2_CNTET") {
  field(DESC, "CPLRTEMP2 increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)50:CPLRTEMP2_CNTSUB") {
  field(DESC, "CPLRTEMP2 fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)50:CPLRTEMP2_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)50:CPLRTEMP2_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)50:CPLRTEMP2_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)50:CPLRTEMP2_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)50:CPLRTEMP2_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)50:CPLRTEMP2_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)50:CPLRTEMP2_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)50:CPLRTEMP2_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)50:CPLRTEMP2_CNTFO PP")
}

record(fanout, "$(CM,undefined)50:CPLRTEMP2_CNTFO") {
  field(DESC, "CPLRTEMP2 fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)50:CPLRTEMP2_CNT")
  field(LNK2, "$(CM,undefined)50:CPLRTEMP2_CNTTC")
  field(LNK3, "$(CM,undefined)50:CPLRTEMP2_CNTUC")
}

record(calc, "$(CM,undefined)50:CPLRTEMP2_CNT") {
  field(DESC, "CPLRTEMP2 total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:CPLRTEMP2_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:CPLRTEMP2_CNTTC") {
  field(DESC, "CPLRTEMP2 today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:CPLRTEMP2_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)50:CPLRTEMP2_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)50:CPLRTEMP2_CNTT") {
  field(DESC, "CPLRTEMP2 today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)50:CPLRTEMP2_CNTY") {
  field(DESC, "CPLRTEMP2 yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:CPLRTEMP2_CNTUC") {
  field(DESC, "CPLRTEMP2 user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:CPLRTEMP2_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)50:CPLRTEMP2_CNTU PP")
}

record(longin, "$(CM,undefined)50:CPLRTEMP2_CNTU") {
  field(DESC, "CPLRTEMP2 user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)50:CPLRTEMP2_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)50:CPLRTEMP2_CNTU PP")
}

record(seq, "$(CM,undefined)50:CPLRTEMP2_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)50:CPLRTEMP2_CNTT")
  field(LNK1, "$(CM,undefined)50:CPLRTEMP2_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)50:CPLRTEMP2_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)50:QUENCH_CNTPV") {
  field(DESC, "QUENCH previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:QUENCH_CNTP") {
  field(DESC, "QUENCH previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:QUENCH_FLTV") {
  field(DESC, "QUENCH value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:QUENCH_BYPV") {
  field(DESC, "QUENCH value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:QUENCH_CNTET") {
  field(DESC, "QUENCH increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)50:QUENCH_CNTSUB") {
  field(DESC, "QUENCH fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)50:QUENCH_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)50:QUENCH_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)50:QUENCH_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)50:QUENCH_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)50:QUENCH_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)50:QUENCH_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)50:QUENCH_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)50:QUENCH_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)50:QUENCH_CNTFO PP")
}

record(fanout, "$(CM,undefined)50:QUENCH_CNTFO") {
  field(DESC, "QUENCH fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)50:QUENCH_CNT")
  field(LNK2, "$(CM,undefined)50:QUENCH_CNTTC")
  field(LNK3, "$(CM,undefined)50:QUENCH_CNTUC")
}

record(calc, "$(CM,undefined)50:QUENCH_CNT") {
  field(DESC, "QUENCH total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:QUENCH_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:QUENCH_CNTTC") {
  field(DESC, "QUENCH today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:QUENCH_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)50:QUENCH_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)50:QUENCH_CNTT") {
  field(DESC, "QUENCH today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)50:QUENCH_CNTY") {
  field(DESC, "QUENCH yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:QUENCH_CNTUC") {
  field(DESC, "QUENCH user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:QUENCH_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)50:QUENCH_CNTU PP")
}

record(longin, "$(CM,undefined)50:QUENCH_CNTU") {
  field(DESC, "QUENCH user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)50:QUENCH_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)50:QUENCH_CNTU PP")
}

record(seq, "$(CM,undefined)50:QUENCH_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)50:QUENCH_CNTT")
  field(LNK1, "$(CM,undefined)50:QUENCH_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)50:QUENCH_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)50:RESINTLK_CNTPV") {
  field(DESC, "RESINTLK previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:RESINTLK_CNTP") {
  field(DESC, "RESINTLK previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:RESINTLK_FLTV") {
  field(DESC, "RESINTLK value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:RESINTLK_BYPV") {
  field(DESC, "RESINTLK value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:RESINTLK_CNTET") {
  field(DESC, "RESINTLK increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)50:RESINTLK_CNTSUB") {
  field(DESC, "RESINTLK fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)50:RESINTLK_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)50:RESINTLK_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)50:RESINTLK_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)50:RESINTLK_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)50:RESINTLK_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)50:RESINTLK_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)50:RESINTLK_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)50:RESINTLK_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)50:RESINTLK_CNTFO PP")
}

record(fanout, "$(CM,undefined)50:RESINTLK_CNTFO") {
  field(DESC, "RESINTLK fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)50:RESINTLK_CNT")
  field(LNK2, "$(CM,undefined)50:RESINTLK_CNTTC")
  field(LNK3, "$(CM,undefined)50:RESINTLK_CNTUC")
}

record(calc, "$(CM,undefined)50:RESINTLK_CNT") {
  field(DESC, "RESINTLK total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:RESINTLK_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:RESINTLK_CNTTC") {
  field(DESC, "RESINTLK today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:RESINTLK_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)50:RESINTLK_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)50:RESINTLK_CNTT") {
  field(DESC, "RESINTLK today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)50:RESINTLK_CNTY") {
  field(DESC, "RESINTLK yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:RESINTLK_CNTUC") {
  field(DESC, "RESINTLK user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:RESINTLK_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)50:RESINTLK_CNTU PP")
}

record(longin, "$(CM,undefined)50:RESINTLK_CNTU") {
  field(DESC, "RESINTLK user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)50:RESINTLK_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)50:RESINTLK_CNTU PP")
}

record(seq, "$(CM,undefined)50:RESINTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)50:RESINTLK_CNTT")
  field(LNK1, "$(CM,undefined)50:RESINTLK_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)50:RESINTLK_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)50:RESLINK_CNTPV") {
  field(DESC, "RESLINK previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:RESLINK_CNTP") {
  field(DESC, "RESLINK previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:RESLINK_FLTV") {
  field(DESC, "RESLINK value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:RESLINK_BYPV") {
  field(DESC, "RESLINK value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:RESLINK_CNTET") {
  field(DESC, "RESLINK increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)50:RESLINK_CNTSUB") {
  field(DESC, "RESLINK fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)50:RESLINK_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)50:RESLINK_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)50:RESLINK_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)50:RESLINK_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)50:RESLINK_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)50:RESLINK_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)50:RESLINK_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)50:RESLINK_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)50:RESLINK_CNTFO PP")
}

record(fanout, "$(CM,undefined)50:RESLINK_CNTFO") {
  field(DESC, "RESLINK fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)50:RESLINK_CNT")
  field(LNK2, "$(CM,undefined)50:RESLINK_CNTTC")
  field(LNK3, "$(CM,undefined)50:RESLINK_CNTUC")
}

record(calc, "$(CM,undefined)50:RESLINK_CNT") {
  field(DESC, "RESLINK total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:RESLINK_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:RESLINK_CNTTC") {
  field(DESC, "RESLINK today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:RESLINK_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)50:RESLINK_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)50:RESLINK_CNTT") {
  field(DESC, "RESLINK today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)50:RESLINK_CNTY") {
  field(DESC, "RESLINK yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:RESLINK_CNTUC") {
  field(DESC, "RESLINK user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:RESLINK_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)50:RESLINK_CNTU PP")
}

record(longin, "$(CM,undefined)50:RESLINK_CNTU") {
  field(DESC, "RESLINK user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)50:RESLINK_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)50:RESLINK_CNTU PP")
}

record(seq, "$(CM,undefined)50:RESLINK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)50:RESLINK_CNTT")
  field(LNK1, "$(CM,undefined)50:RESLINK_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)50:RESLINK_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)50:PLL_CNTPV") {
  field(DESC, "PLL previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:PLL_CNTP") {
  field(DESC, "PLL previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:PLL_FLTV") {
  field(DESC, "PLL value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:PLL_BYPV") {
  field(DESC, "PLL value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:PLL_CNTET") {
  field(DESC, "PLL increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)50:PLL_CNTSUB") {
  field(DESC, "PLL fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)50:PLL_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)50:PLL_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)50:PLL_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)50:PLL_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)50:PLL_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)50:PLL_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)50:PLL_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)50:PLL_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)50:PLL_CNTFO PP")
}

record(fanout, "$(CM,undefined)50:PLL_CNTFO") {
  field(DESC, "PLL fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)50:PLL_CNT")
  field(LNK2, "$(CM,undefined)50:PLL_CNTTC")
  field(LNK3, "$(CM,undefined)50:PLL_CNTUC")
}

record(calc, "$(CM,undefined)50:PLL_CNT") {
  field(DESC, "PLL total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:PLL_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:PLL_CNTTC") {
  field(DESC, "PLL today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:PLL_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)50:PLL_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)50:PLL_CNTT") {
  field(DESC, "PLL today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)50:PLL_CNTY") {
  field(DESC, "PLL yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:PLL_CNTUC") {
  field(DESC, "PLL user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:PLL_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)50:PLL_CNTU PP")
}

record(longin, "$(CM,undefined)50:PLL_CNTU") {
  field(DESC, "PLL user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)50:PLL_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)50:PLL_CNTU PP")
}

record(seq, "$(CM,undefined)50:PLL_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)50:PLL_CNTT")
  field(LNK1, "$(CM,undefined)50:PLL_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)50:PLL_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)50:IOCWDOG_CNTPV") {
  field(DESC, "IOCWDOG previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:IOCWDOG_CNTP") {
  field(DESC, "IOCWDOG previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:IOCWDOG_FLTV") {
  field(DESC, "IOCWDOG value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:IOCWDOG_BYPV") {
  field(DESC, "IOCWDOG value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:IOCWDOG_CNTET") {
  field(DESC, "IOCWDOG increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)50:IOCWDOG_CNTSUB") {
  field(DESC, "IOCWDOG fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)50:IOCWDOG_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)50:IOCWDOG_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)50:IOCWDOG_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)50:IOCWDOG_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)50:IOCWDOG_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)50:IOCWDOG_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)50:IOCWDOG_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)50:IOCWDOG_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)50:IOCWDOG_CNTFO PP")
}

record(fanout, "$(CM,undefined)50:IOCWDOG_CNTFO") {
  field(DESC, "IOCWDOG fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)50:IOCWDOG_CNT")
  field(LNK2, "$(CM,undefined)50:IOCWDOG_CNTTC")
  field(LNK3, "$(CM,undefined)50:IOCWDOG_CNTUC")
}

record(calc, "$(CM,undefined)50:IOCWDOG_CNT") {
  field(DESC, "IOCWDOG total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:IOCWDOG_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:IOCWDOG_CNTTC") {
  field(DESC, "IOCWDOG today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:IOCWDOG_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)50:IOCWDOG_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)50:IOCWDOG_CNTT") {
  field(DESC, "IOCWDOG today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)50:IOCWDOG_CNTY") {
  field(DESC, "IOCWDOG yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:IOCWDOG_CNTUC") {
  field(DESC, "IOCWDOG user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:IOCWDOG_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)50:IOCWDOG_CNTU PP")
}

record(longin, "$(CM,undefined)50:IOCWDOG_CNTU") {
  field(DESC, "IOCWDOG user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)50:IOCWDOG_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)50:IOCWDOG_CNTU PP")
}

record(seq, "$(CM,undefined)50:IOCWDOG_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)50:IOCWDOG_CNTT")
  field(LNK1, "$(CM,undefined)50:IOCWDOG_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)50:IOCWDOG_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)50:SSA_CNTPV") {
  field(DESC, "SSA previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:SSA_CNTP") {
  field(DESC, "SSA previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:SSA_FLTV") {
  field(DESC, "SSA value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:SSA_BYPV") {
  field(DESC, "SSA value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:SSA_CNTET") {
  field(DESC, "SSA increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)50:SSA_CNTSUB") {
  field(DESC, "SSA fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)50:SSA_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)50:SSA_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)50:SSA_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)50:SSA_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)50:SSA_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)50:SSA_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)50:SSA_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)50:SSA_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)50:SSA_CNTFO PP")
}

record(fanout, "$(CM,undefined)50:SSA_CNTFO") {
  field(DESC, "SSA fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)50:SSA_CNT")
  field(LNK2, "$(CM,undefined)50:SSA_CNTTC")
  field(LNK3, "$(CM,undefined)50:SSA_CNTUC")
}

record(calc, "$(CM,undefined)50:SSA_CNT") {
  field(DESC, "SSA total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:SSA_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:SSA_CNTTC") {
  field(DESC, "SSA today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:SSA_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)50:SSA_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)50:SSA_CNTT") {
  field(DESC, "SSA today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)50:SSA_CNTY") {
  field(DESC, "SSA yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:SSA_CNTUC") {
  field(DESC, "SSA user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:SSA_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)50:SSA_CNTU PP")
}

record(longin, "$(CM,undefined)50:SSA_CNTU") {
  field(DESC, "SSA user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)50:SSA_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)50:SSA_CNTU PP")
}

record(seq, "$(CM,undefined)50:SSA_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)50:SSA_CNTT")
  field(LNK1, "$(CM,undefined)50:SSA_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)50:SSA_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)50:CRYO_CNTPV") {
  field(DESC, "CRYO previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:CRYO_CNTP") {
  field(DESC, "CRYO previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:CRYO_FLTV") {
  field(DESC, "CRYO value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:CRYO_BYPV") {
  field(DESC, "CRYO value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:CRYO_CNTET") {
  field(DESC, "CRYO increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)50:CRYO_CNTSUB") {
  field(DESC, "CRYO fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)50:CRYO_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)50:CRYO_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)50:CRYO_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)50:CRYO_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)50:CRYO_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)50:CRYO_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)50:CRYO_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)50:CRYO_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)50:CRYO_CNTFO PP")
}

record(fanout, "$(CM,undefined)50:CRYO_CNTFO") {
  field(DESC, "CRYO fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)50:CRYO_CNT")
  field(LNK2, "$(CM,undefined)50:CRYO_CNTTC")
  field(LNK3, "$(CM,undefined)50:CRYO_CNTUC")
}

record(calc, "$(CM,undefined)50:CRYO_CNT") {
  field(DESC, "CRYO total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:CRYO_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:CRYO_CNTTC") {
  field(DESC, "CRYO today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:CRYO_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)50:CRYO_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)50:CRYO_CNTT") {
  field(DESC, "CRYO today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)50:CRYO_CNTY") {
  field(DESC, "CRYO yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:CRYO_CNTUC") {
  field(DESC, "CRYO user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:CRYO_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)50:CRYO_CNTU PP")
}

record(longin, "$(CM,undefined)50:CRYO_CNTU") {
  field(DESC, "CRYO user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)50:CRYO_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)50:CRYO_CNTU PP")
}

record(seq, "$(CM,undefined)50:CRYO_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)50:CRYO_CNTT")
  field(LNK1, "$(CM,undefined)50:CRYO_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)50:CRYO_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)50:LO_CNTPV") {
  field(DESC, "LO previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:LO_CNTP") {
  field(DESC, "LO previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:LO_FLTV") {
  field(DESC, "LO value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:LO_BYPV") {
  field(DESC, "LO value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:LO_CNTET") {
  field(DESC, "LO increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)50:LO_CNTSUB") {
  field(DESC, "LO fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)50:LO_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)50:LO_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)50:LO_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)50:LO_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)50:LO_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)50:LO_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)50:LO_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)50:LO_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)50:LO_CNTFO PP")
}

record(fanout, "$(CM,undefined)50:LO_CNTFO") {
  field(DESC, "LO fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)50:LO_CNT")
  field(LNK2, "$(CM,undefined)50:LO_CNTTC")
  field(LNK3, "$(CM,undefined)50:LO_CNTUC")
}

record(calc, "$(CM,undefined)50:LO_CNT") {
  field(DESC, "LO total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:LO_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:LO_CNTTC") {
  field(DESC, "LO today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:LO_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)50:LO_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)50:LO_CNTT") {
  field(DESC, "LO today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)50:LO_CNTY") {
  field(DESC, "LO yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:LO_CNTUC") {
  field(DESC, "LO user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:LO_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)50:LO_CNTU PP")
}

record(longin, "$(CM,undefined)50:LO_CNTU") {
  field(DESC, "LO user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)50:LO_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)50:LO_CNTU PP")
}

record(seq, "$(CM,undefined)50:LO_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)50:LO_CNTT")
  field(LNK1, "$(CM,undefined)50:LO_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)50:LO_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)50:ADMIN_CNTPV") {
  field(DESC, "ADMIN previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:ADMIN_CNTP") {
  field(DESC, "ADMIN previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:ADMIN_FLTV") {
  field(DESC, "ADMIN value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:ADMIN_BYPV") {
  field(DESC, "ADMIN value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)50:ADMIN_CNTET") {
  field(DESC, "ADMIN increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)50:ADMIN_CNTSUB") {
  field(DESC, "ADMIN fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)50:ADMIN_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)50:ADMIN_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)50:ADMIN_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)50:ADMIN_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)50:ADMIN_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)50:ADMIN_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)50:ADMIN_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)50:ADMIN_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)50:ADMIN_CNTFO PP")
}

record(fanout, "$(CM,undefined)50:ADMIN_CNTFO") {
  field(DESC, "ADMIN fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)50:ADMIN_CNT")
  field(LNK2, "$(CM,undefined)50:ADMIN_CNTTC")
  field(LNK3, "$(CM,undefined)50:ADMIN_CNTUC")
}

record(calc, "$(CM,undefined)50:ADMIN_CNT") {
  field(DESC, "ADMIN total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:ADMIN_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:ADMIN_CNTTC") {
  field(DESC, "ADMIN today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:ADMIN_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)50:ADMIN_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)50:ADMIN_CNTT") {
  field(DESC, "ADMIN today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)50:ADMIN_CNTY") {
  field(DESC, "ADMIN yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:ADMIN_CNTUC") {
  field(DESC, "ADMIN user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:ADMIN_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)50:ADMIN_CNTU PP")
}

record(longin, "$(CM,undefined)50:ADMIN_CNTU") {
  field(DESC, "ADMIN user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)50:ADMIN_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)50:ADMIN_CNTU PP")
}

record(seq, "$(CM,undefined)50:ADMIN_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)50:ADMIN_CNTT")
  field(LNK1, "$(CM,undefined)50:ADMIN_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)50:ADMIN_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)50:FB_SUM_CNTPV") {
  field(DESC, "FB_SUM previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:FB_SUM_CNTP") {
  field(DESC, "FB_SUM previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)50:FB_SUM_FLTV") {
  field(DESC, "FB_SUM value indicating fault")
  field(PINI, "YES")
  field(VAL, "2")
}

record(bi, "$(CM,undefined)50:FB_SUM_BYPV") {
  field(DESC, "FB_SUM value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "0")
}

record(bi, "$(CM,undefined)50:FB_SUM_CNTET") {
  field(DESC, "FB_SUM increment counter every time")
  field(PINI, "YES")
  field(VAL, "1")
}

record(aSub, "$(CM,undefined)50:FB_SUM_CNTSUB") {
  field(DESC, "FB_SUM fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)50:FB_SUM")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "$(CM,undefined)50:RFREADYFORBEAM CP")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)50:FB_SUM_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)50:FB_SUM_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)50:FB_SUM_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)50:FB_SUM_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)50:FB_SUM_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)50:FB_SUM_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)50:FB_SUM_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)50:FB_SUM_CNTFO PP")
}

record(fanout, "$(CM,undefined)50:FB_SUM_CNTFO") {
  field(DESC, "FB_SUM fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)50:FB_SUM_CNT")
  field(LNK2, "$(CM,undefined)50:FB_SUM_CNTTC")
  field(LNK3, "$(CM,undefined)50:FB_SUM_CNTUC")
}

record(calc, "$(CM,undefined)50:FB_SUM_CNT") {
  field(DESC, "FB_SUM total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:FB_SUM_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:FB_SUM_CNTTC") {
  field(DESC, "FB_SUM today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:FB_SUM_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)50:FB_SUM_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)50:FB_SUM_CNTT") {
  field(DESC, "FB_SUM today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)50:FB_SUM_CNTY") {
  field(DESC, "FB_SUM yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)50:FB_SUM_CNTUC") {
  field(DESC, "FB_SUM user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)50:FB_SUM_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)50:FB_SUM_CNTU PP")
}

record(longin, "$(CM,undefined)50:FB_SUM_CNTU") {
  field(DESC, "FB_SUM user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)50:FB_SUM_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)50:FB_SUM_CNTU PP")
}

record(seq, "$(CM,undefined)50:FB_SUM_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)50:FB_SUM_CNTT")
  field(LNK1, "$(CM,undefined)50:FB_SUM_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)50:FB_SUM_CNTT PP")
}
record(fanout, "$(CM,undefined)60:INTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(LNK0, "$(CM,undefined)60:SSA_CNTRO")
  field(LNK1, "$(CM,undefined)60:STEPTEMP_CNTRO")
  field(LNK2, "$(CM,undefined)60:CPLRTEMP1_CNTRO")
  field(LNK3, "$(CM,undefined)60:CPLRTEMP2_CNTRO")
  field(LNK4, "$(CM,undefined)60:QUENCH_CNTRO")
  field(LNK5, "$(CM,undefined)60:RESINTLK_CNTRO")
  field(LNK6, "$(CM,undefined)60:RESLINK_CNTRO")
  field(LNK7, "$(CM,undefined)60:PLL_CNTRO")
  field(LNK8, "$(CM,undefined)60:IOCWDOG_CNTRO")
  field(LNK9, "$(CM,undefined)60:CRYO_CNTRO")
  field(LNKA, "$(CM,undefined)60:LO_CNTRO")
  field(LNKB, "$(CM,undefined)60:ADMIN_CNTRO")
  field(LNKC, "$(CM,undefined)60:FB_SUM_CNTRO")
}

record(fanout, "$(CM,undefined)60:INTLK_CNTUCLR_ALL") {
  field(DESC, "Clear all intlk counts for cavity")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,undefined)60:SSA_CNTUCLR")
  field(LNK1, "$(CM,undefined)60:STEPTEMP_CNTUCLR")
  field(LNK2, "$(CM,undefined)60:CPLRTEMP1_CNTUCLR")
  field(LNK3, "$(CM,undefined)60:CPLRTEMP2_CNTUCLR")
  field(LNK4, "$(CM,undefined)60:QUENCH_CNTUCLR")
  field(LNK5, "$(CM,undefined)60:RESINTLK_CNTUCLR")
  field(LNK6, "$(CM,undefined)60:RESLINK_CNTUCLR")
  field(LNK7, "$(CM,undefined)60:PLL_CNTUCLR")
  field(LNK8, "$(CM,undefined)60:IOCWDOG_CNTUCLR")
  field(LNK9, "$(CM,undefined)60:CRYO_CNTUCLR")
  field(LNKA, "$(CM,undefined)60:LO_CNTUCLR")
  field(LNKB, "$(CM,undefined)60:ADMIN_CNTUCLR")
  field(LNKC, "$(CM,undefined)60:FB_SUM_CNTUCLR")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)60:STEPTEMP_CNTPV") {
  field(DESC, "STEPTEMP previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:STEPTEMP_CNTP") {
  field(DESC, "STEPTEMP previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:STEPTEMP_FLTV") {
  field(DESC, "STEPTEMP value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:STEPTEMP_BYPV") {
  field(DESC, "STEPTEMP value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:STEPTEMP_CNTET") {
  field(DESC, "STEPTEMP increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)60:STEPTEMP_CNTSUB") {
  field(DESC, "STEPTEMP fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)60:STEPTEMP_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)60:STEPTEMP_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)60:STEPTEMP_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)60:STEPTEMP_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)60:STEPTEMP_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)60:STEPTEMP_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)60:STEPTEMP_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)60:STEPTEMP_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)60:STEPTEMP_CNTFO PP")
}

record(fanout, "$(CM,undefined)60:STEPTEMP_CNTFO") {
  field(DESC, "STEPTEMP fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)60:STEPTEMP_CNT")
  field(LNK2, "$(CM,undefined)60:STEPTEMP_CNTTC")
  field(LNK3, "$(CM,undefined)60:STEPTEMP_CNTUC")
}

record(calc, "$(CM,undefined)60:STEPTEMP_CNT") {
  field(DESC, "STEPTEMP total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:STEPTEMP_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:STEPTEMP_CNTTC") {
  field(DESC, "STEPTEMP today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:STEPTEMP_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)60:STEPTEMP_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)60:STEPTEMP_CNTT") {
  field(DESC, "STEPTEMP today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)60:STEPTEMP_CNTY") {
  field(DESC, "STEPTEMP yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:STEPTEMP_CNTUC") {
  field(DESC, "STEPTEMP user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:STEPTEMP_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)60:STEPTEMP_CNTU PP")
}

record(longin, "$(CM,undefined)60:STEPTEMP_CNTU") {
  field(DESC, "STEPTEMP user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)60:STEPTEMP_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)60:STEPTEMP_CNTU PP")
}

record(seq, "$(CM,undefined)60:STEPTEMP_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)60:STEPTEMP_CNTT")
  field(LNK1, "$(CM,undefined)60:STEPTEMP_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)60:STEPTEMP_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)60:CPLRTEMP1_CNTPV") {
  field(DESC, "CPLRTEMP1 previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:CPLRTEMP1_CNTP") {
  field(DESC, "CPLRTEMP1 previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:CPLRTEMP1_FLTV") {
  field(DESC, "CPLRTEMP1 value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:CPLRTEMP1_BYPV") {
  field(DESC, "CPLRTEMP1 value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:CPLRTEMP1_CNTET") {
  field(DESC, "CPLRTEMP1 increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)60:CPLRTEMP1_CNTSUB") {
  field(DESC, "CPLRTEMP1 fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)60:CPLRTEMP1_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)60:CPLRTEMP1_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)60:CPLRTEMP1_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)60:CPLRTEMP1_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)60:CPLRTEMP1_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)60:CPLRTEMP1_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)60:CPLRTEMP1_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)60:CPLRTEMP1_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)60:CPLRTEMP1_CNTFO PP")
}

record(fanout, "$(CM,undefined)60:CPLRTEMP1_CNTFO") {
  field(DESC, "CPLRTEMP1 fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)60:CPLRTEMP1_CNT")
  field(LNK2, "$(CM,undefined)60:CPLRTEMP1_CNTTC")
  field(LNK3, "$(CM,undefined)60:CPLRTEMP1_CNTUC")
}

record(calc, "$(CM,undefined)60:CPLRTEMP1_CNT") {
  field(DESC, "CPLRTEMP1 total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:CPLRTEMP1_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:CPLRTEMP1_CNTTC") {
  field(DESC, "CPLRTEMP1 today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:CPLRTEMP1_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)60:CPLRTEMP1_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)60:CPLRTEMP1_CNTT") {
  field(DESC, "CPLRTEMP1 today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)60:CPLRTEMP1_CNTY") {
  field(DESC, "CPLRTEMP1 yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:CPLRTEMP1_CNTUC") {
  field(DESC, "CPLRTEMP1 user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:CPLRTEMP1_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)60:CPLRTEMP1_CNTU PP")
}

record(longin, "$(CM,undefined)60:CPLRTEMP1_CNTU") {
  field(DESC, "CPLRTEMP1 user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)60:CPLRTEMP1_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)60:CPLRTEMP1_CNTU PP")
}

record(seq, "$(CM,undefined)60:CPLRTEMP1_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)60:CPLRTEMP1_CNTT")
  field(LNK1, "$(CM,undefined)60:CPLRTEMP1_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)60:CPLRTEMP1_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)60:CPLRTEMP2_CNTPV") {
  field(DESC, "CPLRTEMP2 previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:CPLRTEMP2_CNTP") {
  field(DESC, "CPLRTEMP2 previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:CPLRTEMP2_FLTV") {
  field(DESC, "CPLRTEMP2 value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:CPLRTEMP2_BYPV") {
  field(DESC, "CPLRTEMP2 value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:CPLRTEMP2_CNTET") {
  field(DESC, "CPLRTEMP2 increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)60:CPLRTEMP2_CNTSUB") {
  field(DESC, "CPLRTEMP2 fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)60:CPLRTEMP2_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)60:CPLRTEMP2_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)60:CPLRTEMP2_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)60:CPLRTEMP2_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)60:CPLRTEMP2_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)60:CPLRTEMP2_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)60:CPLRTEMP2_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)60:CPLRTEMP2_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)60:CPLRTEMP2_CNTFO PP")
}

record(fanout, "$(CM,undefined)60:CPLRTEMP2_CNTFO") {
  field(DESC, "CPLRTEMP2 fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)60:CPLRTEMP2_CNT")
  field(LNK2, "$(CM,undefined)60:CPLRTEMP2_CNTTC")
  field(LNK3, "$(CM,undefined)60:CPLRTEMP2_CNTUC")
}

record(calc, "$(CM,undefined)60:CPLRTEMP2_CNT") {
  field(DESC, "CPLRTEMP2 total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:CPLRTEMP2_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:CPLRTEMP2_CNTTC") {
  field(DESC, "CPLRTEMP2 today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:CPLRTEMP2_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)60:CPLRTEMP2_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)60:CPLRTEMP2_CNTT") {
  field(DESC, "CPLRTEMP2 today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)60:CPLRTEMP2_CNTY") {
  field(DESC, "CPLRTEMP2 yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:CPLRTEMP2_CNTUC") {
  field(DESC, "CPLRTEMP2 user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:CPLRTEMP2_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)60:CPLRTEMP2_CNTU PP")
}

record(longin, "$(CM,undefined)60:CPLRTEMP2_CNTU") {
  field(DESC, "CPLRTEMP2 user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)60:CPLRTEMP2_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)60:CPLRTEMP2_CNTU PP")
}

record(seq, "$(CM,undefined)60:CPLRTEMP2_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)60:CPLRTEMP2_CNTT")
  field(LNK1, "$(CM,undefined)60:CPLRTEMP2_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)60:CPLRTEMP2_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)60:QUENCH_CNTPV") {
  field(DESC, "QUENCH previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:QUENCH_CNTP") {
  field(DESC, "QUENCH previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:QUENCH_FLTV") {
  field(DESC, "QUENCH value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:QUENCH_BYPV") {
  field(DESC, "QUENCH value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:QUENCH_CNTET") {
  field(DESC, "QUENCH increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)60:QUENCH_CNTSUB") {
  field(DESC, "QUENCH fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)60:QUENCH_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)60:QUENCH_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)60:QUENCH_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)60:QUENCH_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)60:QUENCH_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)60:QUENCH_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)60:QUENCH_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)60:QUENCH_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)60:QUENCH_CNTFO PP")
}

record(fanout, "$(CM,undefined)60:QUENCH_CNTFO") {
  field(DESC, "QUENCH fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)60:QUENCH_CNT")
  field(LNK2, "$(CM,undefined)60:QUENCH_CNTTC")
  field(LNK3, "$(CM,undefined)60:QUENCH_CNTUC")
}

record(calc, "$(CM,undefined)60:QUENCH_CNT") {
  field(DESC, "QUENCH total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:QUENCH_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:QUENCH_CNTTC") {
  field(DESC, "QUENCH today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:QUENCH_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)60:QUENCH_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)60:QUENCH_CNTT") {
  field(DESC, "QUENCH today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)60:QUENCH_CNTY") {
  field(DESC, "QUENCH yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:QUENCH_CNTUC") {
  field(DESC, "QUENCH user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:QUENCH_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)60:QUENCH_CNTU PP")
}

record(longin, "$(CM,undefined)60:QUENCH_CNTU") {
  field(DESC, "QUENCH user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)60:QUENCH_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)60:QUENCH_CNTU PP")
}

record(seq, "$(CM,undefined)60:QUENCH_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)60:QUENCH_CNTT")
  field(LNK1, "$(CM,undefined)60:QUENCH_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)60:QUENCH_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)60:RESINTLK_CNTPV") {
  field(DESC, "RESINTLK previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:RESINTLK_CNTP") {
  field(DESC, "RESINTLK previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:RESINTLK_FLTV") {
  field(DESC, "RESINTLK value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:RESINTLK_BYPV") {
  field(DESC, "RESINTLK value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:RESINTLK_CNTET") {
  field(DESC, "RESINTLK increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)60:RESINTLK_CNTSUB") {
  field(DESC, "RESINTLK fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)60:RESINTLK_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)60:RESINTLK_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)60:RESINTLK_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)60:RESINTLK_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)60:RESINTLK_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)60:RESINTLK_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)60:RESINTLK_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)60:RESINTLK_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)60:RESINTLK_CNTFO PP")
}

record(fanout, "$(CM,undefined)60:RESINTLK_CNTFO") {
  field(DESC, "RESINTLK fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)60:RESINTLK_CNT")
  field(LNK2, "$(CM,undefined)60:RESINTLK_CNTTC")
  field(LNK3, "$(CM,undefined)60:RESINTLK_CNTUC")
}

record(calc, "$(CM,undefined)60:RESINTLK_CNT") {
  field(DESC, "RESINTLK total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:RESINTLK_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:RESINTLK_CNTTC") {
  field(DESC, "RESINTLK today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:RESINTLK_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)60:RESINTLK_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)60:RESINTLK_CNTT") {
  field(DESC, "RESINTLK today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)60:RESINTLK_CNTY") {
  field(DESC, "RESINTLK yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:RESINTLK_CNTUC") {
  field(DESC, "RESINTLK user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:RESINTLK_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)60:RESINTLK_CNTU PP")
}

record(longin, "$(CM,undefined)60:RESINTLK_CNTU") {
  field(DESC, "RESINTLK user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)60:RESINTLK_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)60:RESINTLK_CNTU PP")
}

record(seq, "$(CM,undefined)60:RESINTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)60:RESINTLK_CNTT")
  field(LNK1, "$(CM,undefined)60:RESINTLK_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)60:RESINTLK_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)60:RESLINK_CNTPV") {
  field(DESC, "RESLINK previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:RESLINK_CNTP") {
  field(DESC, "RESLINK previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:RESLINK_FLTV") {
  field(DESC, "RESLINK value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:RESLINK_BYPV") {
  field(DESC, "RESLINK value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:RESLINK_CNTET") {
  field(DESC, "RESLINK increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)60:RESLINK_CNTSUB") {
  field(DESC, "RESLINK fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)60:RESLINK_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)60:RESLINK_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)60:RESLINK_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)60:RESLINK_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)60:RESLINK_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)60:RESLINK_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)60:RESLINK_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)60:RESLINK_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)60:RESLINK_CNTFO PP")
}

record(fanout, "$(CM,undefined)60:RESLINK_CNTFO") {
  field(DESC, "RESLINK fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)60:RESLINK_CNT")
  field(LNK2, "$(CM,undefined)60:RESLINK_CNTTC")
  field(LNK3, "$(CM,undefined)60:RESLINK_CNTUC")
}

record(calc, "$(CM,undefined)60:RESLINK_CNT") {
  field(DESC, "RESLINK total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:RESLINK_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:RESLINK_CNTTC") {
  field(DESC, "RESLINK today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:RESLINK_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)60:RESLINK_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)60:RESLINK_CNTT") {
  field(DESC, "RESLINK today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)60:RESLINK_CNTY") {
  field(DESC, "RESLINK yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:RESLINK_CNTUC") {
  field(DESC, "RESLINK user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:RESLINK_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)60:RESLINK_CNTU PP")
}

record(longin, "$(CM,undefined)60:RESLINK_CNTU") {
  field(DESC, "RESLINK user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)60:RESLINK_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)60:RESLINK_CNTU PP")
}

record(seq, "$(CM,undefined)60:RESLINK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)60:RESLINK_CNTT")
  field(LNK1, "$(CM,undefined)60:RESLINK_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)60:RESLINK_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)60:PLL_CNTPV") {
  field(DESC, "PLL previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:PLL_CNTP") {
  field(DESC, "PLL previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:PLL_FLTV") {
  field(DESC, "PLL value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:PLL_BYPV") {
  field(DESC, "PLL value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:PLL_CNTET") {
  field(DESC, "PLL increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)60:PLL_CNTSUB") {
  field(DESC, "PLL fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)60:PLL_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)60:PLL_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)60:PLL_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)60:PLL_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)60:PLL_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)60:PLL_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)60:PLL_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)60:PLL_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)60:PLL_CNTFO PP")
}

record(fanout, "$(CM,undefined)60:PLL_CNTFO") {
  field(DESC, "PLL fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)60:PLL_CNT")
  field(LNK2, "$(CM,undefined)60:PLL_CNTTC")
  field(LNK3, "$(CM,undefined)60:PLL_CNTUC")
}

record(calc, "$(CM,undefined)60:PLL_CNT") {
  field(DESC, "PLL total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:PLL_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:PLL_CNTTC") {
  field(DESC, "PLL today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:PLL_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)60:PLL_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)60:PLL_CNTT") {
  field(DESC, "PLL today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)60:PLL_CNTY") {
  field(DESC, "PLL yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:PLL_CNTUC") {
  field(DESC, "PLL user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:PLL_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)60:PLL_CNTU PP")
}

record(longin, "$(CM,undefined)60:PLL_CNTU") {
  field(DESC, "PLL user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)60:PLL_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)60:PLL_CNTU PP")
}

record(seq, "$(CM,undefined)60:PLL_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)60:PLL_CNTT")
  field(LNK1, "$(CM,undefined)60:PLL_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)60:PLL_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)60:IOCWDOG_CNTPV") {
  field(DESC, "IOCWDOG previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:IOCWDOG_CNTP") {
  field(DESC, "IOCWDOG previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:IOCWDOG_FLTV") {
  field(DESC, "IOCWDOG value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:IOCWDOG_BYPV") {
  field(DESC, "IOCWDOG value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:IOCWDOG_CNTET") {
  field(DESC, "IOCWDOG increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)60:IOCWDOG_CNTSUB") {
  field(DESC, "IOCWDOG fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)60:IOCWDOG_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)60:IOCWDOG_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)60:IOCWDOG_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)60:IOCWDOG_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)60:IOCWDOG_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)60:IOCWDOG_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)60:IOCWDOG_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)60:IOCWDOG_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)60:IOCWDOG_CNTFO PP")
}

record(fanout, "$(CM,undefined)60:IOCWDOG_CNTFO") {
  field(DESC, "IOCWDOG fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)60:IOCWDOG_CNT")
  field(LNK2, "$(CM,undefined)60:IOCWDOG_CNTTC")
  field(LNK3, "$(CM,undefined)60:IOCWDOG_CNTUC")
}

record(calc, "$(CM,undefined)60:IOCWDOG_CNT") {
  field(DESC, "IOCWDOG total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:IOCWDOG_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:IOCWDOG_CNTTC") {
  field(DESC, "IOCWDOG today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:IOCWDOG_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)60:IOCWDOG_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)60:IOCWDOG_CNTT") {
  field(DESC, "IOCWDOG today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)60:IOCWDOG_CNTY") {
  field(DESC, "IOCWDOG yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:IOCWDOG_CNTUC") {
  field(DESC, "IOCWDOG user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:IOCWDOG_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)60:IOCWDOG_CNTU PP")
}

record(longin, "$(CM,undefined)60:IOCWDOG_CNTU") {
  field(DESC, "IOCWDOG user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)60:IOCWDOG_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)60:IOCWDOG_CNTU PP")
}

record(seq, "$(CM,undefined)60:IOCWDOG_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)60:IOCWDOG_CNTT")
  field(LNK1, "$(CM,undefined)60:IOCWDOG_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)60:IOCWDOG_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)60:SSA_CNTPV") {
  field(DESC, "SSA previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:SSA_CNTP") {
  field(DESC, "SSA previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:SSA_FLTV") {
  field(DESC, "SSA value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:SSA_BYPV") {
  field(DESC, "SSA value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:SSA_CNTET") {
  field(DESC, "SSA increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)60:SSA_CNTSUB") {
  field(DESC, "SSA fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)60:SSA_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)60:SSA_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)60:SSA_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)60:SSA_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)60:SSA_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)60:SSA_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)60:SSA_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)60:SSA_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)60:SSA_CNTFO PP")
}

record(fanout, "$(CM,undefined)60:SSA_CNTFO") {
  field(DESC, "SSA fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)60:SSA_CNT")
  field(LNK2, "$(CM,undefined)60:SSA_CNTTC")
  field(LNK3, "$(CM,undefined)60:SSA_CNTUC")
}

record(calc, "$(CM,undefined)60:SSA_CNT") {
  field(DESC, "SSA total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:SSA_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:SSA_CNTTC") {
  field(DESC, "SSA today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:SSA_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)60:SSA_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)60:SSA_CNTT") {
  field(DESC, "SSA today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)60:SSA_CNTY") {
  field(DESC, "SSA yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:SSA_CNTUC") {
  field(DESC, "SSA user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:SSA_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)60:SSA_CNTU PP")
}

record(longin, "$(CM,undefined)60:SSA_CNTU") {
  field(DESC, "SSA user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)60:SSA_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)60:SSA_CNTU PP")
}

record(seq, "$(CM,undefined)60:SSA_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)60:SSA_CNTT")
  field(LNK1, "$(CM,undefined)60:SSA_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)60:SSA_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)60:CRYO_CNTPV") {
  field(DESC, "CRYO previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:CRYO_CNTP") {
  field(DESC, "CRYO previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:CRYO_FLTV") {
  field(DESC, "CRYO value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:CRYO_BYPV") {
  field(DESC, "CRYO value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:CRYO_CNTET") {
  field(DESC, "CRYO increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)60:CRYO_CNTSUB") {
  field(DESC, "CRYO fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)60:CRYO_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)60:CRYO_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)60:CRYO_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)60:CRYO_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)60:CRYO_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)60:CRYO_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)60:CRYO_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)60:CRYO_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)60:CRYO_CNTFO PP")
}

record(fanout, "$(CM,undefined)60:CRYO_CNTFO") {
  field(DESC, "CRYO fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)60:CRYO_CNT")
  field(LNK2, "$(CM,undefined)60:CRYO_CNTTC")
  field(LNK3, "$(CM,undefined)60:CRYO_CNTUC")
}

record(calc, "$(CM,undefined)60:CRYO_CNT") {
  field(DESC, "CRYO total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:CRYO_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:CRYO_CNTTC") {
  field(DESC, "CRYO today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:CRYO_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)60:CRYO_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)60:CRYO_CNTT") {
  field(DESC, "CRYO today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)60:CRYO_CNTY") {
  field(DESC, "CRYO yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:CRYO_CNTUC") {
  field(DESC, "CRYO user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:CRYO_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)60:CRYO_CNTU PP")
}

record(longin, "$(CM,undefined)60:CRYO_CNTU") {
  field(DESC, "CRYO user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)60:CRYO_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)60:CRYO_CNTU PP")
}

record(seq, "$(CM,undefined)60:CRYO_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)60:CRYO_CNTT")
  field(LNK1, "$(CM,undefined)60:CRYO_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)60:CRYO_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)60:LO_CNTPV") {
  field(DESC, "LO previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:LO_CNTP") {
  field(DESC, "LO previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:LO_FLTV") {
  field(DESC, "LO value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:LO_BYPV") {
  field(DESC, "LO value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:LO_CNTET") {
  field(DESC, "LO increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)60:LO_CNTSUB") {
  field(DESC, "LO fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)60:LO_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)60:LO_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)60:LO_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)60:LO_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)60:LO_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)60:LO_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)60:LO_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)60:LO_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)60:LO_CNTFO PP")
}

record(fanout, "$(CM,undefined)60:LO_CNTFO") {
  field(DESC, "LO fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)60:LO_CNT")
  field(LNK2, "$(CM,undefined)60:LO_CNTTC")
  field(LNK3, "$(CM,undefined)60:LO_CNTUC")
}

record(calc, "$(CM,undefined)60:LO_CNT") {
  field(DESC, "LO total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:LO_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:LO_CNTTC") {
  field(DESC, "LO today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:LO_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)60:LO_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)60:LO_CNTT") {
  field(DESC, "LO today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)60:LO_CNTY") {
  field(DESC, "LO yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:LO_CNTUC") {
  field(DESC, "LO user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:LO_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)60:LO_CNTU PP")
}

record(longin, "$(CM,undefined)60:LO_CNTU") {
  field(DESC, "LO user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)60:LO_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)60:LO_CNTU PP")
}

record(seq, "$(CM,undefined)60:LO_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)60:LO_CNTT")
  field(LNK1, "$(CM,undefined)60:LO_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)60:LO_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)60:ADMIN_CNTPV") {
  field(DESC, "ADMIN previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:ADMIN_CNTP") {
  field(DESC, "ADMIN previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:ADMIN_FLTV") {
  field(DESC, "ADMIN value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:ADMIN_BYPV") {
  field(DESC, "ADMIN value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)60:ADMIN_CNTET") {
  field(DESC, "ADMIN increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)60:ADMIN_CNTSUB") {
  field(DESC, "ADMIN fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)60:ADMIN_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)60:ADMIN_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)60:ADMIN_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)60:ADMIN_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)60:ADMIN_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)60:ADMIN_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)60:ADMIN_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)60:ADMIN_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)60:ADMIN_CNTFO PP")
}

record(fanout, "$(CM,undefined)60:ADMIN_CNTFO") {
  field(DESC, "ADMIN fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)60:ADMIN_CNT")
  field(LNK2, "$(CM,undefined)60:ADMIN_CNTTC")
  field(LNK3, "$(CM,undefined)60:ADMIN_CNTUC")
}

record(calc, "$(CM,undefined)60:ADMIN_CNT") {
  field(DESC, "ADMIN total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:ADMIN_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:ADMIN_CNTTC") {
  field(DESC, "ADMIN today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:ADMIN_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)60:ADMIN_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)60:ADMIN_CNTT") {
  field(DESC, "ADMIN today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)60:ADMIN_CNTY") {
  field(DESC, "ADMIN yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:ADMIN_CNTUC") {
  field(DESC, "ADMIN user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:ADMIN_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)60:ADMIN_CNTU PP")
}

record(longin, "$(CM,undefined)60:ADMIN_CNTU") {
  field(DESC, "ADMIN user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)60:ADMIN_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)60:ADMIN_CNTU PP")
}

record(seq, "$(CM,undefined)60:ADMIN_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)60:ADMIN_CNTT")
  field(LNK1, "$(CM,undefined)60:ADMIN_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)60:ADMIN_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)60:FB_SUM_CNTPV") {
  field(DESC, "FB_SUM previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:FB_SUM_CNTP") {
  field(DESC, "FB_SUM previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)60:FB_SUM_FLTV") {
  field(DESC, "FB_SUM value indicating fault")
  field(PINI, "YES")
  field(VAL, "2")
}

record(bi, "$(CM,undefined)60:FB_SUM_BYPV") {
  field(DESC, "FB_SUM value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "0")
}

record(bi, "$(CM,undefined)60:FB_SUM_CNTET") {
  field(DESC, "FB_SUM increment counter every time")
  field(PINI, "YES")
  field(VAL, "1")
}

record(aSub, "$(CM,undefined)60:FB_SUM_CNTSUB") {
  field(DESC, "FB_SUM fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)60:FB_SUM")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "$(CM,undefined)60:RFREADYFORBEAM CP")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)60:FB_SUM_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)60:FB_SUM_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)60:FB_SUM_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)60:FB_SUM_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)60:FB_SUM_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)60:FB_SUM_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)60:FB_SUM_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)60:FB_SUM_CNTFO PP")
}

record(fanout, "$(CM,undefined)60:FB_SUM_CNTFO") {
  field(DESC, "FB_SUM fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)60:FB_SUM_CNT")
  field(LNK2, "$(CM,undefined)60:FB_SUM_CNTTC")
  field(LNK3, "$(CM,undefined)60:FB_SUM_CNTUC")
}

record(calc, "$(CM,undefined)60:FB_SUM_CNT") {
  field(DESC, "FB_SUM total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:FB_SUM_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:FB_SUM_CNTTC") {
  field(DESC, "FB_SUM today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:FB_SUM_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)60:FB_SUM_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)60:FB_SUM_CNTT") {
  field(DESC, "FB_SUM today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)60:FB_SUM_CNTY") {
  field(DESC, "FB_SUM yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)60:FB_SUM_CNTUC") {
  field(DESC, "FB_SUM user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)60:FB_SUM_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)60:FB_SUM_CNTU PP")
}

record(longin, "$(CM,undefined)60:FB_SUM_CNTU") {
  field(DESC, "FB_SUM user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)60:FB_SUM_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)60:FB_SUM_CNTU PP")
}

record(seq, "$(CM,undefined)60:FB_SUM_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)60:FB_SUM_CNTT")
  field(LNK1, "$(CM,undefined)60:FB_SUM_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)60:FB_SUM_CNTT PP")
}
record(fanout, "$(CM,undefined)70:INTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(LNK0, "$(CM,undefined)70:SSA_CNTRO")
  field(LNK1, "$(CM,undefined)70:STEPTEMP_CNTRO")
  field(LNK2, "$(CM,undefined)70:CPLRTEMP1_CNTRO")
  field(LNK3, "$(CM,undefined)70:CPLRTEMP2_CNTRO")
  field(LNK4, "$(CM,undefined)70:QUENCH_CNTRO")
  field(LNK5, "$(CM,undefined)70:RESINTLK_CNTRO")
  field(LNK6, "$(CM,undefined)70:RESLINK_CNTRO")
  field(LNK7, "$(CM,undefined)70:PLL_CNTRO")
  field(LNK8, "$(CM,undefined)70:IOCWDOG_CNTRO")
  field(LNK9, "$(CM,undefined)70:CRYO_CNTRO")
  field(LNKA, "$(CM,undefined)70:LO_CNTRO")
  field(LNKB, "$(CM,undefined)70:ADMIN_CNTRO")
  field(LNKC, "$(CM,undefined)70:FB_SUM_CNTRO")
}

record(fanout, "$(CM,undefined)70:INTLK_CNTUCLR_ALL") {
  field(DESC, "Clear all intlk counts for cavity")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,undefined)70:SSA_CNTUCLR")
  field(LNK1, "$(CM,undefined)70:STEPTEMP_CNTUCLR")
  field(LNK2, "$(CM,undefined)70:CPLRTEMP1_CNTUCLR")
  field(LNK3, "$(CM,undefined)70:CPLRTEMP2_CNTUCLR")
  field(LNK4, "$(CM,undefined)70:QUENCH_CNTUCLR")
  field(LNK5, "$(CM,undefined)70:RESINTLK_CNTUCLR")
  field(LNK6, "$(CM,undefined)70:RESLINK_CNTUCLR")
  field(LNK7, "$(CM,undefined)70:PLL_CNTUCLR")
  field(LNK8, "$(CM,undefined)70:IOCWDOG_CNTUCLR")
  field(LNK9, "$(CM,undefined)70:CRYO_CNTUCLR")
  field(LNKA, "$(CM,undefined)70:LO_CNTUCLR")
  field(LNKB, "$(CM,undefined)70:ADMIN_CNTUCLR")
  field(LNKC, "$(CM,undefined)70:FB_SUM_CNTUCLR")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)70:STEPTEMP_CNTPV") {
  field(DESC, "STEPTEMP previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:STEPTEMP_CNTP") {
  field(DESC, "STEPTEMP previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:STEPTEMP_FLTV") {
  field(DESC, "STEPTEMP value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:STEPTEMP_BYPV") {
  field(DESC, "STEPTEMP value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:STEPTEMP_CNTET") {
  field(DESC, "STEPTEMP increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)70:STEPTEMP_CNTSUB") {
  field(DESC, "STEPTEMP fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)70:STEPTEMP_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)70:STEPTEMP_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)70:STEPTEMP_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)70:STEPTEMP_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)70:STEPTEMP_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)70:STEPTEMP_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)70:STEPTEMP_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)70:STEPTEMP_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)70:STEPTEMP_CNTFO PP")
}

record(fanout, "$(CM,undefined)70:STEPTEMP_CNTFO") {
  field(DESC, "STEPTEMP fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)70:STEPTEMP_CNT")
  field(LNK2, "$(CM,undefined)70:STEPTEMP_CNTTC")
  field(LNK3, "$(CM,undefined)70:STEPTEMP_CNTUC")
}

record(calc, "$(CM,undefined)70:STEPTEMP_CNT") {
  field(DESC, "STEPTEMP total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:STEPTEMP_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:STEPTEMP_CNTTC") {
  field(DESC, "STEPTEMP today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:STEPTEMP_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)70:STEPTEMP_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)70:STEPTEMP_CNTT") {
  field(DESC, "STEPTEMP today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)70:STEPTEMP_CNTY") {
  field(DESC, "STEPTEMP yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:STEPTEMP_CNTUC") {
  field(DESC, "STEPTEMP user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:STEPTEMP_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)70:STEPTEMP_CNTU PP")
}

record(longin, "$(CM,undefined)70:STEPTEMP_CNTU") {
  field(DESC, "STEPTEMP user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)70:STEPTEMP_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)70:STEPTEMP_CNTU PP")
}

record(seq, "$(CM,undefined)70:STEPTEMP_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)70:STEPTEMP_CNTT")
  field(LNK1, "$(CM,undefined)70:STEPTEMP_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)70:STEPTEMP_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)70:CPLRTEMP1_CNTPV") {
  field(DESC, "CPLRTEMP1 previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:CPLRTEMP1_CNTP") {
  field(DESC, "CPLRTEMP1 previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:CPLRTEMP1_FLTV") {
  field(DESC, "CPLRTEMP1 value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:CPLRTEMP1_BYPV") {
  field(DESC, "CPLRTEMP1 value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:CPLRTEMP1_CNTET") {
  field(DESC, "CPLRTEMP1 increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)70:CPLRTEMP1_CNTSUB") {
  field(DESC, "CPLRTEMP1 fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)70:CPLRTEMP1_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)70:CPLRTEMP1_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)70:CPLRTEMP1_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)70:CPLRTEMP1_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)70:CPLRTEMP1_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)70:CPLRTEMP1_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)70:CPLRTEMP1_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)70:CPLRTEMP1_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)70:CPLRTEMP1_CNTFO PP")
}

record(fanout, "$(CM,undefined)70:CPLRTEMP1_CNTFO") {
  field(DESC, "CPLRTEMP1 fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)70:CPLRTEMP1_CNT")
  field(LNK2, "$(CM,undefined)70:CPLRTEMP1_CNTTC")
  field(LNK3, "$(CM,undefined)70:CPLRTEMP1_CNTUC")
}

record(calc, "$(CM,undefined)70:CPLRTEMP1_CNT") {
  field(DESC, "CPLRTEMP1 total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:CPLRTEMP1_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:CPLRTEMP1_CNTTC") {
  field(DESC, "CPLRTEMP1 today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:CPLRTEMP1_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)70:CPLRTEMP1_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)70:CPLRTEMP1_CNTT") {
  field(DESC, "CPLRTEMP1 today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)70:CPLRTEMP1_CNTY") {
  field(DESC, "CPLRTEMP1 yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:CPLRTEMP1_CNTUC") {
  field(DESC, "CPLRTEMP1 user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:CPLRTEMP1_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)70:CPLRTEMP1_CNTU PP")
}

record(longin, "$(CM,undefined)70:CPLRTEMP1_CNTU") {
  field(DESC, "CPLRTEMP1 user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)70:CPLRTEMP1_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)70:CPLRTEMP1_CNTU PP")
}

record(seq, "$(CM,undefined)70:CPLRTEMP1_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)70:CPLRTEMP1_CNTT")
  field(LNK1, "$(CM,undefined)70:CPLRTEMP1_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)70:CPLRTEMP1_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)70:CPLRTEMP2_CNTPV") {
  field(DESC, "CPLRTEMP2 previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:CPLRTEMP2_CNTP") {
  field(DESC, "CPLRTEMP2 previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:CPLRTEMP2_FLTV") {
  field(DESC, "CPLRTEMP2 value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:CPLRTEMP2_BYPV") {
  field(DESC, "CPLRTEMP2 value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:CPLRTEMP2_CNTET") {
  field(DESC, "CPLRTEMP2 increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)70:CPLRTEMP2_CNTSUB") {
  field(DESC, "CPLRTEMP2 fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)70:CPLRTEMP2_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)70:CPLRTEMP2_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)70:CPLRTEMP2_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)70:CPLRTEMP2_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)70:CPLRTEMP2_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)70:CPLRTEMP2_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)70:CPLRTEMP2_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)70:CPLRTEMP2_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)70:CPLRTEMP2_CNTFO PP")
}

record(fanout, "$(CM,undefined)70:CPLRTEMP2_CNTFO") {
  field(DESC, "CPLRTEMP2 fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)70:CPLRTEMP2_CNT")
  field(LNK2, "$(CM,undefined)70:CPLRTEMP2_CNTTC")
  field(LNK3, "$(CM,undefined)70:CPLRTEMP2_CNTUC")
}

record(calc, "$(CM,undefined)70:CPLRTEMP2_CNT") {
  field(DESC, "CPLRTEMP2 total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:CPLRTEMP2_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:CPLRTEMP2_CNTTC") {
  field(DESC, "CPLRTEMP2 today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:CPLRTEMP2_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)70:CPLRTEMP2_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)70:CPLRTEMP2_CNTT") {
  field(DESC, "CPLRTEMP2 today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)70:CPLRTEMP2_CNTY") {
  field(DESC, "CPLRTEMP2 yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:CPLRTEMP2_CNTUC") {
  field(DESC, "CPLRTEMP2 user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:CPLRTEMP2_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)70:CPLRTEMP2_CNTU PP")
}

record(longin, "$(CM,undefined)70:CPLRTEMP2_CNTU") {
  field(DESC, "CPLRTEMP2 user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)70:CPLRTEMP2_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)70:CPLRTEMP2_CNTU PP")
}

record(seq, "$(CM,undefined)70:CPLRTEMP2_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)70:CPLRTEMP2_CNTT")
  field(LNK1, "$(CM,undefined)70:CPLRTEMP2_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)70:CPLRTEMP2_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)70:QUENCH_CNTPV") {
  field(DESC, "QUENCH previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:QUENCH_CNTP") {
  field(DESC, "QUENCH previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:QUENCH_FLTV") {
  field(DESC, "QUENCH value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:QUENCH_BYPV") {
  field(DESC, "QUENCH value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:QUENCH_CNTET") {
  field(DESC, "QUENCH increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)70:QUENCH_CNTSUB") {
  field(DESC, "QUENCH fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)70:QUENCH_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)70:QUENCH_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)70:QUENCH_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)70:QUENCH_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)70:QUENCH_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)70:QUENCH_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)70:QUENCH_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)70:QUENCH_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)70:QUENCH_CNTFO PP")
}

record(fanout, "$(CM,undefined)70:QUENCH_CNTFO") {
  field(DESC, "QUENCH fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)70:QUENCH_CNT")
  field(LNK2, "$(CM,undefined)70:QUENCH_CNTTC")
  field(LNK3, "$(CM,undefined)70:QUENCH_CNTUC")
}

record(calc, "$(CM,undefined)70:QUENCH_CNT") {
  field(DESC, "QUENCH total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:QUENCH_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:QUENCH_CNTTC") {
  field(DESC, "QUENCH today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:QUENCH_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)70:QUENCH_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)70:QUENCH_CNTT") {
  field(DESC, "QUENCH today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)70:QUENCH_CNTY") {
  field(DESC, "QUENCH yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:QUENCH_CNTUC") {
  field(DESC, "QUENCH user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:QUENCH_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)70:QUENCH_CNTU PP")
}

record(longin, "$(CM,undefined)70:QUENCH_CNTU") {
  field(DESC, "QUENCH user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)70:QUENCH_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)70:QUENCH_CNTU PP")
}

record(seq, "$(CM,undefined)70:QUENCH_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)70:QUENCH_CNTT")
  field(LNK1, "$(CM,undefined)70:QUENCH_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)70:QUENCH_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)70:RESINTLK_CNTPV") {
  field(DESC, "RESINTLK previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:RESINTLK_CNTP") {
  field(DESC, "RESINTLK previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:RESINTLK_FLTV") {
  field(DESC, "RESINTLK value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:RESINTLK_BYPV") {
  field(DESC, "RESINTLK value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:RESINTLK_CNTET") {
  field(DESC, "RESINTLK increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)70:RESINTLK_CNTSUB") {
  field(DESC, "RESINTLK fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)70:RESINTLK_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)70:RESINTLK_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)70:RESINTLK_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)70:RESINTLK_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)70:RESINTLK_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)70:RESINTLK_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)70:RESINTLK_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)70:RESINTLK_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)70:RESINTLK_CNTFO PP")
}

record(fanout, "$(CM,undefined)70:RESINTLK_CNTFO") {
  field(DESC, "RESINTLK fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)70:RESINTLK_CNT")
  field(LNK2, "$(CM,undefined)70:RESINTLK_CNTTC")
  field(LNK3, "$(CM,undefined)70:RESINTLK_CNTUC")
}

record(calc, "$(CM,undefined)70:RESINTLK_CNT") {
  field(DESC, "RESINTLK total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:RESINTLK_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:RESINTLK_CNTTC") {
  field(DESC, "RESINTLK today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:RESINTLK_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)70:RESINTLK_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)70:RESINTLK_CNTT") {
  field(DESC, "RESINTLK today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)70:RESINTLK_CNTY") {
  field(DESC, "RESINTLK yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:RESINTLK_CNTUC") {
  field(DESC, "RESINTLK user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:RESINTLK_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)70:RESINTLK_CNTU PP")
}

record(longin, "$(CM,undefined)70:RESINTLK_CNTU") {
  field(DESC, "RESINTLK user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)70:RESINTLK_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)70:RESINTLK_CNTU PP")
}

record(seq, "$(CM,undefined)70:RESINTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)70:RESINTLK_CNTT")
  field(LNK1, "$(CM,undefined)70:RESINTLK_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)70:RESINTLK_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)70:RESLINK_CNTPV") {
  field(DESC, "RESLINK previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:RESLINK_CNTP") {
  field(DESC, "RESLINK previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:RESLINK_FLTV") {
  field(DESC, "RESLINK value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:RESLINK_BYPV") {
  field(DESC, "RESLINK value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:RESLINK_CNTET") {
  field(DESC, "RESLINK increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)70:RESLINK_CNTSUB") {
  field(DESC, "RESLINK fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)70:RESLINK_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)70:RESLINK_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)70:RESLINK_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)70:RESLINK_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)70:RESLINK_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)70:RESLINK_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)70:RESLINK_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)70:RESLINK_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)70:RESLINK_CNTFO PP")
}

record(fanout, "$(CM,undefined)70:RESLINK_CNTFO") {
  field(DESC, "RESLINK fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)70:RESLINK_CNT")
  field(LNK2, "$(CM,undefined)70:RESLINK_CNTTC")
  field(LNK3, "$(CM,undefined)70:RESLINK_CNTUC")
}

record(calc, "$(CM,undefined)70:RESLINK_CNT") {
  field(DESC, "RESLINK total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:RESLINK_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:RESLINK_CNTTC") {
  field(DESC, "RESLINK today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:RESLINK_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)70:RESLINK_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)70:RESLINK_CNTT") {
  field(DESC, "RESLINK today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)70:RESLINK_CNTY") {
  field(DESC, "RESLINK yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:RESLINK_CNTUC") {
  field(DESC, "RESLINK user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:RESLINK_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)70:RESLINK_CNTU PP")
}

record(longin, "$(CM,undefined)70:RESLINK_CNTU") {
  field(DESC, "RESLINK user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)70:RESLINK_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)70:RESLINK_CNTU PP")
}

record(seq, "$(CM,undefined)70:RESLINK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)70:RESLINK_CNTT")
  field(LNK1, "$(CM,undefined)70:RESLINK_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)70:RESLINK_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)70:PLL_CNTPV") {
  field(DESC, "PLL previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:PLL_CNTP") {
  field(DESC, "PLL previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:PLL_FLTV") {
  field(DESC, "PLL value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:PLL_BYPV") {
  field(DESC, "PLL value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:PLL_CNTET") {
  field(DESC, "PLL increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)70:PLL_CNTSUB") {
  field(DESC, "PLL fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)70:PLL_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)70:PLL_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)70:PLL_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)70:PLL_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)70:PLL_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)70:PLL_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)70:PLL_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)70:PLL_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)70:PLL_CNTFO PP")
}

record(fanout, "$(CM,undefined)70:PLL_CNTFO") {
  field(DESC, "PLL fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)70:PLL_CNT")
  field(LNK2, "$(CM,undefined)70:PLL_CNTTC")
  field(LNK3, "$(CM,undefined)70:PLL_CNTUC")
}

record(calc, "$(CM,undefined)70:PLL_CNT") {
  field(DESC, "PLL total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:PLL_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:PLL_CNTTC") {
  field(DESC, "PLL today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:PLL_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)70:PLL_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)70:PLL_CNTT") {
  field(DESC, "PLL today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)70:PLL_CNTY") {
  field(DESC, "PLL yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:PLL_CNTUC") {
  field(DESC, "PLL user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:PLL_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)70:PLL_CNTU PP")
}

record(longin, "$(CM,undefined)70:PLL_CNTU") {
  field(DESC, "PLL user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)70:PLL_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)70:PLL_CNTU PP")
}

record(seq, "$(CM,undefined)70:PLL_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)70:PLL_CNTT")
  field(LNK1, "$(CM,undefined)70:PLL_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)70:PLL_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)70:IOCWDOG_CNTPV") {
  field(DESC, "IOCWDOG previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:IOCWDOG_CNTP") {
  field(DESC, "IOCWDOG previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:IOCWDOG_FLTV") {
  field(DESC, "IOCWDOG value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:IOCWDOG_BYPV") {
  field(DESC, "IOCWDOG value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:IOCWDOG_CNTET") {
  field(DESC, "IOCWDOG increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)70:IOCWDOG_CNTSUB") {
  field(DESC, "IOCWDOG fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)70:IOCWDOG_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)70:IOCWDOG_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)70:IOCWDOG_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)70:IOCWDOG_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)70:IOCWDOG_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)70:IOCWDOG_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)70:IOCWDOG_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)70:IOCWDOG_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)70:IOCWDOG_CNTFO PP")
}

record(fanout, "$(CM,undefined)70:IOCWDOG_CNTFO") {
  field(DESC, "IOCWDOG fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)70:IOCWDOG_CNT")
  field(LNK2, "$(CM,undefined)70:IOCWDOG_CNTTC")
  field(LNK3, "$(CM,undefined)70:IOCWDOG_CNTUC")
}

record(calc, "$(CM,undefined)70:IOCWDOG_CNT") {
  field(DESC, "IOCWDOG total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:IOCWDOG_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:IOCWDOG_CNTTC") {
  field(DESC, "IOCWDOG today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:IOCWDOG_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)70:IOCWDOG_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)70:IOCWDOG_CNTT") {
  field(DESC, "IOCWDOG today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)70:IOCWDOG_CNTY") {
  field(DESC, "IOCWDOG yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:IOCWDOG_CNTUC") {
  field(DESC, "IOCWDOG user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:IOCWDOG_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)70:IOCWDOG_CNTU PP")
}

record(longin, "$(CM,undefined)70:IOCWDOG_CNTU") {
  field(DESC, "IOCWDOG user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)70:IOCWDOG_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)70:IOCWDOG_CNTU PP")
}

record(seq, "$(CM,undefined)70:IOCWDOG_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)70:IOCWDOG_CNTT")
  field(LNK1, "$(CM,undefined)70:IOCWDOG_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)70:IOCWDOG_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)70:SSA_CNTPV") {
  field(DESC, "SSA previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:SSA_CNTP") {
  field(DESC, "SSA previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:SSA_FLTV") {
  field(DESC, "SSA value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:SSA_BYPV") {
  field(DESC, "SSA value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:SSA_CNTET") {
  field(DESC, "SSA increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)70:SSA_CNTSUB") {
  field(DESC, "SSA fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)70:SSA_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)70:SSA_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)70:SSA_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)70:SSA_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)70:SSA_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)70:SSA_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)70:SSA_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)70:SSA_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)70:SSA_CNTFO PP")
}

record(fanout, "$(CM,undefined)70:SSA_CNTFO") {
  field(DESC, "SSA fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)70:SSA_CNT")
  field(LNK2, "$(CM,undefined)70:SSA_CNTTC")
  field(LNK3, "$(CM,undefined)70:SSA_CNTUC")
}

record(calc, "$(CM,undefined)70:SSA_CNT") {
  field(DESC, "SSA total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:SSA_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:SSA_CNTTC") {
  field(DESC, "SSA today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:SSA_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)70:SSA_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)70:SSA_CNTT") {
  field(DESC, "SSA today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)70:SSA_CNTY") {
  field(DESC, "SSA yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:SSA_CNTUC") {
  field(DESC, "SSA user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:SSA_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)70:SSA_CNTU PP")
}

record(longin, "$(CM,undefined)70:SSA_CNTU") {
  field(DESC, "SSA user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)70:SSA_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)70:SSA_CNTU PP")
}

record(seq, "$(CM,undefined)70:SSA_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)70:SSA_CNTT")
  field(LNK1, "$(CM,undefined)70:SSA_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)70:SSA_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)70:CRYO_CNTPV") {
  field(DESC, "CRYO previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:CRYO_CNTP") {
  field(DESC, "CRYO previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:CRYO_FLTV") {
  field(DESC, "CRYO value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:CRYO_BYPV") {
  field(DESC, "CRYO value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:CRYO_CNTET") {
  field(DESC, "CRYO increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)70:CRYO_CNTSUB") {
  field(DESC, "CRYO fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)70:CRYO_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)70:CRYO_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)70:CRYO_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)70:CRYO_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)70:CRYO_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)70:CRYO_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)70:CRYO_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)70:CRYO_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)70:CRYO_CNTFO PP")
}

record(fanout, "$(CM,undefined)70:CRYO_CNTFO") {
  field(DESC, "CRYO fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)70:CRYO_CNT")
  field(LNK2, "$(CM,undefined)70:CRYO_CNTTC")
  field(LNK3, "$(CM,undefined)70:CRYO_CNTUC")
}

record(calc, "$(CM,undefined)70:CRYO_CNT") {
  field(DESC, "CRYO total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:CRYO_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:CRYO_CNTTC") {
  field(DESC, "CRYO today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:CRYO_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)70:CRYO_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)70:CRYO_CNTT") {
  field(DESC, "CRYO today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)70:CRYO_CNTY") {
  field(DESC, "CRYO yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:CRYO_CNTUC") {
  field(DESC, "CRYO user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:CRYO_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)70:CRYO_CNTU PP")
}

record(longin, "$(CM,undefined)70:CRYO_CNTU") {
  field(DESC, "CRYO user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)70:CRYO_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)70:CRYO_CNTU PP")
}

record(seq, "$(CM,undefined)70:CRYO_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)70:CRYO_CNTT")
  field(LNK1, "$(CM,undefined)70:CRYO_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)70:CRYO_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)70:LO_CNTPV") {
  field(DESC, "LO previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:LO_CNTP") {
  field(DESC, "LO previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:LO_FLTV") {
  field(DESC, "LO value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:LO_BYPV") {
  field(DESC, "LO value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:LO_CNTET") {
  field(DESC, "LO increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)70:LO_CNTSUB") {
  field(DESC, "LO fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)70:LO_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)70:LO_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)70:LO_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)70:LO_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)70:LO_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)70:LO_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)70:LO_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)70:LO_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)70:LO_CNTFO PP")
}

record(fanout, "$(CM,undefined)70:LO_CNTFO") {
  field(DESC, "LO fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)70:LO_CNT")
  field(LNK2, "$(CM,undefined)70:LO_CNTTC")
  field(LNK3, "$(CM,undefined)70:LO_CNTUC")
}

record(calc, "$(CM,undefined)70:LO_CNT") {
  field(DESC, "LO total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:LO_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:LO_CNTTC") {
  field(DESC, "LO today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:LO_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)70:LO_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)70:LO_CNTT") {
  field(DESC, "LO today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)70:LO_CNTY") {
  field(DESC, "LO yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:LO_CNTUC") {
  field(DESC, "LO user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:LO_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)70:LO_CNTU PP")
}

record(longin, "$(CM,undefined)70:LO_CNTU") {
  field(DESC, "LO user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)70:LO_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)70:LO_CNTU PP")
}

record(seq, "$(CM,undefined)70:LO_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)70:LO_CNTT")
  field(LNK1, "$(CM,undefined)70:LO_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)70:LO_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)70:ADMIN_CNTPV") {
  field(DESC, "ADMIN previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:ADMIN_CNTP") {
  field(DESC, "ADMIN previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:ADMIN_FLTV") {
  field(DESC, "ADMIN value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:ADMIN_BYPV") {
  field(DESC, "ADMIN value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)70:ADMIN_CNTET") {
  field(DESC, "ADMIN increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)70:ADMIN_CNTSUB") {
  field(DESC, "ADMIN fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)70:ADMIN_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)70:ADMIN_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)70:ADMIN_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)70:ADMIN_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)70:ADMIN_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)70:ADMIN_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)70:ADMIN_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)70:ADMIN_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)70:ADMIN_CNTFO PP")
}

record(fanout, "$(CM,undefined)70:ADMIN_CNTFO") {
  field(DESC, "ADMIN fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)70:ADMIN_CNT")
  field(LNK2, "$(CM,undefined)70:ADMIN_CNTTC")
  field(LNK3, "$(CM,undefined)70:ADMIN_CNTUC")
}

record(calc, "$(CM,undefined)70:ADMIN_CNT") {
  field(DESC, "ADMIN total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:ADMIN_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:ADMIN_CNTTC") {
  field(DESC, "ADMIN today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:ADMIN_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)70:ADMIN_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)70:ADMIN_CNTT") {
  field(DESC, "ADMIN today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)70:ADMIN_CNTY") {
  field(DESC, "ADMIN yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:ADMIN_CNTUC") {
  field(DESC, "ADMIN user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:ADMIN_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)70:ADMIN_CNTU PP")
}

record(longin, "$(CM,undefined)70:ADMIN_CNTU") {
  field(DESC, "ADMIN user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)70:ADMIN_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)70:ADMIN_CNTU PP")
}

record(seq, "$(CM,undefined)70:ADMIN_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)70:ADMIN_CNTT")
  field(LNK1, "$(CM,undefined)70:ADMIN_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)70:ADMIN_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)70:FB_SUM_CNTPV") {
  field(DESC, "FB_SUM previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:FB_SUM_CNTP") {
  field(DESC, "FB_SUM previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)70:FB_SUM_FLTV") {
  field(DESC, "FB_SUM value indicating fault")
  field(PINI, "YES")
  field(VAL, "2")
}

record(bi, "$(CM,undefined)70:FB_SUM_BYPV") {
  field(DESC, "FB_SUM value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "0")
}

record(bi, "$(CM,undefined)70:FB_SUM_CNTET") {
  field(DESC, "FB_SUM increment counter every time")
  field(PINI, "YES")
  field(VAL, "1")
}

record(aSub, "$(CM,undefined)70:FB_SUM_CNTSUB") {
  field(DESC, "FB_SUM fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)70:FB_SUM")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "$(CM,undefined)70:RFREADYFORBEAM CP")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)70:FB_SUM_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)70:FB_SUM_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)70:FB_SUM_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)70:FB_SUM_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)70:FB_SUM_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)70:FB_SUM_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)70:FB_SUM_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)70:FB_SUM_CNTFO PP")
}

record(fanout, "$(CM,undefined)70:FB_SUM_CNTFO") {
  field(DESC, "FB_SUM fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)70:FB_SUM_CNT")
  field(LNK2, "$(CM,undefined)70:FB_SUM_CNTTC")
  field(LNK3, "$(CM,undefined)70:FB_SUM_CNTUC")
}

record(calc, "$(CM,undefined)70:FB_SUM_CNT") {
  field(DESC, "FB_SUM total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:FB_SUM_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:FB_SUM_CNTTC") {
  field(DESC, "FB_SUM today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:FB_SUM_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)70:FB_SUM_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)70:FB_SUM_CNTT") {
  field(DESC, "FB_SUM today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)70:FB_SUM_CNTY") {
  field(DESC, "FB_SUM yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)70:FB_SUM_CNTUC") {
  field(DESC, "FB_SUM user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)70:FB_SUM_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)70:FB_SUM_CNTU PP")
}

record(longin, "$(CM,undefined)70:FB_SUM_CNTU") {
  field(DESC, "FB_SUM user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)70:FB_SUM_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)70:FB_SUM_CNTU PP")
}

record(seq, "$(CM,undefined)70:FB_SUM_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)70:FB_SUM_CNTT")
  field(LNK1, "$(CM,undefined)70:FB_SUM_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)70:FB_SUM_CNTT PP")
}
record(fanout, "$(CM,undefined)80:INTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(LNK0, "$(CM,undefined)80:SSA_CNTRO")
  field(LNK1, "$(CM,undefined)80:STEPTEMP_CNTRO")
  field(LNK2, "$(CM,undefined)80:CPLRTEMP1_CNTRO")
  field(LNK3, "$(CM,undefined)80:CPLRTEMP2_CNTRO")
  field(LNK4, "$(CM,undefined)80:QUENCH_CNTRO")
  field(LNK5, "$(CM,undefined)80:RESINTLK_CNTRO")
  field(LNK6, "$(CM,undefined)80:RESLINK_CNTRO")
  field(LNK7, "$(CM,undefined)80:PLL_CNTRO")
  field(LNK8, "$(CM,undefined)80:IOCWDOG_CNTRO")
  field(LNK9, "$(CM,undefined)80:CRYO_CNTRO")
  field(LNKA, "$(CM,undefined)80:LO_CNTRO")
  field(LNKB, "$(CM,undefined)80:ADMIN_CNTRO")
  field(LNKC, "$(CM,undefined)80:FB_SUM_CNTRO")
}

record(fanout, "$(CM,undefined)80:INTLK_CNTUCLR_ALL") {
  field(DESC, "Clear all intlk counts for cavity")
  field(PINI, "NO")
  field(SELM, "All")
  field(LNK0, "$(CM,undefined)80:SSA_CNTUCLR")
  field(LNK1, "$(CM,undefined)80:STEPTEMP_CNTUCLR")
  field(LNK2, "$(CM,undefined)80:CPLRTEMP1_CNTUCLR")
  field(LNK3, "$(CM,undefined)80:CPLRTEMP2_CNTUCLR")
  field(LNK4, "$(CM,undefined)80:QUENCH_CNTUCLR")
  field(LNK5, "$(CM,undefined)80:RESINTLK_CNTUCLR")
  field(LNK6, "$(CM,undefined)80:RESLINK_CNTUCLR")
  field(LNK7, "$(CM,undefined)80:PLL_CNTUCLR")
  field(LNK8, "$(CM,undefined)80:IOCWDOG_CNTUCLR")
  field(LNK9, "$(CM,undefined)80:CRYO_CNTUCLR")
  field(LNKA, "$(CM,undefined)80:LO_CNTUCLR")
  field(LNKB, "$(CM,undefined)80:ADMIN_CNTUCLR")
  field(LNKC, "$(CM,undefined)80:FB_SUM_CNTUCLR")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)80:STEPTEMP_CNTPV") {
  field(DESC, "STEPTEMP previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:STEPTEMP_CNTP") {
  field(DESC, "STEPTEMP previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:STEPTEMP_FLTV") {
  field(DESC, "STEPTEMP value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:STEPTEMP_BYPV") {
  field(DESC, "STEPTEMP value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:STEPTEMP_CNTET") {
  field(DESC, "STEPTEMP increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)80:STEPTEMP_CNTSUB") {
  field(DESC, "STEPTEMP fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)80:STEPTEMP_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)80:STEPTEMP_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)80:STEPTEMP_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)80:STEPTEMP_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)80:STEPTEMP_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)80:STEPTEMP_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)80:STEPTEMP_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)80:STEPTEMP_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)80:STEPTEMP_CNTFO PP")
}

record(fanout, "$(CM,undefined)80:STEPTEMP_CNTFO") {
  field(DESC, "STEPTEMP fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)80:STEPTEMP_CNT")
  field(LNK2, "$(CM,undefined)80:STEPTEMP_CNTTC")
  field(LNK3, "$(CM,undefined)80:STEPTEMP_CNTUC")
}

record(calc, "$(CM,undefined)80:STEPTEMP_CNT") {
  field(DESC, "STEPTEMP total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:STEPTEMP_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:STEPTEMP_CNTTC") {
  field(DESC, "STEPTEMP today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:STEPTEMP_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)80:STEPTEMP_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)80:STEPTEMP_CNTT") {
  field(DESC, "STEPTEMP today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)80:STEPTEMP_CNTY") {
  field(DESC, "STEPTEMP yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:STEPTEMP_CNTUC") {
  field(DESC, "STEPTEMP user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:STEPTEMP_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)80:STEPTEMP_CNTU PP")
}

record(longin, "$(CM,undefined)80:STEPTEMP_CNTU") {
  field(DESC, "STEPTEMP user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)80:STEPTEMP_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)80:STEPTEMP_CNTU PP")
}

record(seq, "$(CM,undefined)80:STEPTEMP_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)80:STEPTEMP_CNTT")
  field(LNK1, "$(CM,undefined)80:STEPTEMP_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)80:STEPTEMP_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)80:CPLRTEMP1_CNTPV") {
  field(DESC, "CPLRTEMP1 previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:CPLRTEMP1_CNTP") {
  field(DESC, "CPLRTEMP1 previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:CPLRTEMP1_FLTV") {
  field(DESC, "CPLRTEMP1 value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:CPLRTEMP1_BYPV") {
  field(DESC, "CPLRTEMP1 value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:CPLRTEMP1_CNTET") {
  field(DESC, "CPLRTEMP1 increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)80:CPLRTEMP1_CNTSUB") {
  field(DESC, "CPLRTEMP1 fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)80:CPLRTEMP1_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)80:CPLRTEMP1_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)80:CPLRTEMP1_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)80:CPLRTEMP1_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)80:CPLRTEMP1_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)80:CPLRTEMP1_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)80:CPLRTEMP1_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)80:CPLRTEMP1_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)80:CPLRTEMP1_CNTFO PP")
}

record(fanout, "$(CM,undefined)80:CPLRTEMP1_CNTFO") {
  field(DESC, "CPLRTEMP1 fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)80:CPLRTEMP1_CNT")
  field(LNK2, "$(CM,undefined)80:CPLRTEMP1_CNTTC")
  field(LNK3, "$(CM,undefined)80:CPLRTEMP1_CNTUC")
}

record(calc, "$(CM,undefined)80:CPLRTEMP1_CNT") {
  field(DESC, "CPLRTEMP1 total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:CPLRTEMP1_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:CPLRTEMP1_CNTTC") {
  field(DESC, "CPLRTEMP1 today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:CPLRTEMP1_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)80:CPLRTEMP1_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)80:CPLRTEMP1_CNTT") {
  field(DESC, "CPLRTEMP1 today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)80:CPLRTEMP1_CNTY") {
  field(DESC, "CPLRTEMP1 yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:CPLRTEMP1_CNTUC") {
  field(DESC, "CPLRTEMP1 user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:CPLRTEMP1_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)80:CPLRTEMP1_CNTU PP")
}

record(longin, "$(CM,undefined)80:CPLRTEMP1_CNTU") {
  field(DESC, "CPLRTEMP1 user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)80:CPLRTEMP1_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)80:CPLRTEMP1_CNTU PP")
}

record(seq, "$(CM,undefined)80:CPLRTEMP1_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)80:CPLRTEMP1_CNTT")
  field(LNK1, "$(CM,undefined)80:CPLRTEMP1_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)80:CPLRTEMP1_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)80:CPLRTEMP2_CNTPV") {
  field(DESC, "CPLRTEMP2 previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:CPLRTEMP2_CNTP") {
  field(DESC, "CPLRTEMP2 previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:CPLRTEMP2_FLTV") {
  field(DESC, "CPLRTEMP2 value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:CPLRTEMP2_BYPV") {
  field(DESC, "CPLRTEMP2 value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:CPLRTEMP2_CNTET") {
  field(DESC, "CPLRTEMP2 increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)80:CPLRTEMP2_CNTSUB") {
  field(DESC, "CPLRTEMP2 fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)80:CPLRTEMP2_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)80:CPLRTEMP2_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)80:CPLRTEMP2_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)80:CPLRTEMP2_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)80:CPLRTEMP2_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)80:CPLRTEMP2_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)80:CPLRTEMP2_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)80:CPLRTEMP2_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)80:CPLRTEMP2_CNTFO PP")
}

record(fanout, "$(CM,undefined)80:CPLRTEMP2_CNTFO") {
  field(DESC, "CPLRTEMP2 fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)80:CPLRTEMP2_CNT")
  field(LNK2, "$(CM,undefined)80:CPLRTEMP2_CNTTC")
  field(LNK3, "$(CM,undefined)80:CPLRTEMP2_CNTUC")
}

record(calc, "$(CM,undefined)80:CPLRTEMP2_CNT") {
  field(DESC, "CPLRTEMP2 total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:CPLRTEMP2_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:CPLRTEMP2_CNTTC") {
  field(DESC, "CPLRTEMP2 today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:CPLRTEMP2_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)80:CPLRTEMP2_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)80:CPLRTEMP2_CNTT") {
  field(DESC, "CPLRTEMP2 today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)80:CPLRTEMP2_CNTY") {
  field(DESC, "CPLRTEMP2 yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:CPLRTEMP2_CNTUC") {
  field(DESC, "CPLRTEMP2 user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:CPLRTEMP2_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)80:CPLRTEMP2_CNTU PP")
}

record(longin, "$(CM,undefined)80:CPLRTEMP2_CNTU") {
  field(DESC, "CPLRTEMP2 user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)80:CPLRTEMP2_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)80:CPLRTEMP2_CNTU PP")
}

record(seq, "$(CM,undefined)80:CPLRTEMP2_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)80:CPLRTEMP2_CNTT")
  field(LNK1, "$(CM,undefined)80:CPLRTEMP2_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)80:CPLRTEMP2_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)80:QUENCH_CNTPV") {
  field(DESC, "QUENCH previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:QUENCH_CNTP") {
  field(DESC, "QUENCH previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:QUENCH_FLTV") {
  field(DESC, "QUENCH value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:QUENCH_BYPV") {
  field(DESC, "QUENCH value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:QUENCH_CNTET") {
  field(DESC, "QUENCH increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)80:QUENCH_CNTSUB") {
  field(DESC, "QUENCH fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)80:QUENCH_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)80:QUENCH_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)80:QUENCH_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)80:QUENCH_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)80:QUENCH_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)80:QUENCH_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)80:QUENCH_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)80:QUENCH_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)80:QUENCH_CNTFO PP")
}

record(fanout, "$(CM,undefined)80:QUENCH_CNTFO") {
  field(DESC, "QUENCH fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)80:QUENCH_CNT")
  field(LNK2, "$(CM,undefined)80:QUENCH_CNTTC")
  field(LNK3, "$(CM,undefined)80:QUENCH_CNTUC")
}

record(calc, "$(CM,undefined)80:QUENCH_CNT") {
  field(DESC, "QUENCH total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:QUENCH_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:QUENCH_CNTTC") {
  field(DESC, "QUENCH today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:QUENCH_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)80:QUENCH_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)80:QUENCH_CNTT") {
  field(DESC, "QUENCH today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)80:QUENCH_CNTY") {
  field(DESC, "QUENCH yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:QUENCH_CNTUC") {
  field(DESC, "QUENCH user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:QUENCH_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)80:QUENCH_CNTU PP")
}

record(longin, "$(CM,undefined)80:QUENCH_CNTU") {
  field(DESC, "QUENCH user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)80:QUENCH_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)80:QUENCH_CNTU PP")
}

record(seq, "$(CM,undefined)80:QUENCH_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)80:QUENCH_CNTT")
  field(LNK1, "$(CM,undefined)80:QUENCH_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)80:QUENCH_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)80:RESINTLK_CNTPV") {
  field(DESC, "RESINTLK previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:RESINTLK_CNTP") {
  field(DESC, "RESINTLK previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:RESINTLK_FLTV") {
  field(DESC, "RESINTLK value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:RESINTLK_BYPV") {
  field(DESC, "RESINTLK value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:RESINTLK_CNTET") {
  field(DESC, "RESINTLK increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)80:RESINTLK_CNTSUB") {
  field(DESC, "RESINTLK fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)80:RESINTLK_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)80:RESINTLK_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)80:RESINTLK_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)80:RESINTLK_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)80:RESINTLK_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)80:RESINTLK_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)80:RESINTLK_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)80:RESINTLK_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)80:RESINTLK_CNTFO PP")
}

record(fanout, "$(CM,undefined)80:RESINTLK_CNTFO") {
  field(DESC, "RESINTLK fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)80:RESINTLK_CNT")
  field(LNK2, "$(CM,undefined)80:RESINTLK_CNTTC")
  field(LNK3, "$(CM,undefined)80:RESINTLK_CNTUC")
}

record(calc, "$(CM,undefined)80:RESINTLK_CNT") {
  field(DESC, "RESINTLK total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:RESINTLK_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:RESINTLK_CNTTC") {
  field(DESC, "RESINTLK today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:RESINTLK_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)80:RESINTLK_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)80:RESINTLK_CNTT") {
  field(DESC, "RESINTLK today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)80:RESINTLK_CNTY") {
  field(DESC, "RESINTLK yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:RESINTLK_CNTUC") {
  field(DESC, "RESINTLK user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:RESINTLK_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)80:RESINTLK_CNTU PP")
}

record(longin, "$(CM,undefined)80:RESINTLK_CNTU") {
  field(DESC, "RESINTLK user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)80:RESINTLK_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)80:RESINTLK_CNTU PP")
}

record(seq, "$(CM,undefined)80:RESINTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)80:RESINTLK_CNTT")
  field(LNK1, "$(CM,undefined)80:RESINTLK_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)80:RESINTLK_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)80:RESLINK_CNTPV") {
  field(DESC, "RESLINK previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:RESLINK_CNTP") {
  field(DESC, "RESLINK previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:RESLINK_FLTV") {
  field(DESC, "RESLINK value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:RESLINK_BYPV") {
  field(DESC, "RESLINK value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:RESLINK_CNTET") {
  field(DESC, "RESLINK increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)80:RESLINK_CNTSUB") {
  field(DESC, "RESLINK fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)80:RESLINK_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)80:RESLINK_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)80:RESLINK_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)80:RESLINK_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)80:RESLINK_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)80:RESLINK_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)80:RESLINK_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)80:RESLINK_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)80:RESLINK_CNTFO PP")
}

record(fanout, "$(CM,undefined)80:RESLINK_CNTFO") {
  field(DESC, "RESLINK fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)80:RESLINK_CNT")
  field(LNK2, "$(CM,undefined)80:RESLINK_CNTTC")
  field(LNK3, "$(CM,undefined)80:RESLINK_CNTUC")
}

record(calc, "$(CM,undefined)80:RESLINK_CNT") {
  field(DESC, "RESLINK total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:RESLINK_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:RESLINK_CNTTC") {
  field(DESC, "RESLINK today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:RESLINK_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)80:RESLINK_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)80:RESLINK_CNTT") {
  field(DESC, "RESLINK today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)80:RESLINK_CNTY") {
  field(DESC, "RESLINK yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:RESLINK_CNTUC") {
  field(DESC, "RESLINK user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:RESLINK_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)80:RESLINK_CNTU PP")
}

record(longin, "$(CM,undefined)80:RESLINK_CNTU") {
  field(DESC, "RESLINK user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)80:RESLINK_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)80:RESLINK_CNTU PP")
}

record(seq, "$(CM,undefined)80:RESLINK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)80:RESLINK_CNTT")
  field(LNK1, "$(CM,undefined)80:RESLINK_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)80:RESLINK_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)80:PLL_CNTPV") {
  field(DESC, "PLL previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:PLL_CNTP") {
  field(DESC, "PLL previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:PLL_FLTV") {
  field(DESC, "PLL value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:PLL_BYPV") {
  field(DESC, "PLL value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:PLL_CNTET") {
  field(DESC, "PLL increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)80:PLL_CNTSUB") {
  field(DESC, "PLL fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)80:PLL_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)80:PLL_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)80:PLL_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)80:PLL_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)80:PLL_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)80:PLL_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)80:PLL_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)80:PLL_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)80:PLL_CNTFO PP")
}

record(fanout, "$(CM,undefined)80:PLL_CNTFO") {
  field(DESC, "PLL fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)80:PLL_CNT")
  field(LNK2, "$(CM,undefined)80:PLL_CNTTC")
  field(LNK3, "$(CM,undefined)80:PLL_CNTUC")
}

record(calc, "$(CM,undefined)80:PLL_CNT") {
  field(DESC, "PLL total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:PLL_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:PLL_CNTTC") {
  field(DESC, "PLL today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:PLL_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)80:PLL_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)80:PLL_CNTT") {
  field(DESC, "PLL today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)80:PLL_CNTY") {
  field(DESC, "PLL yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:PLL_CNTUC") {
  field(DESC, "PLL user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:PLL_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)80:PLL_CNTU PP")
}

record(longin, "$(CM,undefined)80:PLL_CNTU") {
  field(DESC, "PLL user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)80:PLL_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)80:PLL_CNTU PP")
}

record(seq, "$(CM,undefined)80:PLL_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)80:PLL_CNTT")
  field(LNK1, "$(CM,undefined)80:PLL_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)80:PLL_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)80:IOCWDOG_CNTPV") {
  field(DESC, "IOCWDOG previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:IOCWDOG_CNTP") {
  field(DESC, "IOCWDOG previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:IOCWDOG_FLTV") {
  field(DESC, "IOCWDOG value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:IOCWDOG_BYPV") {
  field(DESC, "IOCWDOG value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:IOCWDOG_CNTET") {
  field(DESC, "IOCWDOG increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)80:IOCWDOG_CNTSUB") {
  field(DESC, "IOCWDOG fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)80:IOCWDOG_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)80:IOCWDOG_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)80:IOCWDOG_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)80:IOCWDOG_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)80:IOCWDOG_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)80:IOCWDOG_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)80:IOCWDOG_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)80:IOCWDOG_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)80:IOCWDOG_CNTFO PP")
}

record(fanout, "$(CM,undefined)80:IOCWDOG_CNTFO") {
  field(DESC, "IOCWDOG fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)80:IOCWDOG_CNT")
  field(LNK2, "$(CM,undefined)80:IOCWDOG_CNTTC")
  field(LNK3, "$(CM,undefined)80:IOCWDOG_CNTUC")
}

record(calc, "$(CM,undefined)80:IOCWDOG_CNT") {
  field(DESC, "IOCWDOG total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:IOCWDOG_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:IOCWDOG_CNTTC") {
  field(DESC, "IOCWDOG today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:IOCWDOG_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)80:IOCWDOG_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)80:IOCWDOG_CNTT") {
  field(DESC, "IOCWDOG today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)80:IOCWDOG_CNTY") {
  field(DESC, "IOCWDOG yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:IOCWDOG_CNTUC") {
  field(DESC, "IOCWDOG user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:IOCWDOG_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)80:IOCWDOG_CNTU PP")
}

record(longin, "$(CM,undefined)80:IOCWDOG_CNTU") {
  field(DESC, "IOCWDOG user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)80:IOCWDOG_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)80:IOCWDOG_CNTU PP")
}

record(seq, "$(CM,undefined)80:IOCWDOG_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)80:IOCWDOG_CNTT")
  field(LNK1, "$(CM,undefined)80:IOCWDOG_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)80:IOCWDOG_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)80:SSA_CNTPV") {
  field(DESC, "SSA previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:SSA_CNTP") {
  field(DESC, "SSA previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:SSA_FLTV") {
  field(DESC, "SSA value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:SSA_BYPV") {
  field(DESC, "SSA value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:SSA_CNTET") {
  field(DESC, "SSA increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)80:SSA_CNTSUB") {
  field(DESC, "SSA fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)80:SSA_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)80:SSA_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)80:SSA_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)80:SSA_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)80:SSA_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)80:SSA_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)80:SSA_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)80:SSA_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)80:SSA_CNTFO PP")
}

record(fanout, "$(CM,undefined)80:SSA_CNTFO") {
  field(DESC, "SSA fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)80:SSA_CNT")
  field(LNK2, "$(CM,undefined)80:SSA_CNTTC")
  field(LNK3, "$(CM,undefined)80:SSA_CNTUC")
}

record(calc, "$(CM,undefined)80:SSA_CNT") {
  field(DESC, "SSA total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:SSA_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:SSA_CNTTC") {
  field(DESC, "SSA today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:SSA_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)80:SSA_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)80:SSA_CNTT") {
  field(DESC, "SSA today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)80:SSA_CNTY") {
  field(DESC, "SSA yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:SSA_CNTUC") {
  field(DESC, "SSA user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:SSA_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)80:SSA_CNTU PP")
}

record(longin, "$(CM,undefined)80:SSA_CNTU") {
  field(DESC, "SSA user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)80:SSA_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)80:SSA_CNTU PP")
}

record(seq, "$(CM,undefined)80:SSA_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)80:SSA_CNTT")
  field(LNK1, "$(CM,undefined)80:SSA_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)80:SSA_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)80:CRYO_CNTPV") {
  field(DESC, "CRYO previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:CRYO_CNTP") {
  field(DESC, "CRYO previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:CRYO_FLTV") {
  field(DESC, "CRYO value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:CRYO_BYPV") {
  field(DESC, "CRYO value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:CRYO_CNTET") {
  field(DESC, "CRYO increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)80:CRYO_CNTSUB") {
  field(DESC, "CRYO fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)80:CRYO_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)80:CRYO_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)80:CRYO_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)80:CRYO_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)80:CRYO_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)80:CRYO_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)80:CRYO_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)80:CRYO_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)80:CRYO_CNTFO PP")
}

record(fanout, "$(CM,undefined)80:CRYO_CNTFO") {
  field(DESC, "CRYO fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)80:CRYO_CNT")
  field(LNK2, "$(CM,undefined)80:CRYO_CNTTC")
  field(LNK3, "$(CM,undefined)80:CRYO_CNTUC")
}

record(calc, "$(CM,undefined)80:CRYO_CNT") {
  field(DESC, "CRYO total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:CRYO_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:CRYO_CNTTC") {
  field(DESC, "CRYO today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:CRYO_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)80:CRYO_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)80:CRYO_CNTT") {
  field(DESC, "CRYO today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)80:CRYO_CNTY") {
  field(DESC, "CRYO yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:CRYO_CNTUC") {
  field(DESC, "CRYO user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:CRYO_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)80:CRYO_CNTU PP")
}

record(longin, "$(CM,undefined)80:CRYO_CNTU") {
  field(DESC, "CRYO user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)80:CRYO_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)80:CRYO_CNTU PP")
}

record(seq, "$(CM,undefined)80:CRYO_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)80:CRYO_CNTT")
  field(LNK1, "$(CM,undefined)80:CRYO_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)80:CRYO_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)80:LO_CNTPV") {
  field(DESC, "LO previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:LO_CNTP") {
  field(DESC, "LO previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:LO_FLTV") {
  field(DESC, "LO value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:LO_BYPV") {
  field(DESC, "LO value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:LO_CNTET") {
  field(DESC, "LO increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)80:LO_CNTSUB") {
  field(DESC, "LO fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)80:LO_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)80:LO_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)80:LO_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)80:LO_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)80:LO_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)80:LO_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)80:LO_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)80:LO_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)80:LO_CNTFO PP")
}

record(fanout, "$(CM,undefined)80:LO_CNTFO") {
  field(DESC, "LO fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)80:LO_CNT")
  field(LNK2, "$(CM,undefined)80:LO_CNTTC")
  field(LNK3, "$(CM,undefined)80:LO_CNTUC")
}

record(calc, "$(CM,undefined)80:LO_CNT") {
  field(DESC, "LO total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:LO_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:LO_CNTTC") {
  field(DESC, "LO today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:LO_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)80:LO_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)80:LO_CNTT") {
  field(DESC, "LO today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)80:LO_CNTY") {
  field(DESC, "LO yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:LO_CNTUC") {
  field(DESC, "LO user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:LO_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)80:LO_CNTU PP")
}

record(longin, "$(CM,undefined)80:LO_CNTU") {
  field(DESC, "LO user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)80:LO_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)80:LO_CNTU PP")
}

record(seq, "$(CM,undefined)80:LO_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)80:LO_CNTT")
  field(LNK1, "$(CM,undefined)80:LO_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)80:LO_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)80:ADMIN_CNTPV") {
  field(DESC, "ADMIN previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:ADMIN_CNTP") {
  field(DESC, "ADMIN previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:ADMIN_FLTV") {
  field(DESC, "ADMIN value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:ADMIN_BYPV") {
  field(DESC, "ADMIN value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)80:ADMIN_CNTET") {
  field(DESC, "ADMIN increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)80:ADMIN_CNTSUB") {
  field(DESC, "ADMIN fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)80:ADMIN_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)80:ADMIN_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)80:ADMIN_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)80:ADMIN_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)80:ADMIN_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)80:ADMIN_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)80:ADMIN_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)80:ADMIN_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)80:ADMIN_CNTFO PP")
}

record(fanout, "$(CM,undefined)80:ADMIN_CNTFO") {
  field(DESC, "ADMIN fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)80:ADMIN_CNT")
  field(LNK2, "$(CM,undefined)80:ADMIN_CNTTC")
  field(LNK3, "$(CM,undefined)80:ADMIN_CNTUC")
}

record(calc, "$(CM,undefined)80:ADMIN_CNT") {
  field(DESC, "ADMIN total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:ADMIN_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:ADMIN_CNTTC") {
  field(DESC, "ADMIN today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:ADMIN_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)80:ADMIN_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)80:ADMIN_CNTT") {
  field(DESC, "ADMIN today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)80:ADMIN_CNTY") {
  field(DESC, "ADMIN yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:ADMIN_CNTUC") {
  field(DESC, "ADMIN user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:ADMIN_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)80:ADMIN_CNTU PP")
}

record(longin, "$(CM,undefined)80:ADMIN_CNTU") {
  field(DESC, "ADMIN user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)80:ADMIN_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)80:ADMIN_CNTU PP")
}

record(seq, "$(CM,undefined)80:ADMIN_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)80:ADMIN_CNTT")
  field(LNK1, "$(CM,undefined)80:ADMIN_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)80:ADMIN_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)80:FB_SUM_CNTPV") {
  field(DESC, "FB_SUM previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:FB_SUM_CNTP") {
  field(DESC, "FB_SUM previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)80:FB_SUM_FLTV") {
  field(DESC, "FB_SUM value indicating fault")
  field(PINI, "YES")
  field(VAL, "2")
}

record(bi, "$(CM,undefined)80:FB_SUM_BYPV") {
  field(DESC, "FB_SUM value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "0")
}

record(bi, "$(CM,undefined)80:FB_SUM_CNTET") {
  field(DESC, "FB_SUM increment counter every time")
  field(PINI, "YES")
  field(VAL, "1")
}

record(aSub, "$(CM,undefined)80:FB_SUM_CNTSUB") {
  field(DESC, "FB_SUM fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)80:FB_SUM")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "$(CM,undefined)80:RFREADYFORBEAM CP")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)80:FB_SUM_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)80:FB_SUM_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)80:FB_SUM_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)80:FB_SUM_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)80:FB_SUM_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)80:FB_SUM_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)80:FB_SUM_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)80:FB_SUM_CNTFO PP")
}

record(fanout, "$(CM,undefined)80:FB_SUM_CNTFO") {
  field(DESC, "FB_SUM fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)80:FB_SUM_CNT")
  field(LNK2, "$(CM,undefined)80:FB_SUM_CNTTC")
  field(LNK3, "$(CM,undefined)80:FB_SUM_CNTUC")
}

record(calc, "$(CM,undefined)80:FB_SUM_CNT") {
  field(DESC, "FB_SUM total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:FB_SUM_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:FB_SUM_CNTTC") {
  field(DESC, "FB_SUM today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:FB_SUM_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)80:FB_SUM_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)80:FB_SUM_CNTT") {
  field(DESC, "FB_SUM today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)80:FB_SUM_CNTY") {
  field(DESC, "FB_SUM yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)80:FB_SUM_CNTUC") {
  field(DESC, "FB_SUM user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)80:FB_SUM_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)80:FB_SUM_CNTU PP")
}

record(longin, "$(CM,undefined)80:FB_SUM_CNTU") {
  field(DESC, "FB_SUM user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)80:FB_SUM_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)80:FB_SUM_CNTU PP")
}

record(seq, "$(CM,undefined)80:FB_SUM_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)80:FB_SUM_CNTT")
  field(LNK1, "$(CM,undefined)80:FB_SUM_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)80:FB_SUM_CNTT PP")
}
record(fanout, "$(CM,recursive)00:RESA:INTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(LNK1, "$(CM,recursive)10:CPLRVACA_CNTRO")
  field(LNK2, "$(CM,recursive)00:BMLNVACA_CNTRO")
}

record(dfanout, "$(CM,recursive)00:RESA:INTLK_CNTUCLR_ALL") {
  field(DESC, "Clear all intlk counts for chassis")
  field(PINI, "NO")
  field(SELM, "All")
  field(DOL, "0")
  field(OMSL, "closed_loop")
  field(OUTA, "$(CM,recursive)10:CPLRVACA_CNTUCLR PP")
  field(OUTB, "$(CM,recursive)00:BMLNVACA_CNTUCLR PP")
}
record(fanout, "$(CM,recursive)00:RESB:INTLK_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(LNK1, "$(CM,recursive)10:CPLRVACB_CNTRO")
  field(LNK2, "$(CM,recursive)00:BMLNVACB_CNTRO")
}

record(dfanout, "$(CM,recursive)00:RESB:INTLK_CNTUCLR_ALL") {
  field(DESC, "Clear all intlk counts for chassis")
  field(PINI, "NO")
  field(SELM, "All")
  field(DOL, "0")
  field(OMSL, "closed_loop")
  field(OUTA, "$(CM,recursive)10:CPLRVACB_CNTUCLR PP")
  field(OUTB, "$(CM,recursive)00:BMLNVACB_CNTUCLR PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)10:CPLRVACA_CNTPV") {
  field(DESC, "CPLRVACA previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:CPLRVACA_CNTP") {
  field(DESC, "CPLRVACA previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:CPLRVACA_FLTV") {
  field(DESC, "CPLRVACA value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:CPLRVACA_BYPV") {
  field(DESC, "CPLRVACA value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:CPLRVACA_CNTET") {
  field(DESC, "CPLRVACA increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)10:CPLRVACA_CNTSUB") {
  field(DESC, "CPLRVACA fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)10:CPLRVACA_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)10:CPLRVACA_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)10:CPLRVACA_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)10:CPLRVACA_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)10:CPLRVACA_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)10:CPLRVACA_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)10:CPLRVACA_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)10:CPLRVACA_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)10:CPLRVACA_CNTFO PP")
}

record(fanout, "$(CM,undefined)10:CPLRVACA_CNTFO") {
  field(DESC, "CPLRVACA fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)10:CPLRVACA_CNT")
  field(LNK2, "$(CM,undefined)10:CPLRVACA_CNTTC")
  field(LNK3, "$(CM,undefined)10:CPLRVACA_CNTUC")
}

record(calc, "$(CM,undefined)10:CPLRVACA_CNT") {
  field(DESC, "CPLRVACA total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:CPLRVACA_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:CPLRVACA_CNTTC") {
  field(DESC, "CPLRVACA today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:CPLRVACA_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)10:CPLRVACA_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)10:CPLRVACA_CNTT") {
  field(DESC, "CPLRVACA today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)10:CPLRVACA_CNTY") {
  field(DESC, "CPLRVACA yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:CPLRVACA_CNTUC") {
  field(DESC, "CPLRVACA user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:CPLRVACA_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)10:CPLRVACA_CNTU PP")
}

record(longin, "$(CM,undefined)10:CPLRVACA_CNTU") {
  field(DESC, "CPLRVACA user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)10:CPLRVACA_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)10:CPLRVACA_CNTU PP")
}

record(seq, "$(CM,undefined)10:CPLRVACA_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)10:CPLRVACA_CNTT")
  field(LNK1, "$(CM,undefined)10:CPLRVACA_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)10:CPLRVACA_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)00:BMLNVACA_CNTPV") {
  field(DESC, "BMLNVACA previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)00:BMLNVACA_CNTP") {
  field(DESC, "BMLNVACA previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)00:BMLNVACA_FLTV") {
  field(DESC, "BMLNVACA value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)00:BMLNVACA_BYPV") {
  field(DESC, "BMLNVACA value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)00:BMLNVACA_CNTET") {
  field(DESC, "BMLNVACA increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)00:BMLNVACA_CNTSUB") {
  field(DESC, "BMLNVACA fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)00:BMLNVACA_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)00:BMLNVACA_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)00:BMLNVACA_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)00:BMLNVACA_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)00:BMLNVACA_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)00:BMLNVACA_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)00:BMLNVACA_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)00:BMLNVACA_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)00:BMLNVACA_CNTFO PP")
}

record(fanout, "$(CM,undefined)00:BMLNVACA_CNTFO") {
  field(DESC, "BMLNVACA fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)00:BMLNVACA_CNT")
  field(LNK2, "$(CM,undefined)00:BMLNVACA_CNTTC")
  field(LNK3, "$(CM,undefined)00:BMLNVACA_CNTUC")
}

record(calc, "$(CM,undefined)00:BMLNVACA_CNT") {
  field(DESC, "BMLNVACA total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)00:BMLNVACA_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)00:BMLNVACA_CNTTC") {
  field(DESC, "BMLNVACA today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)00:BMLNVACA_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)00:BMLNVACA_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)00:BMLNVACA_CNTT") {
  field(DESC, "BMLNVACA today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)00:BMLNVACA_CNTY") {
  field(DESC, "BMLNVACA yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)00:BMLNVACA_CNTUC") {
  field(DESC, "BMLNVACA user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)00:BMLNVACA_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)00:BMLNVACA_CNTU PP")
}

record(longin, "$(CM,undefined)00:BMLNVACA_CNTU") {
  field(DESC, "BMLNVACA user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)00:BMLNVACA_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)00:BMLNVACA_CNTU PP")
}

record(seq, "$(CM,undefined)00:BMLNVACA_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)00:BMLNVACA_CNTT")
  field(LNK1, "$(CM,undefined)00:BMLNVACA_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)00:BMLNVACA_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)10:CPLRVACB_CNTPV") {
  field(DESC, "CPLRVACB previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:CPLRVACB_CNTP") {
  field(DESC, "CPLRVACB previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)10:CPLRVACB_FLTV") {
  field(DESC, "CPLRVACB value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:CPLRVACB_BYPV") {
  field(DESC, "CPLRVACB value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)10:CPLRVACB_CNTET") {
  field(DESC, "CPLRVACB increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)10:CPLRVACB_CNTSUB") {
  field(DESC, "CPLRVACB fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)10:CPLRVACB_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)10:CPLRVACB_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)10:CPLRVACB_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)10:CPLRVACB_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)10:CPLRVACB_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)10:CPLRVACB_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)10:CPLRVACB_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)10:CPLRVACB_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)10:CPLRVACB_CNTFO PP")
}

record(fanout, "$(CM,undefined)10:CPLRVACB_CNTFO") {
  field(DESC, "CPLRVACB fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)10:CPLRVACB_CNT")
  field(LNK2, "$(CM,undefined)10:CPLRVACB_CNTTC")
  field(LNK3, "$(CM,undefined)10:CPLRVACB_CNTUC")
}

record(calc, "$(CM,undefined)10:CPLRVACB_CNT") {
  field(DESC, "CPLRVACB total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:CPLRVACB_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:CPLRVACB_CNTTC") {
  field(DESC, "CPLRVACB today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:CPLRVACB_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)10:CPLRVACB_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)10:CPLRVACB_CNTT") {
  field(DESC, "CPLRVACB today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)10:CPLRVACB_CNTY") {
  field(DESC, "CPLRVACB yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)10:CPLRVACB_CNTUC") {
  field(DESC, "CPLRVACB user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)10:CPLRVACB_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)10:CPLRVACB_CNTU PP")
}

record(longin, "$(CM,undefined)10:CPLRVACB_CNTU") {
  field(DESC, "CPLRVACB user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)10:CPLRVACB_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)10:CPLRVACB_CNTU PP")
}

record(seq, "$(CM,undefined)10:CPLRVACB_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)10:CPLRVACB_CNTT")
  field(LNK1, "$(CM,undefined)10:CPLRVACB_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)10:CPLRVACB_CNTT PP")
}
#==================================
#----------------------------------
# intlk_count.template:
#
# Interlock fault counters
#----------------------------------
#==================================

#==================================
#
#==================================

record(bi, "$(CM,undefined)00:BMLNVACB_CNTPV") {
  field(DESC, "BMLNVACB previous valid state")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)00:BMLNVACB_CNTP") {
  field(DESC, "BMLNVACB previous state stored")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bi, "$(CM,undefined)00:BMLNVACB_FLTV") {
  field(DESC, "BMLNVACB value indicating fault")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)00:BMLNVACB_BYPV") {
  field(DESC, "BMLNVACB value indicating bypassed")
  field(PINI, "YES")
  field(VAL, "1")
}

record(bi, "$(CM,undefined)00:BMLNVACB_CNTET") {
  field(DESC, "BMLNVACB increment counter every time")
  field(PINI, "YES")
  field(VAL, "0")
}

record(aSub, "$(CM,undefined)00:BMLNVACB_CNTSUB") {
  field(DESC, "BMLNVACB fault count increment")
  field(INAM, "")
  field(SNAM, "Determine Fault Increment")
  field(SCAN, "Passive")
# Inputs
  field(FTA, "SHORT") 
# Include CP specificer in FLT macro if desired
  field(INPA, "$(CM,undefined)00:BMLNVACB_LTCH CP")
  field(FTB, "SHORT") 
# Include CP specificer in BYP macro if desired
  field(INPB, "")
  field(FTC, "SHORT") 
  field(INPC, "$(CM,undefined)00:BMLNVACB_CNTPV")
  field(FTD, "SHORT") 
  field(INPD, "$(CM,undefined)00:BMLNVACB_FLTV")
  field(FTE, "SHORT") 
  field(INPE, "$(CM,undefined)00:BMLNVACB_BYPV")
  field(FTF, "SHORT") 
  field(INPF, "$(CM,undefined)00:BMLNVACB_CNTP")
  field(FTG, "SHORT") 
  field(INPG, "$(CM,undefined)00:BMLNVACB_CNTET")
# Outputs
# VALA = New 'previous' stored fault state
  field(FTVA, "SHORT")
  field(OUTA, "$(CM,undefined)00:BMLNVACB_CNTPV PP")
# VALB = Flag indicating states stored at least once
  field(FTVB, "SHORT")
  field(OUTB, "$(CM,undefined)00:BMLNVACB_CNTP PP")
# VALC = Increment fault counters
  field(FTVC, "SHORT")
  field(OUTC, "$(CM,undefined)00:BMLNVACB_CNTFO PP")
}

record(fanout, "$(CM,undefined)00:BMLNVACB_CNTFO") {
  field(DESC, "BMLNVACB fault count")
  field(SELM, "All")
  field(LNK1, "$(CM,undefined)00:BMLNVACB_CNT")
  field(LNK2, "$(CM,undefined)00:BMLNVACB_CNTTC")
  field(LNK3, "$(CM,undefined)00:BMLNVACB_CNTUC")
}

record(calc, "$(CM,undefined)00:BMLNVACB_CNT") {
  field(DESC, "BMLNVACB total fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)00:BMLNVACB_CNT")
  field(PINI, "YES")
  field(PREC, "0")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)00:BMLNVACB_CNTTC") {
  field(DESC, "BMLNVACB today fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)00:BMLNVACB_CNTT")
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,undefined)00:BMLNVACB_CNTT PP")
  field(PREC, "0")
}

record(longin, "$(CM,undefined)00:BMLNVACB_CNTT") {
  field(DESC, "BMLNVACB today fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(longin, "$(CM,undefined)00:BMLNVACB_CNTY") {
  field(DESC, "BMLNVACB yesterday fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(calcout, "$(CM,undefined)00:BMLNVACB_CNTUC") {
  field(DESC, "BMLNVACB user fault count")
  field(CALC, "A+1")
  field(INPA, "$(CM,undefined)00:BMLNVACB_CNTU")
  field(OOPT, "Every Time")
  field(PREC, "0")
  field(OUT,  "$(CM,undefined)00:BMLNVACB_CNTU PP")
}

record(longin, "$(CM,undefined)00:BMLNVACB_CNTU") {
  field(DESC, "BMLNVACB user fault count")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(bo, "$(CM,undefined)00:BMLNVACB_CNTUCLR") {
  field(DESC, "Clear user fault count")
  field(OMSL, "supervisory")
  field(ZNAM, "Clear")
  field(ONAM, "Clear")
  field(OMSL, "closed_loop")
  field(DOL,  "0")
  field(OUT,  "$(CM,undefined)00:BMLNVACB_CNTU PP")
}

record(seq, "$(CM,undefined)00:BMLNVACB_CNTRO") {
  field(DESC, "Roll over interlock count")
  field(SELM, "All")
  field(DOL1, "$(CM,undefined)00:BMLNVACB_CNTT")
  field(LNK1, "$(CM,undefined)00:BMLNVACB_CNTY PP")
  field(DOL2, "0")
  field(LNK2, "$(CM,undefined)00:BMLNVACB_CNTT PP")
}
