# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR01:INFO") {
  field(DESC, "B118-IOCMCOR01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR01:TODDIFF")
}

record(longin, "B118-IOCMCOR01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR01:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR01:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR01:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR01:TODSUM")
}

record(bo, "B118-IOCMCOR01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR01:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR01:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR01:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR01:HEARTBEATE01")
  field(INP, "B118-IOCMCOR01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR01:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR01:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR01:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR01:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR01:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR01:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR01:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR01:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR01:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR01:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR01:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR01:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR01:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR01:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR01:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR01:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR01:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR01:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR01:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR01:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR01:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR01:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR01:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR01:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR01:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR01:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR01:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR01:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR01:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR01:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR01:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR01:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR01:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR01:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR01:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR01:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR01:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR01:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR01:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR01:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR01:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR01:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR01:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR01:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR01:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor01")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor01")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR01:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-38-34")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR02:INFO") {
  field(DESC, "B118-IOCMCOR02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR02:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR02:TODDIFF")
}

record(longin, "B118-IOCMCOR02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR02:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR02:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR02:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR02:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR02:TODSUM")
}

record(bo, "B118-IOCMCOR02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR02:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR02:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR02:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR02:HEARTBEATE01")
  field(INP, "B118-IOCMCOR02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR02:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR02:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR02:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR02:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR02:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR02:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR02:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR02:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR02:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR02:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR02:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR02:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR02:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR02:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR02:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR02:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR02:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR02:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR02:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR02:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR02:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR02:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR02:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR02:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR02:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR02:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR02:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR02:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR02:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR02:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR02:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR02:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR02:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR02:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR02:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR02:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR02:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR02:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR02:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR02:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR02:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR02:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR02:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR02:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR02:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR02:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor02")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor02")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR02:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-38-26")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR03:INFO") {
  field(DESC, "B118-IOCMCOR03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR03:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR03:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR03:TODDIFF")
}

record(longin, "B118-IOCMCOR03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR03:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR03:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR03:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR03:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR03:TODSUM")
}

record(bo, "B118-IOCMCOR03:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR03:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR03:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR03:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR03:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR03:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR03:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR03:HEARTBEATE01")
  field(INP, "B118-IOCMCOR03:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR03:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR03:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR03:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR03:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR03:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR03:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR03:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR03:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR03:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR03:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR03:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR03:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR03:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR03:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR03:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR03:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR03:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR03:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR03:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR03:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR03:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR03:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR03:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR03:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR03:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR03:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR03:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR03:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR03:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR03:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR03:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR03:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR03:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR03:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR03:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR03:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR03:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR03:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR03:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR03:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR03:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR03:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR03:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR03:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR03:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR03:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR03:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR03:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR03:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR03:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor03")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor03")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR03:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-38-18")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR04:INFO") {
  field(DESC, "B118-IOCMCOR04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR04:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR04:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR04:TODDIFF")
}

record(longin, "B118-IOCMCOR04:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR04:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR04:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR04:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR04:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR04:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR04:TODSUM")
}

record(bo, "B118-IOCMCOR04:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR04:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR04:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR04:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR04:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR04:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR04:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR04:HEARTBEATE01")
  field(INP, "B118-IOCMCOR04:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR04:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR04:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR04:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR04:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR04:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR04:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR04:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR04:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR04:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR04:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR04:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR04:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR04:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR04:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR04:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR04:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR04:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR04:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR04:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR04:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR04:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR04:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR04:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR04:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR04:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR04:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR04:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR04:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR04:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR04:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR04:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR04:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR04:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR04:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR04:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR04:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR04:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR04:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR04:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR04:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR04:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR04:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR04:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR04:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR04:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR04:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR04:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR04:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR04:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR04:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR04:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR04:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR04:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR04:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR04:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR04:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR04:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR04:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR04:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR04:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor04")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor04")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR04:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-39-34")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR05:INFO") {
  field(DESC, "B118-IOCMCOR05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR05:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR05:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR05:TODDIFF")
}

record(longin, "B118-IOCMCOR05:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR05:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR05:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR05:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR05:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR05:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR05:TODSUM")
}

record(bo, "B118-IOCMCOR05:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR05:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR05:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR05:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR05:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR05:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR05:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR05:HEARTBEATE01")
  field(INP, "B118-IOCMCOR05:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR05:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR05:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR05:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR05:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR05:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR05:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR05:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR05:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR05:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR05:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR05:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR05:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR05:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR05:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR05:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR05:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR05:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR05:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR05:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR05:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR05:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR05:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR05:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR05:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR05:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR05:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR05:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR05:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR05:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR05:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR05:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR05:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR05:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR05:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR05:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR05:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR05:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR05:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR05:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR05:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR05:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR05:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR05:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR05:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR05:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR05:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR05:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR05:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR05:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR05:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR05:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR05:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR05:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR05:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR05:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR05:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR05:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR05:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR05:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR05:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR05:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor05")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor05")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR05:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-39-26")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR06:INFO") {
  field(DESC, "B118-IOCMCOR06 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR06:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR06:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR06:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR06:TODDIFF")
}

record(longin, "B118-IOCMCOR06:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR06:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR06:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR06:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR06:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR06:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR06:TODSUM")
}

record(bo, "B118-IOCMCOR06:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR06:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR06:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR06:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR06:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR06:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR06:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR06:HEARTBEATE01")
  field(INP, "B118-IOCMCOR06:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR06:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR06:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR06:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR06:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR06:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR06:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR06:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR06:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR06:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR06:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR06:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR06:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR06:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR06:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR06:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR06:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR06:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR06:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR06:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR06:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR06:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR06:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR06:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR06:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR06:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR06:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR06:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR06:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR06:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR06:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR06:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR06:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR06:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR06:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR06:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR06:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR06:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR06:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR06:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR06:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR06:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR06:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR06:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR06:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR06:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR06:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR06:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR06:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR06:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR06:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR06:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR06:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR06:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR06:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR06:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR06:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR06:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR06:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR06:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR06:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR06:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR06:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor06")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR06:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor06")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR06:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-39-18")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR07:INFO") {
  field(DESC, "B118-IOCMCOR07 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR07:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR07:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR07:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR07:TODDIFF")
}

record(longin, "B118-IOCMCOR07:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR07:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR07:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR07:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR07:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR07:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR07:TODSUM")
}

record(bo, "B118-IOCMCOR07:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR07:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR07:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR07:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR07:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR07:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR07:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR07:HEARTBEATE01")
  field(INP, "B118-IOCMCOR07:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR07:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR07:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR07:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR07:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR07:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR07:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR07:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR07:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR07:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR07:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR07:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR07:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR07:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR07:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR07:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR07:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR07:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR07:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR07:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR07:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR07:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR07:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR07:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR07:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR07:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR07:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR07:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR07:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR07:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR07:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR07:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR07:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR07:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR07:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR07:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR07:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR07:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR07:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR07:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR07:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR07:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR07:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR07:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR07:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR07:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR07:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR07:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR07:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR07:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR07:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR07:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR07:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR07:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR07:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR07:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR07:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR07:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR07:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR07:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR07:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR07:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR07:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor07")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR07:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor07")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR07:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-40-34")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR08:INFO") {
  field(DESC, "B118-IOCMCOR08 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR08:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR08:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR08:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR08:TODDIFF")
}

record(longin, "B118-IOCMCOR08:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR08:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR08:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR08:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR08:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR08:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR08:TODSUM")
}

record(bo, "B118-IOCMCOR08:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR08:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR08:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR08:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR08:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR08:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR08:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR08:HEARTBEATE01")
  field(INP, "B118-IOCMCOR08:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR08:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR08:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR08:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR08:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR08:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR08:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR08:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR08:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR08:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR08:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR08:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR08:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR08:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR08:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR08:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR08:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR08:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR08:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR08:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR08:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR08:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR08:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR08:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR08:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR08:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR08:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR08:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR08:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR08:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR08:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR08:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR08:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR08:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR08:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR08:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR08:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR08:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR08:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR08:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR08:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR08:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR08:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR08:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR08:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR08:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR08:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR08:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR08:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR08:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR08:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR08:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR08:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR08:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR08:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR08:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR08:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR08:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR08:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR08:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR08:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR08:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR08:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor08")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR08:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor08")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR08:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-40-26")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR09:INFO") {
  field(DESC, "B118-IOCMCOR09 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR09:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR09:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR09:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR09:TODDIFF")
}

record(longin, "B118-IOCMCOR09:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR09:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR09:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR09:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR09:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR09:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR09:TODSUM")
}

record(bo, "B118-IOCMCOR09:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR09:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR09:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR09:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR09:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR09:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR09:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR09:HEARTBEATE01")
  field(INP, "B118-IOCMCOR09:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR09:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR09:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR09:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR09:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR09:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR09:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR09:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR09:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR09:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR09:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR09:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR09:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR09:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR09:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR09:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR09:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR09:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR09:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR09:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR09:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR09:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR09:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR09:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR09:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR09:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR09:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR09:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR09:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR09:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR09:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR09:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR09:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR09:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR09:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR09:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR09:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR09:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR09:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR09:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR09:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR09:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR09:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR09:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR09:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR09:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR09:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR09:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR09:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR09:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR09:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR09:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR09:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR09:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR09:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR09:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR09:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR09:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR09:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR09:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR09:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR09:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR09:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor09")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR09:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor09")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR09:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-40-18")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR10:INFO") {
  field(DESC, "B118-IOCMCOR10 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR10:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR10:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR10:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR10:TODDIFF")
}

record(longin, "B118-IOCMCOR10:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR10:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR10:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR10:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR10:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR10:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR10:TODSUM")
}

record(bo, "B118-IOCMCOR10:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR10:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR10:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR10:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR10:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR10:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR10:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR10:HEARTBEATE01")
  field(INP, "B118-IOCMCOR10:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR10:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR10:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR10:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR10:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR10:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR10:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR10:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR10:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR10:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR10:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR10:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR10:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR10:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR10:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR10:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR10:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR10:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR10:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR10:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR10:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR10:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR10:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR10:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR10:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR10:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR10:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR10:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR10:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR10:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR10:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR10:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR10:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR10:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR10:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR10:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR10:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR10:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR10:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR10:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR10:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR10:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR10:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR10:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR10:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR10:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR10:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR10:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR10:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR10:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR10:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR10:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR10:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR10:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR10:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR10:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR10:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR10:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR10:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR10:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR10:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR10:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR10:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor10")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR10:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor10")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR10:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-41-34")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR11:INFO") {
  field(DESC, "B118-IOCMCOR11 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR11:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR11:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR11:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR11:TODDIFF")
}

record(longin, "B118-IOCMCOR11:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR11:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR11:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR11:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR11:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR11:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR11:TODSUM")
}

record(bo, "B118-IOCMCOR11:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR11:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR11:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR11:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR11:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR11:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR11:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR11:HEARTBEATE01")
  field(INP, "B118-IOCMCOR11:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR11:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR11:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR11:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR11:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR11:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR11:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR11:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR11:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR11:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR11:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR11:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR11:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR11:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR11:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR11:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR11:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR11:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR11:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR11:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR11:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR11:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR11:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR11:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR11:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR11:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR11:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR11:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR11:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR11:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR11:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR11:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR11:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR11:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR11:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR11:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR11:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR11:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR11:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR11:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR11:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR11:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR11:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR11:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR11:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR11:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR11:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR11:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR11:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR11:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR11:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR11:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR11:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR11:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR11:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR11:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR11:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR11:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR11:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR11:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR11:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR11:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR11:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor11")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR11:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor11")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR11:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-41-26")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR12:INFO") {
  field(DESC, "B118-IOCMCOR12 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR12:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR12:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR12:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR12:TODDIFF")
}

record(longin, "B118-IOCMCOR12:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR12:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR12:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR12:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR12:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR12:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR12:TODSUM")
}

record(bo, "B118-IOCMCOR12:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR12:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR12:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR12:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR12:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR12:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR12:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR12:HEARTBEATE01")
  field(INP, "B118-IOCMCOR12:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR12:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR12:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR12:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR12:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR12:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR12:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR12:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR12:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR12:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR12:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR12:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR12:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR12:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR12:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR12:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR12:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR12:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR12:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR12:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR12:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR12:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR12:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR12:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR12:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR12:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR12:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR12:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR12:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR12:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR12:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR12:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR12:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR12:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR12:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR12:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR12:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR12:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR12:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR12:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR12:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR12:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR12:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR12:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR12:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR12:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR12:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR12:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR12:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR12:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR12:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR12:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR12:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR12:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR12:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR12:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR12:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR12:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR12:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR12:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR12:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR12:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR12:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor12")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR12:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor12")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR12:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-41-18")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR13:INFO") {
  field(DESC, "B118-IOCMCOR13 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR13:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR13:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR13:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR13:TODDIFF")
}

record(longin, "B118-IOCMCOR13:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR13:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR13:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR13:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR13:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR13:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR13:TODSUM")
}

record(bo, "B118-IOCMCOR13:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR13:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR13:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR13:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR13:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR13:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR13:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR13:HEARTBEATE01")
  field(INP, "B118-IOCMCOR13:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR13:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR13:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR13:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR13:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR13:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR13:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR13:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR13:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR13:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR13:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR13:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR13:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR13:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR13:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR13:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR13:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR13:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR13:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR13:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR13:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR13:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR13:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR13:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR13:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR13:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR13:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR13:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR13:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR13:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR13:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR13:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR13:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR13:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR13:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR13:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR13:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR13:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR13:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR13:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR13:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR13:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR13:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR13:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR13:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR13:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR13:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR13:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR13:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR13:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR13:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR13:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR13:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR13:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR13:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR13:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR13:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR13:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR13:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR13:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR13:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR13:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR13:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor13")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR13:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor13")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR13:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-42-34")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR14:INFO") {
  field(DESC, "B118-IOCMCOR14 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR14:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR14:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR14:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR14:TODDIFF")
}

record(longin, "B118-IOCMCOR14:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR14:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR14:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR14:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR14:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR14:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR14:TODSUM")
}

record(bo, "B118-IOCMCOR14:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR14:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR14:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR14:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR14:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR14:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR14:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR14:HEARTBEATE01")
  field(INP, "B118-IOCMCOR14:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR14:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR14:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR14:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR14:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR14:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR14:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR14:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR14:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR14:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR14:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR14:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR14:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR14:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR14:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR14:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR14:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR14:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR14:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR14:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR14:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR14:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR14:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR14:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR14:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR14:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR14:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR14:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR14:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR14:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR14:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR14:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR14:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR14:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR14:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR14:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR14:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR14:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR14:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR14:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR14:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR14:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR14:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR14:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR14:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR14:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR14:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR14:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR14:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR14:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR14:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR14:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR14:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR14:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR14:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR14:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR14:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR14:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR14:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR14:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR14:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR14:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR14:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor14")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR14:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor14")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR14:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-42-26")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR15:INFO") {
  field(DESC, "B118-IOCMCOR15 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR15:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR15:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR15:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR15:TODDIFF")
}

record(longin, "B118-IOCMCOR15:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR15:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR15:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR15:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR15:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR15:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR15:TODSUM")
}

record(bo, "B118-IOCMCOR15:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR15:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR15:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR15:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR15:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR15:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR15:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR15:HEARTBEATE01")
  field(INP, "B118-IOCMCOR15:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR15:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR15:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR15:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR15:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR15:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR15:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR15:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR15:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR15:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR15:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR15:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR15:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR15:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR15:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR15:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR15:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR15:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR15:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR15:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR15:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR15:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR15:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR15:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR15:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR15:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR15:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR15:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR15:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR15:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR15:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR15:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR15:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR15:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR15:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR15:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR15:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR15:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR15:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR15:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR15:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR15:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR15:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR15:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR15:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR15:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR15:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR15:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR15:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR15:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR15:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR15:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR15:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR15:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR15:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR15:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR15:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR15:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR15:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR15:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR15:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR15:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR15:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor15")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR15:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor15")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR15:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-42-18")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR17:INFO") {
  field(DESC, "B118-IOCMCOR17 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR17:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR17:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR17:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR17:TODDIFF")
}

record(longin, "B118-IOCMCOR17:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR17:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR17:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR17:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR17:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR17:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR17:TODSUM")
}

record(bo, "B118-IOCMCOR17:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR17:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR17:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR17:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR17:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR17:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR17:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR17:HEARTBEATE01")
  field(INP, "B118-IOCMCOR17:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR17:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR17:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR17:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR17:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR17:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR17:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR17:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR17:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR17:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR17:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR17:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR17:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR17:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR17:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR17:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR17:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR17:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR17:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR17:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR17:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR17:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR17:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR17:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR17:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR17:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR17:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR17:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR17:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR17:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR17:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR17:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR17:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR17:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR17:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR17:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR17:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR17:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR17:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR17:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR17:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR17:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR17:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR17:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR17:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR17:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR17:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR17:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR17:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR17:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR17:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR17:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR17:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR17:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR17:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR17:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR17:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR17:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR17:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR17:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR17:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR17:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR17:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor17")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR17:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor17")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR17:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-43-26")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR18:INFO") {
  field(DESC, "B118-IOCMCOR18 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR18:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR18:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR18:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR18:TODDIFF")
}

record(longin, "B118-IOCMCOR18:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR18:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR18:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR18:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR18:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR18:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR18:TODSUM")
}

record(bo, "B118-IOCMCOR18:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR18:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR18:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR18:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR18:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR18:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR18:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR18:HEARTBEATE01")
  field(INP, "B118-IOCMCOR18:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR18:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR18:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR18:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR18:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR18:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR18:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR18:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR18:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR18:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR18:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR18:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR18:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR18:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR18:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR18:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR18:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR18:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR18:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR18:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR18:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR18:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR18:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR18:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR18:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR18:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR18:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR18:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR18:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR18:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR18:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR18:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR18:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR18:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR18:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR18:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR18:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR18:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR18:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR18:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR18:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR18:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR18:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR18:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR18:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR18:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR18:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR18:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR18:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR18:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR18:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR18:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR18:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR18:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR18:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR18:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR18:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR18:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR18:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR18:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR18:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR18:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR18:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor18")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR18:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor18")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR18:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-43-18")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR20:INFO") {
  field(DESC, "B118-IOCMCOR20 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR20:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR20:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR20:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR20:TODDIFF")
}

record(longin, "B118-IOCMCOR20:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR20:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR20:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR20:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR20:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR20:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR20:TODSUM")
}

record(bo, "B118-IOCMCOR20:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR20:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR20:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR20:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR20:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR20:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR20:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR20:HEARTBEATE01")
  field(INP, "B118-IOCMCOR20:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR20:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR20:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR20:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR20:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR20:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR20:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR20:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR20:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR20:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR20:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR20:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR20:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR20:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR20:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR20:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR20:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR20:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR20:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR20:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR20:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR20:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR20:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR20:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR20:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR20:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR20:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR20:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR20:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR20:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR20:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR20:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR20:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR20:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR20:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR20:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR20:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR20:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR20:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR20:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR20:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR20:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR20:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR20:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR20:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR20:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR20:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR20:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR20:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR20:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR20:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR20:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR20:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR20:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR20:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR20:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR20:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR20:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR20:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR20:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR20:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR20:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR20:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor21")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR20:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor21")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR20:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-44-26")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCMCOR21:INFO") {
  field(DESC, "B118-IOCMCOR21 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR21:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCMCOR21:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCMCOR21:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCMCOR21:TODDIFF")
}

record(longin, "B118-IOCMCOR21:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCMCOR21:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCMCOR21:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCMCOR21:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCMCOR21:TODCHECK.SEVR")
  field(INPB, "B118-IOCMCOR21:TODCHECK.VALB")
  field(FLNK, "B118-IOCMCOR21:TODSUM")
}

record(bo, "B118-IOCMCOR21:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCMCOR21:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCMCOR21:HEARTBEATCALC") {
  field(FLNK, "B118-IOCMCOR21:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR21:HEARTBEAT CA MS")
  field(INPB, "B118-IOCMCOR21:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCMCOR21:HEARTBEATOK") {
  field(FLNK, "B118-IOCMCOR21:HEARTBEATE01")
  field(INP, "B118-IOCMCOR21:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCMCOR21:HEARTBEATECT") {
  field(FLNK, "B118-IOCMCOR21:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCMCOR21:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCMCOR21:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCMCOR21:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCMCOR21:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCMCOR21:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCMCOR21:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCMCOR21:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCMCOR21:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCMCOR21:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCMCOR21:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCMCOR21:HEARTBEATE09") {
  field(FLNK, "B118-IOCMCOR21:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR21:HEARTBEATE08.B")
  field(INPB, "B118-IOCMCOR21:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCMCOR21:HEARTBEATE08") {
  field(FLNK, "B118-IOCMCOR21:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR21:HEARTBEATE07.B")
  field(INPB, "B118-IOCMCOR21:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCMCOR21:HEARTBEATE07") {
  field(FLNK, "B118-IOCMCOR21:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR21:HEARTBEATE06.B")
  field(INPB, "B118-IOCMCOR21:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCMCOR21:HEARTBEATE06") {
  field(FLNK, "B118-IOCMCOR21:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR21:HEARTBEATE05.B")
  field(INPB, "B118-IOCMCOR21:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCMCOR21:HEARTBEATE05") {
  field(FLNK, "B118-IOCMCOR21:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR21:HEARTBEATE04.B")
  field(INPB, "B118-IOCMCOR21:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCMCOR21:HEARTBEATE04") {
  field(FLNK, "B118-IOCMCOR21:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR21:HEARTBEATE03.B")
  field(INPB, "B118-IOCMCOR21:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCMCOR21:HEARTBEATE03") {
  field(FLNK, "B118-IOCMCOR21:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR21:HEARTBEATE02.B")
  field(INPB, "B118-IOCMCOR21:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCMCOR21:HEARTBEATE02") {
  field(FLNK, "B118-IOCMCOR21:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR21:HEARTBEATE01.B")
  field(INPB, "B118-IOCMCOR21:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCMCOR21:HEARTBEATE01") {
  field(FLNK, "B118-IOCMCOR21:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR21:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCMCOR21:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCMCOR21:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCMCOR21:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCMCOR21:HEARTBEATSUM") {
  field(FLNK, "B118-IOCMCOR21:HEARTBEATCLC")
  field(INP, "B118-IOCMCOR21:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCMCOR21:HEARTBEATE10") {
  field(FLNK, "B118-IOCMCOR21:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCMCOR21:HEARTBEATE09.B")
  field(INPB, "B118-IOCMCOR21:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCMCOR21:HEARTBEATERR") {
  field(FLNK, "B118-IOCMCOR21:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCMCOR21:HEARTBEATCALC.A")
  field(INPB, "B118-IOCMCOR21:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCMCOR21:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor21")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCMCOR21:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor21")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCMCOR21:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-44-18")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCPS:INFO") {
  field(DESC, "B118-IOCPS Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCPS:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCPS:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCPS:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCPS:TODDIFF")
}

record(longin, "B118-IOCPS:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCPS:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCPS:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCPS:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCPS:TODCHECK.SEVR")
  field(INPB, "B118-IOCPS:TODCHECK.VALB")
  field(FLNK, "B118-IOCPS:TODSUM")
}

record(bo, "B118-IOCPS:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCPS:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCPS:HEARTBEATCALC") {
  field(FLNK, "B118-IOCPS:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCPS:HEARTBEAT CA MS")
  field(INPB, "B118-IOCPS:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCPS:HEARTBEATOK") {
  field(FLNK, "B118-IOCPS:HEARTBEATE01")
  field(INP, "B118-IOCPS:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCPS:HEARTBEATECT") {
  field(FLNK, "B118-IOCPS:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCPS:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCPS:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCPS:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCPS:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCPS:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCPS:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCPS:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCPS:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCPS:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCPS:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCPS:HEARTBEATE09") {
  field(FLNK, "B118-IOCPS:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCPS:HEARTBEATE08.B")
  field(INPB, "B118-IOCPS:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCPS:HEARTBEATE08") {
  field(FLNK, "B118-IOCPS:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCPS:HEARTBEATE07.B")
  field(INPB, "B118-IOCPS:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCPS:HEARTBEATE07") {
  field(FLNK, "B118-IOCPS:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCPS:HEARTBEATE06.B")
  field(INPB, "B118-IOCPS:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCPS:HEARTBEATE06") {
  field(FLNK, "B118-IOCPS:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCPS:HEARTBEATE05.B")
  field(INPB, "B118-IOCPS:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCPS:HEARTBEATE05") {
  field(FLNK, "B118-IOCPS:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCPS:HEARTBEATE04.B")
  field(INPB, "B118-IOCPS:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCPS:HEARTBEATE04") {
  field(FLNK, "B118-IOCPS:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCPS:HEARTBEATE03.B")
  field(INPB, "B118-IOCPS:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCPS:HEARTBEATE03") {
  field(FLNK, "B118-IOCPS:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCPS:HEARTBEATE02.B")
  field(INPB, "B118-IOCPS:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCPS:HEARTBEATE02") {
  field(FLNK, "B118-IOCPS:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCPS:HEARTBEATE01.B")
  field(INPB, "B118-IOCPS:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCPS:HEARTBEATE01") {
  field(FLNK, "B118-IOCPS:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCPS:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCPS:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCPS:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCPS:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCPS:HEARTBEATSUM") {
  field(FLNK, "B118-IOCPS:HEARTBEATCLC")
  field(INP, "B118-IOCPS:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCPS:HEARTBEATE10") {
  field(FLNK, "B118-IOCPS:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCPS:HEARTBEATE09.B")
  field(INPB, "B118-IOCPS:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCPS:HEARTBEATERR") {
  field(FLNK, "B118-IOCPS:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCPS:HEARTBEATCALC.A")
  field(INPB, "B118-IOCPS:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCPS:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocps")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCPS:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocps")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCPS:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-29-17")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B118-IOCCAMAC:INFO") {
  field(DESC, "B118-IOCCAMAC Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCCAMAC:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B118-IOCCAMAC:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B118-IOCCAMAC:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B118-IOCCAMAC:TODDIFF")
}

record(longin, "B118-IOCCAMAC:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B118-IOCCAMAC:TODCHECK.VALA MS")
  field(FLNK, "B118-IOCCAMAC:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B118-IOCCAMAC:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B118-IOCCAMAC:TODCHECK.SEVR")
  field(INPB, "B118-IOCCAMAC:TODCHECK.VALB")
  field(FLNK, "B118-IOCCAMAC:TODSUM")
}

record(bo, "B118-IOCCAMAC:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B118-IOCCAMAC:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B118-IOCCAMAC:HEARTBEATCALC") {
  field(FLNK, "B118-IOCCAMAC:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B118-IOCCAMAC:HEARTBEAT CA MS")
  field(INPB, "B118-IOCCAMAC:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B118-IOCCAMAC:HEARTBEATOK") {
  field(FLNK, "B118-IOCCAMAC:HEARTBEATE01")
  field(INP, "B118-IOCCAMAC:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B118-IOCCAMAC:HEARTBEATECT") {
  field(FLNK, "B118-IOCCAMAC:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B118-IOCCAMAC:HEARTBEATE01.VAL")
  field(INPB, "B118-IOCCAMAC:HEARTBEATE02.VAL")
  field(INPC, "B118-IOCCAMAC:HEARTBEATE03.VAL")
  field(INPD, "B118-IOCCAMAC:HEARTBEATE04.VAL")
  field(INPE, "B118-IOCCAMAC:HEARTBEATE05.VAL")
  field(INPF, "B118-IOCCAMAC:HEARTBEATE06.VAL")
  field(INPG, "B118-IOCCAMAC:HEARTBEATE07.VAL")
  field(INPH, "B118-IOCCAMAC:HEARTBEATE08.VAL")
  field(INPI, "B118-IOCCAMAC:HEARTBEATE09.VAL")
  field(INPJ, "B118-IOCCAMAC:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B118-IOCCAMAC:HEARTBEATE09") {
  field(FLNK, "B118-IOCCAMAC:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B118-IOCCAMAC:HEARTBEATE08.B")
  field(INPB, "B118-IOCCAMAC:HEARTBEATE09.VAL")
}

record(calc, "B118-IOCCAMAC:HEARTBEATE08") {
  field(FLNK, "B118-IOCCAMAC:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B118-IOCCAMAC:HEARTBEATE07.B")
  field(INPB, "B118-IOCCAMAC:HEARTBEATE08.VAL")
}

record(calc, "B118-IOCCAMAC:HEARTBEATE07") {
  field(FLNK, "B118-IOCCAMAC:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B118-IOCCAMAC:HEARTBEATE06.B")
  field(INPB, "B118-IOCCAMAC:HEARTBEATE07.VAL")
}

record(calc, "B118-IOCCAMAC:HEARTBEATE06") {
  field(FLNK, "B118-IOCCAMAC:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B118-IOCCAMAC:HEARTBEATE05.B")
  field(INPB, "B118-IOCCAMAC:HEARTBEATE06.VAL")
}

record(calc, "B118-IOCCAMAC:HEARTBEATE05") {
  field(FLNK, "B118-IOCCAMAC:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B118-IOCCAMAC:HEARTBEATE04.B")
  field(INPB, "B118-IOCCAMAC:HEARTBEATE05.VAL")
}

record(calc, "B118-IOCCAMAC:HEARTBEATE04") {
  field(FLNK, "B118-IOCCAMAC:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B118-IOCCAMAC:HEARTBEATE03.B")
  field(INPB, "B118-IOCCAMAC:HEARTBEATE04.VAL")
}

record(calc, "B118-IOCCAMAC:HEARTBEATE03") {
  field(FLNK, "B118-IOCCAMAC:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B118-IOCCAMAC:HEARTBEATE02.B")
  field(INPB, "B118-IOCCAMAC:HEARTBEATE03.VAL")
}

record(calc, "B118-IOCCAMAC:HEARTBEATE02") {
  field(FLNK, "B118-IOCCAMAC:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B118-IOCCAMAC:HEARTBEATE01.B")
  field(INPB, "B118-IOCCAMAC:HEARTBEATE02.VAL")
}

record(calc, "B118-IOCCAMAC:HEARTBEATE01") {
  field(FLNK, "B118-IOCCAMAC:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B118-IOCCAMAC:HEARTBEATERR.VAL")
  field(INPB, "B118-IOCCAMAC:HEARTBEATE01.VAL")
}

record(calc, "B118-IOCCAMAC:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B118-IOCCAMAC:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B118-IOCCAMAC:HEARTBEATSUM") {
  field(FLNK, "B118-IOCCAMAC:HEARTBEATCLC")
  field(INP, "B118-IOCCAMAC:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B118-IOCCAMAC:HEARTBEATE10") {
  field(FLNK, "B118-IOCCAMAC:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B118-IOCCAMAC:HEARTBEATE09.B")
  field(INPB, "B118-IOCCAMAC:HEARTBEATE10.VAL")
}

record(calc, "B118-IOCCAMAC:HEARTBEATERR") {
  field(FLNK, "B118-IOCCAMAC:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B118-IOCCAMAC:HEARTBEATCALC.A")
  field(INPB, "B118-IOCCAMAC:HEARTBEATCALC.B")
}

record(stringin, "B118-IOCCAMAC:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "ioccam118")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B118-IOCCAMAC:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "ioccam118")
  info(autosaveFields,"VAL")
}

record(stringin, "B118-IOCCAMAC:LOC") {
  field(PINI, "YES")
  field(VAL, "B118-29-14")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B120-IOCMOTOR1:INFO") {
  field(DESC, "B120-IOCMOTOR1 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B120-IOCMOTOR1:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B120-IOCMOTOR1:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B120-IOCMOTOR1:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B120-IOCMOTOR1:TODDIFF")
}

record(longin, "B120-IOCMOTOR1:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B120-IOCMOTOR1:TODCHECK.VALA MS")
  field(FLNK, "B120-IOCMOTOR1:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B120-IOCMOTOR1:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B120-IOCMOTOR1:TODCHECK.SEVR")
  field(INPB, "B120-IOCMOTOR1:TODCHECK.VALB")
  field(FLNK, "B120-IOCMOTOR1:TODSUM")
}

record(bo, "B120-IOCMOTOR1:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B120-IOCMOTOR1:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B120-IOCMOTOR1:HEARTBEATCALC") {
  field(FLNK, "B120-IOCMOTOR1:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B120-IOCMOTOR1:HEARTBEAT CA MS")
  field(INPB, "B120-IOCMOTOR1:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B120-IOCMOTOR1:HEARTBEATOK") {
  field(FLNK, "B120-IOCMOTOR1:HEARTBEATE01")
  field(INP, "B120-IOCMOTOR1:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B120-IOCMOTOR1:HEARTBEATECT") {
  field(FLNK, "B120-IOCMOTOR1:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B120-IOCMOTOR1:HEARTBEATE01.VAL")
  field(INPB, "B120-IOCMOTOR1:HEARTBEATE02.VAL")
  field(INPC, "B120-IOCMOTOR1:HEARTBEATE03.VAL")
  field(INPD, "B120-IOCMOTOR1:HEARTBEATE04.VAL")
  field(INPE, "B120-IOCMOTOR1:HEARTBEATE05.VAL")
  field(INPF, "B120-IOCMOTOR1:HEARTBEATE06.VAL")
  field(INPG, "B120-IOCMOTOR1:HEARTBEATE07.VAL")
  field(INPH, "B120-IOCMOTOR1:HEARTBEATE08.VAL")
  field(INPI, "B120-IOCMOTOR1:HEARTBEATE09.VAL")
  field(INPJ, "B120-IOCMOTOR1:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B120-IOCMOTOR1:HEARTBEATE09") {
  field(FLNK, "B120-IOCMOTOR1:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B120-IOCMOTOR1:HEARTBEATE08.B")
  field(INPB, "B120-IOCMOTOR1:HEARTBEATE09.VAL")
}

record(calc, "B120-IOCMOTOR1:HEARTBEATE08") {
  field(FLNK, "B120-IOCMOTOR1:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B120-IOCMOTOR1:HEARTBEATE07.B")
  field(INPB, "B120-IOCMOTOR1:HEARTBEATE08.VAL")
}

record(calc, "B120-IOCMOTOR1:HEARTBEATE07") {
  field(FLNK, "B120-IOCMOTOR1:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B120-IOCMOTOR1:HEARTBEATE06.B")
  field(INPB, "B120-IOCMOTOR1:HEARTBEATE07.VAL")
}

record(calc, "B120-IOCMOTOR1:HEARTBEATE06") {
  field(FLNK, "B120-IOCMOTOR1:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B120-IOCMOTOR1:HEARTBEATE05.B")
  field(INPB, "B120-IOCMOTOR1:HEARTBEATE06.VAL")
}

record(calc, "B120-IOCMOTOR1:HEARTBEATE05") {
  field(FLNK, "B120-IOCMOTOR1:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B120-IOCMOTOR1:HEARTBEATE04.B")
  field(INPB, "B120-IOCMOTOR1:HEARTBEATE05.VAL")
}

record(calc, "B120-IOCMOTOR1:HEARTBEATE04") {
  field(FLNK, "B120-IOCMOTOR1:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B120-IOCMOTOR1:HEARTBEATE03.B")
  field(INPB, "B120-IOCMOTOR1:HEARTBEATE04.VAL")
}

record(calc, "B120-IOCMOTOR1:HEARTBEATE03") {
  field(FLNK, "B120-IOCMOTOR1:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B120-IOCMOTOR1:HEARTBEATE02.B")
  field(INPB, "B120-IOCMOTOR1:HEARTBEATE03.VAL")
}

record(calc, "B120-IOCMOTOR1:HEARTBEATE02") {
  field(FLNK, "B120-IOCMOTOR1:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B120-IOCMOTOR1:HEARTBEATE01.B")
  field(INPB, "B120-IOCMOTOR1:HEARTBEATE02.VAL")
}

record(calc, "B120-IOCMOTOR1:HEARTBEATE01") {
  field(FLNK, "B120-IOCMOTOR1:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B120-IOCMOTOR1:HEARTBEATERR.VAL")
  field(INPB, "B120-IOCMOTOR1:HEARTBEATE01.VAL")
}

record(calc, "B120-IOCMOTOR1:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B120-IOCMOTOR1:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B120-IOCMOTOR1:HEARTBEATSUM") {
  field(FLNK, "B120-IOCMOTOR1:HEARTBEATCLC")
  field(INP, "B120-IOCMOTOR1:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B120-IOCMOTOR1:HEARTBEATE10") {
  field(FLNK, "B120-IOCMOTOR1:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B120-IOCMOTOR1:HEARTBEATE09.B")
  field(INPB, "B120-IOCMOTOR1:HEARTBEATE10.VAL")
}

record(calc, "B120-IOCMOTOR1:HEARTBEATERR") {
  field(FLNK, "B120-IOCMOTOR1:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B120-IOCMOTOR1:HEARTBEATCALC.A")
  field(INPB, "B120-IOCMOTOR1:HEARTBEATCALC.B")
}

record(stringin, "B120-IOCMOTOR1:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "bl7")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B120-IOCMOTOR1:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "bl7")
  info(autosaveFields,"VAL")
}

record(stringin, "B120-IOCMOTOR1:LOC") {
  field(PINI, "YES")
  field(VAL, "B120-1006-29")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B131-IOCMCOR01:INFO") {
  field(DESC, "B131-IOCMCOR01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B131-IOCMCOR01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B131-IOCMCOR01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B131-IOCMCOR01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B131-IOCMCOR01:TODDIFF")
}

record(longin, "B131-IOCMCOR01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B131-IOCMCOR01:TODCHECK.VALA MS")
  field(FLNK, "B131-IOCMCOR01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B131-IOCMCOR01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B131-IOCMCOR01:TODCHECK.SEVR")
  field(INPB, "B131-IOCMCOR01:TODCHECK.VALB")
  field(FLNK, "B131-IOCMCOR01:TODSUM")
}

record(bo, "B131-IOCMCOR01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B131-IOCMCOR01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B131-IOCMCOR01:HEARTBEATCALC") {
  field(FLNK, "B131-IOCMCOR01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B131-IOCMCOR01:HEARTBEAT CA MS")
  field(INPB, "B131-IOCMCOR01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B131-IOCMCOR01:HEARTBEATOK") {
  field(FLNK, "B131-IOCMCOR01:HEARTBEATE01")
  field(INP, "B131-IOCMCOR01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B131-IOCMCOR01:HEARTBEATECT") {
  field(FLNK, "B131-IOCMCOR01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B131-IOCMCOR01:HEARTBEATE01.VAL")
  field(INPB, "B131-IOCMCOR01:HEARTBEATE02.VAL")
  field(INPC, "B131-IOCMCOR01:HEARTBEATE03.VAL")
  field(INPD, "B131-IOCMCOR01:HEARTBEATE04.VAL")
  field(INPE, "B131-IOCMCOR01:HEARTBEATE05.VAL")
  field(INPF, "B131-IOCMCOR01:HEARTBEATE06.VAL")
  field(INPG, "B131-IOCMCOR01:HEARTBEATE07.VAL")
  field(INPH, "B131-IOCMCOR01:HEARTBEATE08.VAL")
  field(INPI, "B131-IOCMCOR01:HEARTBEATE09.VAL")
  field(INPJ, "B131-IOCMCOR01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B131-IOCMCOR01:HEARTBEATE09") {
  field(FLNK, "B131-IOCMCOR01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B131-IOCMCOR01:HEARTBEATE08.B")
  field(INPB, "B131-IOCMCOR01:HEARTBEATE09.VAL")
}

record(calc, "B131-IOCMCOR01:HEARTBEATE08") {
  field(FLNK, "B131-IOCMCOR01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B131-IOCMCOR01:HEARTBEATE07.B")
  field(INPB, "B131-IOCMCOR01:HEARTBEATE08.VAL")
}

record(calc, "B131-IOCMCOR01:HEARTBEATE07") {
  field(FLNK, "B131-IOCMCOR01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B131-IOCMCOR01:HEARTBEATE06.B")
  field(INPB, "B131-IOCMCOR01:HEARTBEATE07.VAL")
}

record(calc, "B131-IOCMCOR01:HEARTBEATE06") {
  field(FLNK, "B131-IOCMCOR01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B131-IOCMCOR01:HEARTBEATE05.B")
  field(INPB, "B131-IOCMCOR01:HEARTBEATE06.VAL")
}

record(calc, "B131-IOCMCOR01:HEARTBEATE05") {
  field(FLNK, "B131-IOCMCOR01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B131-IOCMCOR01:HEARTBEATE04.B")
  field(INPB, "B131-IOCMCOR01:HEARTBEATE05.VAL")
}

record(calc, "B131-IOCMCOR01:HEARTBEATE04") {
  field(FLNK, "B131-IOCMCOR01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B131-IOCMCOR01:HEARTBEATE03.B")
  field(INPB, "B131-IOCMCOR01:HEARTBEATE04.VAL")
}

record(calc, "B131-IOCMCOR01:HEARTBEATE03") {
  field(FLNK, "B131-IOCMCOR01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B131-IOCMCOR01:HEARTBEATE02.B")
  field(INPB, "B131-IOCMCOR01:HEARTBEATE03.VAL")
}

record(calc, "B131-IOCMCOR01:HEARTBEATE02") {
  field(FLNK, "B131-IOCMCOR01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B131-IOCMCOR01:HEARTBEATE01.B")
  field(INPB, "B131-IOCMCOR01:HEARTBEATE02.VAL")
}

record(calc, "B131-IOCMCOR01:HEARTBEATE01") {
  field(FLNK, "B131-IOCMCOR01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B131-IOCMCOR01:HEARTBEATERR.VAL")
  field(INPB, "B131-IOCMCOR01:HEARTBEATE01.VAL")
}

record(calc, "B131-IOCMCOR01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B131-IOCMCOR01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B131-IOCMCOR01:HEARTBEATSUM") {
  field(FLNK, "B131-IOCMCOR01:HEARTBEATCLC")
  field(INP, "B131-IOCMCOR01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B131-IOCMCOR01:HEARTBEATE10") {
  field(FLNK, "B131-IOCMCOR01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B131-IOCMCOR01:HEARTBEATE09.B")
  field(INPB, "B131-IOCMCOR01:HEARTBEATE10.VAL")
}

record(calc, "B131-IOCMCOR01:HEARTBEATERR") {
  field(FLNK, "B131-IOCMCOR01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B131-IOCMCOR01:HEARTBEATCALC.A")
  field(INPB, "B131-IOCMCOR01:HEARTBEATCALC.B")
}

record(stringin, "B131-IOCMCOR01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcor131")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B131-IOCMCOR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcor131")
  info(autosaveFields,"VAL")
}

record(stringin, "B131-IOCMCOR01:LOC") {
  field(PINI, "YES")
  field(VAL, "B131-1100-08")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B131-IOCMOTOR1:INFO") {
  field(DESC, "B131-IOCMOTOR1 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B131-IOCMOTOR1:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B131-IOCMOTOR1:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B131-IOCMOTOR1:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B131-IOCMOTOR1:TODDIFF")
}

record(longin, "B131-IOCMOTOR1:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B131-IOCMOTOR1:TODCHECK.VALA MS")
  field(FLNK, "B131-IOCMOTOR1:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B131-IOCMOTOR1:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B131-IOCMOTOR1:TODCHECK.SEVR")
  field(INPB, "B131-IOCMOTOR1:TODCHECK.VALB")
  field(FLNK, "B131-IOCMOTOR1:TODSUM")
}

record(bo, "B131-IOCMOTOR1:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B131-IOCMOTOR1:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B131-IOCMOTOR1:HEARTBEATCALC") {
  field(FLNK, "B131-IOCMOTOR1:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR1:HEARTBEAT CA MS")
  field(INPB, "B131-IOCMOTOR1:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B131-IOCMOTOR1:HEARTBEATOK") {
  field(FLNK, "B131-IOCMOTOR1:HEARTBEATE01")
  field(INP, "B131-IOCMOTOR1:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B131-IOCMOTOR1:HEARTBEATECT") {
  field(FLNK, "B131-IOCMOTOR1:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B131-IOCMOTOR1:HEARTBEATE01.VAL")
  field(INPB, "B131-IOCMOTOR1:HEARTBEATE02.VAL")
  field(INPC, "B131-IOCMOTOR1:HEARTBEATE03.VAL")
  field(INPD, "B131-IOCMOTOR1:HEARTBEATE04.VAL")
  field(INPE, "B131-IOCMOTOR1:HEARTBEATE05.VAL")
  field(INPF, "B131-IOCMOTOR1:HEARTBEATE06.VAL")
  field(INPG, "B131-IOCMOTOR1:HEARTBEATE07.VAL")
  field(INPH, "B131-IOCMOTOR1:HEARTBEATE08.VAL")
  field(INPI, "B131-IOCMOTOR1:HEARTBEATE09.VAL")
  field(INPJ, "B131-IOCMOTOR1:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B131-IOCMOTOR1:HEARTBEATE09") {
  field(FLNK, "B131-IOCMOTOR1:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR1:HEARTBEATE08.B")
  field(INPB, "B131-IOCMOTOR1:HEARTBEATE09.VAL")
}

record(calc, "B131-IOCMOTOR1:HEARTBEATE08") {
  field(FLNK, "B131-IOCMOTOR1:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR1:HEARTBEATE07.B")
  field(INPB, "B131-IOCMOTOR1:HEARTBEATE08.VAL")
}

record(calc, "B131-IOCMOTOR1:HEARTBEATE07") {
  field(FLNK, "B131-IOCMOTOR1:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR1:HEARTBEATE06.B")
  field(INPB, "B131-IOCMOTOR1:HEARTBEATE07.VAL")
}

record(calc, "B131-IOCMOTOR1:HEARTBEATE06") {
  field(FLNK, "B131-IOCMOTOR1:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR1:HEARTBEATE05.B")
  field(INPB, "B131-IOCMOTOR1:HEARTBEATE06.VAL")
}

record(calc, "B131-IOCMOTOR1:HEARTBEATE05") {
  field(FLNK, "B131-IOCMOTOR1:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR1:HEARTBEATE04.B")
  field(INPB, "B131-IOCMOTOR1:HEARTBEATE05.VAL")
}

record(calc, "B131-IOCMOTOR1:HEARTBEATE04") {
  field(FLNK, "B131-IOCMOTOR1:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR1:HEARTBEATE03.B")
  field(INPB, "B131-IOCMOTOR1:HEARTBEATE04.VAL")
}

record(calc, "B131-IOCMOTOR1:HEARTBEATE03") {
  field(FLNK, "B131-IOCMOTOR1:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR1:HEARTBEATE02.B")
  field(INPB, "B131-IOCMOTOR1:HEARTBEATE03.VAL")
}

record(calc, "B131-IOCMOTOR1:HEARTBEATE02") {
  field(FLNK, "B131-IOCMOTOR1:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR1:HEARTBEATE01.B")
  field(INPB, "B131-IOCMOTOR1:HEARTBEATE02.VAL")
}

record(calc, "B131-IOCMOTOR1:HEARTBEATE01") {
  field(FLNK, "B131-IOCMOTOR1:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR1:HEARTBEATERR.VAL")
  field(INPB, "B131-IOCMOTOR1:HEARTBEATE01.VAL")
}

record(calc, "B131-IOCMOTOR1:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B131-IOCMOTOR1:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B131-IOCMOTOR1:HEARTBEATSUM") {
  field(FLNK, "B131-IOCMOTOR1:HEARTBEATCLC")
  field(INP, "B131-IOCMOTOR1:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B131-IOCMOTOR1:HEARTBEATE10") {
  field(FLNK, "B131-IOCMOTOR1:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR1:HEARTBEATE09.B")
  field(INPB, "B131-IOCMOTOR1:HEARTBEATE10.VAL")
}

record(calc, "B131-IOCMOTOR1:HEARTBEATERR") {
  field(FLNK, "B131-IOCMOTOR1:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B131-IOCMOTOR1:HEARTBEATCALC.A")
  field(INPB, "B131-IOCMOTOR1:HEARTBEATCALC.B")
}

record(stringin, "B131-IOCMOTOR1:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "bl13")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B131-IOCMOTOR1:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "bl13")
  info(autosaveFields,"VAL")
}

record(stringin, "B131-IOCMOTOR1:LOC") {
  field(PINI, "YES")
  field(VAL, "B131-1305-20")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B131-IOCMOTOR2:INFO") {
  field(DESC, "B131-IOCMOTOR2 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B131-IOCMOTOR2:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B131-IOCMOTOR2:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B131-IOCMOTOR2:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B131-IOCMOTOR2:TODDIFF")
}

record(longin, "B131-IOCMOTOR2:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B131-IOCMOTOR2:TODCHECK.VALA MS")
  field(FLNK, "B131-IOCMOTOR2:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B131-IOCMOTOR2:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B131-IOCMOTOR2:TODCHECK.SEVR")
  field(INPB, "B131-IOCMOTOR2:TODCHECK.VALB")
  field(FLNK, "B131-IOCMOTOR2:TODSUM")
}

record(bo, "B131-IOCMOTOR2:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B131-IOCMOTOR2:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B131-IOCMOTOR2:HEARTBEATCALC") {
  field(FLNK, "B131-IOCMOTOR2:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR2:HEARTBEAT CA MS")
  field(INPB, "B131-IOCMOTOR2:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B131-IOCMOTOR2:HEARTBEATOK") {
  field(FLNK, "B131-IOCMOTOR2:HEARTBEATE01")
  field(INP, "B131-IOCMOTOR2:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B131-IOCMOTOR2:HEARTBEATECT") {
  field(FLNK, "B131-IOCMOTOR2:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B131-IOCMOTOR2:HEARTBEATE01.VAL")
  field(INPB, "B131-IOCMOTOR2:HEARTBEATE02.VAL")
  field(INPC, "B131-IOCMOTOR2:HEARTBEATE03.VAL")
  field(INPD, "B131-IOCMOTOR2:HEARTBEATE04.VAL")
  field(INPE, "B131-IOCMOTOR2:HEARTBEATE05.VAL")
  field(INPF, "B131-IOCMOTOR2:HEARTBEATE06.VAL")
  field(INPG, "B131-IOCMOTOR2:HEARTBEATE07.VAL")
  field(INPH, "B131-IOCMOTOR2:HEARTBEATE08.VAL")
  field(INPI, "B131-IOCMOTOR2:HEARTBEATE09.VAL")
  field(INPJ, "B131-IOCMOTOR2:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B131-IOCMOTOR2:HEARTBEATE09") {
  field(FLNK, "B131-IOCMOTOR2:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR2:HEARTBEATE08.B")
  field(INPB, "B131-IOCMOTOR2:HEARTBEATE09.VAL")
}

record(calc, "B131-IOCMOTOR2:HEARTBEATE08") {
  field(FLNK, "B131-IOCMOTOR2:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR2:HEARTBEATE07.B")
  field(INPB, "B131-IOCMOTOR2:HEARTBEATE08.VAL")
}

record(calc, "B131-IOCMOTOR2:HEARTBEATE07") {
  field(FLNK, "B131-IOCMOTOR2:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR2:HEARTBEATE06.B")
  field(INPB, "B131-IOCMOTOR2:HEARTBEATE07.VAL")
}

record(calc, "B131-IOCMOTOR2:HEARTBEATE06") {
  field(FLNK, "B131-IOCMOTOR2:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR2:HEARTBEATE05.B")
  field(INPB, "B131-IOCMOTOR2:HEARTBEATE06.VAL")
}

record(calc, "B131-IOCMOTOR2:HEARTBEATE05") {
  field(FLNK, "B131-IOCMOTOR2:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR2:HEARTBEATE04.B")
  field(INPB, "B131-IOCMOTOR2:HEARTBEATE05.VAL")
}

record(calc, "B131-IOCMOTOR2:HEARTBEATE04") {
  field(FLNK, "B131-IOCMOTOR2:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR2:HEARTBEATE03.B")
  field(INPB, "B131-IOCMOTOR2:HEARTBEATE04.VAL")
}

record(calc, "B131-IOCMOTOR2:HEARTBEATE03") {
  field(FLNK, "B131-IOCMOTOR2:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR2:HEARTBEATE02.B")
  field(INPB, "B131-IOCMOTOR2:HEARTBEATE03.VAL")
}

record(calc, "B131-IOCMOTOR2:HEARTBEATE02") {
  field(FLNK, "B131-IOCMOTOR2:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR2:HEARTBEATE01.B")
  field(INPB, "B131-IOCMOTOR2:HEARTBEATE02.VAL")
}

record(calc, "B131-IOCMOTOR2:HEARTBEATE01") {
  field(FLNK, "B131-IOCMOTOR2:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR2:HEARTBEATERR.VAL")
  field(INPB, "B131-IOCMOTOR2:HEARTBEATE01.VAL")
}

record(calc, "B131-IOCMOTOR2:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B131-IOCMOTOR2:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B131-IOCMOTOR2:HEARTBEATSUM") {
  field(FLNK, "B131-IOCMOTOR2:HEARTBEATCLC")
  field(INP, "B131-IOCMOTOR2:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B131-IOCMOTOR2:HEARTBEATE10") {
  field(FLNK, "B131-IOCMOTOR2:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR2:HEARTBEATE09.B")
  field(INPB, "B131-IOCMOTOR2:HEARTBEATE10.VAL")
}

record(calc, "B131-IOCMOTOR2:HEARTBEATERR") {
  field(FLNK, "B131-IOCMOTOR2:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B131-IOCMOTOR2:HEARTBEATCALC.A")
  field(INPB, "B131-IOCMOTOR2:HEARTBEATCALC.B")
}

record(stringin, "B131-IOCMOTOR2:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "bl5")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B131-IOCMOTOR2:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "bl5")
  info(autosaveFields,"VAL")
}

record(stringin, "B131-IOCMOTOR2:LOC") {
  field(PINI, "YES")
  field(VAL, "B131-602")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B131-IOCMOTOR3:INFO") {
  field(DESC, "B131-IOCMOTOR3 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B131-IOCMOTOR3:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B131-IOCMOTOR3:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B131-IOCMOTOR3:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B131-IOCMOTOR3:TODDIFF")
}

record(longin, "B131-IOCMOTOR3:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B131-IOCMOTOR3:TODCHECK.VALA MS")
  field(FLNK, "B131-IOCMOTOR3:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B131-IOCMOTOR3:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B131-IOCMOTOR3:TODCHECK.SEVR")
  field(INPB, "B131-IOCMOTOR3:TODCHECK.VALB")
  field(FLNK, "B131-IOCMOTOR3:TODSUM")
}

record(bo, "B131-IOCMOTOR3:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B131-IOCMOTOR3:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B131-IOCMOTOR3:HEARTBEATCALC") {
  field(FLNK, "B131-IOCMOTOR3:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR3:HEARTBEAT CA MS")
  field(INPB, "B131-IOCMOTOR3:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B131-IOCMOTOR3:HEARTBEATOK") {
  field(FLNK, "B131-IOCMOTOR3:HEARTBEATE01")
  field(INP, "B131-IOCMOTOR3:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B131-IOCMOTOR3:HEARTBEATECT") {
  field(FLNK, "B131-IOCMOTOR3:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B131-IOCMOTOR3:HEARTBEATE01.VAL")
  field(INPB, "B131-IOCMOTOR3:HEARTBEATE02.VAL")
  field(INPC, "B131-IOCMOTOR3:HEARTBEATE03.VAL")
  field(INPD, "B131-IOCMOTOR3:HEARTBEATE04.VAL")
  field(INPE, "B131-IOCMOTOR3:HEARTBEATE05.VAL")
  field(INPF, "B131-IOCMOTOR3:HEARTBEATE06.VAL")
  field(INPG, "B131-IOCMOTOR3:HEARTBEATE07.VAL")
  field(INPH, "B131-IOCMOTOR3:HEARTBEATE08.VAL")
  field(INPI, "B131-IOCMOTOR3:HEARTBEATE09.VAL")
  field(INPJ, "B131-IOCMOTOR3:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B131-IOCMOTOR3:HEARTBEATE09") {
  field(FLNK, "B131-IOCMOTOR3:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR3:HEARTBEATE08.B")
  field(INPB, "B131-IOCMOTOR3:HEARTBEATE09.VAL")
}

record(calc, "B131-IOCMOTOR3:HEARTBEATE08") {
  field(FLNK, "B131-IOCMOTOR3:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR3:HEARTBEATE07.B")
  field(INPB, "B131-IOCMOTOR3:HEARTBEATE08.VAL")
}

record(calc, "B131-IOCMOTOR3:HEARTBEATE07") {
  field(FLNK, "B131-IOCMOTOR3:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR3:HEARTBEATE06.B")
  field(INPB, "B131-IOCMOTOR3:HEARTBEATE07.VAL")
}

record(calc, "B131-IOCMOTOR3:HEARTBEATE06") {
  field(FLNK, "B131-IOCMOTOR3:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR3:HEARTBEATE05.B")
  field(INPB, "B131-IOCMOTOR3:HEARTBEATE06.VAL")
}

record(calc, "B131-IOCMOTOR3:HEARTBEATE05") {
  field(FLNK, "B131-IOCMOTOR3:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR3:HEARTBEATE04.B")
  field(INPB, "B131-IOCMOTOR3:HEARTBEATE05.VAL")
}

record(calc, "B131-IOCMOTOR3:HEARTBEATE04") {
  field(FLNK, "B131-IOCMOTOR3:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR3:HEARTBEATE03.B")
  field(INPB, "B131-IOCMOTOR3:HEARTBEATE04.VAL")
}

record(calc, "B131-IOCMOTOR3:HEARTBEATE03") {
  field(FLNK, "B131-IOCMOTOR3:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR3:HEARTBEATE02.B")
  field(INPB, "B131-IOCMOTOR3:HEARTBEATE03.VAL")
}

record(calc, "B131-IOCMOTOR3:HEARTBEATE02") {
  field(FLNK, "B131-IOCMOTOR3:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR3:HEARTBEATE01.B")
  field(INPB, "B131-IOCMOTOR3:HEARTBEATE02.VAL")
}

record(calc, "B131-IOCMOTOR3:HEARTBEATE01") {
  field(FLNK, "B131-IOCMOTOR3:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR3:HEARTBEATERR.VAL")
  field(INPB, "B131-IOCMOTOR3:HEARTBEATE01.VAL")
}

record(calc, "B131-IOCMOTOR3:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B131-IOCMOTOR3:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B131-IOCMOTOR3:HEARTBEATSUM") {
  field(FLNK, "B131-IOCMOTOR3:HEARTBEATCLC")
  field(INP, "B131-IOCMOTOR3:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B131-IOCMOTOR3:HEARTBEATE10") {
  field(FLNK, "B131-IOCMOTOR3:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B131-IOCMOTOR3:HEARTBEATE09.B")
  field(INPB, "B131-IOCMOTOR3:HEARTBEATE10.VAL")
}

record(calc, "B131-IOCMOTOR3:HEARTBEATERR") {
  field(FLNK, "B131-IOCMOTOR3:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B131-IOCMOTOR3:HEARTBEATCALC.A")
  field(INPB, "B131-IOCMOTOR3:HEARTBEATCALC.B")
}

record(stringin, "B131-IOCMOTOR3:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "bl7")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B131-IOCMOTOR3:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "bl7")
  info(autosaveFields,"VAL")
}

record(stringin, "B131-IOCMOTOR3:LOC") {
  field(PINI, "YES")
  field(VAL, "B131-1100-33")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B116-IOCBPM:INFO") {
  field(DESC, "B116-IOCBPM Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B116-IOCBPM:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B116-IOCBPM:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B116-IOCBPM:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B116-IOCBPM:TODDIFF")
}

record(longin, "B116-IOCBPM:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B116-IOCBPM:TODCHECK.VALA MS")
  field(FLNK, "B116-IOCBPM:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B116-IOCBPM:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B116-IOCBPM:TODCHECK.SEVR")
  field(INPB, "B116-IOCBPM:TODCHECK.VALB")
  field(FLNK, "B116-IOCBPM:TODSUM")
}

record(bo, "B116-IOCBPM:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B116-IOCBPM:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B116-IOCBPM:HEARTBEATCALC") {
  field(FLNK, "B116-IOCBPM:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM:HEARTBEAT CA MS")
  field(INPB, "B116-IOCBPM:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B116-IOCBPM:HEARTBEATOK") {
  field(FLNK, "B116-IOCBPM:HEARTBEATE01")
  field(INP, "B116-IOCBPM:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B116-IOCBPM:HEARTBEATECT") {
  field(FLNK, "B116-IOCBPM:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B116-IOCBPM:HEARTBEATE01.VAL")
  field(INPB, "B116-IOCBPM:HEARTBEATE02.VAL")
  field(INPC, "B116-IOCBPM:HEARTBEATE03.VAL")
  field(INPD, "B116-IOCBPM:HEARTBEATE04.VAL")
  field(INPE, "B116-IOCBPM:HEARTBEATE05.VAL")
  field(INPF, "B116-IOCBPM:HEARTBEATE06.VAL")
  field(INPG, "B116-IOCBPM:HEARTBEATE07.VAL")
  field(INPH, "B116-IOCBPM:HEARTBEATE08.VAL")
  field(INPI, "B116-IOCBPM:HEARTBEATE09.VAL")
  field(INPJ, "B116-IOCBPM:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B116-IOCBPM:HEARTBEATE09") {
  field(FLNK, "B116-IOCBPM:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM:HEARTBEATE08.B")
  field(INPB, "B116-IOCBPM:HEARTBEATE09.VAL")
}

record(calc, "B116-IOCBPM:HEARTBEATE08") {
  field(FLNK, "B116-IOCBPM:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM:HEARTBEATE07.B")
  field(INPB, "B116-IOCBPM:HEARTBEATE08.VAL")
}

record(calc, "B116-IOCBPM:HEARTBEATE07") {
  field(FLNK, "B116-IOCBPM:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM:HEARTBEATE06.B")
  field(INPB, "B116-IOCBPM:HEARTBEATE07.VAL")
}

record(calc, "B116-IOCBPM:HEARTBEATE06") {
  field(FLNK, "B116-IOCBPM:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM:HEARTBEATE05.B")
  field(INPB, "B116-IOCBPM:HEARTBEATE06.VAL")
}

record(calc, "B116-IOCBPM:HEARTBEATE05") {
  field(FLNK, "B116-IOCBPM:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM:HEARTBEATE04.B")
  field(INPB, "B116-IOCBPM:HEARTBEATE05.VAL")
}

record(calc, "B116-IOCBPM:HEARTBEATE04") {
  field(FLNK, "B116-IOCBPM:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM:HEARTBEATE03.B")
  field(INPB, "B116-IOCBPM:HEARTBEATE04.VAL")
}

record(calc, "B116-IOCBPM:HEARTBEATE03") {
  field(FLNK, "B116-IOCBPM:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM:HEARTBEATE02.B")
  field(INPB, "B116-IOCBPM:HEARTBEATE03.VAL")
}

record(calc, "B116-IOCBPM:HEARTBEATE02") {
  field(FLNK, "B116-IOCBPM:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM:HEARTBEATE01.B")
  field(INPB, "B116-IOCBPM:HEARTBEATE02.VAL")
}

record(calc, "B116-IOCBPM:HEARTBEATE01") {
  field(FLNK, "B116-IOCBPM:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM:HEARTBEATERR.VAL")
  field(INPB, "B116-IOCBPM:HEARTBEATE01.VAL")
}

record(calc, "B116-IOCBPM:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B116-IOCBPM:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B116-IOCBPM:HEARTBEATSUM") {
  field(FLNK, "B116-IOCBPM:HEARTBEATCLC")
  field(INP, "B116-IOCBPM:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B116-IOCBPM:HEARTBEATE10") {
  field(FLNK, "B116-IOCBPM:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM:HEARTBEATE09.B")
  field(INPB, "B116-IOCBPM:HEARTBEATE10.VAL")
}

record(calc, "B116-IOCBPM:HEARTBEATERR") {
  field(FLNK, "B116-IOCBPM:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B116-IOCBPM:HEARTBEATCALC.A")
  field(INPB, "B116-IOCBPM:HEARTBEATCALC.B")
}

record(stringin, "B116-IOCBPM:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "ioceast")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B116-IOCBPM:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "ioceast")
  info(autosaveFields,"VAL")
}

record(stringin, "B116-IOCBPM:LOC") {
  field(PINI, "YES")
  field(VAL, "B116-101-6-17")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B116-IOCBPM2:INFO") {
  field(DESC, "B116-IOCBPM2 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B116-IOCBPM2:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B116-IOCBPM2:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B116-IOCBPM2:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B116-IOCBPM2:TODDIFF")
}

record(longin, "B116-IOCBPM2:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B116-IOCBPM2:TODCHECK.VALA MS")
  field(FLNK, "B116-IOCBPM2:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B116-IOCBPM2:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B116-IOCBPM2:TODCHECK.SEVR")
  field(INPB, "B116-IOCBPM2:TODCHECK.VALB")
  field(FLNK, "B116-IOCBPM2:TODSUM")
}

record(bo, "B116-IOCBPM2:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B116-IOCBPM2:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B116-IOCBPM2:HEARTBEATCALC") {
  field(FLNK, "B116-IOCBPM2:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM2:HEARTBEAT CA MS")
  field(INPB, "B116-IOCBPM2:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B116-IOCBPM2:HEARTBEATOK") {
  field(FLNK, "B116-IOCBPM2:HEARTBEATE01")
  field(INP, "B116-IOCBPM2:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B116-IOCBPM2:HEARTBEATECT") {
  field(FLNK, "B116-IOCBPM2:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B116-IOCBPM2:HEARTBEATE01.VAL")
  field(INPB, "B116-IOCBPM2:HEARTBEATE02.VAL")
  field(INPC, "B116-IOCBPM2:HEARTBEATE03.VAL")
  field(INPD, "B116-IOCBPM2:HEARTBEATE04.VAL")
  field(INPE, "B116-IOCBPM2:HEARTBEATE05.VAL")
  field(INPF, "B116-IOCBPM2:HEARTBEATE06.VAL")
  field(INPG, "B116-IOCBPM2:HEARTBEATE07.VAL")
  field(INPH, "B116-IOCBPM2:HEARTBEATE08.VAL")
  field(INPI, "B116-IOCBPM2:HEARTBEATE09.VAL")
  field(INPJ, "B116-IOCBPM2:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B116-IOCBPM2:HEARTBEATE09") {
  field(FLNK, "B116-IOCBPM2:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM2:HEARTBEATE08.B")
  field(INPB, "B116-IOCBPM2:HEARTBEATE09.VAL")
}

record(calc, "B116-IOCBPM2:HEARTBEATE08") {
  field(FLNK, "B116-IOCBPM2:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM2:HEARTBEATE07.B")
  field(INPB, "B116-IOCBPM2:HEARTBEATE08.VAL")
}

record(calc, "B116-IOCBPM2:HEARTBEATE07") {
  field(FLNK, "B116-IOCBPM2:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM2:HEARTBEATE06.B")
  field(INPB, "B116-IOCBPM2:HEARTBEATE07.VAL")
}

record(calc, "B116-IOCBPM2:HEARTBEATE06") {
  field(FLNK, "B116-IOCBPM2:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM2:HEARTBEATE05.B")
  field(INPB, "B116-IOCBPM2:HEARTBEATE06.VAL")
}

record(calc, "B116-IOCBPM2:HEARTBEATE05") {
  field(FLNK, "B116-IOCBPM2:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM2:HEARTBEATE04.B")
  field(INPB, "B116-IOCBPM2:HEARTBEATE05.VAL")
}

record(calc, "B116-IOCBPM2:HEARTBEATE04") {
  field(FLNK, "B116-IOCBPM2:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM2:HEARTBEATE03.B")
  field(INPB, "B116-IOCBPM2:HEARTBEATE04.VAL")
}

record(calc, "B116-IOCBPM2:HEARTBEATE03") {
  field(FLNK, "B116-IOCBPM2:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM2:HEARTBEATE02.B")
  field(INPB, "B116-IOCBPM2:HEARTBEATE03.VAL")
}

record(calc, "B116-IOCBPM2:HEARTBEATE02") {
  field(FLNK, "B116-IOCBPM2:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM2:HEARTBEATE01.B")
  field(INPB, "B116-IOCBPM2:HEARTBEATE02.VAL")
}

record(calc, "B116-IOCBPM2:HEARTBEATE01") {
  field(FLNK, "B116-IOCBPM2:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM2:HEARTBEATERR.VAL")
  field(INPB, "B116-IOCBPM2:HEARTBEATE01.VAL")
}

record(calc, "B116-IOCBPM2:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B116-IOCBPM2:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B116-IOCBPM2:HEARTBEATSUM") {
  field(FLNK, "B116-IOCBPM2:HEARTBEATCLC")
  field(INP, "B116-IOCBPM2:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B116-IOCBPM2:HEARTBEATE10") {
  field(FLNK, "B116-IOCBPM2:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B116-IOCBPM2:HEARTBEATE09.B")
  field(INPB, "B116-IOCBPM2:HEARTBEATE10.VAL")
}

record(calc, "B116-IOCBPM2:HEARTBEATERR") {
  field(FLNK, "B116-IOCBPM2:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B116-IOCBPM2:HEARTBEATCALC.A")
  field(INPB, "B116-IOCBPM2:HEARTBEATCALC.B")
}

record(stringin, "B116-IOCBPM2:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "ioceast2")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B116-IOCBPM2:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "ioceast2")
  info(autosaveFields,"VAL")
}

record(stringin, "B116-IOCBPM2:LOC") {
  field(PINI, "YES")
  field(VAL, "B116-101-5-17")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B116-IOCMOTOR:INFO") {
  field(DESC, "B116-IOCMOTOR Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B116-IOCMOTOR:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B116-IOCMOTOR:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B116-IOCMOTOR:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B116-IOCMOTOR:TODDIFF")
}

record(longin, "B116-IOCMOTOR:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B116-IOCMOTOR:TODCHECK.VALA MS")
  field(FLNK, "B116-IOCMOTOR:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B116-IOCMOTOR:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B116-IOCMOTOR:TODCHECK.SEVR")
  field(INPB, "B116-IOCMOTOR:TODCHECK.VALB")
  field(FLNK, "B116-IOCMOTOR:TODSUM")
}

record(bo, "B116-IOCMOTOR:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B116-IOCMOTOR:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B116-IOCMOTOR:HEARTBEATCALC") {
  field(FLNK, "B116-IOCMOTOR:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B116-IOCMOTOR:HEARTBEAT CA MS")
  field(INPB, "B116-IOCMOTOR:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B116-IOCMOTOR:HEARTBEATOK") {
  field(FLNK, "B116-IOCMOTOR:HEARTBEATE01")
  field(INP, "B116-IOCMOTOR:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B116-IOCMOTOR:HEARTBEATECT") {
  field(FLNK, "B116-IOCMOTOR:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B116-IOCMOTOR:HEARTBEATE01.VAL")
  field(INPB, "B116-IOCMOTOR:HEARTBEATE02.VAL")
  field(INPC, "B116-IOCMOTOR:HEARTBEATE03.VAL")
  field(INPD, "B116-IOCMOTOR:HEARTBEATE04.VAL")
  field(INPE, "B116-IOCMOTOR:HEARTBEATE05.VAL")
  field(INPF, "B116-IOCMOTOR:HEARTBEATE06.VAL")
  field(INPG, "B116-IOCMOTOR:HEARTBEATE07.VAL")
  field(INPH, "B116-IOCMOTOR:HEARTBEATE08.VAL")
  field(INPI, "B116-IOCMOTOR:HEARTBEATE09.VAL")
  field(INPJ, "B116-IOCMOTOR:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B116-IOCMOTOR:HEARTBEATE09") {
  field(FLNK, "B116-IOCMOTOR:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B116-IOCMOTOR:HEARTBEATE08.B")
  field(INPB, "B116-IOCMOTOR:HEARTBEATE09.VAL")
}

record(calc, "B116-IOCMOTOR:HEARTBEATE08") {
  field(FLNK, "B116-IOCMOTOR:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B116-IOCMOTOR:HEARTBEATE07.B")
  field(INPB, "B116-IOCMOTOR:HEARTBEATE08.VAL")
}

record(calc, "B116-IOCMOTOR:HEARTBEATE07") {
  field(FLNK, "B116-IOCMOTOR:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B116-IOCMOTOR:HEARTBEATE06.B")
  field(INPB, "B116-IOCMOTOR:HEARTBEATE07.VAL")
}

record(calc, "B116-IOCMOTOR:HEARTBEATE06") {
  field(FLNK, "B116-IOCMOTOR:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B116-IOCMOTOR:HEARTBEATE05.B")
  field(INPB, "B116-IOCMOTOR:HEARTBEATE06.VAL")
}

record(calc, "B116-IOCMOTOR:HEARTBEATE05") {
  field(FLNK, "B116-IOCMOTOR:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B116-IOCMOTOR:HEARTBEATE04.B")
  field(INPB, "B116-IOCMOTOR:HEARTBEATE05.VAL")
}

record(calc, "B116-IOCMOTOR:HEARTBEATE04") {
  field(FLNK, "B116-IOCMOTOR:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B116-IOCMOTOR:HEARTBEATE03.B")
  field(INPB, "B116-IOCMOTOR:HEARTBEATE04.VAL")
}

record(calc, "B116-IOCMOTOR:HEARTBEATE03") {
  field(FLNK, "B116-IOCMOTOR:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B116-IOCMOTOR:HEARTBEATE02.B")
  field(INPB, "B116-IOCMOTOR:HEARTBEATE03.VAL")
}

record(calc, "B116-IOCMOTOR:HEARTBEATE02") {
  field(FLNK, "B116-IOCMOTOR:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B116-IOCMOTOR:HEARTBEATE01.B")
  field(INPB, "B116-IOCMOTOR:HEARTBEATE02.VAL")
}

record(calc, "B116-IOCMOTOR:HEARTBEATE01") {
  field(FLNK, "B116-IOCMOTOR:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B116-IOCMOTOR:HEARTBEATERR.VAL")
  field(INPB, "B116-IOCMOTOR:HEARTBEATE01.VAL")
}

record(calc, "B116-IOCMOTOR:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B116-IOCMOTOR:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B116-IOCMOTOR:HEARTBEATSUM") {
  field(FLNK, "B116-IOCMOTOR:HEARTBEATCLC")
  field(INP, "B116-IOCMOTOR:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B116-IOCMOTOR:HEARTBEATE10") {
  field(FLNK, "B116-IOCMOTOR:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B116-IOCMOTOR:HEARTBEATE09.B")
  field(INPB, "B116-IOCMOTOR:HEARTBEATE10.VAL")
}

record(calc, "B116-IOCMOTOR:HEARTBEATERR") {
  field(FLNK, "B116-IOCMOTOR:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B116-IOCMOTOR:HEARTBEATCALC.A")
  field(INPB, "B116-IOCMOTOR:HEARTBEATCALC.B")
}

record(stringin, "B116-IOCMOTOR:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "bl12")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B116-IOCMOTOR:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "bl12")
  info(autosaveFields,"VAL")
}

record(stringin, "B116-IOCMOTOR:LOC") {
  field(PINI, "YES")
  field(VAL, "B116-101-4-28")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B116-IOCCAMAC:INFO") {
  field(DESC, "B116-IOCCAMAC Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B116-IOCCAMAC:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B116-IOCCAMAC:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B116-IOCCAMAC:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B116-IOCCAMAC:TODDIFF")
}

record(longin, "B116-IOCCAMAC:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B116-IOCCAMAC:TODCHECK.VALA MS")
  field(FLNK, "B116-IOCCAMAC:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B116-IOCCAMAC:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B116-IOCCAMAC:TODCHECK.SEVR")
  field(INPB, "B116-IOCCAMAC:TODCHECK.VALB")
  field(FLNK, "B116-IOCCAMAC:TODSUM")
}

record(bo, "B116-IOCCAMAC:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B116-IOCCAMAC:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B116-IOCCAMAC:HEARTBEATCALC") {
  field(FLNK, "B116-IOCCAMAC:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B116-IOCCAMAC:HEARTBEAT CA MS")
  field(INPB, "B116-IOCCAMAC:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B116-IOCCAMAC:HEARTBEATOK") {
  field(FLNK, "B116-IOCCAMAC:HEARTBEATE01")
  field(INP, "B116-IOCCAMAC:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B116-IOCCAMAC:HEARTBEATECT") {
  field(FLNK, "B116-IOCCAMAC:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B116-IOCCAMAC:HEARTBEATE01.VAL")
  field(INPB, "B116-IOCCAMAC:HEARTBEATE02.VAL")
  field(INPC, "B116-IOCCAMAC:HEARTBEATE03.VAL")
  field(INPD, "B116-IOCCAMAC:HEARTBEATE04.VAL")
  field(INPE, "B116-IOCCAMAC:HEARTBEATE05.VAL")
  field(INPF, "B116-IOCCAMAC:HEARTBEATE06.VAL")
  field(INPG, "B116-IOCCAMAC:HEARTBEATE07.VAL")
  field(INPH, "B116-IOCCAMAC:HEARTBEATE08.VAL")
  field(INPI, "B116-IOCCAMAC:HEARTBEATE09.VAL")
  field(INPJ, "B116-IOCCAMAC:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B116-IOCCAMAC:HEARTBEATE09") {
  field(FLNK, "B116-IOCCAMAC:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B116-IOCCAMAC:HEARTBEATE08.B")
  field(INPB, "B116-IOCCAMAC:HEARTBEATE09.VAL")
}

record(calc, "B116-IOCCAMAC:HEARTBEATE08") {
  field(FLNK, "B116-IOCCAMAC:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B116-IOCCAMAC:HEARTBEATE07.B")
  field(INPB, "B116-IOCCAMAC:HEARTBEATE08.VAL")
}

record(calc, "B116-IOCCAMAC:HEARTBEATE07") {
  field(FLNK, "B116-IOCCAMAC:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B116-IOCCAMAC:HEARTBEATE06.B")
  field(INPB, "B116-IOCCAMAC:HEARTBEATE07.VAL")
}

record(calc, "B116-IOCCAMAC:HEARTBEATE06") {
  field(FLNK, "B116-IOCCAMAC:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B116-IOCCAMAC:HEARTBEATE05.B")
  field(INPB, "B116-IOCCAMAC:HEARTBEATE06.VAL")
}

record(calc, "B116-IOCCAMAC:HEARTBEATE05") {
  field(FLNK, "B116-IOCCAMAC:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B116-IOCCAMAC:HEARTBEATE04.B")
  field(INPB, "B116-IOCCAMAC:HEARTBEATE05.VAL")
}

record(calc, "B116-IOCCAMAC:HEARTBEATE04") {
  field(FLNK, "B116-IOCCAMAC:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B116-IOCCAMAC:HEARTBEATE03.B")
  field(INPB, "B116-IOCCAMAC:HEARTBEATE04.VAL")
}

record(calc, "B116-IOCCAMAC:HEARTBEATE03") {
  field(FLNK, "B116-IOCCAMAC:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B116-IOCCAMAC:HEARTBEATE02.B")
  field(INPB, "B116-IOCCAMAC:HEARTBEATE03.VAL")
}

record(calc, "B116-IOCCAMAC:HEARTBEATE02") {
  field(FLNK, "B116-IOCCAMAC:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B116-IOCCAMAC:HEARTBEATE01.B")
  field(INPB, "B116-IOCCAMAC:HEARTBEATE02.VAL")
}

record(calc, "B116-IOCCAMAC:HEARTBEATE01") {
  field(FLNK, "B116-IOCCAMAC:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B116-IOCCAMAC:HEARTBEATERR.VAL")
  field(INPB, "B116-IOCCAMAC:HEARTBEATE01.VAL")
}

record(calc, "B116-IOCCAMAC:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B116-IOCCAMAC:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B116-IOCCAMAC:HEARTBEATSUM") {
  field(FLNK, "B116-IOCCAMAC:HEARTBEATCLC")
  field(INP, "B116-IOCCAMAC:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B116-IOCCAMAC:HEARTBEATE10") {
  field(FLNK, "B116-IOCCAMAC:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B116-IOCCAMAC:HEARTBEATE09.B")
  field(INPB, "B116-IOCCAMAC:HEARTBEATE10.VAL")
}

record(calc, "B116-IOCCAMAC:HEARTBEATERR") {
  field(FLNK, "B116-IOCCAMAC:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B116-IOCCAMAC:HEARTBEATCALC.A")
  field(INPB, "B116-IOCCAMAC:HEARTBEATCALC.B")
}

record(stringin, "B116-IOCCAMAC:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "ioccam116")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B116-IOCCAMAC:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "ioccam116")
  info(autosaveFields,"VAL")
}

record(stringin, "B116-IOCCAMAC:LOC") {
  field(PINI, "YES")
  field(VAL, "B116-101-4-28")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B117-IOCMU:INFO") {
  field(DESC, "B117-IOCMU Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B117-IOCMU:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B117-IOCMU:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B117-IOCMU:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B117-IOCMU:TODDIFF")
}

record(longin, "B117-IOCMU:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B117-IOCMU:TODCHECK.VALA MS")
  field(FLNK, "B117-IOCMU:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B117-IOCMU:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B117-IOCMU:TODCHECK.SEVR")
  field(INPB, "B117-IOCMU:TODCHECK.VALB")
  field(FLNK, "B117-IOCMU:TODSUM")
}

record(bo, "B117-IOCMU:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B117-IOCMU:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B117-IOCMU:HEARTBEATCALC") {
  field(FLNK, "B117-IOCMU:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B117-IOCMU:HEARTBEAT CA MS")
  field(INPB, "B117-IOCMU:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B117-IOCMU:HEARTBEATOK") {
  field(FLNK, "B117-IOCMU:HEARTBEATE01")
  field(INP, "B117-IOCMU:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B117-IOCMU:HEARTBEATECT") {
  field(FLNK, "B117-IOCMU:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B117-IOCMU:HEARTBEATE01.VAL")
  field(INPB, "B117-IOCMU:HEARTBEATE02.VAL")
  field(INPC, "B117-IOCMU:HEARTBEATE03.VAL")
  field(INPD, "B117-IOCMU:HEARTBEATE04.VAL")
  field(INPE, "B117-IOCMU:HEARTBEATE05.VAL")
  field(INPF, "B117-IOCMU:HEARTBEATE06.VAL")
  field(INPG, "B117-IOCMU:HEARTBEATE07.VAL")
  field(INPH, "B117-IOCMU:HEARTBEATE08.VAL")
  field(INPI, "B117-IOCMU:HEARTBEATE09.VAL")
  field(INPJ, "B117-IOCMU:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B117-IOCMU:HEARTBEATE09") {
  field(FLNK, "B117-IOCMU:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B117-IOCMU:HEARTBEATE08.B")
  field(INPB, "B117-IOCMU:HEARTBEATE09.VAL")
}

record(calc, "B117-IOCMU:HEARTBEATE08") {
  field(FLNK, "B117-IOCMU:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B117-IOCMU:HEARTBEATE07.B")
  field(INPB, "B117-IOCMU:HEARTBEATE08.VAL")
}

record(calc, "B117-IOCMU:HEARTBEATE07") {
  field(FLNK, "B117-IOCMU:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B117-IOCMU:HEARTBEATE06.B")
  field(INPB, "B117-IOCMU:HEARTBEATE07.VAL")
}

record(calc, "B117-IOCMU:HEARTBEATE06") {
  field(FLNK, "B117-IOCMU:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B117-IOCMU:HEARTBEATE05.B")
  field(INPB, "B117-IOCMU:HEARTBEATE06.VAL")
}

record(calc, "B117-IOCMU:HEARTBEATE05") {
  field(FLNK, "B117-IOCMU:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B117-IOCMU:HEARTBEATE04.B")
  field(INPB, "B117-IOCMU:HEARTBEATE05.VAL")
}

record(calc, "B117-IOCMU:HEARTBEATE04") {
  field(FLNK, "B117-IOCMU:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B117-IOCMU:HEARTBEATE03.B")
  field(INPB, "B117-IOCMU:HEARTBEATE04.VAL")
}

record(calc, "B117-IOCMU:HEARTBEATE03") {
  field(FLNK, "B117-IOCMU:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B117-IOCMU:HEARTBEATE02.B")
  field(INPB, "B117-IOCMU:HEARTBEATE03.VAL")
}

record(calc, "B117-IOCMU:HEARTBEATE02") {
  field(FLNK, "B117-IOCMU:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B117-IOCMU:HEARTBEATE01.B")
  field(INPB, "B117-IOCMU:HEARTBEATE02.VAL")
}

record(calc, "B117-IOCMU:HEARTBEATE01") {
  field(FLNK, "B117-IOCMU:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B117-IOCMU:HEARTBEATERR.VAL")
  field(INPB, "B117-IOCMU:HEARTBEATE01.VAL")
}

record(calc, "B117-IOCMU:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B117-IOCMU:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B117-IOCMU:HEARTBEATSUM") {
  field(FLNK, "B117-IOCMU:HEARTBEATCLC")
  field(INP, "B117-IOCMU:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B117-IOCMU:HEARTBEATE10") {
  field(FLNK, "B117-IOCMU:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B117-IOCMU:HEARTBEATE09.B")
  field(INPB, "B117-IOCMU:HEARTBEATE10.VAL")
}

record(calc, "B117-IOCMU:HEARTBEATERR") {
  field(FLNK, "B117-IOCMU:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B117-IOCMU:HEARTBEATCALC.A")
  field(INPB, "B117-IOCMU:HEARTBEATCALC.B")
}

record(stringin, "B117-IOCMU:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocmu")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B117-IOCMU:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocmu")
  info(autosaveFields,"VAL")
}

record(stringin, "B117-IOCMU:LOC") {
  field(PINI, "YES")
  field(VAL, "B117-14-30")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B117-IOCORBIT:INFO") {
  field(DESC, "B117-IOCORBIT Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B117-IOCORBIT:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B117-IOCORBIT:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B117-IOCORBIT:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B117-IOCORBIT:TODDIFF")
}

record(longin, "B117-IOCORBIT:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B117-IOCORBIT:TODCHECK.VALA MS")
  field(FLNK, "B117-IOCORBIT:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B117-IOCORBIT:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B117-IOCORBIT:TODCHECK.SEVR")
  field(INPB, "B117-IOCORBIT:TODCHECK.VALB")
  field(FLNK, "B117-IOCORBIT:TODSUM")
}

record(bo, "B117-IOCORBIT:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B117-IOCORBIT:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B117-IOCORBIT:HEARTBEATCALC") {
  field(FLNK, "B117-IOCORBIT:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B117-IOCORBIT:HEARTBEAT CA MS")
  field(INPB, "B117-IOCORBIT:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B117-IOCORBIT:HEARTBEATOK") {
  field(FLNK, "B117-IOCORBIT:HEARTBEATE01")
  field(INP, "B117-IOCORBIT:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B117-IOCORBIT:HEARTBEATECT") {
  field(FLNK, "B117-IOCORBIT:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B117-IOCORBIT:HEARTBEATE01.VAL")
  field(INPB, "B117-IOCORBIT:HEARTBEATE02.VAL")
  field(INPC, "B117-IOCORBIT:HEARTBEATE03.VAL")
  field(INPD, "B117-IOCORBIT:HEARTBEATE04.VAL")
  field(INPE, "B117-IOCORBIT:HEARTBEATE05.VAL")
  field(INPF, "B117-IOCORBIT:HEARTBEATE06.VAL")
  field(INPG, "B117-IOCORBIT:HEARTBEATE07.VAL")
  field(INPH, "B117-IOCORBIT:HEARTBEATE08.VAL")
  field(INPI, "B117-IOCORBIT:HEARTBEATE09.VAL")
  field(INPJ, "B117-IOCORBIT:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B117-IOCORBIT:HEARTBEATE09") {
  field(FLNK, "B117-IOCORBIT:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B117-IOCORBIT:HEARTBEATE08.B")
  field(INPB, "B117-IOCORBIT:HEARTBEATE09.VAL")
}

record(calc, "B117-IOCORBIT:HEARTBEATE08") {
  field(FLNK, "B117-IOCORBIT:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B117-IOCORBIT:HEARTBEATE07.B")
  field(INPB, "B117-IOCORBIT:HEARTBEATE08.VAL")
}

record(calc, "B117-IOCORBIT:HEARTBEATE07") {
  field(FLNK, "B117-IOCORBIT:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B117-IOCORBIT:HEARTBEATE06.B")
  field(INPB, "B117-IOCORBIT:HEARTBEATE07.VAL")
}

record(calc, "B117-IOCORBIT:HEARTBEATE06") {
  field(FLNK, "B117-IOCORBIT:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B117-IOCORBIT:HEARTBEATE05.B")
  field(INPB, "B117-IOCORBIT:HEARTBEATE06.VAL")
}

record(calc, "B117-IOCORBIT:HEARTBEATE05") {
  field(FLNK, "B117-IOCORBIT:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B117-IOCORBIT:HEARTBEATE04.B")
  field(INPB, "B117-IOCORBIT:HEARTBEATE05.VAL")
}

record(calc, "B117-IOCORBIT:HEARTBEATE04") {
  field(FLNK, "B117-IOCORBIT:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B117-IOCORBIT:HEARTBEATE03.B")
  field(INPB, "B117-IOCORBIT:HEARTBEATE04.VAL")
}

record(calc, "B117-IOCORBIT:HEARTBEATE03") {
  field(FLNK, "B117-IOCORBIT:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B117-IOCORBIT:HEARTBEATE02.B")
  field(INPB, "B117-IOCORBIT:HEARTBEATE03.VAL")
}

record(calc, "B117-IOCORBIT:HEARTBEATE02") {
  field(FLNK, "B117-IOCORBIT:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B117-IOCORBIT:HEARTBEATE01.B")
  field(INPB, "B117-IOCORBIT:HEARTBEATE02.VAL")
}

record(calc, "B117-IOCORBIT:HEARTBEATE01") {
  field(FLNK, "B117-IOCORBIT:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B117-IOCORBIT:HEARTBEATERR.VAL")
  field(INPB, "B117-IOCORBIT:HEARTBEATE01.VAL")
}

record(calc, "B117-IOCORBIT:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B117-IOCORBIT:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B117-IOCORBIT:HEARTBEATSUM") {
  field(FLNK, "B117-IOCORBIT:HEARTBEATCLC")
  field(INP, "B117-IOCORBIT:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B117-IOCORBIT:HEARTBEATE10") {
  field(FLNK, "B117-IOCORBIT:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B117-IOCORBIT:HEARTBEATE09.B")
  field(INPB, "B117-IOCORBIT:HEARTBEATE10.VAL")
}

record(calc, "B117-IOCORBIT:HEARTBEATERR") {
  field(FLNK, "B117-IOCORBIT:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B117-IOCORBIT:HEARTBEATCALC.A")
  field(INPB, "B117-IOCORBIT:HEARTBEATCALC.B")
}

record(stringin, "B117-IOCORBIT:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocorbit")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B117-IOCORBIT:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocorbit")
  info(autosaveFields,"VAL")
}

record(stringin, "B117-IOCORBIT:LOC") {
  field(PINI, "YES")
  field(VAL, "B117-14-19")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B117-IOCFDBK:INFO") {
  field(DESC, "B117-IOCFDBK Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B117-IOCFDBK:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B117-IOCFDBK:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B117-IOCFDBK:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B117-IOCFDBK:TODDIFF")
}

record(longin, "B117-IOCFDBK:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B117-IOCFDBK:TODCHECK.VALA MS")
  field(FLNK, "B117-IOCFDBK:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B117-IOCFDBK:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B117-IOCFDBK:TODCHECK.SEVR")
  field(INPB, "B117-IOCFDBK:TODCHECK.VALB")
  field(FLNK, "B117-IOCFDBK:TODSUM")
}

record(bo, "B117-IOCFDBK:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B117-IOCFDBK:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B117-IOCFDBK:HEARTBEATCALC") {
  field(FLNK, "B117-IOCFDBK:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B117-IOCFDBK:HEARTBEAT CA MS")
  field(INPB, "B117-IOCFDBK:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B117-IOCFDBK:HEARTBEATOK") {
  field(FLNK, "B117-IOCFDBK:HEARTBEATE01")
  field(INP, "B117-IOCFDBK:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B117-IOCFDBK:HEARTBEATECT") {
  field(FLNK, "B117-IOCFDBK:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B117-IOCFDBK:HEARTBEATE01.VAL")
  field(INPB, "B117-IOCFDBK:HEARTBEATE02.VAL")
  field(INPC, "B117-IOCFDBK:HEARTBEATE03.VAL")
  field(INPD, "B117-IOCFDBK:HEARTBEATE04.VAL")
  field(INPE, "B117-IOCFDBK:HEARTBEATE05.VAL")
  field(INPF, "B117-IOCFDBK:HEARTBEATE06.VAL")
  field(INPG, "B117-IOCFDBK:HEARTBEATE07.VAL")
  field(INPH, "B117-IOCFDBK:HEARTBEATE08.VAL")
  field(INPI, "B117-IOCFDBK:HEARTBEATE09.VAL")
  field(INPJ, "B117-IOCFDBK:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B117-IOCFDBK:HEARTBEATE09") {
  field(FLNK, "B117-IOCFDBK:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B117-IOCFDBK:HEARTBEATE08.B")
  field(INPB, "B117-IOCFDBK:HEARTBEATE09.VAL")
}

record(calc, "B117-IOCFDBK:HEARTBEATE08") {
  field(FLNK, "B117-IOCFDBK:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B117-IOCFDBK:HEARTBEATE07.B")
  field(INPB, "B117-IOCFDBK:HEARTBEATE08.VAL")
}

record(calc, "B117-IOCFDBK:HEARTBEATE07") {
  field(FLNK, "B117-IOCFDBK:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B117-IOCFDBK:HEARTBEATE06.B")
  field(INPB, "B117-IOCFDBK:HEARTBEATE07.VAL")
}

record(calc, "B117-IOCFDBK:HEARTBEATE06") {
  field(FLNK, "B117-IOCFDBK:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B117-IOCFDBK:HEARTBEATE05.B")
  field(INPB, "B117-IOCFDBK:HEARTBEATE06.VAL")
}

record(calc, "B117-IOCFDBK:HEARTBEATE05") {
  field(FLNK, "B117-IOCFDBK:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B117-IOCFDBK:HEARTBEATE04.B")
  field(INPB, "B117-IOCFDBK:HEARTBEATE05.VAL")
}

record(calc, "B117-IOCFDBK:HEARTBEATE04") {
  field(FLNK, "B117-IOCFDBK:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B117-IOCFDBK:HEARTBEATE03.B")
  field(INPB, "B117-IOCFDBK:HEARTBEATE04.VAL")
}

record(calc, "B117-IOCFDBK:HEARTBEATE03") {
  field(FLNK, "B117-IOCFDBK:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B117-IOCFDBK:HEARTBEATE02.B")
  field(INPB, "B117-IOCFDBK:HEARTBEATE03.VAL")
}

record(calc, "B117-IOCFDBK:HEARTBEATE02") {
  field(FLNK, "B117-IOCFDBK:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B117-IOCFDBK:HEARTBEATE01.B")
  field(INPB, "B117-IOCFDBK:HEARTBEATE02.VAL")
}

record(calc, "B117-IOCFDBK:HEARTBEATE01") {
  field(FLNK, "B117-IOCFDBK:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B117-IOCFDBK:HEARTBEATERR.VAL")
  field(INPB, "B117-IOCFDBK:HEARTBEATE01.VAL")
}

record(calc, "B117-IOCFDBK:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B117-IOCFDBK:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B117-IOCFDBK:HEARTBEATSUM") {
  field(FLNK, "B117-IOCFDBK:HEARTBEATCLC")
  field(INP, "B117-IOCFDBK:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B117-IOCFDBK:HEARTBEATE10") {
  field(FLNK, "B117-IOCFDBK:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B117-IOCFDBK:HEARTBEATE09.B")
  field(INPB, "B117-IOCFDBK:HEARTBEATE10.VAL")
}

record(calc, "B117-IOCFDBK:HEARTBEATERR") {
  field(FLNK, "B117-IOCFDBK:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B117-IOCFDBK:HEARTBEATCALC.A")
  field(INPB, "B117-IOCFDBK:HEARTBEATCALC.B")
}

record(stringin, "B117-IOCFDBK:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocfdbk")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B117-IOCFDBK:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocfdbk")
  info(autosaveFields,"VAL")
}

record(stringin, "B117-IOCFDBK:LOC") {
  field(PINI, "YES")
  field(VAL, "B117-14-19")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B132-IOCBPM:INFO") {
  field(DESC, "B132-IOCBPM Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B132-IOCBPM:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B132-IOCBPM:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B132-IOCBPM:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B132-IOCBPM:TODDIFF")
}

record(longin, "B132-IOCBPM:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B132-IOCBPM:TODCHECK.VALA MS")
  field(FLNK, "B132-IOCBPM:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B132-IOCBPM:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B132-IOCBPM:TODCHECK.SEVR")
  field(INPB, "B132-IOCBPM:TODCHECK.VALB")
  field(FLNK, "B132-IOCBPM:TODSUM")
}

record(bo, "B132-IOCBPM:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B132-IOCBPM:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B132-IOCBPM:HEARTBEATCALC") {
  field(FLNK, "B132-IOCBPM:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM:HEARTBEAT CA MS")
  field(INPB, "B132-IOCBPM:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B132-IOCBPM:HEARTBEATOK") {
  field(FLNK, "B132-IOCBPM:HEARTBEATE01")
  field(INP, "B132-IOCBPM:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B132-IOCBPM:HEARTBEATECT") {
  field(FLNK, "B132-IOCBPM:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B132-IOCBPM:HEARTBEATE01.VAL")
  field(INPB, "B132-IOCBPM:HEARTBEATE02.VAL")
  field(INPC, "B132-IOCBPM:HEARTBEATE03.VAL")
  field(INPD, "B132-IOCBPM:HEARTBEATE04.VAL")
  field(INPE, "B132-IOCBPM:HEARTBEATE05.VAL")
  field(INPF, "B132-IOCBPM:HEARTBEATE06.VAL")
  field(INPG, "B132-IOCBPM:HEARTBEATE07.VAL")
  field(INPH, "B132-IOCBPM:HEARTBEATE08.VAL")
  field(INPI, "B132-IOCBPM:HEARTBEATE09.VAL")
  field(INPJ, "B132-IOCBPM:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B132-IOCBPM:HEARTBEATE09") {
  field(FLNK, "B132-IOCBPM:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM:HEARTBEATE08.B")
  field(INPB, "B132-IOCBPM:HEARTBEATE09.VAL")
}

record(calc, "B132-IOCBPM:HEARTBEATE08") {
  field(FLNK, "B132-IOCBPM:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM:HEARTBEATE07.B")
  field(INPB, "B132-IOCBPM:HEARTBEATE08.VAL")
}

record(calc, "B132-IOCBPM:HEARTBEATE07") {
  field(FLNK, "B132-IOCBPM:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM:HEARTBEATE06.B")
  field(INPB, "B132-IOCBPM:HEARTBEATE07.VAL")
}

record(calc, "B132-IOCBPM:HEARTBEATE06") {
  field(FLNK, "B132-IOCBPM:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM:HEARTBEATE05.B")
  field(INPB, "B132-IOCBPM:HEARTBEATE06.VAL")
}

record(calc, "B132-IOCBPM:HEARTBEATE05") {
  field(FLNK, "B132-IOCBPM:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM:HEARTBEATE04.B")
  field(INPB, "B132-IOCBPM:HEARTBEATE05.VAL")
}

record(calc, "B132-IOCBPM:HEARTBEATE04") {
  field(FLNK, "B132-IOCBPM:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM:HEARTBEATE03.B")
  field(INPB, "B132-IOCBPM:HEARTBEATE04.VAL")
}

record(calc, "B132-IOCBPM:HEARTBEATE03") {
  field(FLNK, "B132-IOCBPM:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM:HEARTBEATE02.B")
  field(INPB, "B132-IOCBPM:HEARTBEATE03.VAL")
}

record(calc, "B132-IOCBPM:HEARTBEATE02") {
  field(FLNK, "B132-IOCBPM:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM:HEARTBEATE01.B")
  field(INPB, "B132-IOCBPM:HEARTBEATE02.VAL")
}

record(calc, "B132-IOCBPM:HEARTBEATE01") {
  field(FLNK, "B132-IOCBPM:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM:HEARTBEATERR.VAL")
  field(INPB, "B132-IOCBPM:HEARTBEATE01.VAL")
}

record(calc, "B132-IOCBPM:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B132-IOCBPM:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B132-IOCBPM:HEARTBEATSUM") {
  field(FLNK, "B132-IOCBPM:HEARTBEATCLC")
  field(INP, "B132-IOCBPM:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B132-IOCBPM:HEARTBEATE10") {
  field(FLNK, "B132-IOCBPM:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM:HEARTBEATE09.B")
  field(INPB, "B132-IOCBPM:HEARTBEATE10.VAL")
}

record(calc, "B132-IOCBPM:HEARTBEATERR") {
  field(FLNK, "B132-IOCBPM:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B132-IOCBPM:HEARTBEATCALC.A")
  field(INPB, "B132-IOCBPM:HEARTBEATCALC.B")
}

record(stringin, "B132-IOCBPM:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocwest")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B132-IOCBPM:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocwest")
  info(autosaveFields,"VAL")
}

record(stringin, "B132-IOCBPM:LOC") {
  field(PINI, "YES")
  field(VAL, "B132-102-6-17")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B132-IOCBPM2:INFO") {
  field(DESC, "B132-IOCBPM2 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B132-IOCBPM2:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B132-IOCBPM2:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B132-IOCBPM2:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B132-IOCBPM2:TODDIFF")
}

record(longin, "B132-IOCBPM2:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B132-IOCBPM2:TODCHECK.VALA MS")
  field(FLNK, "B132-IOCBPM2:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B132-IOCBPM2:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B132-IOCBPM2:TODCHECK.SEVR")
  field(INPB, "B132-IOCBPM2:TODCHECK.VALB")
  field(FLNK, "B132-IOCBPM2:TODSUM")
}

record(bo, "B132-IOCBPM2:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B132-IOCBPM2:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B132-IOCBPM2:HEARTBEATCALC") {
  field(FLNK, "B132-IOCBPM2:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM2:HEARTBEAT CA MS")
  field(INPB, "B132-IOCBPM2:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B132-IOCBPM2:HEARTBEATOK") {
  field(FLNK, "B132-IOCBPM2:HEARTBEATE01")
  field(INP, "B132-IOCBPM2:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B132-IOCBPM2:HEARTBEATECT") {
  field(FLNK, "B132-IOCBPM2:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B132-IOCBPM2:HEARTBEATE01.VAL")
  field(INPB, "B132-IOCBPM2:HEARTBEATE02.VAL")
  field(INPC, "B132-IOCBPM2:HEARTBEATE03.VAL")
  field(INPD, "B132-IOCBPM2:HEARTBEATE04.VAL")
  field(INPE, "B132-IOCBPM2:HEARTBEATE05.VAL")
  field(INPF, "B132-IOCBPM2:HEARTBEATE06.VAL")
  field(INPG, "B132-IOCBPM2:HEARTBEATE07.VAL")
  field(INPH, "B132-IOCBPM2:HEARTBEATE08.VAL")
  field(INPI, "B132-IOCBPM2:HEARTBEATE09.VAL")
  field(INPJ, "B132-IOCBPM2:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B132-IOCBPM2:HEARTBEATE09") {
  field(FLNK, "B132-IOCBPM2:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM2:HEARTBEATE08.B")
  field(INPB, "B132-IOCBPM2:HEARTBEATE09.VAL")
}

record(calc, "B132-IOCBPM2:HEARTBEATE08") {
  field(FLNK, "B132-IOCBPM2:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM2:HEARTBEATE07.B")
  field(INPB, "B132-IOCBPM2:HEARTBEATE08.VAL")
}

record(calc, "B132-IOCBPM2:HEARTBEATE07") {
  field(FLNK, "B132-IOCBPM2:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM2:HEARTBEATE06.B")
  field(INPB, "B132-IOCBPM2:HEARTBEATE07.VAL")
}

record(calc, "B132-IOCBPM2:HEARTBEATE06") {
  field(FLNK, "B132-IOCBPM2:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM2:HEARTBEATE05.B")
  field(INPB, "B132-IOCBPM2:HEARTBEATE06.VAL")
}

record(calc, "B132-IOCBPM2:HEARTBEATE05") {
  field(FLNK, "B132-IOCBPM2:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM2:HEARTBEATE04.B")
  field(INPB, "B132-IOCBPM2:HEARTBEATE05.VAL")
}

record(calc, "B132-IOCBPM2:HEARTBEATE04") {
  field(FLNK, "B132-IOCBPM2:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM2:HEARTBEATE03.B")
  field(INPB, "B132-IOCBPM2:HEARTBEATE04.VAL")
}

record(calc, "B132-IOCBPM2:HEARTBEATE03") {
  field(FLNK, "B132-IOCBPM2:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM2:HEARTBEATE02.B")
  field(INPB, "B132-IOCBPM2:HEARTBEATE03.VAL")
}

record(calc, "B132-IOCBPM2:HEARTBEATE02") {
  field(FLNK, "B132-IOCBPM2:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM2:HEARTBEATE01.B")
  field(INPB, "B132-IOCBPM2:HEARTBEATE02.VAL")
}

record(calc, "B132-IOCBPM2:HEARTBEATE01") {
  field(FLNK, "B132-IOCBPM2:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM2:HEARTBEATERR.VAL")
  field(INPB, "B132-IOCBPM2:HEARTBEATE01.VAL")
}

record(calc, "B132-IOCBPM2:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B132-IOCBPM2:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B132-IOCBPM2:HEARTBEATSUM") {
  field(FLNK, "B132-IOCBPM2:HEARTBEATCLC")
  field(INP, "B132-IOCBPM2:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B132-IOCBPM2:HEARTBEATE10") {
  field(FLNK, "B132-IOCBPM2:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B132-IOCBPM2:HEARTBEATE09.B")
  field(INPB, "B132-IOCBPM2:HEARTBEATE10.VAL")
}

record(calc, "B132-IOCBPM2:HEARTBEATERR") {
  field(FLNK, "B132-IOCBPM2:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B132-IOCBPM2:HEARTBEATCALC.A")
  field(INPB, "B132-IOCBPM2:HEARTBEATCALC.B")
}

record(stringin, "B132-IOCBPM2:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocbpmtest")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B132-IOCBPM2:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocbpmtest")
  info(autosaveFields,"VAL")
}

record(stringin, "B132-IOCBPM2:LOC") {
  field(PINI, "YES")
  field(VAL, "B116-101-2")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B132-IOCMOTOR:INFO") {
  field(DESC, "B132-IOCMOTOR Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B132-IOCMOTOR:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B132-IOCMOTOR:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B132-IOCMOTOR:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B132-IOCMOTOR:TODDIFF")
}

record(longin, "B132-IOCMOTOR:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B132-IOCMOTOR:TODCHECK.VALA MS")
  field(FLNK, "B132-IOCMOTOR:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B132-IOCMOTOR:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B132-IOCMOTOR:TODCHECK.SEVR")
  field(INPB, "B132-IOCMOTOR:TODCHECK.VALB")
  field(FLNK, "B132-IOCMOTOR:TODSUM")
}

record(bo, "B132-IOCMOTOR:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B132-IOCMOTOR:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B132-IOCMOTOR:HEARTBEATCALC") {
  field(FLNK, "B132-IOCMOTOR:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B132-IOCMOTOR:HEARTBEAT CA MS")
  field(INPB, "B132-IOCMOTOR:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B132-IOCMOTOR:HEARTBEATOK") {
  field(FLNK, "B132-IOCMOTOR:HEARTBEATE01")
  field(INP, "B132-IOCMOTOR:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B132-IOCMOTOR:HEARTBEATECT") {
  field(FLNK, "B132-IOCMOTOR:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B132-IOCMOTOR:HEARTBEATE01.VAL")
  field(INPB, "B132-IOCMOTOR:HEARTBEATE02.VAL")
  field(INPC, "B132-IOCMOTOR:HEARTBEATE03.VAL")
  field(INPD, "B132-IOCMOTOR:HEARTBEATE04.VAL")
  field(INPE, "B132-IOCMOTOR:HEARTBEATE05.VAL")
  field(INPF, "B132-IOCMOTOR:HEARTBEATE06.VAL")
  field(INPG, "B132-IOCMOTOR:HEARTBEATE07.VAL")
  field(INPH, "B132-IOCMOTOR:HEARTBEATE08.VAL")
  field(INPI, "B132-IOCMOTOR:HEARTBEATE09.VAL")
  field(INPJ, "B132-IOCMOTOR:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B132-IOCMOTOR:HEARTBEATE09") {
  field(FLNK, "B132-IOCMOTOR:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B132-IOCMOTOR:HEARTBEATE08.B")
  field(INPB, "B132-IOCMOTOR:HEARTBEATE09.VAL")
}

record(calc, "B132-IOCMOTOR:HEARTBEATE08") {
  field(FLNK, "B132-IOCMOTOR:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B132-IOCMOTOR:HEARTBEATE07.B")
  field(INPB, "B132-IOCMOTOR:HEARTBEATE08.VAL")
}

record(calc, "B132-IOCMOTOR:HEARTBEATE07") {
  field(FLNK, "B132-IOCMOTOR:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B132-IOCMOTOR:HEARTBEATE06.B")
  field(INPB, "B132-IOCMOTOR:HEARTBEATE07.VAL")
}

record(calc, "B132-IOCMOTOR:HEARTBEATE06") {
  field(FLNK, "B132-IOCMOTOR:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B132-IOCMOTOR:HEARTBEATE05.B")
  field(INPB, "B132-IOCMOTOR:HEARTBEATE06.VAL")
}

record(calc, "B132-IOCMOTOR:HEARTBEATE05") {
  field(FLNK, "B132-IOCMOTOR:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B132-IOCMOTOR:HEARTBEATE04.B")
  field(INPB, "B132-IOCMOTOR:HEARTBEATE05.VAL")
}

record(calc, "B132-IOCMOTOR:HEARTBEATE04") {
  field(FLNK, "B132-IOCMOTOR:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B132-IOCMOTOR:HEARTBEATE03.B")
  field(INPB, "B132-IOCMOTOR:HEARTBEATE04.VAL")
}

record(calc, "B132-IOCMOTOR:HEARTBEATE03") {
  field(FLNK, "B132-IOCMOTOR:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B132-IOCMOTOR:HEARTBEATE02.B")
  field(INPB, "B132-IOCMOTOR:HEARTBEATE03.VAL")
}

record(calc, "B132-IOCMOTOR:HEARTBEATE02") {
  field(FLNK, "B132-IOCMOTOR:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B132-IOCMOTOR:HEARTBEATE01.B")
  field(INPB, "B132-IOCMOTOR:HEARTBEATE02.VAL")
}

record(calc, "B132-IOCMOTOR:HEARTBEATE01") {
  field(FLNK, "B132-IOCMOTOR:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B132-IOCMOTOR:HEARTBEATERR.VAL")
  field(INPB, "B132-IOCMOTOR:HEARTBEATE01.VAL")
}

record(calc, "B132-IOCMOTOR:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B132-IOCMOTOR:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B132-IOCMOTOR:HEARTBEATSUM") {
  field(FLNK, "B132-IOCMOTOR:HEARTBEATCLC")
  field(INP, "B132-IOCMOTOR:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B132-IOCMOTOR:HEARTBEATE10") {
  field(FLNK, "B132-IOCMOTOR:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B132-IOCMOTOR:HEARTBEATE09.B")
  field(INPB, "B132-IOCMOTOR:HEARTBEATE10.VAL")
}

record(calc, "B132-IOCMOTOR:HEARTBEATERR") {
  field(FLNK, "B132-IOCMOTOR:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B132-IOCMOTOR:HEARTBEATCALC.A")
  field(INPB, "B132-IOCMOTOR:HEARTBEATCALC.B")
}

record(stringin, "B132-IOCMOTOR:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocmotor")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B132-IOCMOTOR:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocmotor")
  info(autosaveFields,"VAL")
}

record(stringin, "B132-IOCMOTOR:LOC") {
  field(PINI, "YES")
  field(VAL, "B132-102-3-27")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B132-IOCCAMAC:INFO") {
  field(DESC, "B132-IOCCAMAC Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B132-IOCCAMAC:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B132-IOCCAMAC:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B132-IOCCAMAC:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B132-IOCCAMAC:TODDIFF")
}

record(longin, "B132-IOCCAMAC:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B132-IOCCAMAC:TODCHECK.VALA MS")
  field(FLNK, "B132-IOCCAMAC:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B132-IOCCAMAC:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B132-IOCCAMAC:TODCHECK.SEVR")
  field(INPB, "B132-IOCCAMAC:TODCHECK.VALB")
  field(FLNK, "B132-IOCCAMAC:TODSUM")
}

record(bo, "B132-IOCCAMAC:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B132-IOCCAMAC:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B132-IOCCAMAC:HEARTBEATCALC") {
  field(FLNK, "B132-IOCCAMAC:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B132-IOCCAMAC:HEARTBEAT CA MS")
  field(INPB, "B132-IOCCAMAC:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B132-IOCCAMAC:HEARTBEATOK") {
  field(FLNK, "B132-IOCCAMAC:HEARTBEATE01")
  field(INP, "B132-IOCCAMAC:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B132-IOCCAMAC:HEARTBEATECT") {
  field(FLNK, "B132-IOCCAMAC:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B132-IOCCAMAC:HEARTBEATE01.VAL")
  field(INPB, "B132-IOCCAMAC:HEARTBEATE02.VAL")
  field(INPC, "B132-IOCCAMAC:HEARTBEATE03.VAL")
  field(INPD, "B132-IOCCAMAC:HEARTBEATE04.VAL")
  field(INPE, "B132-IOCCAMAC:HEARTBEATE05.VAL")
  field(INPF, "B132-IOCCAMAC:HEARTBEATE06.VAL")
  field(INPG, "B132-IOCCAMAC:HEARTBEATE07.VAL")
  field(INPH, "B132-IOCCAMAC:HEARTBEATE08.VAL")
  field(INPI, "B132-IOCCAMAC:HEARTBEATE09.VAL")
  field(INPJ, "B132-IOCCAMAC:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B132-IOCCAMAC:HEARTBEATE09") {
  field(FLNK, "B132-IOCCAMAC:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B132-IOCCAMAC:HEARTBEATE08.B")
  field(INPB, "B132-IOCCAMAC:HEARTBEATE09.VAL")
}

record(calc, "B132-IOCCAMAC:HEARTBEATE08") {
  field(FLNK, "B132-IOCCAMAC:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B132-IOCCAMAC:HEARTBEATE07.B")
  field(INPB, "B132-IOCCAMAC:HEARTBEATE08.VAL")
}

record(calc, "B132-IOCCAMAC:HEARTBEATE07") {
  field(FLNK, "B132-IOCCAMAC:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B132-IOCCAMAC:HEARTBEATE06.B")
  field(INPB, "B132-IOCCAMAC:HEARTBEATE07.VAL")
}

record(calc, "B132-IOCCAMAC:HEARTBEATE06") {
  field(FLNK, "B132-IOCCAMAC:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B132-IOCCAMAC:HEARTBEATE05.B")
  field(INPB, "B132-IOCCAMAC:HEARTBEATE06.VAL")
}

record(calc, "B132-IOCCAMAC:HEARTBEATE05") {
  field(FLNK, "B132-IOCCAMAC:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B132-IOCCAMAC:HEARTBEATE04.B")
  field(INPB, "B132-IOCCAMAC:HEARTBEATE05.VAL")
}

record(calc, "B132-IOCCAMAC:HEARTBEATE04") {
  field(FLNK, "B132-IOCCAMAC:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B132-IOCCAMAC:HEARTBEATE03.B")
  field(INPB, "B132-IOCCAMAC:HEARTBEATE04.VAL")
}

record(calc, "B132-IOCCAMAC:HEARTBEATE03") {
  field(FLNK, "B132-IOCCAMAC:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B132-IOCCAMAC:HEARTBEATE02.B")
  field(INPB, "B132-IOCCAMAC:HEARTBEATE03.VAL")
}

record(calc, "B132-IOCCAMAC:HEARTBEATE02") {
  field(FLNK, "B132-IOCCAMAC:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B132-IOCCAMAC:HEARTBEATE01.B")
  field(INPB, "B132-IOCCAMAC:HEARTBEATE02.VAL")
}

record(calc, "B132-IOCCAMAC:HEARTBEATE01") {
  field(FLNK, "B132-IOCCAMAC:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B132-IOCCAMAC:HEARTBEATERR.VAL")
  field(INPB, "B132-IOCCAMAC:HEARTBEATE01.VAL")
}

record(calc, "B132-IOCCAMAC:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B132-IOCCAMAC:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B132-IOCCAMAC:HEARTBEATSUM") {
  field(FLNK, "B132-IOCCAMAC:HEARTBEATCLC")
  field(INP, "B132-IOCCAMAC:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B132-IOCCAMAC:HEARTBEATE10") {
  field(FLNK, "B132-IOCCAMAC:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B132-IOCCAMAC:HEARTBEATE09.B")
  field(INPB, "B132-IOCCAMAC:HEARTBEATE10.VAL")
}

record(calc, "B132-IOCCAMAC:HEARTBEATERR") {
  field(FLNK, "B132-IOCCAMAC:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B132-IOCCAMAC:HEARTBEATCALC.A")
  field(INPB, "B132-IOCCAMAC:HEARTBEATCALC.B")
}

record(stringin, "B132-IOCCAMAC:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "ioccam132")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B132-IOCCAMAC:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "ioccam132")
  info(autosaveFields,"VAL")
}

record(stringin, "B132-IOCCAMAC:LOC") {
  field(PINI, "YES")
  field(VAL, "B132-102-3-23")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B132-IOCRF:INFO") {
  field(DESC, "B132-IOCRF Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B132-IOCRF:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B132-IOCRF:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B132-IOCRF:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B132-IOCRF:TODDIFF")
}

record(longin, "B132-IOCRF:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B132-IOCRF:TODCHECK.VALA MS")
  field(FLNK, "B132-IOCRF:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B132-IOCRF:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B132-IOCRF:TODCHECK.SEVR")
  field(INPB, "B132-IOCRF:TODCHECK.VALB")
  field(FLNK, "B132-IOCRF:TODSUM")
}

record(bo, "B132-IOCRF:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B132-IOCRF:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B132-IOCRF:HEARTBEATCALC") {
  field(FLNK, "B132-IOCRF:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B132-IOCRF:HEARTBEAT CA MS")
  field(INPB, "B132-IOCRF:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B132-IOCRF:HEARTBEATOK") {
  field(FLNK, "B132-IOCRF:HEARTBEATE01")
  field(INP, "B132-IOCRF:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B132-IOCRF:HEARTBEATECT") {
  field(FLNK, "B132-IOCRF:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B132-IOCRF:HEARTBEATE01.VAL")
  field(INPB, "B132-IOCRF:HEARTBEATE02.VAL")
  field(INPC, "B132-IOCRF:HEARTBEATE03.VAL")
  field(INPD, "B132-IOCRF:HEARTBEATE04.VAL")
  field(INPE, "B132-IOCRF:HEARTBEATE05.VAL")
  field(INPF, "B132-IOCRF:HEARTBEATE06.VAL")
  field(INPG, "B132-IOCRF:HEARTBEATE07.VAL")
  field(INPH, "B132-IOCRF:HEARTBEATE08.VAL")
  field(INPI, "B132-IOCRF:HEARTBEATE09.VAL")
  field(INPJ, "B132-IOCRF:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B132-IOCRF:HEARTBEATE09") {
  field(FLNK, "B132-IOCRF:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B132-IOCRF:HEARTBEATE08.B")
  field(INPB, "B132-IOCRF:HEARTBEATE09.VAL")
}

record(calc, "B132-IOCRF:HEARTBEATE08") {
  field(FLNK, "B132-IOCRF:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B132-IOCRF:HEARTBEATE07.B")
  field(INPB, "B132-IOCRF:HEARTBEATE08.VAL")
}

record(calc, "B132-IOCRF:HEARTBEATE07") {
  field(FLNK, "B132-IOCRF:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B132-IOCRF:HEARTBEATE06.B")
  field(INPB, "B132-IOCRF:HEARTBEATE07.VAL")
}

record(calc, "B132-IOCRF:HEARTBEATE06") {
  field(FLNK, "B132-IOCRF:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B132-IOCRF:HEARTBEATE05.B")
  field(INPB, "B132-IOCRF:HEARTBEATE06.VAL")
}

record(calc, "B132-IOCRF:HEARTBEATE05") {
  field(FLNK, "B132-IOCRF:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B132-IOCRF:HEARTBEATE04.B")
  field(INPB, "B132-IOCRF:HEARTBEATE05.VAL")
}

record(calc, "B132-IOCRF:HEARTBEATE04") {
  field(FLNK, "B132-IOCRF:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B132-IOCRF:HEARTBEATE03.B")
  field(INPB, "B132-IOCRF:HEARTBEATE04.VAL")
}

record(calc, "B132-IOCRF:HEARTBEATE03") {
  field(FLNK, "B132-IOCRF:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B132-IOCRF:HEARTBEATE02.B")
  field(INPB, "B132-IOCRF:HEARTBEATE03.VAL")
}

record(calc, "B132-IOCRF:HEARTBEATE02") {
  field(FLNK, "B132-IOCRF:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B132-IOCRF:HEARTBEATE01.B")
  field(INPB, "B132-IOCRF:HEARTBEATE02.VAL")
}

record(calc, "B132-IOCRF:HEARTBEATE01") {
  field(FLNK, "B132-IOCRF:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B132-IOCRF:HEARTBEATERR.VAL")
  field(INPB, "B132-IOCRF:HEARTBEATE01.VAL")
}

record(calc, "B132-IOCRF:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B132-IOCRF:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B132-IOCRF:HEARTBEATSUM") {
  field(FLNK, "B132-IOCRF:HEARTBEATCLC")
  field(INP, "B132-IOCRF:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B132-IOCRF:HEARTBEATE10") {
  field(FLNK, "B132-IOCRF:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B132-IOCRF:HEARTBEATE09.B")
  field(INPB, "B132-IOCRF:HEARTBEATE10.VAL")
}

record(calc, "B132-IOCRF:HEARTBEATERR") {
  field(FLNK, "B132-IOCRF:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B132-IOCRF:HEARTBEATCALC.A")
  field(INPB, "B132-IOCRF:HEARTBEATCALC.B")
}

record(stringin, "B132-IOCRF:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocrf")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B132-IOCRF:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocrf")
  info(autosaveFields,"VAL")
}

record(stringin, "B132-IOCRF:LOC") {
  field(PINI, "YES")
  field(VAL, "B132-101-11-24")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B140-IOCLINAC1:INFO") {
  field(DESC, "B140-IOCLINAC1 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B140-IOCLINAC1:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B140-IOCLINAC1:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B140-IOCLINAC1:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B140-IOCLINAC1:TODDIFF")
}

record(longin, "B140-IOCLINAC1:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B140-IOCLINAC1:TODCHECK.VALA MS")
  field(FLNK, "B140-IOCLINAC1:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B140-IOCLINAC1:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B140-IOCLINAC1:TODCHECK.SEVR")
  field(INPB, "B140-IOCLINAC1:TODCHECK.VALB")
  field(FLNK, "B140-IOCLINAC1:TODSUM")
}

record(bo, "B140-IOCLINAC1:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B140-IOCLINAC1:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B140-IOCLINAC1:HEARTBEATCALC") {
  field(FLNK, "B140-IOCLINAC1:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B140-IOCLINAC1:HEARTBEAT CA MS")
  field(INPB, "B140-IOCLINAC1:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B140-IOCLINAC1:HEARTBEATOK") {
  field(FLNK, "B140-IOCLINAC1:HEARTBEATE01")
  field(INP, "B140-IOCLINAC1:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B140-IOCLINAC1:HEARTBEATECT") {
  field(FLNK, "B140-IOCLINAC1:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B140-IOCLINAC1:HEARTBEATE01.VAL")
  field(INPB, "B140-IOCLINAC1:HEARTBEATE02.VAL")
  field(INPC, "B140-IOCLINAC1:HEARTBEATE03.VAL")
  field(INPD, "B140-IOCLINAC1:HEARTBEATE04.VAL")
  field(INPE, "B140-IOCLINAC1:HEARTBEATE05.VAL")
  field(INPF, "B140-IOCLINAC1:HEARTBEATE06.VAL")
  field(INPG, "B140-IOCLINAC1:HEARTBEATE07.VAL")
  field(INPH, "B140-IOCLINAC1:HEARTBEATE08.VAL")
  field(INPI, "B140-IOCLINAC1:HEARTBEATE09.VAL")
  field(INPJ, "B140-IOCLINAC1:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B140-IOCLINAC1:HEARTBEATE09") {
  field(FLNK, "B140-IOCLINAC1:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B140-IOCLINAC1:HEARTBEATE08.B")
  field(INPB, "B140-IOCLINAC1:HEARTBEATE09.VAL")
}

record(calc, "B140-IOCLINAC1:HEARTBEATE08") {
  field(FLNK, "B140-IOCLINAC1:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B140-IOCLINAC1:HEARTBEATE07.B")
  field(INPB, "B140-IOCLINAC1:HEARTBEATE08.VAL")
}

record(calc, "B140-IOCLINAC1:HEARTBEATE07") {
  field(FLNK, "B140-IOCLINAC1:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B140-IOCLINAC1:HEARTBEATE06.B")
  field(INPB, "B140-IOCLINAC1:HEARTBEATE07.VAL")
}

record(calc, "B140-IOCLINAC1:HEARTBEATE06") {
  field(FLNK, "B140-IOCLINAC1:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B140-IOCLINAC1:HEARTBEATE05.B")
  field(INPB, "B140-IOCLINAC1:HEARTBEATE06.VAL")
}

record(calc, "B140-IOCLINAC1:HEARTBEATE05") {
  field(FLNK, "B140-IOCLINAC1:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B140-IOCLINAC1:HEARTBEATE04.B")
  field(INPB, "B140-IOCLINAC1:HEARTBEATE05.VAL")
}

record(calc, "B140-IOCLINAC1:HEARTBEATE04") {
  field(FLNK, "B140-IOCLINAC1:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B140-IOCLINAC1:HEARTBEATE03.B")
  field(INPB, "B140-IOCLINAC1:HEARTBEATE04.VAL")
}

record(calc, "B140-IOCLINAC1:HEARTBEATE03") {
  field(FLNK, "B140-IOCLINAC1:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B140-IOCLINAC1:HEARTBEATE02.B")
  field(INPB, "B140-IOCLINAC1:HEARTBEATE03.VAL")
}

record(calc, "B140-IOCLINAC1:HEARTBEATE02") {
  field(FLNK, "B140-IOCLINAC1:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B140-IOCLINAC1:HEARTBEATE01.B")
  field(INPB, "B140-IOCLINAC1:HEARTBEATE02.VAL")
}

record(calc, "B140-IOCLINAC1:HEARTBEATE01") {
  field(FLNK, "B140-IOCLINAC1:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B140-IOCLINAC1:HEARTBEATERR.VAL")
  field(INPB, "B140-IOCLINAC1:HEARTBEATE01.VAL")
}

record(calc, "B140-IOCLINAC1:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B140-IOCLINAC1:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B140-IOCLINAC1:HEARTBEATSUM") {
  field(FLNK, "B140-IOCLINAC1:HEARTBEATCLC")
  field(INP, "B140-IOCLINAC1:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B140-IOCLINAC1:HEARTBEATE10") {
  field(FLNK, "B140-IOCLINAC1:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B140-IOCLINAC1:HEARTBEATE09.B")
  field(INPB, "B140-IOCLINAC1:HEARTBEATE10.VAL")
}

record(calc, "B140-IOCLINAC1:HEARTBEATERR") {
  field(FLNK, "B140-IOCLINAC1:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B140-IOCLINAC1:HEARTBEATCALC.A")
  field(INPB, "B140-IOCLINAC1:HEARTBEATCALC.B")
}

record(stringin, "B140-IOCLINAC1:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "ioclinac1")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B140-IOCLINAC1:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "ioclinac1")
  info(autosaveFields,"VAL")
}

record(stringin, "B140-IOCLINAC1:LOC") {
  field(PINI, "YES")
  field(VAL, "B140-111-24")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B140-IOCBOO1:INFO") {
  field(DESC, "B140-IOCBOO1 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B140-IOCBOO1:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B140-IOCBOO1:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B140-IOCBOO1:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B140-IOCBOO1:TODDIFF")
}

record(longin, "B140-IOCBOO1:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B140-IOCBOO1:TODCHECK.VALA MS")
  field(FLNK, "B140-IOCBOO1:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B140-IOCBOO1:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B140-IOCBOO1:TODCHECK.SEVR")
  field(INPB, "B140-IOCBOO1:TODCHECK.VALB")
  field(FLNK, "B140-IOCBOO1:TODSUM")
}

record(bo, "B140-IOCBOO1:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B140-IOCBOO1:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B140-IOCBOO1:HEARTBEATCALC") {
  field(FLNK, "B140-IOCBOO1:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO1:HEARTBEAT CA MS")
  field(INPB, "B140-IOCBOO1:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B140-IOCBOO1:HEARTBEATOK") {
  field(FLNK, "B140-IOCBOO1:HEARTBEATE01")
  field(INP, "B140-IOCBOO1:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B140-IOCBOO1:HEARTBEATECT") {
  field(FLNK, "B140-IOCBOO1:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B140-IOCBOO1:HEARTBEATE01.VAL")
  field(INPB, "B140-IOCBOO1:HEARTBEATE02.VAL")
  field(INPC, "B140-IOCBOO1:HEARTBEATE03.VAL")
  field(INPD, "B140-IOCBOO1:HEARTBEATE04.VAL")
  field(INPE, "B140-IOCBOO1:HEARTBEATE05.VAL")
  field(INPF, "B140-IOCBOO1:HEARTBEATE06.VAL")
  field(INPG, "B140-IOCBOO1:HEARTBEATE07.VAL")
  field(INPH, "B140-IOCBOO1:HEARTBEATE08.VAL")
  field(INPI, "B140-IOCBOO1:HEARTBEATE09.VAL")
  field(INPJ, "B140-IOCBOO1:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B140-IOCBOO1:HEARTBEATE09") {
  field(FLNK, "B140-IOCBOO1:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO1:HEARTBEATE08.B")
  field(INPB, "B140-IOCBOO1:HEARTBEATE09.VAL")
}

record(calc, "B140-IOCBOO1:HEARTBEATE08") {
  field(FLNK, "B140-IOCBOO1:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO1:HEARTBEATE07.B")
  field(INPB, "B140-IOCBOO1:HEARTBEATE08.VAL")
}

record(calc, "B140-IOCBOO1:HEARTBEATE07") {
  field(FLNK, "B140-IOCBOO1:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO1:HEARTBEATE06.B")
  field(INPB, "B140-IOCBOO1:HEARTBEATE07.VAL")
}

record(calc, "B140-IOCBOO1:HEARTBEATE06") {
  field(FLNK, "B140-IOCBOO1:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO1:HEARTBEATE05.B")
  field(INPB, "B140-IOCBOO1:HEARTBEATE06.VAL")
}

record(calc, "B140-IOCBOO1:HEARTBEATE05") {
  field(FLNK, "B140-IOCBOO1:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO1:HEARTBEATE04.B")
  field(INPB, "B140-IOCBOO1:HEARTBEATE05.VAL")
}

record(calc, "B140-IOCBOO1:HEARTBEATE04") {
  field(FLNK, "B140-IOCBOO1:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO1:HEARTBEATE03.B")
  field(INPB, "B140-IOCBOO1:HEARTBEATE04.VAL")
}

record(calc, "B140-IOCBOO1:HEARTBEATE03") {
  field(FLNK, "B140-IOCBOO1:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO1:HEARTBEATE02.B")
  field(INPB, "B140-IOCBOO1:HEARTBEATE03.VAL")
}

record(calc, "B140-IOCBOO1:HEARTBEATE02") {
  field(FLNK, "B140-IOCBOO1:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO1:HEARTBEATE01.B")
  field(INPB, "B140-IOCBOO1:HEARTBEATE02.VAL")
}

record(calc, "B140-IOCBOO1:HEARTBEATE01") {
  field(FLNK, "B140-IOCBOO1:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO1:HEARTBEATERR.VAL")
  field(INPB, "B140-IOCBOO1:HEARTBEATE01.VAL")
}

record(calc, "B140-IOCBOO1:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B140-IOCBOO1:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B140-IOCBOO1:HEARTBEATSUM") {
  field(FLNK, "B140-IOCBOO1:HEARTBEATCLC")
  field(INP, "B140-IOCBOO1:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B140-IOCBOO1:HEARTBEATE10") {
  field(FLNK, "B140-IOCBOO1:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO1:HEARTBEATE09.B")
  field(INPB, "B140-IOCBOO1:HEARTBEATE10.VAL")
}

record(calc, "B140-IOCBOO1:HEARTBEATERR") {
  field(FLNK, "B140-IOCBOO1:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B140-IOCBOO1:HEARTBEATCALC.A")
  field(INPB, "B140-IOCBOO1:HEARTBEATCALC.B")
}

record(stringin, "B140-IOCBOO1:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocboo")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B140-IOCBOO1:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocboo")
  info(autosaveFields,"VAL")
}

record(stringin, "B140-IOCBOO1:LOC") {
  field(PINI, "YES")
  field(VAL, "B140-321-20")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B140-IOCBOO2:INFO") {
  field(DESC, "B140-IOCBOO2 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B140-IOCBOO2:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B140-IOCBOO2:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B140-IOCBOO2:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B140-IOCBOO2:TODDIFF")
}

record(longin, "B140-IOCBOO2:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B140-IOCBOO2:TODCHECK.VALA MS")
  field(FLNK, "B140-IOCBOO2:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B140-IOCBOO2:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B140-IOCBOO2:TODCHECK.SEVR")
  field(INPB, "B140-IOCBOO2:TODCHECK.VALB")
  field(FLNK, "B140-IOCBOO2:TODSUM")
}

record(bo, "B140-IOCBOO2:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B140-IOCBOO2:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B140-IOCBOO2:HEARTBEATCALC") {
  field(FLNK, "B140-IOCBOO2:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO2:HEARTBEAT CA MS")
  field(INPB, "B140-IOCBOO2:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B140-IOCBOO2:HEARTBEATOK") {
  field(FLNK, "B140-IOCBOO2:HEARTBEATE01")
  field(INP, "B140-IOCBOO2:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B140-IOCBOO2:HEARTBEATECT") {
  field(FLNK, "B140-IOCBOO2:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B140-IOCBOO2:HEARTBEATE01.VAL")
  field(INPB, "B140-IOCBOO2:HEARTBEATE02.VAL")
  field(INPC, "B140-IOCBOO2:HEARTBEATE03.VAL")
  field(INPD, "B140-IOCBOO2:HEARTBEATE04.VAL")
  field(INPE, "B140-IOCBOO2:HEARTBEATE05.VAL")
  field(INPF, "B140-IOCBOO2:HEARTBEATE06.VAL")
  field(INPG, "B140-IOCBOO2:HEARTBEATE07.VAL")
  field(INPH, "B140-IOCBOO2:HEARTBEATE08.VAL")
  field(INPI, "B140-IOCBOO2:HEARTBEATE09.VAL")
  field(INPJ, "B140-IOCBOO2:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B140-IOCBOO2:HEARTBEATE09") {
  field(FLNK, "B140-IOCBOO2:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO2:HEARTBEATE08.B")
  field(INPB, "B140-IOCBOO2:HEARTBEATE09.VAL")
}

record(calc, "B140-IOCBOO2:HEARTBEATE08") {
  field(FLNK, "B140-IOCBOO2:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO2:HEARTBEATE07.B")
  field(INPB, "B140-IOCBOO2:HEARTBEATE08.VAL")
}

record(calc, "B140-IOCBOO2:HEARTBEATE07") {
  field(FLNK, "B140-IOCBOO2:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO2:HEARTBEATE06.B")
  field(INPB, "B140-IOCBOO2:HEARTBEATE07.VAL")
}

record(calc, "B140-IOCBOO2:HEARTBEATE06") {
  field(FLNK, "B140-IOCBOO2:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO2:HEARTBEATE05.B")
  field(INPB, "B140-IOCBOO2:HEARTBEATE06.VAL")
}

record(calc, "B140-IOCBOO2:HEARTBEATE05") {
  field(FLNK, "B140-IOCBOO2:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO2:HEARTBEATE04.B")
  field(INPB, "B140-IOCBOO2:HEARTBEATE05.VAL")
}

record(calc, "B140-IOCBOO2:HEARTBEATE04") {
  field(FLNK, "B140-IOCBOO2:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO2:HEARTBEATE03.B")
  field(INPB, "B140-IOCBOO2:HEARTBEATE04.VAL")
}

record(calc, "B140-IOCBOO2:HEARTBEATE03") {
  field(FLNK, "B140-IOCBOO2:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO2:HEARTBEATE02.B")
  field(INPB, "B140-IOCBOO2:HEARTBEATE03.VAL")
}

record(calc, "B140-IOCBOO2:HEARTBEATE02") {
  field(FLNK, "B140-IOCBOO2:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO2:HEARTBEATE01.B")
  field(INPB, "B140-IOCBOO2:HEARTBEATE02.VAL")
}

record(calc, "B140-IOCBOO2:HEARTBEATE01") {
  field(FLNK, "B140-IOCBOO2:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO2:HEARTBEATERR.VAL")
  field(INPB, "B140-IOCBOO2:HEARTBEATE01.VAL")
}

record(calc, "B140-IOCBOO2:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B140-IOCBOO2:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B140-IOCBOO2:HEARTBEATSUM") {
  field(FLNK, "B140-IOCBOO2:HEARTBEATCLC")
  field(INP, "B140-IOCBOO2:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B140-IOCBOO2:HEARTBEATE10") {
  field(FLNK, "B140-IOCBOO2:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B140-IOCBOO2:HEARTBEATE09.B")
  field(INPB, "B140-IOCBOO2:HEARTBEATE10.VAL")
}

record(calc, "B140-IOCBOO2:HEARTBEATERR") {
  field(FLNK, "B140-IOCBOO2:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B140-IOCBOO2:HEARTBEATCALC.A")
  field(INPB, "B140-IOCBOO2:HEARTBEATCALC.B")
}

record(stringin, "B140-IOCBOO2:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocboo2")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B140-IOCBOO2:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocboo2")
  info(autosaveFields,"VAL")
}

record(stringin, "B140-IOCBOO2:LOC") {
  field(PINI, "YES")
  field(VAL, "B140-321-20")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B140-IOCBPM2:INFO") {
  field(DESC, "B140-IOCBPM2 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B140-IOCBPM2:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B140-IOCBPM2:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B140-IOCBPM2:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B140-IOCBPM2:TODDIFF")
}

record(longin, "B140-IOCBPM2:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B140-IOCBPM2:TODCHECK.VALA MS")
  field(FLNK, "B140-IOCBPM2:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B140-IOCBPM2:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B140-IOCBPM2:TODCHECK.SEVR")
  field(INPB, "B140-IOCBPM2:TODCHECK.VALB")
  field(FLNK, "B140-IOCBPM2:TODSUM")
}

record(bo, "B140-IOCBPM2:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B140-IOCBPM2:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B140-IOCBPM2:HEARTBEATCALC") {
  field(FLNK, "B140-IOCBPM2:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM2:HEARTBEAT CA MS")
  field(INPB, "B140-IOCBPM2:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B140-IOCBPM2:HEARTBEATOK") {
  field(FLNK, "B140-IOCBPM2:HEARTBEATE01")
  field(INP, "B140-IOCBPM2:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B140-IOCBPM2:HEARTBEATECT") {
  field(FLNK, "B140-IOCBPM2:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B140-IOCBPM2:HEARTBEATE01.VAL")
  field(INPB, "B140-IOCBPM2:HEARTBEATE02.VAL")
  field(INPC, "B140-IOCBPM2:HEARTBEATE03.VAL")
  field(INPD, "B140-IOCBPM2:HEARTBEATE04.VAL")
  field(INPE, "B140-IOCBPM2:HEARTBEATE05.VAL")
  field(INPF, "B140-IOCBPM2:HEARTBEATE06.VAL")
  field(INPG, "B140-IOCBPM2:HEARTBEATE07.VAL")
  field(INPH, "B140-IOCBPM2:HEARTBEATE08.VAL")
  field(INPI, "B140-IOCBPM2:HEARTBEATE09.VAL")
  field(INPJ, "B140-IOCBPM2:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B140-IOCBPM2:HEARTBEATE09") {
  field(FLNK, "B140-IOCBPM2:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM2:HEARTBEATE08.B")
  field(INPB, "B140-IOCBPM2:HEARTBEATE09.VAL")
}

record(calc, "B140-IOCBPM2:HEARTBEATE08") {
  field(FLNK, "B140-IOCBPM2:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM2:HEARTBEATE07.B")
  field(INPB, "B140-IOCBPM2:HEARTBEATE08.VAL")
}

record(calc, "B140-IOCBPM2:HEARTBEATE07") {
  field(FLNK, "B140-IOCBPM2:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM2:HEARTBEATE06.B")
  field(INPB, "B140-IOCBPM2:HEARTBEATE07.VAL")
}

record(calc, "B140-IOCBPM2:HEARTBEATE06") {
  field(FLNK, "B140-IOCBPM2:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM2:HEARTBEATE05.B")
  field(INPB, "B140-IOCBPM2:HEARTBEATE06.VAL")
}

record(calc, "B140-IOCBPM2:HEARTBEATE05") {
  field(FLNK, "B140-IOCBPM2:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM2:HEARTBEATE04.B")
  field(INPB, "B140-IOCBPM2:HEARTBEATE05.VAL")
}

record(calc, "B140-IOCBPM2:HEARTBEATE04") {
  field(FLNK, "B140-IOCBPM2:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM2:HEARTBEATE03.B")
  field(INPB, "B140-IOCBPM2:HEARTBEATE04.VAL")
}

record(calc, "B140-IOCBPM2:HEARTBEATE03") {
  field(FLNK, "B140-IOCBPM2:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM2:HEARTBEATE02.B")
  field(INPB, "B140-IOCBPM2:HEARTBEATE03.VAL")
}

record(calc, "B140-IOCBPM2:HEARTBEATE02") {
  field(FLNK, "B140-IOCBPM2:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM2:HEARTBEATE01.B")
  field(INPB, "B140-IOCBPM2:HEARTBEATE02.VAL")
}

record(calc, "B140-IOCBPM2:HEARTBEATE01") {
  field(FLNK, "B140-IOCBPM2:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM2:HEARTBEATERR.VAL")
  field(INPB, "B140-IOCBPM2:HEARTBEATE01.VAL")
}

record(calc, "B140-IOCBPM2:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B140-IOCBPM2:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B140-IOCBPM2:HEARTBEATSUM") {
  field(FLNK, "B140-IOCBPM2:HEARTBEATCLC")
  field(INP, "B140-IOCBPM2:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B140-IOCBPM2:HEARTBEATE10") {
  field(FLNK, "B140-IOCBPM2:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM2:HEARTBEATE09.B")
  field(INPB, "B140-IOCBPM2:HEARTBEATE10.VAL")
}

record(calc, "B140-IOCBPM2:HEARTBEATERR") {
  field(FLNK, "B140-IOCBPM2:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B140-IOCBPM2:HEARTBEATCALC.A")
  field(INPB, "B140-IOCBPM2:HEARTBEATCALC.B")
}

record(stringin, "B140-IOCBPM2:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocbpm2")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B140-IOCBPM2:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocbpm2")
  info(autosaveFields,"VAL")
}

record(stringin, "B140-IOCBPM2:LOC") {
  field(PINI, "YES")
  field(VAL, "B140-321-20")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "B140-IOCBPM:INFO") {
  field(DESC, "B140-IOCBPM Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "B140-IOCBPM:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "B140-IOCBPM:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "B140-IOCBPM:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "B140-IOCBPM:TODDIFF")
}

record(longin, "B140-IOCBPM:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "B140-IOCBPM:TODCHECK.VALA MS")
  field(FLNK, "B140-IOCBPM:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "B140-IOCBPM:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "B140-IOCBPM:TODCHECK.SEVR")
  field(INPB, "B140-IOCBPM:TODCHECK.VALB")
  field(FLNK, "B140-IOCBPM:TODSUM")
}

record(bo, "B140-IOCBPM:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "B140-IOCBPM:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "B140-IOCBPM:HEARTBEATCALC") {
  field(FLNK, "B140-IOCBPM:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM:HEARTBEAT CA MS")
  field(INPB, "B140-IOCBPM:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "B140-IOCBPM:HEARTBEATOK") {
  field(FLNK, "B140-IOCBPM:HEARTBEATE01")
  field(INP, "B140-IOCBPM:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "B140-IOCBPM:HEARTBEATECT") {
  field(FLNK, "B140-IOCBPM:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "B140-IOCBPM:HEARTBEATE01.VAL")
  field(INPB, "B140-IOCBPM:HEARTBEATE02.VAL")
  field(INPC, "B140-IOCBPM:HEARTBEATE03.VAL")
  field(INPD, "B140-IOCBPM:HEARTBEATE04.VAL")
  field(INPE, "B140-IOCBPM:HEARTBEATE05.VAL")
  field(INPF, "B140-IOCBPM:HEARTBEATE06.VAL")
  field(INPG, "B140-IOCBPM:HEARTBEATE07.VAL")
  field(INPH, "B140-IOCBPM:HEARTBEATE08.VAL")
  field(INPI, "B140-IOCBPM:HEARTBEATE09.VAL")
  field(INPJ, "B140-IOCBPM:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "B140-IOCBPM:HEARTBEATE09") {
  field(FLNK, "B140-IOCBPM:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM:HEARTBEATE08.B")
  field(INPB, "B140-IOCBPM:HEARTBEATE09.VAL")
}

record(calc, "B140-IOCBPM:HEARTBEATE08") {
  field(FLNK, "B140-IOCBPM:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM:HEARTBEATE07.B")
  field(INPB, "B140-IOCBPM:HEARTBEATE08.VAL")
}

record(calc, "B140-IOCBPM:HEARTBEATE07") {
  field(FLNK, "B140-IOCBPM:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM:HEARTBEATE06.B")
  field(INPB, "B140-IOCBPM:HEARTBEATE07.VAL")
}

record(calc, "B140-IOCBPM:HEARTBEATE06") {
  field(FLNK, "B140-IOCBPM:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM:HEARTBEATE05.B")
  field(INPB, "B140-IOCBPM:HEARTBEATE06.VAL")
}

record(calc, "B140-IOCBPM:HEARTBEATE05") {
  field(FLNK, "B140-IOCBPM:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM:HEARTBEATE04.B")
  field(INPB, "B140-IOCBPM:HEARTBEATE05.VAL")
}

record(calc, "B140-IOCBPM:HEARTBEATE04") {
  field(FLNK, "B140-IOCBPM:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM:HEARTBEATE03.B")
  field(INPB, "B140-IOCBPM:HEARTBEATE04.VAL")
}

record(calc, "B140-IOCBPM:HEARTBEATE03") {
  field(FLNK, "B140-IOCBPM:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM:HEARTBEATE02.B")
  field(INPB, "B140-IOCBPM:HEARTBEATE03.VAL")
}

record(calc, "B140-IOCBPM:HEARTBEATE02") {
  field(FLNK, "B140-IOCBPM:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM:HEARTBEATE01.B")
  field(INPB, "B140-IOCBPM:HEARTBEATE02.VAL")
}

record(calc, "B140-IOCBPM:HEARTBEATE01") {
  field(FLNK, "B140-IOCBPM:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM:HEARTBEATERR.VAL")
  field(INPB, "B140-IOCBPM:HEARTBEATE01.VAL")
}

record(calc, "B140-IOCBPM:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "B140-IOCBPM:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "B140-IOCBPM:HEARTBEATSUM") {
  field(FLNK, "B140-IOCBPM:HEARTBEATCLC")
  field(INP, "B140-IOCBPM:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "B140-IOCBPM:HEARTBEATE10") {
  field(FLNK, "B140-IOCBPM:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "B140-IOCBPM:HEARTBEATE09.B")
  field(INPB, "B140-IOCBPM:HEARTBEATE10.VAL")
}

record(calc, "B140-IOCBPM:HEARTBEATERR") {
  field(FLNK, "B140-IOCBPM:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "B140-IOCBPM:HEARTBEATCALC.A")
  field(INPB, "B140-IOCBPM:HEARTBEATCALC.B")
}

record(stringin, "B140-IOCBPM:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocbpm")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "B140-IOCBPM:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocbpm")
  info(autosaveFields,"VAL")
}

record(stringin, "B140-IOCBPM:LOC") {
  field(PINI, "YES")
  field(VAL, "B140-106-20")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCMGR:INFO") {
  field(DESC, "SOFT-IOCMGR Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMGR:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCMGR:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCMGR:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCMGR:TODDIFF")
}

record(longin, "SOFT-IOCMGR:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCMGR:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCMGR:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCMGR:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCMGR:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCMGR:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCMGR:TODSUM")
}

record(bo, "SOFT-IOCMGR:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCMGR:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCMGR:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCMGR:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCMGR:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCMGR:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCMGR:HEARTBEATE01")
  field(INP, "SOFT-IOCMGR:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCMGR:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCMGR:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCMGR:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCMGR:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCMGR:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCMGR:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCMGR:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCMGR:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCMGR:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCMGR:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCMGR:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCMGR:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCMGR:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCMGR:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCMGR:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCMGR:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCMGR:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCMGR:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCMGR:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCMGR:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCMGR:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCMGR:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCMGR:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCMGR:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCMGR:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCMGR:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCMGR:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCMGR:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCMGR:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCMGR:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCMGR:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCMGR:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCMGR:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCMGR:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCMGR:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCMGR:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCMGR:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCMGR:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCMGR:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCMGR:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCMGR:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCMGR:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCMGR:HEARTBEATCLC")
  field(INP, "SOFT-IOCMGR:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCMGR:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCMGR:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCMGR:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCMGR:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCMGR:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCMGR:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCMGR:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCMGR:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocmgr")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCMGR:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocmgr")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMGR:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCWSNMP:INFO") {
  field(DESC, "SOFT-IOCWSNMP Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCWSNMP:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCWSNMP:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCWSNMP:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCWSNMP:TODDIFF")
}

record(longin, "SOFT-IOCWSNMP:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCWSNMP:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCWSNMP:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCWSNMP:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCWSNMP:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCWSNMP:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCWSNMP:TODSUM")
}

record(bo, "SOFT-IOCWSNMP:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCWSNMP:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCWSNMP:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCWSNMP:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCWSNMP:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCWSNMP:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCWSNMP:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCWSNMP:HEARTBEATE01")
  field(INP, "SOFT-IOCWSNMP:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCWSNMP:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCWSNMP:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCWSNMP:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCWSNMP:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCWSNMP:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCWSNMP:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCWSNMP:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCWSNMP:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCWSNMP:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCWSNMP:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCWSNMP:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCWSNMP:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCWSNMP:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCWSNMP:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCWSNMP:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCWSNMP:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCWSNMP:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCWSNMP:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCWSNMP:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCWSNMP:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCWSNMP:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCWSNMP:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCWSNMP:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCWSNMP:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCWSNMP:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCWSNMP:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCWSNMP:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCWSNMP:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCWSNMP:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCWSNMP:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCWSNMP:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCWSNMP:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCWSNMP:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCWSNMP:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCWSNMP:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCWSNMP:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCWSNMP:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCWSNMP:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCWSNMP:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCWSNMP:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCWSNMP:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCWSNMP:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCWSNMP:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCWSNMP:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCWSNMP:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCWSNMP:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCWSNMP:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCWSNMP:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCWSNMP:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCWSNMP:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCWSNMP:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCWSNMP:HEARTBEATCLC")
  field(INP, "SOFT-IOCWSNMP:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCWSNMP:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCWSNMP:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCWSNMP:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCWSNMP:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCWSNMP:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCWSNMP:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCWSNMP:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCWSNMP:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCWSNMP:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocwsnmp")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCWSNMP:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocwsnmp")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCWSNMP:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCFACSNMP:INFO") {
  field(DESC, "SOFT-IOCFACSNMP Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCFACSNMP:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCFACSNMP:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCFACSNMP:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCFACSNMP:TODDIFF")
}

record(longin, "SOFT-IOCFACSNMP:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCFACSNMP:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCFACSNMP:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCFACSNMP:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCFACSNMP:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCFACSNMP:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCFACSNMP:TODSUM")
}

record(bo, "SOFT-IOCFACSNMP:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCFACSNMP:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCFACSNMP:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCFACSNMP:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFACSNMP:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCFACSNMP:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCFACSNMP:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCFACSNMP:HEARTBEATE01")
  field(INP, "SOFT-IOCFACSNMP:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCFACSNMP:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCFACSNMP:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCFACSNMP:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCFACSNMP:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCFACSNMP:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCFACSNMP:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCFACSNMP:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCFACSNMP:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCFACSNMP:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCFACSNMP:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCFACSNMP:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCFACSNMP:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCFACSNMP:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCFACSNMP:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFACSNMP:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCFACSNMP:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCFACSNMP:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCFACSNMP:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFACSNMP:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCFACSNMP:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCFACSNMP:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCFACSNMP:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFACSNMP:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCFACSNMP:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCFACSNMP:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCFACSNMP:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFACSNMP:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCFACSNMP:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCFACSNMP:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCFACSNMP:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFACSNMP:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCFACSNMP:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCFACSNMP:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCFACSNMP:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFACSNMP:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCFACSNMP:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCFACSNMP:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCFACSNMP:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFACSNMP:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCFACSNMP:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCFACSNMP:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCFACSNMP:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFACSNMP:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCFACSNMP:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCFACSNMP:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCFACSNMP:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFACSNMP:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCFACSNMP:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCFACSNMP:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCFACSNMP:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCFACSNMP:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCFACSNMP:HEARTBEATCLC")
  field(INP, "SOFT-IOCFACSNMP:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCFACSNMP:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCFACSNMP:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFACSNMP:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCFACSNMP:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCFACSNMP:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCFACSNMP:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCFACSNMP:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCFACSNMP:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCFACSNMP:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocfacsnmp")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCFACSNMP:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocfacsnmp")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCFACSNMP:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCSRVSNMP:INFO") {
  field(DESC, "SOFT-IOCSRVSNMP Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCSRVSNMP:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCSRVSNMP:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCSRVSNMP:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCSRVSNMP:TODDIFF")
}

record(longin, "SOFT-IOCSRVSNMP:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCSRVSNMP:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCSRVSNMP:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCSRVSNMP:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCSRVSNMP:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCSRVSNMP:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCSRVSNMP:TODSUM")
}

record(bo, "SOFT-IOCSRVSNMP:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCSRVSNMP:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCSRVSNMP:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCSRVSNMP:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSRVSNMP:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCSRVSNMP:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCSRVSNMP:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCSRVSNMP:HEARTBEATE01")
  field(INP, "SOFT-IOCSRVSNMP:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCSRVSNMP:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCSRVSNMP:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCSRVSNMP:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCSRVSNMP:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCSRVSNMP:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCSRVSNMP:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCSRVSNMP:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCSRVSNMP:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCSRVSNMP:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCSRVSNMP:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCSRVSNMP:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCSRVSNMP:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCSRVSNMP:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCSRVSNMP:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSRVSNMP:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCSRVSNMP:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCSRVSNMP:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCSRVSNMP:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSRVSNMP:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCSRVSNMP:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCSRVSNMP:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCSRVSNMP:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSRVSNMP:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCSRVSNMP:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCSRVSNMP:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCSRVSNMP:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSRVSNMP:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCSRVSNMP:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCSRVSNMP:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCSRVSNMP:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSRVSNMP:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCSRVSNMP:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCSRVSNMP:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCSRVSNMP:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSRVSNMP:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCSRVSNMP:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCSRVSNMP:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCSRVSNMP:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSRVSNMP:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCSRVSNMP:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCSRVSNMP:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCSRVSNMP:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSRVSNMP:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCSRVSNMP:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCSRVSNMP:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCSRVSNMP:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSRVSNMP:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCSRVSNMP:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCSRVSNMP:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCSRVSNMP:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCSRVSNMP:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCSRVSNMP:HEARTBEATCLC")
  field(INP, "SOFT-IOCSRVSNMP:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCSRVSNMP:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCSRVSNMP:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSRVSNMP:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCSRVSNMP:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCSRVSNMP:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCSRVSNMP:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCSRVSNMP:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCSRVSNMP:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCSRVSNMP:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocsrvsnmp")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCSRVSNMP:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocsrvsnmp")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCSRVSNMP:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCB132MOTOR:INFO") {
  field(DESC, "SOFT-IOCB132MOTOR Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCB132MOTOR:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCB132MOTOR:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCB132MOTOR:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCB132MOTOR:TODDIFF")
}

record(longin, "SOFT-IOCB132MOTOR:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCB132MOTOR:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCB132MOTOR:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCB132MOTOR:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCB132MOTOR:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCB132MOTOR:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCB132MOTOR:TODSUM")
}

record(bo, "SOFT-IOCB132MOTOR:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCB132MOTOR:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCB132MOTOR:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCB132MOTOR:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCB132MOTOR:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCB132MOTOR:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCB132MOTOR:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCB132MOTOR:HEARTBEATE01")
  field(INP, "SOFT-IOCB132MOTOR:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCB132MOTOR:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCB132MOTOR:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCB132MOTOR:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCB132MOTOR:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCB132MOTOR:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCB132MOTOR:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCB132MOTOR:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCB132MOTOR:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCB132MOTOR:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCB132MOTOR:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCB132MOTOR:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCB132MOTOR:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCB132MOTOR:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCB132MOTOR:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCB132MOTOR:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCB132MOTOR:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCB132MOTOR:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCB132MOTOR:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCB132MOTOR:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCB132MOTOR:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCB132MOTOR:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCB132MOTOR:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCB132MOTOR:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCB132MOTOR:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCB132MOTOR:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCB132MOTOR:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCB132MOTOR:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCB132MOTOR:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCB132MOTOR:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCB132MOTOR:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCB132MOTOR:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCB132MOTOR:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCB132MOTOR:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCB132MOTOR:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCB132MOTOR:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCB132MOTOR:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCB132MOTOR:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCB132MOTOR:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCB132MOTOR:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCB132MOTOR:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCB132MOTOR:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCB132MOTOR:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCB132MOTOR:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCB132MOTOR:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCB132MOTOR:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCB132MOTOR:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCB132MOTOR:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCB132MOTOR:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCB132MOTOR:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCB132MOTOR:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCB132MOTOR:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCB132MOTOR:HEARTBEATCLC")
  field(INP, "SOFT-IOCB132MOTOR:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCB132MOTOR:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCB132MOTOR:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCB132MOTOR:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCB132MOTOR:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCB132MOTOR:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCB132MOTOR:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCB132MOTOR:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCB132MOTOR:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCB132MOTOR:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCB132MOTOR:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCB132MOTOR:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCBLMMGR:INFO") {
  field(DESC, "SOFT-IOCBLMMGR Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCBLMMGR:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCBLMMGR:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCBLMMGR:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCBLMMGR:TODDIFF")
}

record(longin, "SOFT-IOCBLMMGR:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCBLMMGR:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCBLMMGR:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCBLMMGR:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCBLMMGR:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCBLMMGR:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCBLMMGR:TODSUM")
}

record(bo, "SOFT-IOCBLMMGR:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCBLMMGR:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCBLMMGR:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCBLMMGR:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBLMMGR:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCBLMMGR:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCBLMMGR:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCBLMMGR:HEARTBEATE01")
  field(INP, "SOFT-IOCBLMMGR:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCBLMMGR:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCBLMMGR:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCBLMMGR:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCBLMMGR:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCBLMMGR:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCBLMMGR:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCBLMMGR:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCBLMMGR:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCBLMMGR:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCBLMMGR:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCBLMMGR:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCBLMMGR:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCBLMMGR:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCBLMMGR:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBLMMGR:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCBLMMGR:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCBLMMGR:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCBLMMGR:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBLMMGR:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCBLMMGR:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCBLMMGR:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCBLMMGR:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBLMMGR:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCBLMMGR:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCBLMMGR:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCBLMMGR:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBLMMGR:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCBLMMGR:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCBLMMGR:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCBLMMGR:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBLMMGR:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCBLMMGR:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCBLMMGR:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCBLMMGR:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBLMMGR:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCBLMMGR:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCBLMMGR:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCBLMMGR:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBLMMGR:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCBLMMGR:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCBLMMGR:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCBLMMGR:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBLMMGR:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCBLMMGR:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCBLMMGR:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCBLMMGR:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBLMMGR:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCBLMMGR:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCBLMMGR:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCBLMMGR:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCBLMMGR:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCBLMMGR:HEARTBEATCLC")
  field(INP, "SOFT-IOCBLMMGR:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCBLMMGR:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCBLMMGR:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBLMMGR:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCBLMMGR:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCBLMMGR:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCBLMMGR:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCBLMMGR:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCBLMMGR:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCBLMMGR:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocblmmgr")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCBLMMGR:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocblmmgr")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCBLMMGR:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCBPMMGR:INFO") {
  field(DESC, "SOFT-IOCBPMMGR Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCBPMMGR:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCBPMMGR:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCBPMMGR:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCBPMMGR:TODDIFF")
}

record(longin, "SOFT-IOCBPMMGR:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCBPMMGR:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCBPMMGR:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCBPMMGR:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCBPMMGR:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCBPMMGR:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCBPMMGR:TODSUM")
}

record(bo, "SOFT-IOCBPMMGR:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCBPMMGR:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCBPMMGR:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCBPMMGR:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMMGR:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCBPMMGR:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCBPMMGR:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCBPMMGR:HEARTBEATE01")
  field(INP, "SOFT-IOCBPMMGR:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCBPMMGR:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCBPMMGR:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCBPMMGR:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCBPMMGR:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCBPMMGR:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCBPMMGR:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCBPMMGR:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCBPMMGR:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCBPMMGR:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCBPMMGR:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCBPMMGR:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCBPMMGR:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCBPMMGR:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCBPMMGR:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMMGR:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCBPMMGR:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCBPMMGR:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCBPMMGR:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMMGR:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCBPMMGR:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCBPMMGR:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCBPMMGR:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMMGR:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCBPMMGR:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCBPMMGR:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCBPMMGR:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMMGR:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCBPMMGR:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCBPMMGR:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCBPMMGR:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMMGR:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCBPMMGR:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCBPMMGR:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCBPMMGR:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMMGR:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCBPMMGR:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCBPMMGR:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCBPMMGR:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMMGR:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCBPMMGR:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCBPMMGR:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCBPMMGR:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMMGR:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCBPMMGR:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCBPMMGR:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCBPMMGR:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMMGR:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCBPMMGR:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCBPMMGR:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCBPMMGR:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCBPMMGR:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCBPMMGR:HEARTBEATCLC")
  field(INP, "SOFT-IOCBPMMGR:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCBPMMGR:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCBPMMGR:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMMGR:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCBPMMGR:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCBPMMGR:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCBPMMGR:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCBPMMGR:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCBPMMGR:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCBPMMGR:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocbpmmgr")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCBPMMGR:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocbpmmgr")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCBPMMGR:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCALH-AL00:INFO") {
  field(DESC, "SOFT-IOCALH-AL00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-AL00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCALH-AL00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCALH-AL00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCALH-AL00:TODDIFF")
}

record(longin, "SOFT-IOCALH-AL00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCALH-AL00:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCALH-AL00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCALH-AL00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCALH-AL00:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCALH-AL00:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCALH-AL00:TODSUM")
}

record(bo, "SOFT-IOCALH-AL00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCALH-AL00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCALH-AL00:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCALH-AL00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-AL00:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCALH-AL00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCALH-AL00:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCALH-AL00:HEARTBEATE01")
  field(INP, "SOFT-IOCALH-AL00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCALH-AL00:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCALH-AL00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCALH-AL00:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCALH-AL00:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCALH-AL00:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCALH-AL00:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCALH-AL00:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCALH-AL00:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCALH-AL00:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCALH-AL00:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCALH-AL00:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCALH-AL00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCALH-AL00:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCALH-AL00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-AL00:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCALH-AL00:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCALH-AL00:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCALH-AL00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-AL00:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCALH-AL00:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCALH-AL00:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCALH-AL00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-AL00:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCALH-AL00:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCALH-AL00:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCALH-AL00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-AL00:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCALH-AL00:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCALH-AL00:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCALH-AL00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-AL00:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCALH-AL00:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCALH-AL00:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCALH-AL00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-AL00:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCALH-AL00:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCALH-AL00:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCALH-AL00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-AL00:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCALH-AL00:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCALH-AL00:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCALH-AL00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-AL00:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCALH-AL00:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCALH-AL00:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCALH-AL00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-AL00:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCALH-AL00:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCALH-AL00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCALH-AL00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCALH-AL00:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCALH-AL00:HEARTBEATCLC")
  field(INP, "SOFT-IOCALH-AL00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCALH-AL00:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCALH-AL00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-AL00:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCALH-AL00:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCALH-AL00:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCALH-AL00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCALH-AL00:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCALH-AL00:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCALH-AL00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCALH-AL00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-AL00:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCALH-NTWK00:INFO") {
  field(DESC, "SOFT-IOCALH-NTWK00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-NTWK00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCALH-NTWK00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCALH-NTWK00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCALH-NTWK00:TODDIFF")
}

record(longin, "SOFT-IOCALH-NTWK00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCALH-NTWK00:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCALH-NTWK00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCALH-NTWK00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCALH-NTWK00:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCALH-NTWK00:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCALH-NTWK00:TODSUM")
}

record(bo, "SOFT-IOCALH-NTWK00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCALH-NTWK00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCALH-NTWK00:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCALH-NTWK00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-NTWK00:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCALH-NTWK00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCALH-NTWK00:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCALH-NTWK00:HEARTBEATE01")
  field(INP, "SOFT-IOCALH-NTWK00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCALH-NTWK00:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCALH-NTWK00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCALH-NTWK00:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCALH-NTWK00:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCALH-NTWK00:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCALH-NTWK00:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCALH-NTWK00:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCALH-NTWK00:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCALH-NTWK00:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCALH-NTWK00:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCALH-NTWK00:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCALH-NTWK00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCALH-NTWK00:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCALH-NTWK00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-NTWK00:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCALH-NTWK00:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCALH-NTWK00:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCALH-NTWK00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-NTWK00:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCALH-NTWK00:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCALH-NTWK00:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCALH-NTWK00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-NTWK00:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCALH-NTWK00:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCALH-NTWK00:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCALH-NTWK00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-NTWK00:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCALH-NTWK00:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCALH-NTWK00:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCALH-NTWK00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-NTWK00:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCALH-NTWK00:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCALH-NTWK00:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCALH-NTWK00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-NTWK00:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCALH-NTWK00:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCALH-NTWK00:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCALH-NTWK00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-NTWK00:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCALH-NTWK00:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCALH-NTWK00:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCALH-NTWK00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-NTWK00:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCALH-NTWK00:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCALH-NTWK00:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCALH-NTWK00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-NTWK00:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCALH-NTWK00:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCALH-NTWK00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCALH-NTWK00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCALH-NTWK00:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCALH-NTWK00:HEARTBEATCLC")
  field(INP, "SOFT-IOCALH-NTWK00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCALH-NTWK00:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCALH-NTWK00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-NTWK00:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCALH-NTWK00:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCALH-NTWK00:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCALH-NTWK00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCALH-NTWK00:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCALH-NTWK00:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCALH-NTWK00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCALH-NTWK00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-NTWK00:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCALH-VAC00:INFO") {
  field(DESC, "SOFT-IOCALH-VAC00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-VAC00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCALH-VAC00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCALH-VAC00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCALH-VAC00:TODDIFF")
}

record(longin, "SOFT-IOCALH-VAC00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCALH-VAC00:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCALH-VAC00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCALH-VAC00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCALH-VAC00:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCALH-VAC00:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCALH-VAC00:TODSUM")
}

record(bo, "SOFT-IOCALH-VAC00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCALH-VAC00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCALH-VAC00:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCALH-VAC00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-VAC00:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCALH-VAC00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCALH-VAC00:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCALH-VAC00:HEARTBEATE01")
  field(INP, "SOFT-IOCALH-VAC00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCALH-VAC00:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCALH-VAC00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCALH-VAC00:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCALH-VAC00:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCALH-VAC00:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCALH-VAC00:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCALH-VAC00:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCALH-VAC00:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCALH-VAC00:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCALH-VAC00:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCALH-VAC00:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCALH-VAC00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCALH-VAC00:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCALH-VAC00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-VAC00:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCALH-VAC00:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCALH-VAC00:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCALH-VAC00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-VAC00:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCALH-VAC00:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCALH-VAC00:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCALH-VAC00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-VAC00:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCALH-VAC00:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCALH-VAC00:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCALH-VAC00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-VAC00:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCALH-VAC00:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCALH-VAC00:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCALH-VAC00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-VAC00:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCALH-VAC00:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCALH-VAC00:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCALH-VAC00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-VAC00:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCALH-VAC00:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCALH-VAC00:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCALH-VAC00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-VAC00:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCALH-VAC00:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCALH-VAC00:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCALH-VAC00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-VAC00:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCALH-VAC00:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCALH-VAC00:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCALH-VAC00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-VAC00:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCALH-VAC00:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCALH-VAC00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCALH-VAC00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCALH-VAC00:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCALH-VAC00:HEARTBEATCLC")
  field(INP, "SOFT-IOCALH-VAC00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCALH-VAC00:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCALH-VAC00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-VAC00:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCALH-VAC00:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCALH-VAC00:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCALH-VAC00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCALH-VAC00:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCALH-VAC00:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCALH-VAC00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCALH-VAC00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-VAC00:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCALH-MC00:INFO") {
  field(DESC, "SOFT-IOCALH-MC00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-MC00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCALH-MC00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCALH-MC00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCALH-MC00:TODDIFF")
}

record(longin, "SOFT-IOCALH-MC00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCALH-MC00:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCALH-MC00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCALH-MC00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCALH-MC00:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCALH-MC00:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCALH-MC00:TODSUM")
}

record(bo, "SOFT-IOCALH-MC00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCALH-MC00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCALH-MC00:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCALH-MC00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MC00:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCALH-MC00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCALH-MC00:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCALH-MC00:HEARTBEATE01")
  field(INP, "SOFT-IOCALH-MC00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCALH-MC00:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCALH-MC00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCALH-MC00:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCALH-MC00:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCALH-MC00:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCALH-MC00:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCALH-MC00:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCALH-MC00:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCALH-MC00:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCALH-MC00:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCALH-MC00:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCALH-MC00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCALH-MC00:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCALH-MC00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MC00:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCALH-MC00:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCALH-MC00:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCALH-MC00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MC00:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCALH-MC00:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCALH-MC00:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCALH-MC00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MC00:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCALH-MC00:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCALH-MC00:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCALH-MC00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MC00:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCALH-MC00:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCALH-MC00:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCALH-MC00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MC00:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCALH-MC00:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCALH-MC00:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCALH-MC00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MC00:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCALH-MC00:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCALH-MC00:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCALH-MC00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MC00:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCALH-MC00:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCALH-MC00:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCALH-MC00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MC00:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCALH-MC00:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCALH-MC00:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCALH-MC00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MC00:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCALH-MC00:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCALH-MC00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCALH-MC00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCALH-MC00:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCALH-MC00:HEARTBEATCLC")
  field(INP, "SOFT-IOCALH-MC00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCALH-MC00:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCALH-MC00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MC00:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCALH-MC00:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCALH-MC00:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCALH-MC00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCALH-MC00:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCALH-MC00:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCALH-MC00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCALH-MC00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-MC00:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCALH-TEMP00:INFO") {
  field(DESC, "SOFT-IOCALH-TEMP00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-TEMP00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCALH-TEMP00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCALH-TEMP00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCALH-TEMP00:TODDIFF")
}

record(longin, "SOFT-IOCALH-TEMP00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCALH-TEMP00:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCALH-TEMP00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCALH-TEMP00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCALH-TEMP00:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCALH-TEMP00:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCALH-TEMP00:TODSUM")
}

record(bo, "SOFT-IOCALH-TEMP00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCALH-TEMP00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCALH-TEMP00:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCALH-TEMP00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-TEMP00:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCALH-TEMP00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCALH-TEMP00:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCALH-TEMP00:HEARTBEATE01")
  field(INP, "SOFT-IOCALH-TEMP00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCALH-TEMP00:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCALH-TEMP00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCALH-TEMP00:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCALH-TEMP00:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCALH-TEMP00:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCALH-TEMP00:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCALH-TEMP00:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCALH-TEMP00:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCALH-TEMP00:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCALH-TEMP00:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCALH-TEMP00:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCALH-TEMP00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCALH-TEMP00:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCALH-TEMP00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-TEMP00:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCALH-TEMP00:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCALH-TEMP00:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCALH-TEMP00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-TEMP00:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCALH-TEMP00:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCALH-TEMP00:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCALH-TEMP00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-TEMP00:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCALH-TEMP00:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCALH-TEMP00:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCALH-TEMP00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-TEMP00:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCALH-TEMP00:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCALH-TEMP00:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCALH-TEMP00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-TEMP00:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCALH-TEMP00:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCALH-TEMP00:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCALH-TEMP00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-TEMP00:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCALH-TEMP00:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCALH-TEMP00:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCALH-TEMP00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-TEMP00:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCALH-TEMP00:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCALH-TEMP00:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCALH-TEMP00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-TEMP00:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCALH-TEMP00:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCALH-TEMP00:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCALH-TEMP00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-TEMP00:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCALH-TEMP00:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCALH-TEMP00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCALH-TEMP00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCALH-TEMP00:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCALH-TEMP00:HEARTBEATCLC")
  field(INP, "SOFT-IOCALH-TEMP00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCALH-TEMP00:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCALH-TEMP00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-TEMP00:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCALH-TEMP00:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCALH-TEMP00:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCALH-TEMP00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCALH-TEMP00:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCALH-TEMP00:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCALH-TEMP00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCALH-TEMP00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-TEMP00:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCALH-GADC00:INFO") {
  field(DESC, "SOFT-IOCALH-GADC00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-GADC00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCALH-GADC00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCALH-GADC00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCALH-GADC00:TODDIFF")
}

record(longin, "SOFT-IOCALH-GADC00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCALH-GADC00:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCALH-GADC00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCALH-GADC00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCALH-GADC00:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCALH-GADC00:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCALH-GADC00:TODSUM")
}

record(bo, "SOFT-IOCALH-GADC00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCALH-GADC00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCALH-GADC00:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCALH-GADC00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-GADC00:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCALH-GADC00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCALH-GADC00:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCALH-GADC00:HEARTBEATE01")
  field(INP, "SOFT-IOCALH-GADC00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCALH-GADC00:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCALH-GADC00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCALH-GADC00:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCALH-GADC00:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCALH-GADC00:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCALH-GADC00:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCALH-GADC00:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCALH-GADC00:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCALH-GADC00:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCALH-GADC00:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCALH-GADC00:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCALH-GADC00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCALH-GADC00:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCALH-GADC00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-GADC00:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCALH-GADC00:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCALH-GADC00:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCALH-GADC00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-GADC00:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCALH-GADC00:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCALH-GADC00:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCALH-GADC00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-GADC00:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCALH-GADC00:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCALH-GADC00:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCALH-GADC00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-GADC00:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCALH-GADC00:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCALH-GADC00:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCALH-GADC00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-GADC00:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCALH-GADC00:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCALH-GADC00:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCALH-GADC00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-GADC00:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCALH-GADC00:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCALH-GADC00:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCALH-GADC00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-GADC00:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCALH-GADC00:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCALH-GADC00:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCALH-GADC00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-GADC00:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCALH-GADC00:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCALH-GADC00:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCALH-GADC00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-GADC00:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCALH-GADC00:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCALH-GADC00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCALH-GADC00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCALH-GADC00:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCALH-GADC00:HEARTBEATCLC")
  field(INP, "SOFT-IOCALH-GADC00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCALH-GADC00:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCALH-GADC00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-GADC00:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCALH-GADC00:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCALH-GADC00:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCALH-GADC00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCALH-GADC00:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCALH-GADC00:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCALH-GADC00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCALH-GADC00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-GADC00:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCALH-UTIL00:INFO") {
  field(DESC, "SOFT-IOCALH-UTIL00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-UTIL00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCALH-UTIL00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCALH-UTIL00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCALH-UTIL00:TODDIFF")
}

record(longin, "SOFT-IOCALH-UTIL00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCALH-UTIL00:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCALH-UTIL00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCALH-UTIL00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCALH-UTIL00:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCALH-UTIL00:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCALH-UTIL00:TODSUM")
}

record(bo, "SOFT-IOCALH-UTIL00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCALH-UTIL00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCALH-UTIL00:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCALH-UTIL00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-UTIL00:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCALH-UTIL00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCALH-UTIL00:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCALH-UTIL00:HEARTBEATE01")
  field(INP, "SOFT-IOCALH-UTIL00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCALH-UTIL00:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCALH-UTIL00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCALH-UTIL00:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCALH-UTIL00:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCALH-UTIL00:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCALH-UTIL00:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCALH-UTIL00:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCALH-UTIL00:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCALH-UTIL00:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCALH-UTIL00:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCALH-UTIL00:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCALH-UTIL00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCALH-UTIL00:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCALH-UTIL00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-UTIL00:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCALH-UTIL00:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCALH-UTIL00:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCALH-UTIL00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-UTIL00:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCALH-UTIL00:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCALH-UTIL00:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCALH-UTIL00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-UTIL00:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCALH-UTIL00:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCALH-UTIL00:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCALH-UTIL00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-UTIL00:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCALH-UTIL00:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCALH-UTIL00:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCALH-UTIL00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-UTIL00:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCALH-UTIL00:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCALH-UTIL00:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCALH-UTIL00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-UTIL00:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCALH-UTIL00:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCALH-UTIL00:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCALH-UTIL00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-UTIL00:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCALH-UTIL00:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCALH-UTIL00:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCALH-UTIL00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-UTIL00:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCALH-UTIL00:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCALH-UTIL00:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCALH-UTIL00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-UTIL00:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCALH-UTIL00:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCALH-UTIL00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCALH-UTIL00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCALH-UTIL00:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCALH-UTIL00:HEARTBEATCLC")
  field(INP, "SOFT-IOCALH-UTIL00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCALH-UTIL00:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCALH-UTIL00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-UTIL00:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCALH-UTIL00:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCALH-UTIL00:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCALH-UTIL00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCALH-UTIL00:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCALH-UTIL00:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCALH-UTIL00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCALH-UTIL00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-UTIL00:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCALH-BCS00:INFO") {
  field(DESC, "SOFT-IOCALH-BCS00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-BCS00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCALH-BCS00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCALH-BCS00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCALH-BCS00:TODDIFF")
}

record(longin, "SOFT-IOCALH-BCS00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCALH-BCS00:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCALH-BCS00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCALH-BCS00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCALH-BCS00:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCALH-BCS00:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCALH-BCS00:TODSUM")
}

record(bo, "SOFT-IOCALH-BCS00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCALH-BCS00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCALH-BCS00:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCALH-BCS00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-BCS00:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCALH-BCS00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCALH-BCS00:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCALH-BCS00:HEARTBEATE01")
  field(INP, "SOFT-IOCALH-BCS00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCALH-BCS00:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCALH-BCS00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCALH-BCS00:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCALH-BCS00:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCALH-BCS00:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCALH-BCS00:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCALH-BCS00:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCALH-BCS00:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCALH-BCS00:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCALH-BCS00:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCALH-BCS00:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCALH-BCS00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCALH-BCS00:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCALH-BCS00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-BCS00:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCALH-BCS00:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCALH-BCS00:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCALH-BCS00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-BCS00:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCALH-BCS00:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCALH-BCS00:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCALH-BCS00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-BCS00:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCALH-BCS00:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCALH-BCS00:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCALH-BCS00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-BCS00:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCALH-BCS00:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCALH-BCS00:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCALH-BCS00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-BCS00:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCALH-BCS00:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCALH-BCS00:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCALH-BCS00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-BCS00:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCALH-BCS00:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCALH-BCS00:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCALH-BCS00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-BCS00:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCALH-BCS00:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCALH-BCS00:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCALH-BCS00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-BCS00:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCALH-BCS00:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCALH-BCS00:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCALH-BCS00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-BCS00:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCALH-BCS00:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCALH-BCS00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCALH-BCS00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCALH-BCS00:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCALH-BCS00:HEARTBEATCLC")
  field(INP, "SOFT-IOCALH-BCS00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCALH-BCS00:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCALH-BCS00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-BCS00:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCALH-BCS00:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCALH-BCS00:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCALH-BCS00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCALH-BCS00:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCALH-BCS00:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCALH-BCS00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCALH-BCS00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-BCS00:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCALH-PPS00:INFO") {
  field(DESC, "SOFT-IOCALH-PPS00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-PPS00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCALH-PPS00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCALH-PPS00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCALH-PPS00:TODDIFF")
}

record(longin, "SOFT-IOCALH-PPS00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCALH-PPS00:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCALH-PPS00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCALH-PPS00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCALH-PPS00:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCALH-PPS00:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCALH-PPS00:TODSUM")
}

record(bo, "SOFT-IOCALH-PPS00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCALH-PPS00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCALH-PPS00:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCALH-PPS00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PPS00:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCALH-PPS00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCALH-PPS00:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCALH-PPS00:HEARTBEATE01")
  field(INP, "SOFT-IOCALH-PPS00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCALH-PPS00:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCALH-PPS00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCALH-PPS00:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCALH-PPS00:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCALH-PPS00:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCALH-PPS00:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCALH-PPS00:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCALH-PPS00:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCALH-PPS00:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCALH-PPS00:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCALH-PPS00:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCALH-PPS00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCALH-PPS00:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCALH-PPS00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PPS00:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCALH-PPS00:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCALH-PPS00:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCALH-PPS00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PPS00:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCALH-PPS00:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCALH-PPS00:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCALH-PPS00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PPS00:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCALH-PPS00:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCALH-PPS00:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCALH-PPS00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PPS00:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCALH-PPS00:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCALH-PPS00:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCALH-PPS00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PPS00:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCALH-PPS00:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCALH-PPS00:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCALH-PPS00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PPS00:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCALH-PPS00:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCALH-PPS00:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCALH-PPS00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PPS00:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCALH-PPS00:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCALH-PPS00:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCALH-PPS00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PPS00:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCALH-PPS00:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCALH-PPS00:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCALH-PPS00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PPS00:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCALH-PPS00:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCALH-PPS00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCALH-PPS00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCALH-PPS00:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCALH-PPS00:HEARTBEATCLC")
  field(INP, "SOFT-IOCALH-PPS00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCALH-PPS00:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCALH-PPS00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PPS00:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCALH-PPS00:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCALH-PPS00:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCALH-PPS00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCALH-PPS00:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCALH-PPS00:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCALH-PPS00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCALH-PPS00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-PPS00:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCALH-MPS00:INFO") {
  field(DESC, "SOFT-IOCALH-MPS00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-MPS00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCALH-MPS00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCALH-MPS00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCALH-MPS00:TODDIFF")
}

record(longin, "SOFT-IOCALH-MPS00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCALH-MPS00:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCALH-MPS00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCALH-MPS00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCALH-MPS00:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCALH-MPS00:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCALH-MPS00:TODSUM")
}

record(bo, "SOFT-IOCALH-MPS00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCALH-MPS00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCALH-MPS00:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCALH-MPS00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MPS00:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCALH-MPS00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCALH-MPS00:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCALH-MPS00:HEARTBEATE01")
  field(INP, "SOFT-IOCALH-MPS00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCALH-MPS00:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCALH-MPS00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCALH-MPS00:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCALH-MPS00:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCALH-MPS00:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCALH-MPS00:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCALH-MPS00:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCALH-MPS00:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCALH-MPS00:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCALH-MPS00:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCALH-MPS00:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCALH-MPS00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCALH-MPS00:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCALH-MPS00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MPS00:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCALH-MPS00:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCALH-MPS00:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCALH-MPS00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MPS00:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCALH-MPS00:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCALH-MPS00:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCALH-MPS00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MPS00:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCALH-MPS00:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCALH-MPS00:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCALH-MPS00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MPS00:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCALH-MPS00:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCALH-MPS00:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCALH-MPS00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MPS00:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCALH-MPS00:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCALH-MPS00:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCALH-MPS00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MPS00:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCALH-MPS00:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCALH-MPS00:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCALH-MPS00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MPS00:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCALH-MPS00:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCALH-MPS00:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCALH-MPS00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MPS00:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCALH-MPS00:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCALH-MPS00:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCALH-MPS00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MPS00:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCALH-MPS00:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCALH-MPS00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCALH-MPS00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCALH-MPS00:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCALH-MPS00:HEARTBEATCLC")
  field(INP, "SOFT-IOCALH-MPS00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCALH-MPS00:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCALH-MPS00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MPS00:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCALH-MPS00:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCALH-MPS00:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCALH-MPS00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCALH-MPS00:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCALH-MPS00:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCALH-MPS00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCALH-MPS00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-MPS00:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCALH-EVNT00:INFO") {
  field(DESC, "SOFT-IOCALH-EVNT00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-EVNT00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCALH-EVNT00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCALH-EVNT00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCALH-EVNT00:TODDIFF")
}

record(longin, "SOFT-IOCALH-EVNT00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCALH-EVNT00:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCALH-EVNT00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCALH-EVNT00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCALH-EVNT00:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCALH-EVNT00:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCALH-EVNT00:TODSUM")
}

record(bo, "SOFT-IOCALH-EVNT00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCALH-EVNT00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCALH-EVNT00:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCALH-EVNT00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-EVNT00:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCALH-EVNT00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCALH-EVNT00:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCALH-EVNT00:HEARTBEATE01")
  field(INP, "SOFT-IOCALH-EVNT00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCALH-EVNT00:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCALH-EVNT00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCALH-EVNT00:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCALH-EVNT00:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCALH-EVNT00:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCALH-EVNT00:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCALH-EVNT00:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCALH-EVNT00:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCALH-EVNT00:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCALH-EVNT00:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCALH-EVNT00:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCALH-EVNT00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCALH-EVNT00:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCALH-EVNT00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-EVNT00:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCALH-EVNT00:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCALH-EVNT00:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCALH-EVNT00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-EVNT00:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCALH-EVNT00:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCALH-EVNT00:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCALH-EVNT00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-EVNT00:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCALH-EVNT00:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCALH-EVNT00:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCALH-EVNT00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-EVNT00:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCALH-EVNT00:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCALH-EVNT00:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCALH-EVNT00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-EVNT00:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCALH-EVNT00:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCALH-EVNT00:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCALH-EVNT00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-EVNT00:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCALH-EVNT00:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCALH-EVNT00:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCALH-EVNT00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-EVNT00:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCALH-EVNT00:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCALH-EVNT00:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCALH-EVNT00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-EVNT00:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCALH-EVNT00:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCALH-EVNT00:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCALH-EVNT00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-EVNT00:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCALH-EVNT00:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCALH-EVNT00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCALH-EVNT00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCALH-EVNT00:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCALH-EVNT00:HEARTBEATCLC")
  field(INP, "SOFT-IOCALH-EVNT00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCALH-EVNT00:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCALH-EVNT00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-EVNT00:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCALH-EVNT00:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCALH-EVNT00:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCALH-EVNT00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCALH-EVNT00:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCALH-EVNT00:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCALH-EVNT00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCALH-EVNT00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-EVNT00:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCALH-PROF00:INFO") {
  field(DESC, "SOFT-IOCALH-PROF00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-PROF00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCALH-PROF00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCALH-PROF00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCALH-PROF00:TODDIFF")
}

record(longin, "SOFT-IOCALH-PROF00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCALH-PROF00:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCALH-PROF00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCALH-PROF00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCALH-PROF00:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCALH-PROF00:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCALH-PROF00:TODSUM")
}

record(bo, "SOFT-IOCALH-PROF00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCALH-PROF00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCALH-PROF00:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCALH-PROF00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PROF00:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCALH-PROF00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCALH-PROF00:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCALH-PROF00:HEARTBEATE01")
  field(INP, "SOFT-IOCALH-PROF00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCALH-PROF00:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCALH-PROF00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCALH-PROF00:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCALH-PROF00:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCALH-PROF00:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCALH-PROF00:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCALH-PROF00:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCALH-PROF00:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCALH-PROF00:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCALH-PROF00:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCALH-PROF00:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCALH-PROF00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCALH-PROF00:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCALH-PROF00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PROF00:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCALH-PROF00:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCALH-PROF00:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCALH-PROF00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PROF00:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCALH-PROF00:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCALH-PROF00:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCALH-PROF00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PROF00:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCALH-PROF00:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCALH-PROF00:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCALH-PROF00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PROF00:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCALH-PROF00:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCALH-PROF00:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCALH-PROF00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PROF00:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCALH-PROF00:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCALH-PROF00:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCALH-PROF00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PROF00:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCALH-PROF00:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCALH-PROF00:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCALH-PROF00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PROF00:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCALH-PROF00:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCALH-PROF00:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCALH-PROF00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PROF00:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCALH-PROF00:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCALH-PROF00:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCALH-PROF00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PROF00:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCALH-PROF00:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCALH-PROF00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCALH-PROF00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCALH-PROF00:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCALH-PROF00:HEARTBEATCLC")
  field(INP, "SOFT-IOCALH-PROF00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCALH-PROF00:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCALH-PROF00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-PROF00:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCALH-PROF00:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCALH-PROF00:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCALH-PROF00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCALH-PROF00:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCALH-PROF00:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCALH-PROF00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCALH-PROF00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-PROF00:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCALH-FBCK00:INFO") {
  field(DESC, "SOFT-IOCALH-FBCK00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-FBCK00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCALH-FBCK00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCALH-FBCK00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCALH-FBCK00:TODDIFF")
}

record(longin, "SOFT-IOCALH-FBCK00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCALH-FBCK00:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCALH-FBCK00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCALH-FBCK00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCALH-FBCK00:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCALH-FBCK00:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCALH-FBCK00:TODSUM")
}

record(bo, "SOFT-IOCALH-FBCK00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCALH-FBCK00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCALH-FBCK00:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCALH-FBCK00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-FBCK00:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCALH-FBCK00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCALH-FBCK00:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCALH-FBCK00:HEARTBEATE01")
  field(INP, "SOFT-IOCALH-FBCK00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCALH-FBCK00:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCALH-FBCK00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCALH-FBCK00:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCALH-FBCK00:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCALH-FBCK00:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCALH-FBCK00:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCALH-FBCK00:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCALH-FBCK00:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCALH-FBCK00:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCALH-FBCK00:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCALH-FBCK00:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCALH-FBCK00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCALH-FBCK00:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCALH-FBCK00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-FBCK00:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCALH-FBCK00:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCALH-FBCK00:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCALH-FBCK00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-FBCK00:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCALH-FBCK00:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCALH-FBCK00:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCALH-FBCK00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-FBCK00:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCALH-FBCK00:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCALH-FBCK00:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCALH-FBCK00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-FBCK00:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCALH-FBCK00:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCALH-FBCK00:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCALH-FBCK00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-FBCK00:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCALH-FBCK00:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCALH-FBCK00:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCALH-FBCK00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-FBCK00:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCALH-FBCK00:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCALH-FBCK00:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCALH-FBCK00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-FBCK00:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCALH-FBCK00:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCALH-FBCK00:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCALH-FBCK00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-FBCK00:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCALH-FBCK00:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCALH-FBCK00:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCALH-FBCK00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-FBCK00:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCALH-FBCK00:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCALH-FBCK00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCALH-FBCK00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCALH-FBCK00:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCALH-FBCK00:HEARTBEATCLC")
  field(INP, "SOFT-IOCALH-FBCK00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCALH-FBCK00:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCALH-FBCK00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-FBCK00:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCALH-FBCK00:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCALH-FBCK00:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCALH-FBCK00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCALH-FBCK00:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCALH-FBCK00:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCALH-FBCK00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCALH-FBCK00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-FBCK00:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCALH-RF00:INFO") {
  field(DESC, "SOFT-IOCALH-RF00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-RF00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCALH-RF00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCALH-RF00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCALH-RF00:TODDIFF")
}

record(longin, "SOFT-IOCALH-RF00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCALH-RF00:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCALH-RF00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCALH-RF00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCALH-RF00:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCALH-RF00:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCALH-RF00:TODSUM")
}

record(bo, "SOFT-IOCALH-RF00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCALH-RF00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCALH-RF00:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCALH-RF00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-RF00:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCALH-RF00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCALH-RF00:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCALH-RF00:HEARTBEATE01")
  field(INP, "SOFT-IOCALH-RF00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCALH-RF00:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCALH-RF00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCALH-RF00:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCALH-RF00:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCALH-RF00:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCALH-RF00:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCALH-RF00:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCALH-RF00:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCALH-RF00:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCALH-RF00:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCALH-RF00:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCALH-RF00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCALH-RF00:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCALH-RF00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-RF00:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCALH-RF00:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCALH-RF00:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCALH-RF00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-RF00:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCALH-RF00:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCALH-RF00:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCALH-RF00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-RF00:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCALH-RF00:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCALH-RF00:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCALH-RF00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-RF00:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCALH-RF00:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCALH-RF00:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCALH-RF00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-RF00:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCALH-RF00:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCALH-RF00:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCALH-RF00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-RF00:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCALH-RF00:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCALH-RF00:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCALH-RF00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-RF00:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCALH-RF00:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCALH-RF00:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCALH-RF00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-RF00:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCALH-RF00:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCALH-RF00:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCALH-RF00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-RF00:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCALH-RF00:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCALH-RF00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCALH-RF00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCALH-RF00:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCALH-RF00:HEARTBEATCLC")
  field(INP, "SOFT-IOCALH-RF00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCALH-RF00:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCALH-RF00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-RF00:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCALH-RF00:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCALH-RF00:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCALH-RF00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCALH-RF00:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCALH-RF00:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCALH-RF00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCALH-RF00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-RF00:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCALH-MGNT00:INFO") {
  field(DESC, "SOFT-IOCALH-MGNT00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-MGNT00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCALH-MGNT00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCALH-MGNT00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCALH-MGNT00:TODDIFF")
}

record(longin, "SOFT-IOCALH-MGNT00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCALH-MGNT00:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCALH-MGNT00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCALH-MGNT00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCALH-MGNT00:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCALH-MGNT00:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCALH-MGNT00:TODSUM")
}

record(bo, "SOFT-IOCALH-MGNT00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCALH-MGNT00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCALH-MGNT00:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCALH-MGNT00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MGNT00:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCALH-MGNT00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCALH-MGNT00:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCALH-MGNT00:HEARTBEATE01")
  field(INP, "SOFT-IOCALH-MGNT00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCALH-MGNT00:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCALH-MGNT00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCALH-MGNT00:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCALH-MGNT00:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCALH-MGNT00:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCALH-MGNT00:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCALH-MGNT00:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCALH-MGNT00:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCALH-MGNT00:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCALH-MGNT00:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCALH-MGNT00:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCALH-MGNT00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCALH-MGNT00:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCALH-MGNT00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MGNT00:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCALH-MGNT00:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCALH-MGNT00:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCALH-MGNT00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MGNT00:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCALH-MGNT00:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCALH-MGNT00:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCALH-MGNT00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MGNT00:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCALH-MGNT00:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCALH-MGNT00:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCALH-MGNT00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MGNT00:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCALH-MGNT00:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCALH-MGNT00:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCALH-MGNT00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MGNT00:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCALH-MGNT00:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCALH-MGNT00:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCALH-MGNT00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MGNT00:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCALH-MGNT00:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCALH-MGNT00:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCALH-MGNT00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MGNT00:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCALH-MGNT00:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCALH-MGNT00:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCALH-MGNT00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MGNT00:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCALH-MGNT00:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCALH-MGNT00:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCALH-MGNT00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MGNT00:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCALH-MGNT00:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCALH-MGNT00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCALH-MGNT00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCALH-MGNT00:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCALH-MGNT00:HEARTBEATCLC")
  field(INP, "SOFT-IOCALH-MGNT00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCALH-MGNT00:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCALH-MGNT00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALH-MGNT00:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCALH-MGNT00:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCALH-MGNT00:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCALH-MGNT00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCALH-MGNT00:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCALH-MGNT00:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCALH-MGNT00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCALH-MGNT00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALH-MGNT00:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCALARA:INFO") {
  field(DESC, "SOFT-IOCALARA Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALARA:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCALARA:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCALARA:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCALARA:TODDIFF")
}

record(longin, "SOFT-IOCALARA:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCALARA:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCALARA:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCALARA:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCALARA:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCALARA:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCALARA:TODSUM")
}

record(bo, "SOFT-IOCALARA:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCALARA:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCALARA:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCALARA:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALARA:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCALARA:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCALARA:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCALARA:HEARTBEATE01")
  field(INP, "SOFT-IOCALARA:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCALARA:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCALARA:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCALARA:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCALARA:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCALARA:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCALARA:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCALARA:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCALARA:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCALARA:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCALARA:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCALARA:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCALARA:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCALARA:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCALARA:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALARA:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCALARA:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCALARA:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCALARA:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALARA:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCALARA:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCALARA:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCALARA:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALARA:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCALARA:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCALARA:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCALARA:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALARA:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCALARA:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCALARA:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCALARA:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALARA:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCALARA:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCALARA:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCALARA:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALARA:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCALARA:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCALARA:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCALARA:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALARA:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCALARA:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCALARA:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCALARA:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALARA:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCALARA:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCALARA:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCALARA:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALARA:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCALARA:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCALARA:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCALARA:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCALARA:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCALARA:HEARTBEATCLC")
  field(INP, "SOFT-IOCALARA:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCALARA:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCALARA:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCALARA:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCALARA:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCALARA:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCALARA:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCALARA:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCALARA:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCALARA:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCALARA:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCALARA:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCGPIB:INFO") {
  field(DESC, "SOFT-IOCGPIB Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCGPIB:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCGPIB:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCGPIB:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCGPIB:TODDIFF")
}

record(longin, "SOFT-IOCGPIB:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCGPIB:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCGPIB:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCGPIB:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCGPIB:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCGPIB:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCGPIB:TODSUM")
}

record(bo, "SOFT-IOCGPIB:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCGPIB:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCGPIB:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCGPIB:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCGPIB:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCGPIB:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCGPIB:HEARTBEATE01")
  field(INP, "SOFT-IOCGPIB:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCGPIB:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCGPIB:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCGPIB:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCGPIB:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCGPIB:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCGPIB:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCGPIB:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCGPIB:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCGPIB:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCGPIB:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCGPIB:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCGPIB:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCGPIB:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCGPIB:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCGPIB:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCGPIB:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCGPIB:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCGPIB:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCGPIB:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCGPIB:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCGPIB:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCGPIB:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCGPIB:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCGPIB:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCGPIB:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCGPIB:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCGPIB:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCGPIB:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCGPIB:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCGPIB:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCGPIB:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCGPIB:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCGPIB:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCGPIB:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCGPIB:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCGPIB:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCGPIB:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCGPIB:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCGPIB:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCGPIB:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCGPIB:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCGPIB:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCGPIB:HEARTBEATCLC")
  field(INP, "SOFT-IOCGPIB:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCGPIB:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCGPIB:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCGPIB:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCGPIB:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCGPIB:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCGPIB:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCGPIB:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCGPIB:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocgpib")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCGPIB:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocgpib")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCGPIB:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCLCW:INFO") {
  field(DESC, "SOFT-IOCLCW Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCLCW:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCLCW:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCLCW:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCLCW:TODDIFF")
}

record(longin, "SOFT-IOCLCW:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCLCW:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCLCW:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCLCW:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCLCW:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCLCW:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCLCW:TODSUM")
}

record(bo, "SOFT-IOCLCW:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCLCW:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCLCW:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCLCW:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLCW:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCLCW:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCLCW:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCLCW:HEARTBEATE01")
  field(INP, "SOFT-IOCLCW:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCLCW:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCLCW:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCLCW:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCLCW:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCLCW:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCLCW:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCLCW:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCLCW:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCLCW:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCLCW:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCLCW:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCLCW:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCLCW:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCLCW:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLCW:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCLCW:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCLCW:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCLCW:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLCW:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCLCW:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCLCW:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCLCW:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLCW:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCLCW:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCLCW:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCLCW:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLCW:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCLCW:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCLCW:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCLCW:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLCW:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCLCW:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCLCW:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCLCW:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLCW:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCLCW:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCLCW:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCLCW:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLCW:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCLCW:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCLCW:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCLCW:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLCW:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCLCW:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCLCW:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCLCW:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLCW:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCLCW:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCLCW:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCLCW:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCLCW:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCLCW:HEARTBEATCLC")
  field(INP, "SOFT-IOCLCW:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCLCW:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCLCW:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLCW:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCLCW:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCLCW:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCLCW:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCLCW:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCLCW:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCLCW:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "ioclcw")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCLCW:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "ioclcw")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCLCW:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCMPSBL:INFO") {
  field(DESC, "SOFT-IOCMPSBL Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMPSBL:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCMPSBL:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCMPSBL:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCMPSBL:TODDIFF")
}

record(longin, "SOFT-IOCMPSBL:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCMPSBL:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCMPSBL:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCMPSBL:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCMPSBL:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCMPSBL:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCMPSBL:TODSUM")
}

record(bo, "SOFT-IOCMPSBL:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCMPSBL:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCMPSBL:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCMPSBL:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBL:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCMPSBL:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCMPSBL:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCMPSBL:HEARTBEATE01")
  field(INP, "SOFT-IOCMPSBL:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCMPSBL:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCMPSBL:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCMPSBL:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCMPSBL:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCMPSBL:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCMPSBL:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCMPSBL:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCMPSBL:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCMPSBL:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCMPSBL:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCMPSBL:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCMPSBL:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCMPSBL:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCMPSBL:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBL:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCMPSBL:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCMPSBL:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCMPSBL:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBL:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCMPSBL:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCMPSBL:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCMPSBL:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBL:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCMPSBL:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCMPSBL:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCMPSBL:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBL:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCMPSBL:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCMPSBL:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCMPSBL:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBL:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCMPSBL:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCMPSBL:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCMPSBL:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBL:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCMPSBL:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCMPSBL:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCMPSBL:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBL:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCMPSBL:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCMPSBL:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCMPSBL:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBL:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCMPSBL:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCMPSBL:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCMPSBL:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBL:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCMPSBL:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCMPSBL:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCMPSBL:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCMPSBL:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCMPSBL:HEARTBEATCLC")
  field(INP, "SOFT-IOCMPSBL:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCMPSBL:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCMPSBL:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBL:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCMPSBL:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCMPSBL:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCMPSBL:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCMPSBL:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCMPSBL:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCMPSBL:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocmpsbl")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCMPSBL:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocmpsbl")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMPSBL:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCMPSINJ:INFO") {
  field(DESC, "SOFT-IOCMPSINJ Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMPSINJ:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCMPSINJ:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCMPSINJ:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCMPSINJ:TODDIFF")
}

record(longin, "SOFT-IOCMPSINJ:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCMPSINJ:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCMPSINJ:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCMPSINJ:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCMPSINJ:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCMPSINJ:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCMPSINJ:TODSUM")
}

record(bo, "SOFT-IOCMPSINJ:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCMPSINJ:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCMPSINJ:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCMPSINJ:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSINJ:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCMPSINJ:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCMPSINJ:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCMPSINJ:HEARTBEATE01")
  field(INP, "SOFT-IOCMPSINJ:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCMPSINJ:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCMPSINJ:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCMPSINJ:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCMPSINJ:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCMPSINJ:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCMPSINJ:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCMPSINJ:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCMPSINJ:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCMPSINJ:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCMPSINJ:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCMPSINJ:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCMPSINJ:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCMPSINJ:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCMPSINJ:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSINJ:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCMPSINJ:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCMPSINJ:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCMPSINJ:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSINJ:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCMPSINJ:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCMPSINJ:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCMPSINJ:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSINJ:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCMPSINJ:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCMPSINJ:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCMPSINJ:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSINJ:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCMPSINJ:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCMPSINJ:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCMPSINJ:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSINJ:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCMPSINJ:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCMPSINJ:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCMPSINJ:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSINJ:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCMPSINJ:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCMPSINJ:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCMPSINJ:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSINJ:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCMPSINJ:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCMPSINJ:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCMPSINJ:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSINJ:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCMPSINJ:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCMPSINJ:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCMPSINJ:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSINJ:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCMPSINJ:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCMPSINJ:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCMPSINJ:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCMPSINJ:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCMPSINJ:HEARTBEATCLC")
  field(INP, "SOFT-IOCMPSINJ:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCMPSINJ:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCMPSINJ:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSINJ:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCMPSINJ:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCMPSINJ:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCMPSINJ:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCMPSINJ:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCMPSINJ:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCMPSINJ:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocmpsinj")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCMPSINJ:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocmpsinj")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMPSINJ:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCMPSSPR:INFO") {
  field(DESC, "SOFT-IOCMPSSPR Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMPSSPR:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCMPSSPR:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCMPSSPR:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCMPSSPR:TODDIFF")
}

record(longin, "SOFT-IOCMPSSPR:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCMPSSPR:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCMPSSPR:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCMPSSPR:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCMPSSPR:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCMPSSPR:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCMPSSPR:TODSUM")
}

record(bo, "SOFT-IOCMPSSPR:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCMPSSPR:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCMPSSPR:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCMPSSPR:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSSPR:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCMPSSPR:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCMPSSPR:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCMPSSPR:HEARTBEATE01")
  field(INP, "SOFT-IOCMPSSPR:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCMPSSPR:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCMPSSPR:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCMPSSPR:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCMPSSPR:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCMPSSPR:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCMPSSPR:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCMPSSPR:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCMPSSPR:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCMPSSPR:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCMPSSPR:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCMPSSPR:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCMPSSPR:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCMPSSPR:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCMPSSPR:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSSPR:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCMPSSPR:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCMPSSPR:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCMPSSPR:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSSPR:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCMPSSPR:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCMPSSPR:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCMPSSPR:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSSPR:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCMPSSPR:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCMPSSPR:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCMPSSPR:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSSPR:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCMPSSPR:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCMPSSPR:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCMPSSPR:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSSPR:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCMPSSPR:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCMPSSPR:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCMPSSPR:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSSPR:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCMPSSPR:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCMPSSPR:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCMPSSPR:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSSPR:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCMPSSPR:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCMPSSPR:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCMPSSPR:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSSPR:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCMPSSPR:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCMPSSPR:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCMPSSPR:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSSPR:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCMPSSPR:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCMPSSPR:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCMPSSPR:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCMPSSPR:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCMPSSPR:HEARTBEATCLC")
  field(INP, "SOFT-IOCMPSSPR:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCMPSSPR:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCMPSSPR:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSSPR:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCMPSSPR:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCMPSSPR:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCMPSSPR:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCMPSSPR:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCMPSSPR:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCMPSSPR:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocmpsspr")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCMPSSPR:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocmpsspr")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMPSSPR:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCPPS:INFO") {
  field(DESC, "SOFT-IOCPPS Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPPS:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCPPS:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCPPS:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCPPS:TODDIFF")
}

record(longin, "SOFT-IOCPPS:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCPPS:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCPPS:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCPPS:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCPPS:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCPPS:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCPPS:TODSUM")
}

record(bo, "SOFT-IOCPPS:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCPPS:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCPPS:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCPPS:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPPS:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCPPS:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCPPS:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCPPS:HEARTBEATE01")
  field(INP, "SOFT-IOCPPS:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCPPS:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCPPS:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCPPS:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCPPS:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCPPS:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCPPS:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCPPS:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCPPS:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCPPS:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCPPS:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCPPS:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCPPS:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCPPS:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCPPS:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPPS:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCPPS:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCPPS:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCPPS:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPPS:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCPPS:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCPPS:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCPPS:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPPS:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCPPS:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCPPS:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCPPS:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPPS:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCPPS:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCPPS:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCPPS:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPPS:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCPPS:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCPPS:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCPPS:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPPS:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCPPS:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCPPS:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCPPS:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPPS:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCPPS:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCPPS:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCPPS:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPPS:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCPPS:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCPPS:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCPPS:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPPS:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCPPS:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCPPS:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCPPS:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCPPS:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCPPS:HEARTBEATCLC")
  field(INP, "SOFT-IOCPPS:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCPPS:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCPPS:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPPS:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCPPS:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCPPS:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCPPS:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCPPS:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCPPS:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCPPS:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocpps")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCPPS:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocpps")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPPS:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCRP:INFO") {
  field(DESC, "SOFT-IOCRP Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCRP:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCRP:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCRP:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCRP:TODDIFF")
}

record(longin, "SOFT-IOCRP:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCRP:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCRP:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCRP:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCRP:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCRP:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCRP:TODSUM")
}

record(bo, "SOFT-IOCRP:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCRP:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCRP:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCRP:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCRP:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCRP:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCRP:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCRP:HEARTBEATE01")
  field(INP, "SOFT-IOCRP:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCRP:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCRP:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCRP:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCRP:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCRP:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCRP:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCRP:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCRP:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCRP:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCRP:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCRP:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCRP:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCRP:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCRP:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCRP:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCRP:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCRP:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCRP:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCRP:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCRP:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCRP:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCRP:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCRP:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCRP:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCRP:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCRP:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCRP:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCRP:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCRP:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCRP:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCRP:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCRP:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCRP:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCRP:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCRP:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCRP:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCRP:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCRP:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCRP:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCRP:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCRP:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCRP:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCRP:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCRP:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCRP:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCRP:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCRP:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCRP:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCRP:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCRP:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCRP:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCRP:HEARTBEATCLC")
  field(INP, "SOFT-IOCRP:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCRP:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCRP:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCRP:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCRP:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCRP:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCRP:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCRP:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCRP:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCRP:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocrp")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCRP:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocrp")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCRP:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCCAMAC:INFO") {
  field(DESC, "SOFT-IOCCAMAC Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAMAC:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCCAMAC:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCCAMAC:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCCAMAC:TODDIFF")
}

record(longin, "SOFT-IOCCAMAC:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCCAMAC:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCCAMAC:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCCAMAC:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCCAMAC:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCCAMAC:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCCAMAC:TODSUM")
}

record(bo, "SOFT-IOCCAMAC:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCCAMAC:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCCAMAC:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCCAMAC:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAMAC:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCCAMAC:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCCAMAC:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCCAMAC:HEARTBEATE01")
  field(INP, "SOFT-IOCCAMAC:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCCAMAC:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCCAMAC:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCCAMAC:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCCAMAC:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCCAMAC:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCCAMAC:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCCAMAC:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCCAMAC:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCCAMAC:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCCAMAC:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCCAMAC:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCCAMAC:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCCAMAC:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCCAMAC:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAMAC:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCCAMAC:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCCAMAC:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCCAMAC:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAMAC:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCCAMAC:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCCAMAC:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCCAMAC:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAMAC:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCCAMAC:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCCAMAC:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCCAMAC:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAMAC:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCCAMAC:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCCAMAC:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCCAMAC:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAMAC:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCCAMAC:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCCAMAC:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCCAMAC:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAMAC:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCCAMAC:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCCAMAC:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCCAMAC:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAMAC:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCCAMAC:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCCAMAC:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCCAMAC:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAMAC:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCCAMAC:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCCAMAC:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCCAMAC:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAMAC:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCCAMAC:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCCAMAC:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCCAMAC:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCCAMAC:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCCAMAC:HEARTBEATCLC")
  field(INP, "SOFT-IOCCAMAC:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCCAMAC:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCCAMAC:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAMAC:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCCAMAC:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCCAMAC:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCCAMAC:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCCAMAC:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCCAMAC:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCCAMAC:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "ioccam")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCCAMAC:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "ioccam")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAMAC:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCMATLAB:INFO") {
  field(DESC, "SOFT-IOCMATLAB Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMATLAB:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCMATLAB:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCMATLAB:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCMATLAB:TODDIFF")
}

record(longin, "SOFT-IOCMATLAB:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCMATLAB:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCMATLAB:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCMATLAB:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCMATLAB:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCMATLAB:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCMATLAB:TODSUM")
}

record(bo, "SOFT-IOCMATLAB:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCMATLAB:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCMATLAB:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCMATLAB:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATLAB:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCMATLAB:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCMATLAB:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCMATLAB:HEARTBEATE01")
  field(INP, "SOFT-IOCMATLAB:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCMATLAB:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCMATLAB:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCMATLAB:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCMATLAB:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCMATLAB:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCMATLAB:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCMATLAB:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCMATLAB:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCMATLAB:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCMATLAB:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCMATLAB:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCMATLAB:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCMATLAB:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCMATLAB:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATLAB:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCMATLAB:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCMATLAB:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCMATLAB:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATLAB:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCMATLAB:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCMATLAB:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCMATLAB:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATLAB:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCMATLAB:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCMATLAB:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCMATLAB:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATLAB:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCMATLAB:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCMATLAB:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCMATLAB:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATLAB:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCMATLAB:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCMATLAB:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCMATLAB:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATLAB:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCMATLAB:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCMATLAB:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCMATLAB:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATLAB:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCMATLAB:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCMATLAB:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCMATLAB:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATLAB:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCMATLAB:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCMATLAB:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCMATLAB:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATLAB:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCMATLAB:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCMATLAB:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCMATLAB:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCMATLAB:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCMATLAB:HEARTBEATCLC")
  field(INP, "SOFT-IOCMATLAB:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCMATLAB:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCMATLAB:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATLAB:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCMATLAB:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCMATLAB:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCMATLAB:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCMATLAB:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCMATLAB:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCMATLAB:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocmat")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCMATLAB:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocmat")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMATLAB:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCPSINJ:INFO") {
  field(DESC, "SOFT-IOCPSINJ Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPSINJ:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCPSINJ:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCPSINJ:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCPSINJ:TODDIFF")
}

record(longin, "SOFT-IOCPSINJ:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCPSINJ:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCPSINJ:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCPSINJ:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCPSINJ:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCPSINJ:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCPSINJ:TODSUM")
}

record(bo, "SOFT-IOCPSINJ:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCPSINJ:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCPSINJ:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCPSINJ:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSINJ:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCPSINJ:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCPSINJ:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCPSINJ:HEARTBEATE01")
  field(INP, "SOFT-IOCPSINJ:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCPSINJ:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCPSINJ:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCPSINJ:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCPSINJ:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCPSINJ:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCPSINJ:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCPSINJ:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCPSINJ:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCPSINJ:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCPSINJ:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCPSINJ:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCPSINJ:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCPSINJ:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCPSINJ:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSINJ:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCPSINJ:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCPSINJ:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCPSINJ:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSINJ:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCPSINJ:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCPSINJ:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCPSINJ:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSINJ:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCPSINJ:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCPSINJ:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCPSINJ:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSINJ:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCPSINJ:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCPSINJ:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCPSINJ:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSINJ:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCPSINJ:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCPSINJ:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCPSINJ:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSINJ:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCPSINJ:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCPSINJ:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCPSINJ:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSINJ:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCPSINJ:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCPSINJ:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCPSINJ:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSINJ:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCPSINJ:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCPSINJ:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCPSINJ:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSINJ:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCPSINJ:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCPSINJ:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCPSINJ:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCPSINJ:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCPSINJ:HEARTBEATCLC")
  field(INP, "SOFT-IOCPSINJ:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCPSINJ:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCPSINJ:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSINJ:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCPSINJ:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCPSINJ:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCPSINJ:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCPSINJ:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCPSINJ:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCPSINJ:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocpsinj")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCPSINJ:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocpsinj")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPSINJ:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCPSSPR:INFO") {
  field(DESC, "SOFT-IOCPSSPR Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPSSPR:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCPSSPR:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCPSSPR:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCPSSPR:TODDIFF")
}

record(longin, "SOFT-IOCPSSPR:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCPSSPR:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCPSSPR:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCPSSPR:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCPSSPR:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCPSSPR:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCPSSPR:TODSUM")
}

record(bo, "SOFT-IOCPSSPR:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCPSSPR:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCPSSPR:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCPSSPR:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSSPR:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCPSSPR:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCPSSPR:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCPSSPR:HEARTBEATE01")
  field(INP, "SOFT-IOCPSSPR:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCPSSPR:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCPSSPR:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCPSSPR:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCPSSPR:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCPSSPR:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCPSSPR:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCPSSPR:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCPSSPR:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCPSSPR:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCPSSPR:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCPSSPR:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCPSSPR:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCPSSPR:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCPSSPR:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSSPR:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCPSSPR:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCPSSPR:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCPSSPR:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSSPR:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCPSSPR:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCPSSPR:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCPSSPR:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSSPR:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCPSSPR:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCPSSPR:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCPSSPR:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSSPR:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCPSSPR:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCPSSPR:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCPSSPR:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSSPR:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCPSSPR:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCPSSPR:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCPSSPR:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSSPR:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCPSSPR:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCPSSPR:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCPSSPR:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSSPR:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCPSSPR:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCPSSPR:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCPSSPR:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSSPR:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCPSSPR:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCPSSPR:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCPSSPR:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSSPR:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCPSSPR:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCPSSPR:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCPSSPR:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCPSSPR:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCPSSPR:HEARTBEATCLC")
  field(INP, "SOFT-IOCPSSPR:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCPSSPR:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCPSSPR:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSSPR:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCPSSPR:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCPSSPR:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCPSSPR:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCPSSPR:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCPSSPR:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCPSSPR:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocpsspr")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCPSSPR:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocpsspr")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPSSPR:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCPSKICK:INFO") {
  field(DESC, "SOFT-IOCPSKICK Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPSKICK:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCPSKICK:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCPSKICK:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCPSKICK:TODDIFF")
}

record(longin, "SOFT-IOCPSKICK:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCPSKICK:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCPSKICK:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCPSKICK:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCPSKICK:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCPSKICK:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCPSKICK:TODSUM")
}

record(bo, "SOFT-IOCPSKICK:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCPSKICK:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCPSKICK:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCPSKICK:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSKICK:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCPSKICK:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCPSKICK:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCPSKICK:HEARTBEATE01")
  field(INP, "SOFT-IOCPSKICK:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCPSKICK:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCPSKICK:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCPSKICK:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCPSKICK:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCPSKICK:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCPSKICK:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCPSKICK:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCPSKICK:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCPSKICK:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCPSKICK:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCPSKICK:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCPSKICK:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCPSKICK:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCPSKICK:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSKICK:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCPSKICK:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCPSKICK:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCPSKICK:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSKICK:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCPSKICK:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCPSKICK:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCPSKICK:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSKICK:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCPSKICK:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCPSKICK:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCPSKICK:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSKICK:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCPSKICK:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCPSKICK:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCPSKICK:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSKICK:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCPSKICK:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCPSKICK:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCPSKICK:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSKICK:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCPSKICK:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCPSKICK:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCPSKICK:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSKICK:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCPSKICK:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCPSKICK:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCPSKICK:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSKICK:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCPSKICK:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCPSKICK:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCPSKICK:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSKICK:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCPSKICK:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCPSKICK:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCPSKICK:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCPSKICK:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCPSKICK:HEARTBEATCLC")
  field(INP, "SOFT-IOCPSKICK:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCPSKICK:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCPSKICK:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPSKICK:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCPSKICK:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCPSKICK:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCPSKICK:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCPSKICK:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCPSKICK:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCPSKICK:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocpskick")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCPSKICK:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocpskick")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPSKICK:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCSSA-BOO-RF:INFO") {
  field(DESC, "SOFT-IOCSSA-BOO-RF Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCSSA-BOO-RF:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCSSA-BOO-RF:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCSSA-BOO-RF:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCSSA-BOO-RF:TODDIFF")
}

record(longin, "SOFT-IOCSSA-BOO-RF:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCSSA-BOO-RF:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCSSA-BOO-RF:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCSSA-BOO-RF:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCSSA-BOO-RF:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCSSA-BOO-RF:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCSSA-BOO-RF:TODSUM")
}

record(bo, "SOFT-IOCSSA-BOO-RF:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCSSA-BOO-RF:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCSSA-BOO-RF:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCSSA-BOO-RF:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSA-BOO-RF:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCSSA-BOO-RF:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCSSA-BOO-RF:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCSSA-BOO-RF:HEARTBEATE01")
  field(INP, "SOFT-IOCSSA-BOO-RF:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCSSA-BOO-RF:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCSSA-BOO-RF:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCSSA-BOO-RF:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCSSA-BOO-RF:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCSSA-BOO-RF:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCSSA-BOO-RF:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCSSA-BOO-RF:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCSSA-BOO-RF:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCSSA-BOO-RF:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCSSA-BOO-RF:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCSSA-BOO-RF:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCSSA-BOO-RF:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCSSA-BOO-RF:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCSSA-BOO-RF:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSA-BOO-RF:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCSSA-BOO-RF:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCSSA-BOO-RF:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCSSA-BOO-RF:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSA-BOO-RF:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCSSA-BOO-RF:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCSSA-BOO-RF:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCSSA-BOO-RF:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSA-BOO-RF:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCSSA-BOO-RF:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCSSA-BOO-RF:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCSSA-BOO-RF:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSA-BOO-RF:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCSSA-BOO-RF:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCSSA-BOO-RF:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCSSA-BOO-RF:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSA-BOO-RF:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCSSA-BOO-RF:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCSSA-BOO-RF:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCSSA-BOO-RF:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSA-BOO-RF:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCSSA-BOO-RF:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCSSA-BOO-RF:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCSSA-BOO-RF:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSA-BOO-RF:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCSSA-BOO-RF:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCSSA-BOO-RF:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCSSA-BOO-RF:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSA-BOO-RF:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCSSA-BOO-RF:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCSSA-BOO-RF:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCSSA-BOO-RF:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSA-BOO-RF:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCSSA-BOO-RF:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCSSA-BOO-RF:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCSSA-BOO-RF:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCSSA-BOO-RF:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCSSA-BOO-RF:HEARTBEATCLC")
  field(INP, "SOFT-IOCSSA-BOO-RF:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCSSA-BOO-RF:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCSSA-BOO-RF:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSA-BOO-RF:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCSSA-BOO-RF:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCSSA-BOO-RF:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCSSA-BOO-RF:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCSSA-BOO-RF:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCSSA-BOO-RF:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCSSA-BOO-RF:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocssa")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCSSA-BOO-RF:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocssa")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCSSA-BOO-RF:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCBUCKET:INFO") {
  field(DESC, "SOFT-IOCBUCKET Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCBUCKET:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCBUCKET:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCBUCKET:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCBUCKET:TODDIFF")
}

record(longin, "SOFT-IOCBUCKET:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCBUCKET:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCBUCKET:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCBUCKET:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCBUCKET:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCBUCKET:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCBUCKET:TODSUM")
}

record(bo, "SOFT-IOCBUCKET:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCBUCKET:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCBUCKET:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCBUCKET:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBUCKET:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCBUCKET:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCBUCKET:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCBUCKET:HEARTBEATE01")
  field(INP, "SOFT-IOCBUCKET:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCBUCKET:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCBUCKET:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCBUCKET:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCBUCKET:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCBUCKET:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCBUCKET:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCBUCKET:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCBUCKET:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCBUCKET:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCBUCKET:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCBUCKET:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCBUCKET:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCBUCKET:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCBUCKET:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBUCKET:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCBUCKET:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCBUCKET:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCBUCKET:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBUCKET:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCBUCKET:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCBUCKET:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCBUCKET:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBUCKET:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCBUCKET:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCBUCKET:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCBUCKET:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBUCKET:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCBUCKET:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCBUCKET:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCBUCKET:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBUCKET:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCBUCKET:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCBUCKET:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCBUCKET:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBUCKET:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCBUCKET:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCBUCKET:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCBUCKET:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBUCKET:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCBUCKET:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCBUCKET:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCBUCKET:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBUCKET:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCBUCKET:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCBUCKET:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCBUCKET:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBUCKET:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCBUCKET:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCBUCKET:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCBUCKET:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCBUCKET:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCBUCKET:HEARTBEATCLC")
  field(INP, "SOFT-IOCBUCKET:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCBUCKET:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCBUCKET:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBUCKET:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCBUCKET:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCBUCKET:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCBUCKET:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCBUCKET:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCBUCKET:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCBUCKET:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocbuck")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCBUCKET:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocbuck")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCBUCKET:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCHLS:INFO") {
  field(DESC, "SOFT-IOCHLS Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCHLS:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCHLS:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCHLS:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCHLS:TODDIFF")
}

record(longin, "SOFT-IOCHLS:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCHLS:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCHLS:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCHLS:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCHLS:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCHLS:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCHLS:TODSUM")
}

record(bo, "SOFT-IOCHLS:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCHLS:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCHLS:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCHLS:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCHLS:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCHLS:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCHLS:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCHLS:HEARTBEATE01")
  field(INP, "SOFT-IOCHLS:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCHLS:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCHLS:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCHLS:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCHLS:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCHLS:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCHLS:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCHLS:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCHLS:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCHLS:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCHLS:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCHLS:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCHLS:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCHLS:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCHLS:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCHLS:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCHLS:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCHLS:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCHLS:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCHLS:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCHLS:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCHLS:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCHLS:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCHLS:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCHLS:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCHLS:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCHLS:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCHLS:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCHLS:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCHLS:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCHLS:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCHLS:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCHLS:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCHLS:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCHLS:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCHLS:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCHLS:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCHLS:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCHLS:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCHLS:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCHLS:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCHLS:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCHLS:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCHLS:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCHLS:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCHLS:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCHLS:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCHLS:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCHLS:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCHLS:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCHLS:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCHLS:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCHLS:HEARTBEATCLC")
  field(INP, "SOFT-IOCHLS:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCHLS:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCHLS:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCHLS:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCHLS:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCHLS:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCHLS:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCHLS:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCHLS:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCHLS:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iochls")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCHLS:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iochls")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCHLS:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCTEMP:INFO") {
  field(DESC, "SOFT-IOCTEMP Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCTEMP:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCTEMP:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCTEMP:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCTEMP:TODDIFF")
}

record(longin, "SOFT-IOCTEMP:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCTEMP:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCTEMP:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCTEMP:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCTEMP:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCTEMP:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCTEMP:TODSUM")
}

record(bo, "SOFT-IOCTEMP:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCTEMP:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCTEMP:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCTEMP:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCTEMP:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCTEMP:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCTEMP:HEARTBEATE01")
  field(INP, "SOFT-IOCTEMP:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCTEMP:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCTEMP:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCTEMP:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCTEMP:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCTEMP:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCTEMP:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCTEMP:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCTEMP:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCTEMP:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCTEMP:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCTEMP:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCTEMP:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCTEMP:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCTEMP:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCTEMP:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCTEMP:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCTEMP:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCTEMP:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCTEMP:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCTEMP:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCTEMP:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCTEMP:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCTEMP:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCTEMP:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCTEMP:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCTEMP:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCTEMP:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCTEMP:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCTEMP:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCTEMP:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCTEMP:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCTEMP:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCTEMP:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCTEMP:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCTEMP:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCTEMP:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCTEMP:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCTEMP:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCTEMP:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCTEMP:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCTEMP:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCTEMP:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCTEMP:HEARTBEATCLC")
  field(INP, "SOFT-IOCTEMP:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCTEMP:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCTEMP:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCTEMP:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCTEMP:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCTEMP:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCTEMP:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCTEMP:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCTEMP:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "ioctemp")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCTEMP:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "ioctemp")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCTEMP:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCPLCBL:INFO") {
  field(DESC, "SOFT-IOCPLCBL Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPLCBL:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCPLCBL:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCPLCBL:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCPLCBL:TODDIFF")
}

record(longin, "SOFT-IOCPLCBL:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCPLCBL:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCPLCBL:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCPLCBL:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCPLCBL:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCPLCBL:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCPLCBL:TODSUM")
}

record(bo, "SOFT-IOCPLCBL:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCPLCBL:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCPLCBL:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCPLCBL:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCBL:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCPLCBL:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCPLCBL:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCPLCBL:HEARTBEATE01")
  field(INP, "SOFT-IOCPLCBL:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCPLCBL:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCPLCBL:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCPLCBL:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCPLCBL:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCPLCBL:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCPLCBL:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCPLCBL:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCPLCBL:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCPLCBL:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCPLCBL:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCPLCBL:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCPLCBL:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCPLCBL:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCPLCBL:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCBL:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCPLCBL:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCPLCBL:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCPLCBL:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCBL:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCPLCBL:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCPLCBL:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCPLCBL:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCBL:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCPLCBL:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCPLCBL:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCPLCBL:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCBL:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCPLCBL:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCPLCBL:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCPLCBL:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCBL:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCPLCBL:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCPLCBL:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCPLCBL:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCBL:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCPLCBL:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCPLCBL:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCPLCBL:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCBL:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCPLCBL:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCPLCBL:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCPLCBL:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCBL:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCPLCBL:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCPLCBL:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCPLCBL:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCBL:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCPLCBL:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCPLCBL:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCPLCBL:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCPLCBL:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCPLCBL:HEARTBEATCLC")
  field(INP, "SOFT-IOCPLCBL:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCPLCBL:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCPLCBL:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCBL:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCPLCBL:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCPLCBL:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCPLCBL:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCPLCBL:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCPLCBL:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCPLCBL:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocplcbl")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCPLCBL:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocplcbl")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPLCBL:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCPLCSPR:INFO") {
  field(DESC, "SOFT-IOCPLCSPR Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPLCSPR:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCPLCSPR:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCPLCSPR:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCPLCSPR:TODDIFF")
}

record(longin, "SOFT-IOCPLCSPR:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCPLCSPR:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCPLCSPR:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCPLCSPR:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCPLCSPR:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCPLCSPR:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCPLCSPR:TODSUM")
}

record(bo, "SOFT-IOCPLCSPR:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCPLCSPR:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCPLCSPR:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCPLCSPR:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCSPR:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCPLCSPR:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCPLCSPR:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCPLCSPR:HEARTBEATE01")
  field(INP, "SOFT-IOCPLCSPR:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCPLCSPR:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCPLCSPR:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCPLCSPR:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCPLCSPR:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCPLCSPR:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCPLCSPR:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCPLCSPR:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCPLCSPR:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCPLCSPR:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCPLCSPR:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCPLCSPR:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCPLCSPR:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCPLCSPR:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCPLCSPR:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCSPR:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCPLCSPR:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCPLCSPR:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCPLCSPR:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCSPR:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCPLCSPR:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCPLCSPR:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCPLCSPR:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCSPR:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCPLCSPR:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCPLCSPR:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCPLCSPR:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCSPR:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCPLCSPR:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCPLCSPR:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCPLCSPR:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCSPR:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCPLCSPR:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCPLCSPR:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCPLCSPR:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCSPR:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCPLCSPR:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCPLCSPR:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCPLCSPR:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCSPR:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCPLCSPR:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCPLCSPR:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCPLCSPR:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCSPR:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCPLCSPR:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCPLCSPR:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCPLCSPR:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCSPR:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCPLCSPR:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCPLCSPR:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCPLCSPR:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCPLCSPR:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCPLCSPR:HEARTBEATCLC")
  field(INP, "SOFT-IOCPLCSPR:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCPLCSPR:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCPLCSPR:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPLCSPR:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCPLCSPR:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCPLCSPR:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCPLCSPR:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCPLCSPR:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCPLCSPR:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCPLCSPR:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocplcspr")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCPLCSPR:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocplcspr")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPLCSPR:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCTESLA:INFO") {
  field(DESC, "SOFT-IOCTESLA Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCTESLA:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCTESLA:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCTESLA:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCTESLA:TODDIFF")
}

record(longin, "SOFT-IOCTESLA:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCTESLA:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCTESLA:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCTESLA:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCTESLA:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCTESLA:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCTESLA:TODSUM")
}

record(bo, "SOFT-IOCTESLA:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCTESLA:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCTESLA:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCTESLA:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTESLA:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCTESLA:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCTESLA:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCTESLA:HEARTBEATE01")
  field(INP, "SOFT-IOCTESLA:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCTESLA:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCTESLA:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCTESLA:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCTESLA:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCTESLA:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCTESLA:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCTESLA:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCTESLA:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCTESLA:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCTESLA:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCTESLA:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCTESLA:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCTESLA:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCTESLA:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTESLA:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCTESLA:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCTESLA:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCTESLA:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTESLA:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCTESLA:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCTESLA:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCTESLA:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTESLA:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCTESLA:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCTESLA:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCTESLA:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTESLA:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCTESLA:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCTESLA:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCTESLA:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTESLA:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCTESLA:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCTESLA:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCTESLA:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTESLA:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCTESLA:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCTESLA:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCTESLA:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTESLA:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCTESLA:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCTESLA:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCTESLA:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTESLA:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCTESLA:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCTESLA:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCTESLA:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTESLA:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCTESLA:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCTESLA:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCTESLA:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCTESLA:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCTESLA:HEARTBEATCLC")
  field(INP, "SOFT-IOCTESLA:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCTESLA:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCTESLA:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTESLA:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCTESLA:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCTESLA:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCTESLA:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCTESLA:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCTESLA:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCTESLA:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "ioctesla")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCTESLA:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "ioctesla")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCTESLA:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCIDCTRL:INFO") {
  field(DESC, "SOFT-IOCIDCTRL Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCIDCTRL:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCIDCTRL:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCIDCTRL:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCIDCTRL:TODDIFF")
}

record(longin, "SOFT-IOCIDCTRL:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCIDCTRL:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCIDCTRL:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCIDCTRL:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCIDCTRL:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCIDCTRL:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCIDCTRL:TODSUM")
}

record(bo, "SOFT-IOCIDCTRL:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCIDCTRL:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCIDCTRL:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCIDCTRL:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDCTRL:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCIDCTRL:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCIDCTRL:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCIDCTRL:HEARTBEATE01")
  field(INP, "SOFT-IOCIDCTRL:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCIDCTRL:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCIDCTRL:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCIDCTRL:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCIDCTRL:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCIDCTRL:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCIDCTRL:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCIDCTRL:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCIDCTRL:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCIDCTRL:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCIDCTRL:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCIDCTRL:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCIDCTRL:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCIDCTRL:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCIDCTRL:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDCTRL:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCIDCTRL:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCIDCTRL:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCIDCTRL:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDCTRL:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCIDCTRL:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCIDCTRL:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCIDCTRL:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDCTRL:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCIDCTRL:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCIDCTRL:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCIDCTRL:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDCTRL:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCIDCTRL:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCIDCTRL:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCIDCTRL:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDCTRL:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCIDCTRL:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCIDCTRL:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCIDCTRL:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDCTRL:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCIDCTRL:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCIDCTRL:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCIDCTRL:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDCTRL:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCIDCTRL:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCIDCTRL:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCIDCTRL:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDCTRL:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCIDCTRL:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCIDCTRL:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCIDCTRL:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDCTRL:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCIDCTRL:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCIDCTRL:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCIDCTRL:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCIDCTRL:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCIDCTRL:HEARTBEATCLC")
  field(INP, "SOFT-IOCIDCTRL:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCIDCTRL:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCIDCTRL:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDCTRL:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCIDCTRL:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCIDCTRL:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCIDCTRL:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCIDCTRL:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCIDCTRL:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCIDCTRL:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocidctrl")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCIDCTRL:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocidctrl")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCIDCTRL:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCIDINTLK:INFO") {
  field(DESC, "SOFT-IOCIDINTLK Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCIDINTLK:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCIDINTLK:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCIDINTLK:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCIDINTLK:TODDIFF")
}

record(longin, "SOFT-IOCIDINTLK:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCIDINTLK:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCIDINTLK:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCIDINTLK:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCIDINTLK:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCIDINTLK:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCIDINTLK:TODSUM")
}

record(bo, "SOFT-IOCIDINTLK:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCIDINTLK:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCIDINTLK:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCIDINTLK:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDINTLK:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCIDINTLK:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCIDINTLK:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCIDINTLK:HEARTBEATE01")
  field(INP, "SOFT-IOCIDINTLK:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCIDINTLK:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCIDINTLK:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCIDINTLK:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCIDINTLK:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCIDINTLK:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCIDINTLK:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCIDINTLK:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCIDINTLK:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCIDINTLK:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCIDINTLK:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCIDINTLK:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCIDINTLK:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCIDINTLK:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCIDINTLK:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDINTLK:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCIDINTLK:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCIDINTLK:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCIDINTLK:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDINTLK:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCIDINTLK:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCIDINTLK:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCIDINTLK:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDINTLK:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCIDINTLK:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCIDINTLK:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCIDINTLK:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDINTLK:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCIDINTLK:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCIDINTLK:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCIDINTLK:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDINTLK:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCIDINTLK:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCIDINTLK:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCIDINTLK:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDINTLK:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCIDINTLK:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCIDINTLK:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCIDINTLK:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDINTLK:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCIDINTLK:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCIDINTLK:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCIDINTLK:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDINTLK:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCIDINTLK:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCIDINTLK:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCIDINTLK:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDINTLK:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCIDINTLK:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCIDINTLK:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCIDINTLK:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCIDINTLK:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCIDINTLK:HEARTBEATCLC")
  field(INP, "SOFT-IOCIDINTLK:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCIDINTLK:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCIDINTLK:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDINTLK:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCIDINTLK:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCIDINTLK:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCIDINTLK:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCIDINTLK:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCIDINTLK:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCIDINTLK:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocidintlk")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCIDINTLK:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocidintlk")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCIDINTLK:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCIVUNINTLK:INFO") {
  field(DESC, "SOFT-IOCIVUNINTLK Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCIVUNINTLK:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCIVUNINTLK:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCIVUNINTLK:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCIVUNINTLK:TODDIFF")
}

record(longin, "SOFT-IOCIVUNINTLK:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCIVUNINTLK:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCIVUNINTLK:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCIVUNINTLK:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCIVUNINTLK:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCIVUNINTLK:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCIVUNINTLK:TODSUM")
}

record(bo, "SOFT-IOCIVUNINTLK:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCIVUNINTLK:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCIVUNINTLK:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCIVUNINTLK:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIVUNINTLK:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCIVUNINTLK:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCIVUNINTLK:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCIVUNINTLK:HEARTBEATE01")
  field(INP, "SOFT-IOCIVUNINTLK:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCIVUNINTLK:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCIVUNINTLK:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCIVUNINTLK:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCIVUNINTLK:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCIVUNINTLK:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCIVUNINTLK:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCIVUNINTLK:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCIVUNINTLK:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCIVUNINTLK:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCIVUNINTLK:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCIVUNINTLK:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCIVUNINTLK:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCIVUNINTLK:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCIVUNINTLK:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIVUNINTLK:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCIVUNINTLK:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCIVUNINTLK:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCIVUNINTLK:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIVUNINTLK:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCIVUNINTLK:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCIVUNINTLK:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCIVUNINTLK:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIVUNINTLK:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCIVUNINTLK:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCIVUNINTLK:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCIVUNINTLK:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIVUNINTLK:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCIVUNINTLK:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCIVUNINTLK:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCIVUNINTLK:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIVUNINTLK:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCIVUNINTLK:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCIVUNINTLK:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCIVUNINTLK:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIVUNINTLK:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCIVUNINTLK:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCIVUNINTLK:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCIVUNINTLK:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIVUNINTLK:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCIVUNINTLK:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCIVUNINTLK:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCIVUNINTLK:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIVUNINTLK:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCIVUNINTLK:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCIVUNINTLK:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCIVUNINTLK:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIVUNINTLK:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCIVUNINTLK:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCIVUNINTLK:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCIVUNINTLK:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCIVUNINTLK:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCIVUNINTLK:HEARTBEATCLC")
  field(INP, "SOFT-IOCIVUNINTLK:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCIVUNINTLK:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCIVUNINTLK:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIVUNINTLK:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCIVUNINTLK:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCIVUNINTLK:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCIVUNINTLK:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCIVUNINTLK:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCIVUNINTLK:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCIVUNINTLK:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocidintlk")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCIVUNINTLK:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocidintlk")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCIVUNINTLK:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCMCORTRIM:INFO") {
  field(DESC, "SOFT-IOCMCORTRIM Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMCORTRIM:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCMCORTRIM:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCMCORTRIM:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCMCORTRIM:TODDIFF")
}

record(longin, "SOFT-IOCMCORTRIM:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCMCORTRIM:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCMCORTRIM:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCMCORTRIM:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCMCORTRIM:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCMCORTRIM:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCMCORTRIM:TODSUM")
}

record(bo, "SOFT-IOCMCORTRIM:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCMCORTRIM:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCMCORTRIM:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCMCORTRIM:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMCORTRIM:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCMCORTRIM:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCMCORTRIM:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCMCORTRIM:HEARTBEATE01")
  field(INP, "SOFT-IOCMCORTRIM:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCMCORTRIM:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCMCORTRIM:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCMCORTRIM:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCMCORTRIM:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCMCORTRIM:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCMCORTRIM:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCMCORTRIM:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCMCORTRIM:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCMCORTRIM:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCMCORTRIM:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCMCORTRIM:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCMCORTRIM:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCMCORTRIM:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCMCORTRIM:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMCORTRIM:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCMCORTRIM:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCMCORTRIM:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCMCORTRIM:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMCORTRIM:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCMCORTRIM:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCMCORTRIM:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCMCORTRIM:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMCORTRIM:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCMCORTRIM:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCMCORTRIM:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCMCORTRIM:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMCORTRIM:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCMCORTRIM:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCMCORTRIM:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCMCORTRIM:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMCORTRIM:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCMCORTRIM:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCMCORTRIM:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCMCORTRIM:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMCORTRIM:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCMCORTRIM:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCMCORTRIM:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCMCORTRIM:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMCORTRIM:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCMCORTRIM:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCMCORTRIM:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCMCORTRIM:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMCORTRIM:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCMCORTRIM:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCMCORTRIM:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCMCORTRIM:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMCORTRIM:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCMCORTRIM:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCMCORTRIM:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCMCORTRIM:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCMCORTRIM:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCMCORTRIM:HEARTBEATCLC")
  field(INP, "SOFT-IOCMCORTRIM:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCMCORTRIM:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCMCORTRIM:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMCORTRIM:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCMCORTRIM:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCMCORTRIM:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCMCORTRIM:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCMCORTRIM:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCMCORTRIM:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCMCORTRIM:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "mcortrim")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCMCORTRIM:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "mcortrim")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMCORTRIM:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCINJEFF:INFO") {
  field(DESC, "SOFT-IOCINJEFF Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCINJEFF:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCINJEFF:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCINJEFF:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCINJEFF:TODDIFF")
}

record(longin, "SOFT-IOCINJEFF:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCINJEFF:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCINJEFF:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCINJEFF:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCINJEFF:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCINJEFF:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCINJEFF:TODSUM")
}

record(bo, "SOFT-IOCINJEFF:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCINJEFF:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCINJEFF:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCINJEFF:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCINJEFF:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCINJEFF:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCINJEFF:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCINJEFF:HEARTBEATE01")
  field(INP, "SOFT-IOCINJEFF:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCINJEFF:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCINJEFF:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCINJEFF:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCINJEFF:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCINJEFF:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCINJEFF:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCINJEFF:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCINJEFF:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCINJEFF:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCINJEFF:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCINJEFF:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCINJEFF:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCINJEFF:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCINJEFF:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCINJEFF:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCINJEFF:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCINJEFF:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCINJEFF:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCINJEFF:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCINJEFF:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCINJEFF:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCINJEFF:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCINJEFF:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCINJEFF:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCINJEFF:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCINJEFF:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCINJEFF:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCINJEFF:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCINJEFF:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCINJEFF:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCINJEFF:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCINJEFF:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCINJEFF:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCINJEFF:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCINJEFF:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCINJEFF:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCINJEFF:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCINJEFF:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCINJEFF:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCINJEFF:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCINJEFF:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCINJEFF:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCINJEFF:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCINJEFF:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCINJEFF:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCINJEFF:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCINJEFF:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCINJEFF:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCINJEFF:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCINJEFF:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCINJEFF:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCINJEFF:HEARTBEATCLC")
  field(INP, "SOFT-IOCINJEFF:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCINJEFF:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCINJEFF:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCINJEFF:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCINJEFF:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCINJEFF:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCINJEFF:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCINJEFF:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCINJEFF:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCINJEFF:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocinjeff")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCINJEFF:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocinjeff")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCINJEFF:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCCAM-GTL-CHOP1:INFO") {
  field(DESC, "SOFT-IOCCAM-GTL-CHOP1 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-GTL-CHOP1:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCCAM-GTL-CHOP1:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP1:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:TODDIFF")
}

record(longin, "SOFT-IOCCAM-GTL-CHOP1:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCCAM-GTL-CHOP1:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCCAM-GTL-CHOP1:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP1:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP1:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:TODSUM")
}

record(bo, "SOFT-IOCCAM-GTL-CHOP1:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCCAM-GTL-CHOP1:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE01")
  field(INP, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATCLC")
  field(INP, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP1:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCCAM-GTL-CHOP1:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCCAM-GTL-CHOP1:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-GTL-CHOP1:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCCAM-GTL-CHOP2:INFO") {
  field(DESC, "SOFT-IOCCAM-GTL-CHOP2 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-GTL-CHOP2:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCCAM-GTL-CHOP2:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP2:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:TODDIFF")
}

record(longin, "SOFT-IOCCAM-GTL-CHOP2:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCCAM-GTL-CHOP2:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCCAM-GTL-CHOP2:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP2:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP2:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:TODSUM")
}

record(bo, "SOFT-IOCCAM-GTL-CHOP2:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCCAM-GTL-CHOP2:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE01")
  field(INP, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATCLC")
  field(INP, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCCAM-GTL-CHOP2:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCCAM-GTL-CHOP2:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCCAM-GTL-CHOP2:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-GTL-CHOP2:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCCAM-LTB-B1:INFO") {
  field(DESC, "SOFT-IOCCAM-LTB-B1 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-LTB-B1:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCCAM-LTB-B1:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCCAM-LTB-B1:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCCAM-LTB-B1:TODDIFF")
}

record(longin, "SOFT-IOCCAM-LTB-B1:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCCAM-LTB-B1:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCCAM-LTB-B1:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCCAM-LTB-B1:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCCAM-LTB-B1:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCCAM-LTB-B1:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCCAM-LTB-B1:TODSUM")
}

record(bo, "SOFT-IOCCAM-LTB-B1:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCCAM-LTB-B1:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCCAM-LTB-B1:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCCAM-LTB-B1:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTB-B1:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCCAM-LTB-B1:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCCAM-LTB-B1:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCCAM-LTB-B1:HEARTBEATE01")
  field(INP, "SOFT-IOCCAM-LTB-B1:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCCAM-LTB-B1:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCCAM-LTB-B1:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCCAM-LTB-B1:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCCAM-LTB-B1:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCCAM-LTB-B1:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCCAM-LTB-B1:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCCAM-LTB-B1:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCCAM-LTB-B1:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCCAM-LTB-B1:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCCAM-LTB-B1:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCCAM-LTB-B1:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCCAM-LTB-B1:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCCAM-LTB-B1:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCCAM-LTB-B1:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTB-B1:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCCAM-LTB-B1:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCCAM-LTB-B1:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCCAM-LTB-B1:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTB-B1:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCCAM-LTB-B1:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCCAM-LTB-B1:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCCAM-LTB-B1:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTB-B1:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCCAM-LTB-B1:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCCAM-LTB-B1:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCCAM-LTB-B1:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTB-B1:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCCAM-LTB-B1:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCCAM-LTB-B1:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCCAM-LTB-B1:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTB-B1:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCCAM-LTB-B1:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCCAM-LTB-B1:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCCAM-LTB-B1:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTB-B1:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCCAM-LTB-B1:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCCAM-LTB-B1:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCCAM-LTB-B1:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTB-B1:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCCAM-LTB-B1:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCCAM-LTB-B1:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCCAM-LTB-B1:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTB-B1:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCCAM-LTB-B1:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCCAM-LTB-B1:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCCAM-LTB-B1:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTB-B1:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCCAM-LTB-B1:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCCAM-LTB-B1:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCCAM-LTB-B1:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCCAM-LTB-B1:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCCAM-LTB-B1:HEARTBEATCLC")
  field(INP, "SOFT-IOCCAM-LTB-B1:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCCAM-LTB-B1:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCCAM-LTB-B1:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTB-B1:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCCAM-LTB-B1:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCCAM-LTB-B1:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCCAM-LTB-B1:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCCAM-LTB-B1:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCCAM-LTB-B1:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCCAM-LTB-B1:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCCAM-LTB-B1:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-LTB-B1:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCCAM-LTD:INFO") {
  field(DESC, "SOFT-IOCCAM-LTD Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-LTD:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCCAM-LTD:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCCAM-LTD:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCCAM-LTD:TODDIFF")
}

record(longin, "SOFT-IOCCAM-LTD:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCCAM-LTD:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCCAM-LTD:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCCAM-LTD:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCCAM-LTD:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCCAM-LTD:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCCAM-LTD:TODSUM")
}

record(bo, "SOFT-IOCCAM-LTD:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCCAM-LTD:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCCAM-LTD:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCCAM-LTD:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTD:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCCAM-LTD:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCCAM-LTD:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCCAM-LTD:HEARTBEATE01")
  field(INP, "SOFT-IOCCAM-LTD:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCCAM-LTD:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCCAM-LTD:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCCAM-LTD:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCCAM-LTD:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCCAM-LTD:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCCAM-LTD:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCCAM-LTD:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCCAM-LTD:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCCAM-LTD:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCCAM-LTD:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCCAM-LTD:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCCAM-LTD:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCCAM-LTD:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCCAM-LTD:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTD:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCCAM-LTD:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCCAM-LTD:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCCAM-LTD:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTD:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCCAM-LTD:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCCAM-LTD:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCCAM-LTD:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTD:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCCAM-LTD:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCCAM-LTD:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCCAM-LTD:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTD:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCCAM-LTD:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCCAM-LTD:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCCAM-LTD:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTD:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCCAM-LTD:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCCAM-LTD:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCCAM-LTD:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTD:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCCAM-LTD:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCCAM-LTD:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCCAM-LTD:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTD:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCCAM-LTD:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCCAM-LTD:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCCAM-LTD:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTD:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCCAM-LTD:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCCAM-LTD:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCCAM-LTD:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTD:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCCAM-LTD:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCCAM-LTD:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCCAM-LTD:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCCAM-LTD:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCCAM-LTD:HEARTBEATCLC")
  field(INP, "SOFT-IOCCAM-LTD:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCCAM-LTD:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCCAM-LTD:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-LTD:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCCAM-LTD:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCCAM-LTD:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCCAM-LTD:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCCAM-LTD:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCCAM-LTD:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCCAM-LTD:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCCAM-LTD:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-LTD:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCCAM-BOO-G13:INFO") {
  field(DESC, "SOFT-IOCCAM-BOO-G13 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-BOO-G13:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCCAM-BOO-G13:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCCAM-BOO-G13:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCCAM-BOO-G13:TODDIFF")
}

record(longin, "SOFT-IOCCAM-BOO-G13:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCCAM-BOO-G13:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCCAM-BOO-G13:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCCAM-BOO-G13:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCCAM-BOO-G13:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCCAM-BOO-G13:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCCAM-BOO-G13:TODSUM")
}

record(bo, "SOFT-IOCCAM-BOO-G13:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCCAM-BOO-G13:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCCAM-BOO-G13:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCCAM-BOO-G13:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G13:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCCAM-BOO-G13:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCCAM-BOO-G13:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCCAM-BOO-G13:HEARTBEATE01")
  field(INP, "SOFT-IOCCAM-BOO-G13:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCCAM-BOO-G13:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCCAM-BOO-G13:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCCAM-BOO-G13:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCCAM-BOO-G13:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCCAM-BOO-G13:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCCAM-BOO-G13:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCCAM-BOO-G13:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCCAM-BOO-G13:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCCAM-BOO-G13:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCCAM-BOO-G13:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCCAM-BOO-G13:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCCAM-BOO-G13:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCCAM-BOO-G13:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCCAM-BOO-G13:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G13:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCCAM-BOO-G13:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G13:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCCAM-BOO-G13:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G13:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCCAM-BOO-G13:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G13:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCCAM-BOO-G13:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G13:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCCAM-BOO-G13:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G13:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCCAM-BOO-G13:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G13:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCCAM-BOO-G13:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G13:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCCAM-BOO-G13:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G13:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCCAM-BOO-G13:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G13:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCCAM-BOO-G13:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G13:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCCAM-BOO-G13:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G13:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCCAM-BOO-G13:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G13:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCCAM-BOO-G13:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G13:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCCAM-BOO-G13:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G13:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCCAM-BOO-G13:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G13:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCCAM-BOO-G13:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G13:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCCAM-BOO-G13:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G13:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCCAM-BOO-G13:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCCAM-BOO-G13:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCCAM-BOO-G13:HEARTBEATCLC")
  field(INP, "SOFT-IOCCAM-BOO-G13:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCCAM-BOO-G13:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCCAM-BOO-G13:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G13:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCCAM-BOO-G13:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G13:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCCAM-BOO-G13:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCCAM-BOO-G13:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCCAM-BOO-G13:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCCAM-BOO-G13:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCCAM-BOO-G13:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-BOO-G13:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCCAM-BOO-G49:INFO") {
  field(DESC, "SOFT-IOCCAM-BOO-G49 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-BOO-G49:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCCAM-BOO-G49:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCCAM-BOO-G49:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCCAM-BOO-G49:TODDIFF")
}

record(longin, "SOFT-IOCCAM-BOO-G49:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCCAM-BOO-G49:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCCAM-BOO-G49:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCCAM-BOO-G49:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCCAM-BOO-G49:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCCAM-BOO-G49:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCCAM-BOO-G49:TODSUM")
}

record(bo, "SOFT-IOCCAM-BOO-G49:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCCAM-BOO-G49:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCCAM-BOO-G49:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCCAM-BOO-G49:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G49:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCCAM-BOO-G49:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCCAM-BOO-G49:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCCAM-BOO-G49:HEARTBEATE01")
  field(INP, "SOFT-IOCCAM-BOO-G49:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCCAM-BOO-G49:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCCAM-BOO-G49:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCCAM-BOO-G49:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCCAM-BOO-G49:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCCAM-BOO-G49:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCCAM-BOO-G49:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCCAM-BOO-G49:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCCAM-BOO-G49:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCCAM-BOO-G49:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCCAM-BOO-G49:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCCAM-BOO-G49:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCCAM-BOO-G49:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCCAM-BOO-G49:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCCAM-BOO-G49:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G49:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCCAM-BOO-G49:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G49:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCCAM-BOO-G49:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G49:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCCAM-BOO-G49:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G49:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCCAM-BOO-G49:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G49:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCCAM-BOO-G49:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G49:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCCAM-BOO-G49:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G49:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCCAM-BOO-G49:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G49:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCCAM-BOO-G49:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G49:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCCAM-BOO-G49:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G49:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCCAM-BOO-G49:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G49:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCCAM-BOO-G49:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G49:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCCAM-BOO-G49:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G49:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCCAM-BOO-G49:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G49:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCCAM-BOO-G49:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G49:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCCAM-BOO-G49:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G49:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCCAM-BOO-G49:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G49:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCCAM-BOO-G49:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G49:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCCAM-BOO-G49:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCCAM-BOO-G49:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCCAM-BOO-G49:HEARTBEATCLC")
  field(INP, "SOFT-IOCCAM-BOO-G49:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCCAM-BOO-G49:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCCAM-BOO-G49:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G49:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCCAM-BOO-G49:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G49:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCCAM-BOO-G49:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCCAM-BOO-G49:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCCAM-BOO-G49:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCCAM-BOO-G49:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCCAM-BOO-G49:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-BOO-G49:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCCAM-BOO-G56:INFO") {
  field(DESC, "SOFT-IOCCAM-BOO-G56 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-BOO-G56:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCCAM-BOO-G56:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCCAM-BOO-G56:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCCAM-BOO-G56:TODDIFF")
}

record(longin, "SOFT-IOCCAM-BOO-G56:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCCAM-BOO-G56:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCCAM-BOO-G56:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCCAM-BOO-G56:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCCAM-BOO-G56:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCCAM-BOO-G56:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCCAM-BOO-G56:TODSUM")
}

record(bo, "SOFT-IOCCAM-BOO-G56:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCCAM-BOO-G56:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCCAM-BOO-G56:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCCAM-BOO-G56:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G56:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCCAM-BOO-G56:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCCAM-BOO-G56:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCCAM-BOO-G56:HEARTBEATE01")
  field(INP, "SOFT-IOCCAM-BOO-G56:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCCAM-BOO-G56:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCCAM-BOO-G56:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCCAM-BOO-G56:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCCAM-BOO-G56:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCCAM-BOO-G56:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCCAM-BOO-G56:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCCAM-BOO-G56:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCCAM-BOO-G56:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCCAM-BOO-G56:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCCAM-BOO-G56:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCCAM-BOO-G56:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCCAM-BOO-G56:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCCAM-BOO-G56:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCCAM-BOO-G56:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G56:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCCAM-BOO-G56:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G56:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCCAM-BOO-G56:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G56:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCCAM-BOO-G56:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G56:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCCAM-BOO-G56:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G56:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCCAM-BOO-G56:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G56:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCCAM-BOO-G56:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G56:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCCAM-BOO-G56:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G56:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCCAM-BOO-G56:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G56:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCCAM-BOO-G56:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G56:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCCAM-BOO-G56:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G56:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCCAM-BOO-G56:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G56:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCCAM-BOO-G56:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G56:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCCAM-BOO-G56:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G56:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCCAM-BOO-G56:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G56:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCCAM-BOO-G56:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G56:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCCAM-BOO-G56:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G56:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCCAM-BOO-G56:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G56:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCCAM-BOO-G56:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCCAM-BOO-G56:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCCAM-BOO-G56:HEARTBEATCLC")
  field(INP, "SOFT-IOCCAM-BOO-G56:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCCAM-BOO-G56:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCCAM-BOO-G56:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BOO-G56:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCCAM-BOO-G56:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCCAM-BOO-G56:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCCAM-BOO-G56:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCCAM-BOO-G56:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCCAM-BOO-G56:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCCAM-BOO-G56:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCCAM-BOO-G56:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-BOO-G56:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCCAM-BTS-PR1:INFO") {
  field(DESC, "SOFT-IOCCAM-BTS-PR1 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-BTS-PR1:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCCAM-BTS-PR1:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCCAM-BTS-PR1:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:TODDIFF")
}

record(longin, "SOFT-IOCCAM-BTS-PR1:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCCAM-BTS-PR1:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCCAM-BTS-PR1:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCCAM-BTS-PR1:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCCAM-BTS-PR1:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:TODSUM")
}

record(bo, "SOFT-IOCCAM-BTS-PR1:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCCAM-BTS-PR1:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCCAM-BTS-PR1:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR1:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCCAM-BTS-PR1:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCCAM-BTS-PR1:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE01")
  field(INP, "SOFT-IOCCAM-BTS-PR1:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCCAM-BTS-PR1:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR1:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR1:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCCAM-BTS-PR1:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCCAM-BTS-PR1:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:HEARTBEATCLC")
  field(INP, "SOFT-IOCCAM-BTS-PR1:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR1:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR1:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR1:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCCAM-BTS-PR1:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCCAM-BTS-PR1:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCCAM-BTS-PR1:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCCAM-BTS-PR1:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-BTS-PR1:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCCAM-BTS-PR2:INFO") {
  field(DESC, "SOFT-IOCCAM-BTS-PR2 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-BTS-PR2:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCCAM-BTS-PR2:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCCAM-BTS-PR2:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:TODDIFF")
}

record(longin, "SOFT-IOCCAM-BTS-PR2:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCCAM-BTS-PR2:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCCAM-BTS-PR2:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCCAM-BTS-PR2:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCCAM-BTS-PR2:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:TODSUM")
}

record(bo, "SOFT-IOCCAM-BTS-PR2:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCCAM-BTS-PR2:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCCAM-BTS-PR2:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR2:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCCAM-BTS-PR2:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCCAM-BTS-PR2:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE01")
  field(INP, "SOFT-IOCCAM-BTS-PR2:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCCAM-BTS-PR2:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR2:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR2:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCCAM-BTS-PR2:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCCAM-BTS-PR2:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:HEARTBEATCLC")
  field(INP, "SOFT-IOCCAM-BTS-PR2:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCCAM-BTS-PR2:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCCAM-BTS-PR2:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCCAM-BTS-PR2:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCCAM-BTS-PR2:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCCAM-BTS-PR2:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCCAM-BTS-PR2:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCCAM-BTS-PR2:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-BTS-PR2:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCCAM-SLM:INFO") {
  field(DESC, "SOFT-IOCCAM-SLM Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-SLM:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCCAM-SLM:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCCAM-SLM:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCCAM-SLM:TODDIFF")
}

record(longin, "SOFT-IOCCAM-SLM:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCCAM-SLM:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCCAM-SLM:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCCAM-SLM:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCCAM-SLM:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCCAM-SLM:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCCAM-SLM:TODSUM")
}

record(bo, "SOFT-IOCCAM-SLM:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCCAM-SLM:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCCAM-SLM:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCCAM-SLM:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-SLM:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCCAM-SLM:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCCAM-SLM:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCCAM-SLM:HEARTBEATE01")
  field(INP, "SOFT-IOCCAM-SLM:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCCAM-SLM:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCCAM-SLM:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCCAM-SLM:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCCAM-SLM:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCCAM-SLM:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCCAM-SLM:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCCAM-SLM:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCCAM-SLM:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCCAM-SLM:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCCAM-SLM:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCCAM-SLM:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCCAM-SLM:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCCAM-SLM:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCCAM-SLM:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-SLM:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCCAM-SLM:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCCAM-SLM:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCCAM-SLM:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-SLM:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCCAM-SLM:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCCAM-SLM:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCCAM-SLM:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-SLM:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCCAM-SLM:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCCAM-SLM:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCCAM-SLM:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-SLM:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCCAM-SLM:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCCAM-SLM:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCCAM-SLM:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-SLM:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCCAM-SLM:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCCAM-SLM:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCCAM-SLM:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-SLM:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCCAM-SLM:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCCAM-SLM:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCCAM-SLM:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-SLM:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCCAM-SLM:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCCAM-SLM:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCCAM-SLM:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-SLM:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCCAM-SLM:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCCAM-SLM:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCCAM-SLM:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-SLM:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCCAM-SLM:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCCAM-SLM:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCCAM-SLM:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCCAM-SLM:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCCAM-SLM:HEARTBEATCLC")
  field(INP, "SOFT-IOCCAM-SLM:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCCAM-SLM:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCCAM-SLM:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-SLM:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCCAM-SLM:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCCAM-SLM:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCCAM-SLM:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCCAM-SLM:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCCAM-SLM:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCCAM-SLM:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCCAM-SLM:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-SLM:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCCAM-WATCHER:INFO") {
  field(DESC, "SOFT-IOCCAM-WATCHER Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-WATCHER:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCCAM-WATCHER:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCCAM-WATCHER:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCCAM-WATCHER:TODDIFF")
}

record(longin, "SOFT-IOCCAM-WATCHER:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCCAM-WATCHER:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCCAM-WATCHER:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCCAM-WATCHER:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCCAM-WATCHER:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCCAM-WATCHER:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCCAM-WATCHER:TODSUM")
}

record(bo, "SOFT-IOCCAM-WATCHER:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCCAM-WATCHER:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCCAM-WATCHER:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCCAM-WATCHER:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-WATCHER:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCCAM-WATCHER:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCCAM-WATCHER:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCCAM-WATCHER:HEARTBEATE01")
  field(INP, "SOFT-IOCCAM-WATCHER:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCCAM-WATCHER:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCCAM-WATCHER:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCCAM-WATCHER:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCCAM-WATCHER:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCCAM-WATCHER:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCCAM-WATCHER:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCCAM-WATCHER:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCCAM-WATCHER:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCCAM-WATCHER:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCCAM-WATCHER:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCCAM-WATCHER:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCCAM-WATCHER:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCCAM-WATCHER:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCCAM-WATCHER:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-WATCHER:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCCAM-WATCHER:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCCAM-WATCHER:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCCAM-WATCHER:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-WATCHER:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCCAM-WATCHER:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCCAM-WATCHER:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCCAM-WATCHER:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-WATCHER:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCCAM-WATCHER:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCCAM-WATCHER:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCCAM-WATCHER:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-WATCHER:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCCAM-WATCHER:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCCAM-WATCHER:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCCAM-WATCHER:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-WATCHER:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCCAM-WATCHER:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCCAM-WATCHER:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCCAM-WATCHER:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-WATCHER:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCCAM-WATCHER:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCCAM-WATCHER:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCCAM-WATCHER:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-WATCHER:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCCAM-WATCHER:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCCAM-WATCHER:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCCAM-WATCHER:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-WATCHER:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCCAM-WATCHER:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCCAM-WATCHER:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCCAM-WATCHER:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-WATCHER:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCCAM-WATCHER:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCCAM-WATCHER:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCCAM-WATCHER:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCCAM-WATCHER:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCCAM-WATCHER:HEARTBEATCLC")
  field(INP, "SOFT-IOCCAM-WATCHER:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCCAM-WATCHER:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCCAM-WATCHER:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCAM-WATCHER:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCCAM-WATCHER:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCCAM-WATCHER:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCCAM-WATCHER:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCCAM-WATCHER:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCCAM-WATCHER:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCCAM-WATCHER:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCCAM-WATCHER:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCAM-WATCHER:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCKNOB-B117-CTRL:INFO") {
  field(DESC, "SOFT-IOCKNOB-B117-CTRL Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCKNOB-B117-CTRL:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCKNOB-B117-CTRL:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCKNOB-B117-CTRL:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:TODDIFF")
}

record(longin, "SOFT-IOCKNOB-B117-CTRL:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCKNOB-B117-CTRL:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCKNOB-B117-CTRL:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCKNOB-B117-CTRL:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCKNOB-B117-CTRL:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:TODSUM")
}

record(bo, "SOFT-IOCKNOB-B117-CTRL:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCKNOB-B117-CTRL:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-CTRL:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE01")
  field(INP, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATCLC")
  field(INP, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCKNOB-B117-CTRL:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCKNOB-B117-CTRL:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCKNOB-B117-CTRL:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCKNOB-B117-CTRL:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCKNOB-B117-USER:INFO") {
  field(DESC, "SOFT-IOCKNOB-B117-USER Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCKNOB-B117-USER:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCKNOB-B117-USER:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCKNOB-B117-USER:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCKNOB-B117-USER:TODDIFF")
}

record(longin, "SOFT-IOCKNOB-B117-USER:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCKNOB-B117-USER:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCKNOB-B117-USER:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCKNOB-B117-USER:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCKNOB-B117-USER:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCKNOB-B117-USER:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCKNOB-B117-USER:TODSUM")
}

record(bo, "SOFT-IOCKNOB-B117-USER:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCKNOB-B117-USER:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCKNOB-B117-USER:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCKNOB-B117-USER:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-USER:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCKNOB-B117-USER:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCKNOB-B117-USER:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCKNOB-B117-USER:HEARTBEATE01")
  field(INP, "SOFT-IOCKNOB-B117-USER:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCKNOB-B117-USER:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCKNOB-B117-USER:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCKNOB-B117-USER:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCKNOB-B117-USER:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCKNOB-B117-USER:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCKNOB-B117-USER:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCKNOB-B117-USER:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCKNOB-B117-USER:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCKNOB-B117-USER:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCKNOB-B117-USER:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCKNOB-B117-USER:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCKNOB-B117-USER:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCKNOB-B117-USER:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCKNOB-B117-USER:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-USER:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCKNOB-B117-USER:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-USER:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCKNOB-B117-USER:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-USER:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCKNOB-B117-USER:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-USER:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCKNOB-B117-USER:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-USER:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCKNOB-B117-USER:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-USER:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCKNOB-B117-USER:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-USER:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCKNOB-B117-USER:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-USER:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCKNOB-B117-USER:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-USER:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCKNOB-B117-USER:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-USER:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCKNOB-B117-USER:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-USER:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCKNOB-B117-USER:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-USER:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCKNOB-B117-USER:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-USER:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCKNOB-B117-USER:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-USER:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCKNOB-B117-USER:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-USER:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCKNOB-B117-USER:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-USER:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCKNOB-B117-USER:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-USER:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCKNOB-B117-USER:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-USER:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCKNOB-B117-USER:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCKNOB-B117-USER:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCKNOB-B117-USER:HEARTBEATCLC")
  field(INP, "SOFT-IOCKNOB-B117-USER:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCKNOB-B117-USER:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCKNOB-B117-USER:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B117-USER:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCKNOB-B117-USER:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCKNOB-B117-USER:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCKNOB-B117-USER:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCKNOB-B117-USER:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCKNOB-B117-USER:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCKNOB-B117-USER:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCKNOB-B117-USER:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCKNOB-B117-USER:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCKNOB-B052-CTRL:INFO") {
  field(DESC, "SOFT-IOCKNOB-B052-CTRL Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCKNOB-B052-CTRL:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCKNOB-B052-CTRL:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCKNOB-B052-CTRL:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:TODDIFF")
}

record(longin, "SOFT-IOCKNOB-B052-CTRL:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCKNOB-B052-CTRL:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCKNOB-B052-CTRL:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCKNOB-B052-CTRL:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCKNOB-B052-CTRL:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:TODSUM")
}

record(bo, "SOFT-IOCKNOB-B052-CTRL:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCKNOB-B052-CTRL:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-CTRL:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE01")
  field(INP, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATCLC")
  field(INP, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCKNOB-B052-CTRL:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCKNOB-B052-CTRL:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCKNOB-B052-CTRL:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCKNOB-B052-CTRL:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCKNOB-B052-USER:INFO") {
  field(DESC, "SOFT-IOCKNOB-B052-USER Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCKNOB-B052-USER:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCKNOB-B052-USER:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCKNOB-B052-USER:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCKNOB-B052-USER:TODDIFF")
}

record(longin, "SOFT-IOCKNOB-B052-USER:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCKNOB-B052-USER:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCKNOB-B052-USER:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCKNOB-B052-USER:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCKNOB-B052-USER:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCKNOB-B052-USER:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCKNOB-B052-USER:TODSUM")
}

record(bo, "SOFT-IOCKNOB-B052-USER:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCKNOB-B052-USER:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCKNOB-B052-USER:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCKNOB-B052-USER:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-USER:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCKNOB-B052-USER:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCKNOB-B052-USER:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCKNOB-B052-USER:HEARTBEATE01")
  field(INP, "SOFT-IOCKNOB-B052-USER:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCKNOB-B052-USER:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCKNOB-B052-USER:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCKNOB-B052-USER:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCKNOB-B052-USER:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCKNOB-B052-USER:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCKNOB-B052-USER:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCKNOB-B052-USER:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCKNOB-B052-USER:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCKNOB-B052-USER:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCKNOB-B052-USER:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCKNOB-B052-USER:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCKNOB-B052-USER:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCKNOB-B052-USER:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCKNOB-B052-USER:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-USER:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCKNOB-B052-USER:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-USER:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCKNOB-B052-USER:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-USER:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCKNOB-B052-USER:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-USER:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCKNOB-B052-USER:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-USER:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCKNOB-B052-USER:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-USER:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCKNOB-B052-USER:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-USER:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCKNOB-B052-USER:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-USER:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCKNOB-B052-USER:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-USER:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCKNOB-B052-USER:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-USER:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCKNOB-B052-USER:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-USER:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCKNOB-B052-USER:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-USER:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCKNOB-B052-USER:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-USER:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCKNOB-B052-USER:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-USER:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCKNOB-B052-USER:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-USER:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCKNOB-B052-USER:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-USER:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCKNOB-B052-USER:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-USER:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCKNOB-B052-USER:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-USER:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCKNOB-B052-USER:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCKNOB-B052-USER:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCKNOB-B052-USER:HEARTBEATCLC")
  field(INP, "SOFT-IOCKNOB-B052-USER:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCKNOB-B052-USER:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCKNOB-B052-USER:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCKNOB-B052-USER:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCKNOB-B052-USER:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCKNOB-B052-USER:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCKNOB-B052-USER:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCKNOB-B052-USER:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCKNOB-B052-USER:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCKNOB-B052-USER:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCKNOB-B052-USER:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCKNOB-B052-USER:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCTUNER-BOO-RF:INFO") {
  field(DESC, "SOFT-IOCTUNER-BOO-RF Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCTUNER-BOO-RF:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCTUNER-BOO-RF:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCTUNER-BOO-RF:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:TODDIFF")
}

record(longin, "SOFT-IOCTUNER-BOO-RF:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCTUNER-BOO-RF:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCTUNER-BOO-RF:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCTUNER-BOO-RF:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCTUNER-BOO-RF:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:TODSUM")
}

record(bo, "SOFT-IOCTUNER-BOO-RF:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCTUNER-BOO-RF:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCTUNER-BOO-RF:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-BOO-RF:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCTUNER-BOO-RF:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCTUNER-BOO-RF:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE01")
  field(INP, "SOFT-IOCTUNER-BOO-RF:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCTUNER-BOO-RF:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-BOO-RF:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCTUNER-BOO-RF:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCTUNER-BOO-RF:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCTUNER-BOO-RF:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:HEARTBEATCLC")
  field(INP, "SOFT-IOCTUNER-BOO-RF:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCTUNER-BOO-RF:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCTUNER-BOO-RF:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCTUNER-BOO-RF:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCTUNER-BOO-RF:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCTUNER-BOO-RF:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCTUNER-BOO-RF:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocbootuner")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCTUNER-BOO-RF:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocbootuner")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCTUNER-BOO-RF:LOC") {
  field(PINI, "YES")
  field(VAL, "B140 RK351")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCGTR-BOO-RF:INFO") {
  field(DESC, "SOFT-IOCGTR-BOO-RF Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCGTR-BOO-RF:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCGTR-BOO-RF:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCGTR-BOO-RF:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCGTR-BOO-RF:TODDIFF")
}

record(longin, "SOFT-IOCGTR-BOO-RF:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCGTR-BOO-RF:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCGTR-BOO-RF:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCGTR-BOO-RF:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCGTR-BOO-RF:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCGTR-BOO-RF:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCGTR-BOO-RF:TODSUM")
}

record(bo, "SOFT-IOCGTR-BOO-RF:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCGTR-BOO-RF:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCGTR-BOO-RF:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCGTR-BOO-RF:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGTR-BOO-RF:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCGTR-BOO-RF:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCGTR-BOO-RF:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCGTR-BOO-RF:HEARTBEATE01")
  field(INP, "SOFT-IOCGTR-BOO-RF:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCGTR-BOO-RF:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCGTR-BOO-RF:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCGTR-BOO-RF:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCGTR-BOO-RF:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCGTR-BOO-RF:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCGTR-BOO-RF:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCGTR-BOO-RF:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCGTR-BOO-RF:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCGTR-BOO-RF:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCGTR-BOO-RF:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCGTR-BOO-RF:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCGTR-BOO-RF:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCGTR-BOO-RF:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCGTR-BOO-RF:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGTR-BOO-RF:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCGTR-BOO-RF:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCGTR-BOO-RF:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCGTR-BOO-RF:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGTR-BOO-RF:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCGTR-BOO-RF:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCGTR-BOO-RF:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCGTR-BOO-RF:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGTR-BOO-RF:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCGTR-BOO-RF:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCGTR-BOO-RF:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCGTR-BOO-RF:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGTR-BOO-RF:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCGTR-BOO-RF:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCGTR-BOO-RF:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCGTR-BOO-RF:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGTR-BOO-RF:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCGTR-BOO-RF:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCGTR-BOO-RF:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCGTR-BOO-RF:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGTR-BOO-RF:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCGTR-BOO-RF:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCGTR-BOO-RF:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCGTR-BOO-RF:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGTR-BOO-RF:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCGTR-BOO-RF:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCGTR-BOO-RF:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCGTR-BOO-RF:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGTR-BOO-RF:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCGTR-BOO-RF:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCGTR-BOO-RF:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCGTR-BOO-RF:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGTR-BOO-RF:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCGTR-BOO-RF:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCGTR-BOO-RF:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCGTR-BOO-RF:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCGTR-BOO-RF:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCGTR-BOO-RF:HEARTBEATCLC")
  field(INP, "SOFT-IOCGTR-BOO-RF:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCGTR-BOO-RF:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCGTR-BOO-RF:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGTR-BOO-RF:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCGTR-BOO-RF:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCGTR-BOO-RF:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCGTR-BOO-RF:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCGTR-BOO-RF:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCGTR-BOO-RF:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCGTR-BOO-RF:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocboogtr")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCGTR-BOO-RF:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocboogtr")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCGTR-BOO-RF:LOC") {
  field(PINI, "YES")
  field(VAL, "B140 RK351")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCMGR-BOO-RF:INFO") {
  field(DESC, "SOFT-IOCMGR-BOO-RF Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMGR-BOO-RF:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCMGR-BOO-RF:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCMGR-BOO-RF:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCMGR-BOO-RF:TODDIFF")
}

record(longin, "SOFT-IOCMGR-BOO-RF:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCMGR-BOO-RF:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCMGR-BOO-RF:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCMGR-BOO-RF:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCMGR-BOO-RF:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCMGR-BOO-RF:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCMGR-BOO-RF:TODSUM")
}

record(bo, "SOFT-IOCMGR-BOO-RF:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCMGR-BOO-RF:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCMGR-BOO-RF:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCMGR-BOO-RF:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-BOO-RF:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCMGR-BOO-RF:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCMGR-BOO-RF:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCMGR-BOO-RF:HEARTBEATE01")
  field(INP, "SOFT-IOCMGR-BOO-RF:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCMGR-BOO-RF:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCMGR-BOO-RF:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCMGR-BOO-RF:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCMGR-BOO-RF:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCMGR-BOO-RF:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCMGR-BOO-RF:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCMGR-BOO-RF:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCMGR-BOO-RF:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCMGR-BOO-RF:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCMGR-BOO-RF:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCMGR-BOO-RF:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCMGR-BOO-RF:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCMGR-BOO-RF:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCMGR-BOO-RF:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-BOO-RF:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCMGR-BOO-RF:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCMGR-BOO-RF:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCMGR-BOO-RF:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-BOO-RF:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCMGR-BOO-RF:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCMGR-BOO-RF:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCMGR-BOO-RF:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-BOO-RF:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCMGR-BOO-RF:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCMGR-BOO-RF:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCMGR-BOO-RF:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-BOO-RF:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCMGR-BOO-RF:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCMGR-BOO-RF:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCMGR-BOO-RF:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-BOO-RF:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCMGR-BOO-RF:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCMGR-BOO-RF:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCMGR-BOO-RF:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-BOO-RF:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCMGR-BOO-RF:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCMGR-BOO-RF:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCMGR-BOO-RF:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-BOO-RF:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCMGR-BOO-RF:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCMGR-BOO-RF:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCMGR-BOO-RF:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-BOO-RF:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCMGR-BOO-RF:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCMGR-BOO-RF:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCMGR-BOO-RF:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-BOO-RF:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCMGR-BOO-RF:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCMGR-BOO-RF:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCMGR-BOO-RF:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCMGR-BOO-RF:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCMGR-BOO-RF:HEARTBEATCLC")
  field(INP, "SOFT-IOCMGR-BOO-RF:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCMGR-BOO-RF:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCMGR-BOO-RF:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-BOO-RF:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCMGR-BOO-RF:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCMGR-BOO-RF:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCMGR-BOO-RF:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCMGR-BOO-RF:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCMGR-BOO-RF:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCMGR-BOO-RF:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocmgrboorf")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCMGR-BOO-RF:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocmgrboorf")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMGR-BOO-RF:LOC") {
  field(PINI, "YES")
  field(VAL, "B140 RK351")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCTUNER-GTL-RF:INFO") {
  field(DESC, "SOFT-IOCTUNER-GTL-RF Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCTUNER-GTL-RF:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCTUNER-GTL-RF:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCTUNER-GTL-RF:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:TODDIFF")
}

record(longin, "SOFT-IOCTUNER-GTL-RF:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCTUNER-GTL-RF:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCTUNER-GTL-RF:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCTUNER-GTL-RF:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCTUNER-GTL-RF:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:TODSUM")
}

record(bo, "SOFT-IOCTUNER-GTL-RF:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCTUNER-GTL-RF:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCTUNER-GTL-RF:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-GTL-RF:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCTUNER-GTL-RF:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCTUNER-GTL-RF:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE01")
  field(INP, "SOFT-IOCTUNER-GTL-RF:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCTUNER-GTL-RF:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-GTL-RF:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCTUNER-GTL-RF:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCTUNER-GTL-RF:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCTUNER-GTL-RF:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:HEARTBEATCLC")
  field(INP, "SOFT-IOCTUNER-GTL-RF:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCTUNER-GTL-RF:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCTUNER-GTL-RF:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCTUNER-GTL-RF:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCTUNER-GTL-RF:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCTUNER-GTL-RF:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCTUNER-GTL-RF:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocgtltuner")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCTUNER-GTL-RF:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocgtltuner")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCTUNER-GTL-RF:LOC") {
  field(PINI, "YES")
  field(VAL, "B140 RK106A")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCMGR-GTL-RF:INFO") {
  field(DESC, "SOFT-IOCMGR-GTL-RF Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMGR-GTL-RF:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCMGR-GTL-RF:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCMGR-GTL-RF:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCMGR-GTL-RF:TODDIFF")
}

record(longin, "SOFT-IOCMGR-GTL-RF:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCMGR-GTL-RF:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCMGR-GTL-RF:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCMGR-GTL-RF:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCMGR-GTL-RF:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCMGR-GTL-RF:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCMGR-GTL-RF:TODSUM")
}

record(bo, "SOFT-IOCMGR-GTL-RF:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCMGR-GTL-RF:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCMGR-GTL-RF:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCMGR-GTL-RF:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-GTL-RF:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCMGR-GTL-RF:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCMGR-GTL-RF:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCMGR-GTL-RF:HEARTBEATE01")
  field(INP, "SOFT-IOCMGR-GTL-RF:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCMGR-GTL-RF:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCMGR-GTL-RF:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCMGR-GTL-RF:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCMGR-GTL-RF:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCMGR-GTL-RF:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCMGR-GTL-RF:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCMGR-GTL-RF:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCMGR-GTL-RF:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCMGR-GTL-RF:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCMGR-GTL-RF:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCMGR-GTL-RF:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCMGR-GTL-RF:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCMGR-GTL-RF:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCMGR-GTL-RF:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-GTL-RF:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCMGR-GTL-RF:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCMGR-GTL-RF:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCMGR-GTL-RF:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-GTL-RF:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCMGR-GTL-RF:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCMGR-GTL-RF:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCMGR-GTL-RF:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-GTL-RF:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCMGR-GTL-RF:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCMGR-GTL-RF:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCMGR-GTL-RF:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-GTL-RF:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCMGR-GTL-RF:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCMGR-GTL-RF:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCMGR-GTL-RF:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-GTL-RF:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCMGR-GTL-RF:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCMGR-GTL-RF:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCMGR-GTL-RF:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-GTL-RF:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCMGR-GTL-RF:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCMGR-GTL-RF:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCMGR-GTL-RF:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-GTL-RF:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCMGR-GTL-RF:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCMGR-GTL-RF:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCMGR-GTL-RF:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-GTL-RF:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCMGR-GTL-RF:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCMGR-GTL-RF:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCMGR-GTL-RF:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-GTL-RF:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCMGR-GTL-RF:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCMGR-GTL-RF:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCMGR-GTL-RF:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCMGR-GTL-RF:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCMGR-GTL-RF:HEARTBEATCLC")
  field(INP, "SOFT-IOCMGR-GTL-RF:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCMGR-GTL-RF:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCMGR-GTL-RF:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMGR-GTL-RF:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCMGR-GTL-RF:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCMGR-GTL-RF:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCMGR-GTL-RF:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCMGR-GTL-RF:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCMGR-GTL-RF:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCMGR-GTL-RF:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "iocgtlmgrrf")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCMGR-GTL-RF:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "iocgtlmgrrf")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMGR-GTL-RF:LOC") {
  field(PINI, "YES")
  field(VAL, "B140 RK106A")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCFDBK-BOO-RF:INFO") {
  field(DESC, "SOFT-IOCFDBK-BOO-RF Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCFDBK-BOO-RF:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCFDBK-BOO-RF:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCFDBK-BOO-RF:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:TODDIFF")
}

record(longin, "SOFT-IOCFDBK-BOO-RF:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCFDBK-BOO-RF:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCFDBK-BOO-RF:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCFDBK-BOO-RF:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCFDBK-BOO-RF:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:TODSUM")
}

record(bo, "SOFT-IOCFDBK-BOO-RF:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCFDBK-BOO-RF:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCFDBK-BOO-RF:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFDBK-BOO-RF:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCFDBK-BOO-RF:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCFDBK-BOO-RF:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE01")
  field(INP, "SOFT-IOCFDBK-BOO-RF:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCFDBK-BOO-RF:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFDBK-BOO-RF:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCFDBK-BOO-RF:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCFDBK-BOO-RF:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCFDBK-BOO-RF:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:HEARTBEATCLC")
  field(INP, "SOFT-IOCFDBK-BOO-RF:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCFDBK-BOO-RF:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCFDBK-BOO-RF:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCFDBK-BOO-RF:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCFDBK-BOO-RF:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCFDBK-BOO-RF:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCFDBK-BOO-RF:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCFDBK-BOO-RF:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCFDBK-BOO-RF:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCPMON:INFO") {
  field(DESC, "SOFT-IOCPMON Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPMON:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCPMON:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCPMON:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCPMON:TODDIFF")
}

record(longin, "SOFT-IOCPMON:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCPMON:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCPMON:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCPMON:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCPMON:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCPMON:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCPMON:TODSUM")
}

record(bo, "SOFT-IOCPMON:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCPMON:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCPMON:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCPMON:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPMON:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCPMON:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCPMON:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCPMON:HEARTBEATE01")
  field(INP, "SOFT-IOCPMON:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCPMON:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCPMON:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCPMON:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCPMON:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCPMON:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCPMON:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCPMON:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCPMON:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCPMON:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCPMON:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCPMON:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCPMON:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCPMON:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCPMON:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPMON:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCPMON:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCPMON:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCPMON:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPMON:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCPMON:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCPMON:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCPMON:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPMON:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCPMON:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCPMON:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCPMON:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPMON:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCPMON:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCPMON:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCPMON:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPMON:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCPMON:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCPMON:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCPMON:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPMON:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCPMON:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCPMON:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCPMON:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPMON:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCPMON:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCPMON:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCPMON:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPMON:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCPMON:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCPMON:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCPMON:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPMON:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCPMON:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCPMON:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCPMON:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCPMON:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCPMON:HEARTBEATCLC")
  field(INP, "SOFT-IOCPMON:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCPMON:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCPMON:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPMON:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCPMON:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCPMON:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCPMON:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCPMON:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCPMON:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCPMON:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCPMON:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPMON:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCSSRL:INFO") {
  field(DESC, "SOFT-IOCSSRL Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCSSRL:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCSSRL:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCSSRL:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCSSRL:TODDIFF")
}

record(longin, "SOFT-IOCSSRL:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCSSRL:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCSSRL:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCSSRL:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCSSRL:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCSSRL:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCSSRL:TODSUM")
}

record(bo, "SOFT-IOCSSRL:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCSSRL:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCSSRL:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCSSRL:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSRL:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCSSRL:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCSSRL:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCSSRL:HEARTBEATE01")
  field(INP, "SOFT-IOCSSRL:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCSSRL:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCSSRL:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCSSRL:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCSSRL:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCSSRL:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCSSRL:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCSSRL:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCSSRL:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCSSRL:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCSSRL:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCSSRL:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCSSRL:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCSSRL:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCSSRL:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSRL:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCSSRL:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCSSRL:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCSSRL:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSRL:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCSSRL:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCSSRL:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCSSRL:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSRL:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCSSRL:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCSSRL:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCSSRL:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSRL:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCSSRL:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCSSRL:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCSSRL:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSRL:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCSSRL:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCSSRL:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCSSRL:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSRL:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCSSRL:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCSSRL:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCSSRL:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSRL:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCSSRL:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCSSRL:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCSSRL:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSRL:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCSSRL:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCSSRL:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCSSRL:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSRL:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCSSRL:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCSSRL:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCSSRL:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCSSRL:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCSSRL:HEARTBEATCLC")
  field(INP, "SOFT-IOCSSRL:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCSSRL:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCSSRL:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCSSRL:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCSSRL:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCSSRL:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCSSRL:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCSSRL:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCSSRL:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCSSRL:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCSSRL:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCSSRL:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCTCINTRLK:INFO") {
  field(DESC, "SOFT-IOCTCINTRLK Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCTCINTRLK:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCTCINTRLK:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCTCINTRLK:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCTCINTRLK:TODDIFF")
}

record(longin, "SOFT-IOCTCINTRLK:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCTCINTRLK:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCTCINTRLK:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCTCINTRLK:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCTCINTRLK:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCTCINTRLK:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCTCINTRLK:TODSUM")
}

record(bo, "SOFT-IOCTCINTRLK:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCTCINTRLK:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCTCINTRLK:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCTCINTRLK:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTCINTRLK:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCTCINTRLK:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCTCINTRLK:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCTCINTRLK:HEARTBEATE01")
  field(INP, "SOFT-IOCTCINTRLK:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCTCINTRLK:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCTCINTRLK:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCTCINTRLK:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCTCINTRLK:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCTCINTRLK:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCTCINTRLK:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCTCINTRLK:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCTCINTRLK:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCTCINTRLK:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCTCINTRLK:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCTCINTRLK:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCTCINTRLK:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCTCINTRLK:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCTCINTRLK:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTCINTRLK:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCTCINTRLK:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCTCINTRLK:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCTCINTRLK:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTCINTRLK:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCTCINTRLK:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCTCINTRLK:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCTCINTRLK:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTCINTRLK:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCTCINTRLK:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCTCINTRLK:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCTCINTRLK:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTCINTRLK:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCTCINTRLK:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCTCINTRLK:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCTCINTRLK:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTCINTRLK:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCTCINTRLK:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCTCINTRLK:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCTCINTRLK:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTCINTRLK:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCTCINTRLK:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCTCINTRLK:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCTCINTRLK:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTCINTRLK:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCTCINTRLK:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCTCINTRLK:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCTCINTRLK:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTCINTRLK:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCTCINTRLK:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCTCINTRLK:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCTCINTRLK:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTCINTRLK:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCTCINTRLK:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCTCINTRLK:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCTCINTRLK:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCTCINTRLK:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCTCINTRLK:HEARTBEATCLC")
  field(INP, "SOFT-IOCTCINTRLK:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCTCINTRLK:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCTCINTRLK:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTCINTRLK:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCTCINTRLK:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCTCINTRLK:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCTCINTRLK:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCTCINTRLK:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCTCINTRLK:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCTCINTRLK:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCTCINTRLK:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCTCINTRLK:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCBEAMINT:INFO") {
  field(DESC, "SOFT-IOCBEAMINT Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCBEAMINT:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCBEAMINT:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCBEAMINT:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCBEAMINT:TODDIFF")
}

record(longin, "SOFT-IOCBEAMINT:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCBEAMINT:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCBEAMINT:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCBEAMINT:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCBEAMINT:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCBEAMINT:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCBEAMINT:TODSUM")
}

record(bo, "SOFT-IOCBEAMINT:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCBEAMINT:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCBEAMINT:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCBEAMINT:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBEAMINT:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCBEAMINT:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCBEAMINT:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCBEAMINT:HEARTBEATE01")
  field(INP, "SOFT-IOCBEAMINT:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCBEAMINT:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCBEAMINT:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCBEAMINT:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCBEAMINT:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCBEAMINT:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCBEAMINT:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCBEAMINT:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCBEAMINT:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCBEAMINT:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCBEAMINT:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCBEAMINT:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCBEAMINT:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCBEAMINT:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCBEAMINT:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBEAMINT:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCBEAMINT:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCBEAMINT:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCBEAMINT:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBEAMINT:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCBEAMINT:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCBEAMINT:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCBEAMINT:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBEAMINT:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCBEAMINT:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCBEAMINT:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCBEAMINT:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBEAMINT:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCBEAMINT:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCBEAMINT:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCBEAMINT:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBEAMINT:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCBEAMINT:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCBEAMINT:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCBEAMINT:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBEAMINT:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCBEAMINT:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCBEAMINT:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCBEAMINT:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBEAMINT:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCBEAMINT:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCBEAMINT:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCBEAMINT:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBEAMINT:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCBEAMINT:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCBEAMINT:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCBEAMINT:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBEAMINT:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCBEAMINT:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCBEAMINT:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCBEAMINT:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCBEAMINT:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCBEAMINT:HEARTBEATCLC")
  field(INP, "SOFT-IOCBEAMINT:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCBEAMINT:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCBEAMINT:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBEAMINT:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCBEAMINT:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCBEAMINT:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCBEAMINT:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCBEAMINT:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCBEAMINT:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCBEAMINT:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCBEAMINT:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCBEAMINT:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCTSPFLASH:INFO") {
  field(DESC, "SOFT-IOCTSPFLASH Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCTSPFLASH:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCTSPFLASH:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCTSPFLASH:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCTSPFLASH:TODDIFF")
}

record(longin, "SOFT-IOCTSPFLASH:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCTSPFLASH:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCTSPFLASH:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCTSPFLASH:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCTSPFLASH:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCTSPFLASH:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCTSPFLASH:TODSUM")
}

record(bo, "SOFT-IOCTSPFLASH:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCTSPFLASH:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCTSPFLASH:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCTSPFLASH:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTSPFLASH:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCTSPFLASH:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCTSPFLASH:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCTSPFLASH:HEARTBEATE01")
  field(INP, "SOFT-IOCTSPFLASH:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCTSPFLASH:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCTSPFLASH:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCTSPFLASH:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCTSPFLASH:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCTSPFLASH:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCTSPFLASH:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCTSPFLASH:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCTSPFLASH:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCTSPFLASH:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCTSPFLASH:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCTSPFLASH:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCTSPFLASH:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCTSPFLASH:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCTSPFLASH:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTSPFLASH:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCTSPFLASH:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCTSPFLASH:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCTSPFLASH:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTSPFLASH:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCTSPFLASH:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCTSPFLASH:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCTSPFLASH:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTSPFLASH:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCTSPFLASH:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCTSPFLASH:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCTSPFLASH:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTSPFLASH:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCTSPFLASH:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCTSPFLASH:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCTSPFLASH:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTSPFLASH:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCTSPFLASH:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCTSPFLASH:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCTSPFLASH:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTSPFLASH:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCTSPFLASH:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCTSPFLASH:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCTSPFLASH:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTSPFLASH:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCTSPFLASH:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCTSPFLASH:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCTSPFLASH:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTSPFLASH:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCTSPFLASH:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCTSPFLASH:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCTSPFLASH:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTSPFLASH:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCTSPFLASH:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCTSPFLASH:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCTSPFLASH:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCTSPFLASH:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCTSPFLASH:HEARTBEATCLC")
  field(INP, "SOFT-IOCTSPFLASH:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCTSPFLASH:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCTSPFLASH:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTSPFLASH:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCTSPFLASH:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCTSPFLASH:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCTSPFLASH:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCTSPFLASH:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCTSPFLASH:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCTSPFLASH:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCTSPFLASH:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCTSPFLASH:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCCURRINTRLK:INFO") {
  field(DESC, "SOFT-IOCCURRINTRLK Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCURRINTRLK:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCCURRINTRLK:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCCURRINTRLK:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCCURRINTRLK:TODDIFF")
}

record(longin, "SOFT-IOCCURRINTRLK:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCCURRINTRLK:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCCURRINTRLK:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCCURRINTRLK:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCCURRINTRLK:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCCURRINTRLK:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCCURRINTRLK:TODSUM")
}

record(bo, "SOFT-IOCCURRINTRLK:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCCURRINTRLK:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCCURRINTRLK:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCCURRINTRLK:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURRINTRLK:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCCURRINTRLK:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCCURRINTRLK:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCCURRINTRLK:HEARTBEATE01")
  field(INP, "SOFT-IOCCURRINTRLK:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCCURRINTRLK:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCCURRINTRLK:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCCURRINTRLK:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCCURRINTRLK:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCCURRINTRLK:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCCURRINTRLK:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCCURRINTRLK:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCCURRINTRLK:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCCURRINTRLK:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCCURRINTRLK:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCCURRINTRLK:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCCURRINTRLK:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCCURRINTRLK:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCCURRINTRLK:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURRINTRLK:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCCURRINTRLK:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCCURRINTRLK:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCCURRINTRLK:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURRINTRLK:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCCURRINTRLK:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCCURRINTRLK:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCCURRINTRLK:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURRINTRLK:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCCURRINTRLK:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCCURRINTRLK:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCCURRINTRLK:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURRINTRLK:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCCURRINTRLK:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCCURRINTRLK:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCCURRINTRLK:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURRINTRLK:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCCURRINTRLK:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCCURRINTRLK:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCCURRINTRLK:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURRINTRLK:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCCURRINTRLK:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCCURRINTRLK:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCCURRINTRLK:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURRINTRLK:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCCURRINTRLK:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCCURRINTRLK:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCCURRINTRLK:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURRINTRLK:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCCURRINTRLK:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCCURRINTRLK:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCCURRINTRLK:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURRINTRLK:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCCURRINTRLK:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCCURRINTRLK:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCCURRINTRLK:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCCURRINTRLK:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCCURRINTRLK:HEARTBEATCLC")
  field(INP, "SOFT-IOCCURRINTRLK:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCCURRINTRLK:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCCURRINTRLK:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURRINTRLK:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCCURRINTRLK:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCCURRINTRLK:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCCURRINTRLK:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCCURRINTRLK:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCCURRINTRLK:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCCURRINTRLK:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCCURRINTRLK:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCURRINTRLK:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCBPMRACKTEMP:INFO") {
  field(DESC, "SOFT-IOCBPMRACKTEMP Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCBPMRACKTEMP:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCBPMRACKTEMP:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCBPMRACKTEMP:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCBPMRACKTEMP:TODDIFF")
}

record(longin, "SOFT-IOCBPMRACKTEMP:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCBPMRACKTEMP:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCBPMRACKTEMP:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCBPMRACKTEMP:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCBPMRACKTEMP:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCBPMRACKTEMP:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCBPMRACKTEMP:TODSUM")
}

record(bo, "SOFT-IOCBPMRACKTEMP:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCBPMRACKTEMP:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCBPMRACKTEMP:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCBPMRACKTEMP:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMRACKTEMP:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCBPMRACKTEMP:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCBPMRACKTEMP:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCBPMRACKTEMP:HEARTBEATE01")
  field(INP, "SOFT-IOCBPMRACKTEMP:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCBPMRACKTEMP:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCBPMRACKTEMP:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCBPMRACKTEMP:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCBPMRACKTEMP:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCBPMRACKTEMP:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCBPMRACKTEMP:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCBPMRACKTEMP:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCBPMRACKTEMP:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCBPMRACKTEMP:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCBPMRACKTEMP:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCBPMRACKTEMP:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCBPMRACKTEMP:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCBPMRACKTEMP:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCBPMRACKTEMP:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMRACKTEMP:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCBPMRACKTEMP:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCBPMRACKTEMP:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCBPMRACKTEMP:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMRACKTEMP:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCBPMRACKTEMP:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCBPMRACKTEMP:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCBPMRACKTEMP:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMRACKTEMP:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCBPMRACKTEMP:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCBPMRACKTEMP:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCBPMRACKTEMP:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMRACKTEMP:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCBPMRACKTEMP:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCBPMRACKTEMP:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCBPMRACKTEMP:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMRACKTEMP:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCBPMRACKTEMP:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCBPMRACKTEMP:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCBPMRACKTEMP:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMRACKTEMP:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCBPMRACKTEMP:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCBPMRACKTEMP:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCBPMRACKTEMP:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMRACKTEMP:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCBPMRACKTEMP:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCBPMRACKTEMP:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCBPMRACKTEMP:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMRACKTEMP:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCBPMRACKTEMP:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCBPMRACKTEMP:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCBPMRACKTEMP:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMRACKTEMP:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCBPMRACKTEMP:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCBPMRACKTEMP:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCBPMRACKTEMP:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCBPMRACKTEMP:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCBPMRACKTEMP:HEARTBEATCLC")
  field(INP, "SOFT-IOCBPMRACKTEMP:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCBPMRACKTEMP:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCBPMRACKTEMP:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCBPMRACKTEMP:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCBPMRACKTEMP:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCBPMRACKTEMP:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCBPMRACKTEMP:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCBPMRACKTEMP:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCBPMRACKTEMP:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCBPMRACKTEMP:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCBPMRACKTEMP:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCBPMRACKTEMP:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCIDSCAN:INFO") {
  field(DESC, "SOFT-IOCIDSCAN Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCIDSCAN:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCIDSCAN:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCIDSCAN:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCIDSCAN:TODDIFF")
}

record(longin, "SOFT-IOCIDSCAN:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCIDSCAN:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCIDSCAN:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCIDSCAN:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCIDSCAN:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCIDSCAN:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCIDSCAN:TODSUM")
}

record(bo, "SOFT-IOCIDSCAN:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCIDSCAN:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCIDSCAN:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCIDSCAN:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDSCAN:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCIDSCAN:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCIDSCAN:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCIDSCAN:HEARTBEATE01")
  field(INP, "SOFT-IOCIDSCAN:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCIDSCAN:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCIDSCAN:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCIDSCAN:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCIDSCAN:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCIDSCAN:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCIDSCAN:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCIDSCAN:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCIDSCAN:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCIDSCAN:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCIDSCAN:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCIDSCAN:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCIDSCAN:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCIDSCAN:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCIDSCAN:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDSCAN:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCIDSCAN:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCIDSCAN:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCIDSCAN:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDSCAN:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCIDSCAN:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCIDSCAN:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCIDSCAN:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDSCAN:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCIDSCAN:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCIDSCAN:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCIDSCAN:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDSCAN:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCIDSCAN:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCIDSCAN:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCIDSCAN:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDSCAN:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCIDSCAN:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCIDSCAN:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCIDSCAN:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDSCAN:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCIDSCAN:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCIDSCAN:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCIDSCAN:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDSCAN:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCIDSCAN:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCIDSCAN:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCIDSCAN:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDSCAN:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCIDSCAN:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCIDSCAN:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCIDSCAN:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDSCAN:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCIDSCAN:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCIDSCAN:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCIDSCAN:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCIDSCAN:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCIDSCAN:HEARTBEATCLC")
  field(INP, "SOFT-IOCIDSCAN:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCIDSCAN:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCIDSCAN:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCIDSCAN:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCIDSCAN:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCIDSCAN:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCIDSCAN:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCIDSCAN:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCIDSCAN:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCIDSCAN:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCIDSCAN:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCIDSCAN:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCPDUSNMP1:INFO") {
  field(DESC, "SOFT-IOCPDUSNMP1 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPDUSNMP1:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCPDUSNMP1:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCPDUSNMP1:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCPDUSNMP1:TODDIFF")
}

record(longin, "SOFT-IOCPDUSNMP1:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCPDUSNMP1:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCPDUSNMP1:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCPDUSNMP1:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCPDUSNMP1:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCPDUSNMP1:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCPDUSNMP1:TODSUM")
}

record(bo, "SOFT-IOCPDUSNMP1:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCPDUSNMP1:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCPDUSNMP1:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCPDUSNMP1:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP1:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCPDUSNMP1:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCPDUSNMP1:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCPDUSNMP1:HEARTBEATE01")
  field(INP, "SOFT-IOCPDUSNMP1:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCPDUSNMP1:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCPDUSNMP1:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCPDUSNMP1:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCPDUSNMP1:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCPDUSNMP1:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCPDUSNMP1:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCPDUSNMP1:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCPDUSNMP1:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCPDUSNMP1:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCPDUSNMP1:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCPDUSNMP1:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCPDUSNMP1:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCPDUSNMP1:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCPDUSNMP1:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP1:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCPDUSNMP1:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCPDUSNMP1:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCPDUSNMP1:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP1:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCPDUSNMP1:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCPDUSNMP1:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCPDUSNMP1:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP1:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCPDUSNMP1:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCPDUSNMP1:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCPDUSNMP1:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP1:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCPDUSNMP1:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCPDUSNMP1:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCPDUSNMP1:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP1:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCPDUSNMP1:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCPDUSNMP1:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCPDUSNMP1:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP1:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCPDUSNMP1:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCPDUSNMP1:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCPDUSNMP1:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP1:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCPDUSNMP1:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCPDUSNMP1:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCPDUSNMP1:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP1:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCPDUSNMP1:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCPDUSNMP1:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCPDUSNMP1:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP1:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCPDUSNMP1:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCPDUSNMP1:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCPDUSNMP1:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCPDUSNMP1:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCPDUSNMP1:HEARTBEATCLC")
  field(INP, "SOFT-IOCPDUSNMP1:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCPDUSNMP1:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCPDUSNMP1:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP1:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCPDUSNMP1:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCPDUSNMP1:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCPDUSNMP1:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCPDUSNMP1:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCPDUSNMP1:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCPDUSNMP1:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCPDUSNMP1:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPDUSNMP1:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCPDUSNMP2:INFO") {
  field(DESC, "SOFT-IOCPDUSNMP2 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPDUSNMP2:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCPDUSNMP2:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCPDUSNMP2:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCPDUSNMP2:TODDIFF")
}

record(longin, "SOFT-IOCPDUSNMP2:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCPDUSNMP2:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCPDUSNMP2:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCPDUSNMP2:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCPDUSNMP2:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCPDUSNMP2:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCPDUSNMP2:TODSUM")
}

record(bo, "SOFT-IOCPDUSNMP2:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCPDUSNMP2:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCPDUSNMP2:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCPDUSNMP2:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP2:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCPDUSNMP2:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCPDUSNMP2:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCPDUSNMP2:HEARTBEATE01")
  field(INP, "SOFT-IOCPDUSNMP2:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCPDUSNMP2:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCPDUSNMP2:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCPDUSNMP2:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCPDUSNMP2:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCPDUSNMP2:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCPDUSNMP2:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCPDUSNMP2:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCPDUSNMP2:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCPDUSNMP2:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCPDUSNMP2:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCPDUSNMP2:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCPDUSNMP2:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCPDUSNMP2:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCPDUSNMP2:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP2:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCPDUSNMP2:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCPDUSNMP2:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCPDUSNMP2:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP2:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCPDUSNMP2:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCPDUSNMP2:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCPDUSNMP2:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP2:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCPDUSNMP2:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCPDUSNMP2:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCPDUSNMP2:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP2:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCPDUSNMP2:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCPDUSNMP2:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCPDUSNMP2:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP2:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCPDUSNMP2:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCPDUSNMP2:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCPDUSNMP2:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP2:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCPDUSNMP2:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCPDUSNMP2:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCPDUSNMP2:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP2:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCPDUSNMP2:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCPDUSNMP2:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCPDUSNMP2:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP2:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCPDUSNMP2:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCPDUSNMP2:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCPDUSNMP2:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP2:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCPDUSNMP2:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCPDUSNMP2:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCPDUSNMP2:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCPDUSNMP2:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCPDUSNMP2:HEARTBEATCLC")
  field(INP, "SOFT-IOCPDUSNMP2:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCPDUSNMP2:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCPDUSNMP2:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP2:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCPDUSNMP2:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCPDUSNMP2:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCPDUSNMP2:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCPDUSNMP2:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCPDUSNMP2:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCPDUSNMP2:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCPDUSNMP2:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPDUSNMP2:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCPDUSNMP3:INFO") {
  field(DESC, "SOFT-IOCPDUSNMP3 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPDUSNMP3:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCPDUSNMP3:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCPDUSNMP3:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCPDUSNMP3:TODDIFF")
}

record(longin, "SOFT-IOCPDUSNMP3:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCPDUSNMP3:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCPDUSNMP3:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCPDUSNMP3:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCPDUSNMP3:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCPDUSNMP3:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCPDUSNMP3:TODSUM")
}

record(bo, "SOFT-IOCPDUSNMP3:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCPDUSNMP3:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCPDUSNMP3:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCPDUSNMP3:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP3:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCPDUSNMP3:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCPDUSNMP3:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCPDUSNMP3:HEARTBEATE01")
  field(INP, "SOFT-IOCPDUSNMP3:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCPDUSNMP3:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCPDUSNMP3:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCPDUSNMP3:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCPDUSNMP3:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCPDUSNMP3:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCPDUSNMP3:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCPDUSNMP3:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCPDUSNMP3:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCPDUSNMP3:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCPDUSNMP3:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCPDUSNMP3:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCPDUSNMP3:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCPDUSNMP3:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCPDUSNMP3:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP3:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCPDUSNMP3:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCPDUSNMP3:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCPDUSNMP3:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP3:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCPDUSNMP3:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCPDUSNMP3:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCPDUSNMP3:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP3:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCPDUSNMP3:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCPDUSNMP3:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCPDUSNMP3:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP3:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCPDUSNMP3:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCPDUSNMP3:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCPDUSNMP3:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP3:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCPDUSNMP3:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCPDUSNMP3:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCPDUSNMP3:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP3:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCPDUSNMP3:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCPDUSNMP3:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCPDUSNMP3:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP3:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCPDUSNMP3:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCPDUSNMP3:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCPDUSNMP3:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP3:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCPDUSNMP3:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCPDUSNMP3:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCPDUSNMP3:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP3:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCPDUSNMP3:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCPDUSNMP3:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCPDUSNMP3:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCPDUSNMP3:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCPDUSNMP3:HEARTBEATCLC")
  field(INP, "SOFT-IOCPDUSNMP3:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCPDUSNMP3:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCPDUSNMP3:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP3:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCPDUSNMP3:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCPDUSNMP3:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCPDUSNMP3:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCPDUSNMP3:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCPDUSNMP3:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCPDUSNMP3:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCPDUSNMP3:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPDUSNMP3:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCPDUSNMP4:INFO") {
  field(DESC, "SOFT-IOCPDUSNMP4 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPDUSNMP4:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCPDUSNMP4:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCPDUSNMP4:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCPDUSNMP4:TODDIFF")
}

record(longin, "SOFT-IOCPDUSNMP4:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCPDUSNMP4:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCPDUSNMP4:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCPDUSNMP4:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCPDUSNMP4:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCPDUSNMP4:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCPDUSNMP4:TODSUM")
}

record(bo, "SOFT-IOCPDUSNMP4:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCPDUSNMP4:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCPDUSNMP4:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCPDUSNMP4:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP4:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCPDUSNMP4:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCPDUSNMP4:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCPDUSNMP4:HEARTBEATE01")
  field(INP, "SOFT-IOCPDUSNMP4:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCPDUSNMP4:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCPDUSNMP4:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCPDUSNMP4:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCPDUSNMP4:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCPDUSNMP4:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCPDUSNMP4:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCPDUSNMP4:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCPDUSNMP4:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCPDUSNMP4:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCPDUSNMP4:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCPDUSNMP4:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCPDUSNMP4:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCPDUSNMP4:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCPDUSNMP4:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP4:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCPDUSNMP4:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCPDUSNMP4:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCPDUSNMP4:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP4:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCPDUSNMP4:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCPDUSNMP4:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCPDUSNMP4:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP4:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCPDUSNMP4:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCPDUSNMP4:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCPDUSNMP4:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP4:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCPDUSNMP4:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCPDUSNMP4:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCPDUSNMP4:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP4:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCPDUSNMP4:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCPDUSNMP4:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCPDUSNMP4:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP4:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCPDUSNMP4:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCPDUSNMP4:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCPDUSNMP4:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP4:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCPDUSNMP4:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCPDUSNMP4:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCPDUSNMP4:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP4:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCPDUSNMP4:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCPDUSNMP4:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCPDUSNMP4:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP4:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCPDUSNMP4:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCPDUSNMP4:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCPDUSNMP4:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCPDUSNMP4:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCPDUSNMP4:HEARTBEATCLC")
  field(INP, "SOFT-IOCPDUSNMP4:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCPDUSNMP4:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCPDUSNMP4:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPDUSNMP4:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCPDUSNMP4:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCPDUSNMP4:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCPDUSNMP4:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCPDUSNMP4:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCPDUSNMP4:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCPDUSNMP4:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCPDUSNMP4:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPDUSNMP4:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCUPSSNMP1:INFO") {
  field(DESC, "SOFT-IOCUPSSNMP1 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCUPSSNMP1:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCUPSSNMP1:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCUPSSNMP1:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCUPSSNMP1:TODDIFF")
}

record(longin, "SOFT-IOCUPSSNMP1:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCUPSSNMP1:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCUPSSNMP1:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCUPSSNMP1:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCUPSSNMP1:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCUPSSNMP1:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCUPSSNMP1:TODSUM")
}

record(bo, "SOFT-IOCUPSSNMP1:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCUPSSNMP1:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCUPSSNMP1:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCUPSSNMP1:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUPSSNMP1:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCUPSSNMP1:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCUPSSNMP1:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCUPSSNMP1:HEARTBEATE01")
  field(INP, "SOFT-IOCUPSSNMP1:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCUPSSNMP1:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCUPSSNMP1:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCUPSSNMP1:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCUPSSNMP1:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCUPSSNMP1:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCUPSSNMP1:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCUPSSNMP1:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCUPSSNMP1:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCUPSSNMP1:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCUPSSNMP1:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCUPSSNMP1:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCUPSSNMP1:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCUPSSNMP1:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCUPSSNMP1:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUPSSNMP1:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCUPSSNMP1:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCUPSSNMP1:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCUPSSNMP1:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUPSSNMP1:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCUPSSNMP1:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCUPSSNMP1:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCUPSSNMP1:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUPSSNMP1:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCUPSSNMP1:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCUPSSNMP1:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCUPSSNMP1:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUPSSNMP1:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCUPSSNMP1:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCUPSSNMP1:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCUPSSNMP1:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUPSSNMP1:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCUPSSNMP1:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCUPSSNMP1:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCUPSSNMP1:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUPSSNMP1:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCUPSSNMP1:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCUPSSNMP1:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCUPSSNMP1:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUPSSNMP1:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCUPSSNMP1:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCUPSSNMP1:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCUPSSNMP1:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUPSSNMP1:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCUPSSNMP1:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCUPSSNMP1:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCUPSSNMP1:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUPSSNMP1:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCUPSSNMP1:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCUPSSNMP1:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCUPSSNMP1:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCUPSSNMP1:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCUPSSNMP1:HEARTBEATCLC")
  field(INP, "SOFT-IOCUPSSNMP1:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCUPSSNMP1:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCUPSSNMP1:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUPSSNMP1:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCUPSSNMP1:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCUPSSNMP1:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCUPSSNMP1:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCUPSSNMP1:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCUPSSNMP1:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCUPSSNMP1:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCUPSSNMP1:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCUPSSNMP1:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCTEMP-BOO:INFO") {
  field(DESC, "SOFT-IOCTEMP-BOO Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCTEMP-BOO:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCTEMP-BOO:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCTEMP-BOO:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCTEMP-BOO:TODDIFF")
}

record(longin, "SOFT-IOCTEMP-BOO:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCTEMP-BOO:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCTEMP-BOO:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCTEMP-BOO:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCTEMP-BOO:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCTEMP-BOO:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCTEMP-BOO:TODSUM")
}

record(bo, "SOFT-IOCTEMP-BOO:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCTEMP-BOO:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCTEMP-BOO:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCTEMP-BOO:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP-BOO:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCTEMP-BOO:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCTEMP-BOO:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCTEMP-BOO:HEARTBEATE01")
  field(INP, "SOFT-IOCTEMP-BOO:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCTEMP-BOO:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCTEMP-BOO:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCTEMP-BOO:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCTEMP-BOO:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCTEMP-BOO:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCTEMP-BOO:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCTEMP-BOO:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCTEMP-BOO:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCTEMP-BOO:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCTEMP-BOO:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCTEMP-BOO:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCTEMP-BOO:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCTEMP-BOO:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCTEMP-BOO:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP-BOO:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCTEMP-BOO:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCTEMP-BOO:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCTEMP-BOO:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP-BOO:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCTEMP-BOO:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCTEMP-BOO:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCTEMP-BOO:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP-BOO:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCTEMP-BOO:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCTEMP-BOO:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCTEMP-BOO:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP-BOO:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCTEMP-BOO:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCTEMP-BOO:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCTEMP-BOO:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP-BOO:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCTEMP-BOO:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCTEMP-BOO:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCTEMP-BOO:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP-BOO:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCTEMP-BOO:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCTEMP-BOO:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCTEMP-BOO:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP-BOO:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCTEMP-BOO:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCTEMP-BOO:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCTEMP-BOO:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP-BOO:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCTEMP-BOO:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCTEMP-BOO:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCTEMP-BOO:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP-BOO:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCTEMP-BOO:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCTEMP-BOO:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCTEMP-BOO:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCTEMP-BOO:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCTEMP-BOO:HEARTBEATCLC")
  field(INP, "SOFT-IOCTEMP-BOO:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCTEMP-BOO:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCTEMP-BOO:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCTEMP-BOO:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCTEMP-BOO:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCTEMP-BOO:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCTEMP-BOO:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCTEMP-BOO:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCTEMP-BOO:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCTEMP-BOO:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCTEMP-BOO:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCTEMP-BOO:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCGPIB2:INFO") {
  field(DESC, "SOFT-IOCGPIB2 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCGPIB2:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCGPIB2:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCGPIB2:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCGPIB2:TODDIFF")
}

record(longin, "SOFT-IOCGPIB2:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCGPIB2:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCGPIB2:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCGPIB2:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCGPIB2:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCGPIB2:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCGPIB2:TODSUM")
}

record(bo, "SOFT-IOCGPIB2:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCGPIB2:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCGPIB2:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCGPIB2:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB2:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCGPIB2:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCGPIB2:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCGPIB2:HEARTBEATE01")
  field(INP, "SOFT-IOCGPIB2:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCGPIB2:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCGPIB2:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCGPIB2:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCGPIB2:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCGPIB2:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCGPIB2:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCGPIB2:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCGPIB2:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCGPIB2:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCGPIB2:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCGPIB2:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCGPIB2:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCGPIB2:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCGPIB2:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB2:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCGPIB2:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCGPIB2:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCGPIB2:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB2:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCGPIB2:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCGPIB2:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCGPIB2:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB2:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCGPIB2:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCGPIB2:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCGPIB2:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB2:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCGPIB2:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCGPIB2:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCGPIB2:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB2:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCGPIB2:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCGPIB2:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCGPIB2:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB2:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCGPIB2:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCGPIB2:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCGPIB2:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB2:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCGPIB2:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCGPIB2:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCGPIB2:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB2:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCGPIB2:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCGPIB2:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCGPIB2:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB2:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCGPIB2:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCGPIB2:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCGPIB2:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCGPIB2:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCGPIB2:HEARTBEATCLC")
  field(INP, "SOFT-IOCGPIB2:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCGPIB2:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCGPIB2:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCGPIB2:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCGPIB2:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCGPIB2:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCGPIB2:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCGPIB2:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCGPIB2:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCGPIB2:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCGPIB2:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCGPIB2:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCMPSBOORF:INFO") {
  field(DESC, "SOFT-IOCMPSBOORF Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMPSBOORF:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCMPSBOORF:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCMPSBOORF:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCMPSBOORF:TODDIFF")
}

record(longin, "SOFT-IOCMPSBOORF:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCMPSBOORF:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCMPSBOORF:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCMPSBOORF:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCMPSBOORF:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCMPSBOORF:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCMPSBOORF:TODSUM")
}

record(bo, "SOFT-IOCMPSBOORF:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCMPSBOORF:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCMPSBOORF:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCMPSBOORF:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBOORF:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCMPSBOORF:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCMPSBOORF:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCMPSBOORF:HEARTBEATE01")
  field(INP, "SOFT-IOCMPSBOORF:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCMPSBOORF:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCMPSBOORF:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCMPSBOORF:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCMPSBOORF:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCMPSBOORF:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCMPSBOORF:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCMPSBOORF:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCMPSBOORF:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCMPSBOORF:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCMPSBOORF:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCMPSBOORF:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCMPSBOORF:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCMPSBOORF:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCMPSBOORF:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBOORF:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCMPSBOORF:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCMPSBOORF:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCMPSBOORF:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBOORF:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCMPSBOORF:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCMPSBOORF:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCMPSBOORF:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBOORF:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCMPSBOORF:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCMPSBOORF:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCMPSBOORF:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBOORF:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCMPSBOORF:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCMPSBOORF:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCMPSBOORF:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBOORF:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCMPSBOORF:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCMPSBOORF:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCMPSBOORF:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBOORF:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCMPSBOORF:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCMPSBOORF:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCMPSBOORF:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBOORF:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCMPSBOORF:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCMPSBOORF:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCMPSBOORF:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBOORF:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCMPSBOORF:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCMPSBOORF:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCMPSBOORF:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBOORF:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCMPSBOORF:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCMPSBOORF:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCMPSBOORF:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCMPSBOORF:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCMPSBOORF:HEARTBEATCLC")
  field(INP, "SOFT-IOCMPSBOORF:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCMPSBOORF:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCMPSBOORF:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSBOORF:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCMPSBOORF:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCMPSBOORF:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCMPSBOORF:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCMPSBOORF:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCMPSBOORF:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCMPSBOORF:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCMPSBOORF:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMPSBOORF:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCPICOHARP:INFO") {
  field(DESC, "SOFT-IOCPICOHARP Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPICOHARP:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCPICOHARP:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCPICOHARP:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCPICOHARP:TODDIFF")
}

record(longin, "SOFT-IOCPICOHARP:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCPICOHARP:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCPICOHARP:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCPICOHARP:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCPICOHARP:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCPICOHARP:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCPICOHARP:TODSUM")
}

record(bo, "SOFT-IOCPICOHARP:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCPICOHARP:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCPICOHARP:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCPICOHARP:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPICOHARP:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCPICOHARP:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCPICOHARP:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCPICOHARP:HEARTBEATE01")
  field(INP, "SOFT-IOCPICOHARP:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCPICOHARP:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCPICOHARP:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCPICOHARP:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCPICOHARP:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCPICOHARP:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCPICOHARP:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCPICOHARP:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCPICOHARP:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCPICOHARP:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCPICOHARP:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCPICOHARP:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCPICOHARP:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCPICOHARP:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCPICOHARP:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPICOHARP:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCPICOHARP:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCPICOHARP:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCPICOHARP:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPICOHARP:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCPICOHARP:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCPICOHARP:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCPICOHARP:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPICOHARP:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCPICOHARP:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCPICOHARP:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCPICOHARP:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPICOHARP:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCPICOHARP:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCPICOHARP:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCPICOHARP:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPICOHARP:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCPICOHARP:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCPICOHARP:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCPICOHARP:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPICOHARP:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCPICOHARP:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCPICOHARP:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCPICOHARP:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPICOHARP:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCPICOHARP:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCPICOHARP:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCPICOHARP:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPICOHARP:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCPICOHARP:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCPICOHARP:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCPICOHARP:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPICOHARP:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCPICOHARP:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCPICOHARP:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCPICOHARP:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCPICOHARP:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCPICOHARP:HEARTBEATCLC")
  field(INP, "SOFT-IOCPICOHARP:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCPICOHARP:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCPICOHARP:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCPICOHARP:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCPICOHARP:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCPICOHARP:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCPICOHARP:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCPICOHARP:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCPICOHARP:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCPICOHARP:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCPICOHARP:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCPICOHARP:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCMPSHVPSAUX:INFO") {
  field(DESC, "SOFT-IOCMPSHVPSAUX Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMPSHVPSAUX:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCMPSHVPSAUX:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCMPSHVPSAUX:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCMPSHVPSAUX:TODDIFF")
}

record(longin, "SOFT-IOCMPSHVPSAUX:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCMPSHVPSAUX:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCMPSHVPSAUX:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCMPSHVPSAUX:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCMPSHVPSAUX:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCMPSHVPSAUX:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCMPSHVPSAUX:TODSUM")
}

record(bo, "SOFT-IOCMPSHVPSAUX:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCMPSHVPSAUX:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCMPSHVPSAUX:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCMPSHVPSAUX:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSHVPSAUX:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCMPSHVPSAUX:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCMPSHVPSAUX:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCMPSHVPSAUX:HEARTBEATE01")
  field(INP, "SOFT-IOCMPSHVPSAUX:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCMPSHVPSAUX:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCMPSHVPSAUX:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCMPSHVPSAUX:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCMPSHVPSAUX:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCMPSHVPSAUX:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCMPSHVPSAUX:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCMPSHVPSAUX:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCMPSHVPSAUX:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCMPSHVPSAUX:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCMPSHVPSAUX:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCMPSHVPSAUX:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCMPSHVPSAUX:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCMPSHVPSAUX:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCMPSHVPSAUX:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSHVPSAUX:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCMPSHVPSAUX:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCMPSHVPSAUX:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCMPSHVPSAUX:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSHVPSAUX:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCMPSHVPSAUX:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCMPSHVPSAUX:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCMPSHVPSAUX:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSHVPSAUX:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCMPSHVPSAUX:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCMPSHVPSAUX:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCMPSHVPSAUX:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSHVPSAUX:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCMPSHVPSAUX:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCMPSHVPSAUX:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCMPSHVPSAUX:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSHVPSAUX:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCMPSHVPSAUX:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCMPSHVPSAUX:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCMPSHVPSAUX:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSHVPSAUX:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCMPSHVPSAUX:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCMPSHVPSAUX:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCMPSHVPSAUX:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSHVPSAUX:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCMPSHVPSAUX:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCMPSHVPSAUX:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCMPSHVPSAUX:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSHVPSAUX:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCMPSHVPSAUX:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCMPSHVPSAUX:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCMPSHVPSAUX:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSHVPSAUX:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCMPSHVPSAUX:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCMPSHVPSAUX:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCMPSHVPSAUX:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCMPSHVPSAUX:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCMPSHVPSAUX:HEARTBEATCLC")
  field(INP, "SOFT-IOCMPSHVPSAUX:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCMPSHVPSAUX:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCMPSHVPSAUX:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMPSHVPSAUX:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCMPSHVPSAUX:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCMPSHVPSAUX:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCMPSHVPSAUX:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCMPSHVPSAUX:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCMPSHVPSAUX:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCMPSHVPSAUX:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCMPSHVPSAUX:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMPSHVPSAUX:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCMATSUP:INFO") {
  field(DESC, "SOFT-IOCMATSUP Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMATSUP:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCMATSUP:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCMATSUP:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCMATSUP:TODDIFF")
}

record(longin, "SOFT-IOCMATSUP:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCMATSUP:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCMATSUP:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCMATSUP:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCMATSUP:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCMATSUP:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCMATSUP:TODSUM")
}

record(bo, "SOFT-IOCMATSUP:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCMATSUP:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCMATSUP:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCMATSUP:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATSUP:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCMATSUP:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCMATSUP:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCMATSUP:HEARTBEATE01")
  field(INP, "SOFT-IOCMATSUP:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCMATSUP:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCMATSUP:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCMATSUP:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCMATSUP:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCMATSUP:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCMATSUP:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCMATSUP:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCMATSUP:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCMATSUP:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCMATSUP:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCMATSUP:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCMATSUP:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCMATSUP:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCMATSUP:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATSUP:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCMATSUP:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCMATSUP:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCMATSUP:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATSUP:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCMATSUP:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCMATSUP:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCMATSUP:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATSUP:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCMATSUP:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCMATSUP:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCMATSUP:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATSUP:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCMATSUP:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCMATSUP:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCMATSUP:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATSUP:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCMATSUP:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCMATSUP:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCMATSUP:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATSUP:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCMATSUP:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCMATSUP:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCMATSUP:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATSUP:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCMATSUP:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCMATSUP:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCMATSUP:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATSUP:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCMATSUP:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCMATSUP:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCMATSUP:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATSUP:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCMATSUP:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCMATSUP:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCMATSUP:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCMATSUP:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCMATSUP:HEARTBEATCLC")
  field(INP, "SOFT-IOCMATSUP:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCMATSUP:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCMATSUP:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCMATSUP:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCMATSUP:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCMATSUP:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCMATSUP:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCMATSUP:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCMATSUP:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCMATSUP:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCMATSUP:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCMATSUP:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCCURMON:INFO") {
  field(DESC, "SOFT-IOCCURMON Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCURMON:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCCURMON:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCCURMON:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCCURMON:TODDIFF")
}

record(longin, "SOFT-IOCCURMON:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCCURMON:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCCURMON:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCCURMON:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCCURMON:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCCURMON:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCCURMON:TODSUM")
}

record(bo, "SOFT-IOCCURMON:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCCURMON:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCCURMON:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCCURMON:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURMON:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCCURMON:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCCURMON:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCCURMON:HEARTBEATE01")
  field(INP, "SOFT-IOCCURMON:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCCURMON:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCCURMON:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCCURMON:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCCURMON:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCCURMON:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCCURMON:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCCURMON:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCCURMON:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCCURMON:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCCURMON:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCCURMON:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCCURMON:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCCURMON:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCCURMON:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURMON:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCCURMON:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCCURMON:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCCURMON:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURMON:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCCURMON:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCCURMON:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCCURMON:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURMON:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCCURMON:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCCURMON:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCCURMON:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURMON:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCCURMON:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCCURMON:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCCURMON:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURMON:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCCURMON:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCCURMON:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCCURMON:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURMON:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCCURMON:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCCURMON:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCCURMON:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURMON:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCCURMON:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCCURMON:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCCURMON:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURMON:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCCURMON:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCCURMON:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCCURMON:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURMON:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCCURMON:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCCURMON:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCCURMON:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCCURMON:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCCURMON:HEARTBEATCLC")
  field(INP, "SOFT-IOCCURMON:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCCURMON:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCCURMON:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCCURMON:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCCURMON:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCCURMON:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCCURMON:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCCURMON:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCCURMON:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCCURMON:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCCURMON:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCCURMON:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCUDC:INFO") {
  field(DESC, "SOFT-IOCUDC Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCUDC:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCUDC:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCUDC:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCUDC:TODDIFF")
}

record(longin, "SOFT-IOCUDC:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCUDC:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCUDC:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCUDC:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCUDC:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCUDC:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCUDC:TODSUM")
}

record(bo, "SOFT-IOCUDC:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCUDC:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCUDC:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCUDC:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUDC:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCUDC:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCUDC:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCUDC:HEARTBEATE01")
  field(INP, "SOFT-IOCUDC:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCUDC:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCUDC:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCUDC:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCUDC:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCUDC:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCUDC:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCUDC:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCUDC:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCUDC:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCUDC:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCUDC:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCUDC:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCUDC:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCUDC:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUDC:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCUDC:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCUDC:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCUDC:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUDC:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCUDC:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCUDC:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCUDC:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUDC:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCUDC:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCUDC:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCUDC:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUDC:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCUDC:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCUDC:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCUDC:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUDC:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCUDC:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCUDC:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCUDC:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUDC:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCUDC:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCUDC:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCUDC:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUDC:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCUDC:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCUDC:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCUDC:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUDC:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCUDC:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCUDC:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCUDC:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUDC:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCUDC:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCUDC:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCUDC:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCUDC:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCUDC:HEARTBEATCLC")
  field(INP, "SOFT-IOCUDC:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCUDC:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCUDC:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCUDC:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCUDC:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCUDC:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCUDC:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCUDC:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCUDC:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCUDC:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCUDC:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCUDC:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCLINACK2:INFO") {
  field(DESC, "SOFT-IOCLINACK2 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCLINACK2:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCLINACK2:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCLINACK2:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCLINACK2:TODDIFF")
}

record(longin, "SOFT-IOCLINACK2:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCLINACK2:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCLINACK2:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCLINACK2:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCLINACK2:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCLINACK2:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCLINACK2:TODSUM")
}

record(bo, "SOFT-IOCLINACK2:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCLINACK2:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCLINACK2:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCLINACK2:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK2:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCLINACK2:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCLINACK2:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCLINACK2:HEARTBEATE01")
  field(INP, "SOFT-IOCLINACK2:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCLINACK2:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCLINACK2:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCLINACK2:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCLINACK2:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCLINACK2:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCLINACK2:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCLINACK2:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCLINACK2:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCLINACK2:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCLINACK2:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCLINACK2:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCLINACK2:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCLINACK2:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCLINACK2:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK2:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCLINACK2:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCLINACK2:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCLINACK2:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK2:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCLINACK2:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCLINACK2:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCLINACK2:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK2:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCLINACK2:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCLINACK2:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCLINACK2:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK2:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCLINACK2:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCLINACK2:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCLINACK2:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK2:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCLINACK2:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCLINACK2:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCLINACK2:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK2:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCLINACK2:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCLINACK2:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCLINACK2:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK2:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCLINACK2:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCLINACK2:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCLINACK2:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK2:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCLINACK2:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCLINACK2:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCLINACK2:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK2:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCLINACK2:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCLINACK2:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCLINACK2:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCLINACK2:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCLINACK2:HEARTBEATCLC")
  field(INP, "SOFT-IOCLINACK2:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCLINACK2:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCLINACK2:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK2:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCLINACK2:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCLINACK2:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCLINACK2:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCLINACK2:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCLINACK2:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCLINACK2:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCLINACK2:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCLINACK2:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SOFT-IOCLINACK3:INFO") {
  field(DESC, "SOFT-IOCLINACK3 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCLINACK3:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SOFT-IOCLINACK3:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SOFT-IOCLINACK3:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SOFT-IOCLINACK3:TODDIFF")
}

record(longin, "SOFT-IOCLINACK3:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SOFT-IOCLINACK3:TODCHECK.VALA MS")
  field(FLNK, "SOFT-IOCLINACK3:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SOFT-IOCLINACK3:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SOFT-IOCLINACK3:TODCHECK.SEVR")
  field(INPB, "SOFT-IOCLINACK3:TODCHECK.VALB")
  field(FLNK, "SOFT-IOCLINACK3:TODSUM")
}

record(bo, "SOFT-IOCLINACK3:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SOFT-IOCLINACK3:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SOFT-IOCLINACK3:HEARTBEATCALC") {
  field(FLNK, "SOFT-IOCLINACK3:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK3:HEARTBEAT CA MS")
  field(INPB, "SOFT-IOCLINACK3:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SOFT-IOCLINACK3:HEARTBEATOK") {
  field(FLNK, "SOFT-IOCLINACK3:HEARTBEATE01")
  field(INP, "SOFT-IOCLINACK3:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SOFT-IOCLINACK3:HEARTBEATECT") {
  field(FLNK, "SOFT-IOCLINACK3:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SOFT-IOCLINACK3:HEARTBEATE01.VAL")
  field(INPB, "SOFT-IOCLINACK3:HEARTBEATE02.VAL")
  field(INPC, "SOFT-IOCLINACK3:HEARTBEATE03.VAL")
  field(INPD, "SOFT-IOCLINACK3:HEARTBEATE04.VAL")
  field(INPE, "SOFT-IOCLINACK3:HEARTBEATE05.VAL")
  field(INPF, "SOFT-IOCLINACK3:HEARTBEATE06.VAL")
  field(INPG, "SOFT-IOCLINACK3:HEARTBEATE07.VAL")
  field(INPH, "SOFT-IOCLINACK3:HEARTBEATE08.VAL")
  field(INPI, "SOFT-IOCLINACK3:HEARTBEATE09.VAL")
  field(INPJ, "SOFT-IOCLINACK3:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SOFT-IOCLINACK3:HEARTBEATE09") {
  field(FLNK, "SOFT-IOCLINACK3:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK3:HEARTBEATE08.B")
  field(INPB, "SOFT-IOCLINACK3:HEARTBEATE09.VAL")
}

record(calc, "SOFT-IOCLINACK3:HEARTBEATE08") {
  field(FLNK, "SOFT-IOCLINACK3:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK3:HEARTBEATE07.B")
  field(INPB, "SOFT-IOCLINACK3:HEARTBEATE08.VAL")
}

record(calc, "SOFT-IOCLINACK3:HEARTBEATE07") {
  field(FLNK, "SOFT-IOCLINACK3:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK3:HEARTBEATE06.B")
  field(INPB, "SOFT-IOCLINACK3:HEARTBEATE07.VAL")
}

record(calc, "SOFT-IOCLINACK3:HEARTBEATE06") {
  field(FLNK, "SOFT-IOCLINACK3:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK3:HEARTBEATE05.B")
  field(INPB, "SOFT-IOCLINACK3:HEARTBEATE06.VAL")
}

record(calc, "SOFT-IOCLINACK3:HEARTBEATE05") {
  field(FLNK, "SOFT-IOCLINACK3:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK3:HEARTBEATE04.B")
  field(INPB, "SOFT-IOCLINACK3:HEARTBEATE05.VAL")
}

record(calc, "SOFT-IOCLINACK3:HEARTBEATE04") {
  field(FLNK, "SOFT-IOCLINACK3:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK3:HEARTBEATE03.B")
  field(INPB, "SOFT-IOCLINACK3:HEARTBEATE04.VAL")
}

record(calc, "SOFT-IOCLINACK3:HEARTBEATE03") {
  field(FLNK, "SOFT-IOCLINACK3:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK3:HEARTBEATE02.B")
  field(INPB, "SOFT-IOCLINACK3:HEARTBEATE03.VAL")
}

record(calc, "SOFT-IOCLINACK3:HEARTBEATE02") {
  field(FLNK, "SOFT-IOCLINACK3:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK3:HEARTBEATE01.B")
  field(INPB, "SOFT-IOCLINACK3:HEARTBEATE02.VAL")
}

record(calc, "SOFT-IOCLINACK3:HEARTBEATE01") {
  field(FLNK, "SOFT-IOCLINACK3:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK3:HEARTBEATERR.VAL")
  field(INPB, "SOFT-IOCLINACK3:HEARTBEATE01.VAL")
}

record(calc, "SOFT-IOCLINACK3:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SOFT-IOCLINACK3:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SOFT-IOCLINACK3:HEARTBEATSUM") {
  field(FLNK, "SOFT-IOCLINACK3:HEARTBEATCLC")
  field(INP, "SOFT-IOCLINACK3:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SOFT-IOCLINACK3:HEARTBEATE10") {
  field(FLNK, "SOFT-IOCLINACK3:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SOFT-IOCLINACK3:HEARTBEATE09.B")
  field(INPB, "SOFT-IOCLINACK3:HEARTBEATE10.VAL")
}

record(calc, "SOFT-IOCLINACK3:HEARTBEATERR") {
  field(FLNK, "SOFT-IOCLINACK3:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SOFT-IOCLINACK3:HEARTBEATCALC.A")
  field(INPB, "SOFT-IOCLINACK3:HEARTBEATCALC.B")
}

record(stringin, "SOFT-IOCLINACK3:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SOFT-IOCLINACK3:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SOFT-IOCLINACK3:LOC") {
  field(PINI, "YES")
  field(VAL, "Computer Room")
  info(autosaveFields,"VAL")
}

