# 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, "IOC:LTUH:BP02:INFO") {
  field(DESC, "IOC:LTUH:BP02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:BP02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "IOC:LTUH:BP02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:LTUH:BP02: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, "IOC:LTUH:BP02:TODDIFF")
}

record(longin, "IOC:LTUH:BP02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "IOC:LTUH:BP02:TODCHECK.VALA MS")
  field(FLNK, "IOC:LTUH:BP02: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, "IOC:LTUH:BP02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "IOC:LTUH:BP02:TODCHECK.SEVR")
  field(INPB, "IOC:LTUH:BP02:TODCHECK.VALB")
  field(FLNK, "IOC:LTUH:BP02:TODSUM")
}

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

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

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

record(calc, "IOC:LTUH:BP02:HEARTBEATECT") {
  field(FLNK, "IOC:LTUH:BP02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "IOC:LTUH:BP02:HEARTBEATE01.VAL")
  field(INPB, "IOC:LTUH:BP02:HEARTBEATE02.VAL")
  field(INPC, "IOC:LTUH:BP02:HEARTBEATE03.VAL")
  field(INPD, "IOC:LTUH:BP02:HEARTBEATE04.VAL")
  field(INPE, "IOC:LTUH:BP02:HEARTBEATE05.VAL")
  field(INPF, "IOC:LTUH:BP02:HEARTBEATE06.VAL")
  field(INPG, "IOC:LTUH:BP02:HEARTBEATE07.VAL")
  field(INPH, "IOC:LTUH:BP02:HEARTBEATE08.VAL")
  field(INPI, "IOC:LTUH:BP02:HEARTBEATE09.VAL")
  field(INPJ, "IOC:LTUH:BP02: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, "IOC:LTUH:BP02:HEARTBEATE09") {
  field(FLNK, "IOC:LTUH:BP02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP02:HEARTBEATE08.B")
  field(INPB, "IOC:LTUH:BP02:HEARTBEATE09.VAL")
}

record(calc, "IOC:LTUH:BP02:HEARTBEATE08") {
  field(FLNK, "IOC:LTUH:BP02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP02:HEARTBEATE07.B")
  field(INPB, "IOC:LTUH:BP02:HEARTBEATE08.VAL")
}

record(calc, "IOC:LTUH:BP02:HEARTBEATE07") {
  field(FLNK, "IOC:LTUH:BP02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP02:HEARTBEATE06.B")
  field(INPB, "IOC:LTUH:BP02:HEARTBEATE07.VAL")
}

record(calc, "IOC:LTUH:BP02:HEARTBEATE06") {
  field(FLNK, "IOC:LTUH:BP02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP02:HEARTBEATE05.B")
  field(INPB, "IOC:LTUH:BP02:HEARTBEATE06.VAL")
}

record(calc, "IOC:LTUH:BP02:HEARTBEATE05") {
  field(FLNK, "IOC:LTUH:BP02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP02:HEARTBEATE04.B")
  field(INPB, "IOC:LTUH:BP02:HEARTBEATE05.VAL")
}

record(calc, "IOC:LTUH:BP02:HEARTBEATE04") {
  field(FLNK, "IOC:LTUH:BP02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP02:HEARTBEATE03.B")
  field(INPB, "IOC:LTUH:BP02:HEARTBEATE04.VAL")
}

record(calc, "IOC:LTUH:BP02:HEARTBEATE03") {
  field(FLNK, "IOC:LTUH:BP02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP02:HEARTBEATE02.B")
  field(INPB, "IOC:LTUH:BP02:HEARTBEATE03.VAL")
}

record(calc, "IOC:LTUH:BP02:HEARTBEATE02") {
  field(FLNK, "IOC:LTUH:BP02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP02:HEARTBEATE01.B")
  field(INPB, "IOC:LTUH:BP02:HEARTBEATE02.VAL")
}

record(calc, "IOC:LTUH:BP02:HEARTBEATE01") {
  field(FLNK, "IOC:LTUH:BP02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP02:HEARTBEATERR.VAL")
  field(INPB, "IOC:LTUH:BP02:HEARTBEATE01.VAL")
}

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

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

record(calc, "IOC:LTUH:BP02:HEARTBEATE10") {
  field(FLNK, "IOC:LTUH:BP02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP02:HEARTBEATE09.B")
  field(INPB, "IOC:LTUH:BP02:HEARTBEATE10.VAL")
}

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

record(stringin, "IOC:LTUH:BP02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "IOC:LTUH:BP02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:BP02:LOC") {
  field(PINI, "YES")
  field(VAL, "B911-0124")
  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, "IOC:LTUH:BP03:INFO") {
  field(DESC, "IOC:LTUH:BP03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:BP03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "IOC:LTUH:BP03:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:LTUH:BP03: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, "IOC:LTUH:BP03:TODDIFF")
}

record(longin, "IOC:LTUH:BP03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "IOC:LTUH:BP03:TODCHECK.VALA MS")
  field(FLNK, "IOC:LTUH:BP03: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, "IOC:LTUH:BP03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "IOC:LTUH:BP03:TODCHECK.SEVR")
  field(INPB, "IOC:LTUH:BP03:TODCHECK.VALB")
  field(FLNK, "IOC:LTUH:BP03:TODSUM")
}

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

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

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

record(calc, "IOC:LTUH:BP03:HEARTBEATECT") {
  field(FLNK, "IOC:LTUH:BP03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "IOC:LTUH:BP03:HEARTBEATE01.VAL")
  field(INPB, "IOC:LTUH:BP03:HEARTBEATE02.VAL")
  field(INPC, "IOC:LTUH:BP03:HEARTBEATE03.VAL")
  field(INPD, "IOC:LTUH:BP03:HEARTBEATE04.VAL")
  field(INPE, "IOC:LTUH:BP03:HEARTBEATE05.VAL")
  field(INPF, "IOC:LTUH:BP03:HEARTBEATE06.VAL")
  field(INPG, "IOC:LTUH:BP03:HEARTBEATE07.VAL")
  field(INPH, "IOC:LTUH:BP03:HEARTBEATE08.VAL")
  field(INPI, "IOC:LTUH:BP03:HEARTBEATE09.VAL")
  field(INPJ, "IOC:LTUH:BP03: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, "IOC:LTUH:BP03:HEARTBEATE09") {
  field(FLNK, "IOC:LTUH:BP03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP03:HEARTBEATE08.B")
  field(INPB, "IOC:LTUH:BP03:HEARTBEATE09.VAL")
}

record(calc, "IOC:LTUH:BP03:HEARTBEATE08") {
  field(FLNK, "IOC:LTUH:BP03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP03:HEARTBEATE07.B")
  field(INPB, "IOC:LTUH:BP03:HEARTBEATE08.VAL")
}

record(calc, "IOC:LTUH:BP03:HEARTBEATE07") {
  field(FLNK, "IOC:LTUH:BP03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP03:HEARTBEATE06.B")
  field(INPB, "IOC:LTUH:BP03:HEARTBEATE07.VAL")
}

record(calc, "IOC:LTUH:BP03:HEARTBEATE06") {
  field(FLNK, "IOC:LTUH:BP03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP03:HEARTBEATE05.B")
  field(INPB, "IOC:LTUH:BP03:HEARTBEATE06.VAL")
}

record(calc, "IOC:LTUH:BP03:HEARTBEATE05") {
  field(FLNK, "IOC:LTUH:BP03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP03:HEARTBEATE04.B")
  field(INPB, "IOC:LTUH:BP03:HEARTBEATE05.VAL")
}

record(calc, "IOC:LTUH:BP03:HEARTBEATE04") {
  field(FLNK, "IOC:LTUH:BP03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP03:HEARTBEATE03.B")
  field(INPB, "IOC:LTUH:BP03:HEARTBEATE04.VAL")
}

record(calc, "IOC:LTUH:BP03:HEARTBEATE03") {
  field(FLNK, "IOC:LTUH:BP03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP03:HEARTBEATE02.B")
  field(INPB, "IOC:LTUH:BP03:HEARTBEATE03.VAL")
}

record(calc, "IOC:LTUH:BP03:HEARTBEATE02") {
  field(FLNK, "IOC:LTUH:BP03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP03:HEARTBEATE01.B")
  field(INPB, "IOC:LTUH:BP03:HEARTBEATE02.VAL")
}

record(calc, "IOC:LTUH:BP03:HEARTBEATE01") {
  field(FLNK, "IOC:LTUH:BP03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP03:HEARTBEATERR.VAL")
  field(INPB, "IOC:LTUH:BP03:HEARTBEATE01.VAL")
}

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

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

record(calc, "IOC:LTUH:BP03:HEARTBEATE10") {
  field(FLNK, "IOC:LTUH:BP03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP03:HEARTBEATE09.B")
  field(INPB, "IOC:LTUH:BP03:HEARTBEATE10.VAL")
}

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

record(stringin, "IOC:LTUH:BP03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "IOC:LTUH:BP03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:BP03:LOC") {
  field(PINI, "YES")
  field(VAL, "B912-0324")
  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, "IOC:LTUH:BP04:INFO") {
  field(DESC, "IOC:LTUH:BP04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:BP04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "IOC:LTUH:BP04:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:LTUH:BP04: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, "IOC:LTUH:BP04:TODDIFF")
}

record(longin, "IOC:LTUH:BP04:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "IOC:LTUH:BP04:TODCHECK.VALA MS")
  field(FLNK, "IOC:LTUH:BP04: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, "IOC:LTUH:BP04:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "IOC:LTUH:BP04:TODCHECK.SEVR")
  field(INPB, "IOC:LTUH:BP04:TODCHECK.VALB")
  field(FLNK, "IOC:LTUH:BP04:TODSUM")
}

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

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

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

record(calc, "IOC:LTUH:BP04:HEARTBEATECT") {
  field(FLNK, "IOC:LTUH:BP04:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "IOC:LTUH:BP04:HEARTBEATE01.VAL")
  field(INPB, "IOC:LTUH:BP04:HEARTBEATE02.VAL")
  field(INPC, "IOC:LTUH:BP04:HEARTBEATE03.VAL")
  field(INPD, "IOC:LTUH:BP04:HEARTBEATE04.VAL")
  field(INPE, "IOC:LTUH:BP04:HEARTBEATE05.VAL")
  field(INPF, "IOC:LTUH:BP04:HEARTBEATE06.VAL")
  field(INPG, "IOC:LTUH:BP04:HEARTBEATE07.VAL")
  field(INPH, "IOC:LTUH:BP04:HEARTBEATE08.VAL")
  field(INPI, "IOC:LTUH:BP04:HEARTBEATE09.VAL")
  field(INPJ, "IOC:LTUH:BP04: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, "IOC:LTUH:BP04:HEARTBEATE09") {
  field(FLNK, "IOC:LTUH:BP04:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP04:HEARTBEATE08.B")
  field(INPB, "IOC:LTUH:BP04:HEARTBEATE09.VAL")
}

record(calc, "IOC:LTUH:BP04:HEARTBEATE08") {
  field(FLNK, "IOC:LTUH:BP04:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP04:HEARTBEATE07.B")
  field(INPB, "IOC:LTUH:BP04:HEARTBEATE08.VAL")
}

record(calc, "IOC:LTUH:BP04:HEARTBEATE07") {
  field(FLNK, "IOC:LTUH:BP04:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP04:HEARTBEATE06.B")
  field(INPB, "IOC:LTUH:BP04:HEARTBEATE07.VAL")
}

record(calc, "IOC:LTUH:BP04:HEARTBEATE06") {
  field(FLNK, "IOC:LTUH:BP04:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP04:HEARTBEATE05.B")
  field(INPB, "IOC:LTUH:BP04:HEARTBEATE06.VAL")
}

record(calc, "IOC:LTUH:BP04:HEARTBEATE05") {
  field(FLNK, "IOC:LTUH:BP04:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP04:HEARTBEATE04.B")
  field(INPB, "IOC:LTUH:BP04:HEARTBEATE05.VAL")
}

record(calc, "IOC:LTUH:BP04:HEARTBEATE04") {
  field(FLNK, "IOC:LTUH:BP04:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP04:HEARTBEATE03.B")
  field(INPB, "IOC:LTUH:BP04:HEARTBEATE04.VAL")
}

record(calc, "IOC:LTUH:BP04:HEARTBEATE03") {
  field(FLNK, "IOC:LTUH:BP04:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP04:HEARTBEATE02.B")
  field(INPB, "IOC:LTUH:BP04:HEARTBEATE03.VAL")
}

record(calc, "IOC:LTUH:BP04:HEARTBEATE02") {
  field(FLNK, "IOC:LTUH:BP04:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP04:HEARTBEATE01.B")
  field(INPB, "IOC:LTUH:BP04:HEARTBEATE02.VAL")
}

record(calc, "IOC:LTUH:BP04:HEARTBEATE01") {
  field(FLNK, "IOC:LTUH:BP04:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP04:HEARTBEATERR.VAL")
  field(INPB, "IOC:LTUH:BP04:HEARTBEATE01.VAL")
}

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

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

record(calc, "IOC:LTUH:BP04:HEARTBEATE10") {
  field(FLNK, "IOC:LTUH:BP04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BP04:HEARTBEATE09.B")
  field(INPB, "IOC:LTUH:BP04:HEARTBEATE10.VAL")
}

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

record(stringin, "IOC:LTUH:BP04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "IOC:LTUH:BP04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:BP04:LOC") {
  field(PINI, "YES")
  field(VAL, "B913-0124")
  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, "IOC:LTUH:MG01:INFO") {
  field(DESC, "IOC:LTUH:MG01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:MG01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "An Le (anle)")
  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, "IOC:LTUH:MG01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:LTUH:MG01: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, "IOC:LTUH:MG01:TODDIFF")
}

record(longin, "IOC:LTUH:MG01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "IOC:LTUH:MG01:TODCHECK.VALA MS")
  field(FLNK, "IOC:LTUH:MG01: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, "IOC:LTUH:MG01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "IOC:LTUH:MG01:TODCHECK.SEVR")
  field(INPB, "IOC:LTUH:MG01:TODCHECK.VALB")
  field(FLNK, "IOC:LTUH:MG01:TODSUM")
}

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

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

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

record(calc, "IOC:LTUH:MG01:HEARTBEATECT") {
  field(FLNK, "IOC:LTUH:MG01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "IOC:LTUH:MG01:HEARTBEATE01.VAL")
  field(INPB, "IOC:LTUH:MG01:HEARTBEATE02.VAL")
  field(INPC, "IOC:LTUH:MG01:HEARTBEATE03.VAL")
  field(INPD, "IOC:LTUH:MG01:HEARTBEATE04.VAL")
  field(INPE, "IOC:LTUH:MG01:HEARTBEATE05.VAL")
  field(INPF, "IOC:LTUH:MG01:HEARTBEATE06.VAL")
  field(INPG, "IOC:LTUH:MG01:HEARTBEATE07.VAL")
  field(INPH, "IOC:LTUH:MG01:HEARTBEATE08.VAL")
  field(INPI, "IOC:LTUH:MG01:HEARTBEATE09.VAL")
  field(INPJ, "IOC:LTUH:MG01: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, "IOC:LTUH:MG01:HEARTBEATE09") {
  field(FLNK, "IOC:LTUH:MG01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG01:HEARTBEATE08.B")
  field(INPB, "IOC:LTUH:MG01:HEARTBEATE09.VAL")
}

record(calc, "IOC:LTUH:MG01:HEARTBEATE08") {
  field(FLNK, "IOC:LTUH:MG01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG01:HEARTBEATE07.B")
  field(INPB, "IOC:LTUH:MG01:HEARTBEATE08.VAL")
}

record(calc, "IOC:LTUH:MG01:HEARTBEATE07") {
  field(FLNK, "IOC:LTUH:MG01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG01:HEARTBEATE06.B")
  field(INPB, "IOC:LTUH:MG01:HEARTBEATE07.VAL")
}

record(calc, "IOC:LTUH:MG01:HEARTBEATE06") {
  field(FLNK, "IOC:LTUH:MG01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG01:HEARTBEATE05.B")
  field(INPB, "IOC:LTUH:MG01:HEARTBEATE06.VAL")
}

record(calc, "IOC:LTUH:MG01:HEARTBEATE05") {
  field(FLNK, "IOC:LTUH:MG01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG01:HEARTBEATE04.B")
  field(INPB, "IOC:LTUH:MG01:HEARTBEATE05.VAL")
}

record(calc, "IOC:LTUH:MG01:HEARTBEATE04") {
  field(FLNK, "IOC:LTUH:MG01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG01:HEARTBEATE03.B")
  field(INPB, "IOC:LTUH:MG01:HEARTBEATE04.VAL")
}

record(calc, "IOC:LTUH:MG01:HEARTBEATE03") {
  field(FLNK, "IOC:LTUH:MG01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG01:HEARTBEATE02.B")
  field(INPB, "IOC:LTUH:MG01:HEARTBEATE03.VAL")
}

record(calc, "IOC:LTUH:MG01:HEARTBEATE02") {
  field(FLNK, "IOC:LTUH:MG01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG01:HEARTBEATE01.B")
  field(INPB, "IOC:LTUH:MG01:HEARTBEATE02.VAL")
}

record(calc, "IOC:LTUH:MG01:HEARTBEATE01") {
  field(FLNK, "IOC:LTUH:MG01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG01:HEARTBEATERR.VAL")
  field(INPB, "IOC:LTUH:MG01:HEARTBEATE01.VAL")
}

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

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

record(calc, "IOC:LTUH:MG01:HEARTBEATE10") {
  field(FLNK, "IOC:LTUH:MG01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG01:HEARTBEATE09.B")
  field(INPB, "IOC:LTUH:MG01:HEARTBEATE10.VAL")
}

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

record(stringin, "IOC:LTUH:MG01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "IOC:LTUH:MG01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:MG01:LOC") {
  field(PINI, "YES")
  field(VAL, "B005-L0518")
  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, "IOC:LTUH:MG02:INFO") {
  field(DESC, "IOC:LTUH:MG02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:MG02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "An Le (anle)")
  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, "IOC:LTUH:MG02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:LTUH:MG02: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, "IOC:LTUH:MG02:TODDIFF")
}

record(longin, "IOC:LTUH:MG02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "IOC:LTUH:MG02:TODCHECK.VALA MS")
  field(FLNK, "IOC:LTUH:MG02: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, "IOC:LTUH:MG02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "IOC:LTUH:MG02:TODCHECK.SEVR")
  field(INPB, "IOC:LTUH:MG02:TODCHECK.VALB")
  field(FLNK, "IOC:LTUH:MG02:TODSUM")
}

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

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

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

record(calc, "IOC:LTUH:MG02:HEARTBEATECT") {
  field(FLNK, "IOC:LTUH:MG02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "IOC:LTUH:MG02:HEARTBEATE01.VAL")
  field(INPB, "IOC:LTUH:MG02:HEARTBEATE02.VAL")
  field(INPC, "IOC:LTUH:MG02:HEARTBEATE03.VAL")
  field(INPD, "IOC:LTUH:MG02:HEARTBEATE04.VAL")
  field(INPE, "IOC:LTUH:MG02:HEARTBEATE05.VAL")
  field(INPF, "IOC:LTUH:MG02:HEARTBEATE06.VAL")
  field(INPG, "IOC:LTUH:MG02:HEARTBEATE07.VAL")
  field(INPH, "IOC:LTUH:MG02:HEARTBEATE08.VAL")
  field(INPI, "IOC:LTUH:MG02:HEARTBEATE09.VAL")
  field(INPJ, "IOC:LTUH:MG02: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, "IOC:LTUH:MG02:HEARTBEATE09") {
  field(FLNK, "IOC:LTUH:MG02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG02:HEARTBEATE08.B")
  field(INPB, "IOC:LTUH:MG02:HEARTBEATE09.VAL")
}

record(calc, "IOC:LTUH:MG02:HEARTBEATE08") {
  field(FLNK, "IOC:LTUH:MG02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG02:HEARTBEATE07.B")
  field(INPB, "IOC:LTUH:MG02:HEARTBEATE08.VAL")
}

record(calc, "IOC:LTUH:MG02:HEARTBEATE07") {
  field(FLNK, "IOC:LTUH:MG02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG02:HEARTBEATE06.B")
  field(INPB, "IOC:LTUH:MG02:HEARTBEATE07.VAL")
}

record(calc, "IOC:LTUH:MG02:HEARTBEATE06") {
  field(FLNK, "IOC:LTUH:MG02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG02:HEARTBEATE05.B")
  field(INPB, "IOC:LTUH:MG02:HEARTBEATE06.VAL")
}

record(calc, "IOC:LTUH:MG02:HEARTBEATE05") {
  field(FLNK, "IOC:LTUH:MG02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG02:HEARTBEATE04.B")
  field(INPB, "IOC:LTUH:MG02:HEARTBEATE05.VAL")
}

record(calc, "IOC:LTUH:MG02:HEARTBEATE04") {
  field(FLNK, "IOC:LTUH:MG02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG02:HEARTBEATE03.B")
  field(INPB, "IOC:LTUH:MG02:HEARTBEATE04.VAL")
}

record(calc, "IOC:LTUH:MG02:HEARTBEATE03") {
  field(FLNK, "IOC:LTUH:MG02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG02:HEARTBEATE02.B")
  field(INPB, "IOC:LTUH:MG02:HEARTBEATE03.VAL")
}

record(calc, "IOC:LTUH:MG02:HEARTBEATE02") {
  field(FLNK, "IOC:LTUH:MG02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG02:HEARTBEATE01.B")
  field(INPB, "IOC:LTUH:MG02:HEARTBEATE02.VAL")
}

record(calc, "IOC:LTUH:MG02:HEARTBEATE01") {
  field(FLNK, "IOC:LTUH:MG02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG02:HEARTBEATERR.VAL")
  field(INPB, "IOC:LTUH:MG02:HEARTBEATE01.VAL")
}

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

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

record(calc, "IOC:LTUH:MG02:HEARTBEATE10") {
  field(FLNK, "IOC:LTUH:MG02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MG02:HEARTBEATE09.B")
  field(INPB, "IOC:LTUH:MG02:HEARTBEATE10.VAL")
}

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

record(stringin, "IOC:LTUH:MG02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "IOC:LTUH:MG02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:MG02:LOC") {
  field(PINI, "YES")
  field(VAL, "B911-1324")
  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, "IOC:LTUH:BC01:INFO") {
  field(DESC, "IOC:LTUH:BC01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:BC01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Garth Brown (gwbrown)")
  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, "IOC:LTUH:BC01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:LTUH:BC01: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, "IOC:LTUH:BC01:TODDIFF")
}

record(longin, "IOC:LTUH:BC01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "IOC:LTUH:BC01:TODCHECK.VALA MS")
  field(FLNK, "IOC:LTUH:BC01: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, "IOC:LTUH:BC01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "IOC:LTUH:BC01:TODCHECK.SEVR")
  field(INPB, "IOC:LTUH:BC01:TODCHECK.VALB")
  field(FLNK, "IOC:LTUH:BC01:TODSUM")
}

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

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

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

record(calc, "IOC:LTUH:BC01:HEARTBEATECT") {
  field(FLNK, "IOC:LTUH:BC01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "IOC:LTUH:BC01:HEARTBEATE01.VAL")
  field(INPB, "IOC:LTUH:BC01:HEARTBEATE02.VAL")
  field(INPC, "IOC:LTUH:BC01:HEARTBEATE03.VAL")
  field(INPD, "IOC:LTUH:BC01:HEARTBEATE04.VAL")
  field(INPE, "IOC:LTUH:BC01:HEARTBEATE05.VAL")
  field(INPF, "IOC:LTUH:BC01:HEARTBEATE06.VAL")
  field(INPG, "IOC:LTUH:BC01:HEARTBEATE07.VAL")
  field(INPH, "IOC:LTUH:BC01:HEARTBEATE08.VAL")
  field(INPI, "IOC:LTUH:BC01:HEARTBEATE09.VAL")
  field(INPJ, "IOC:LTUH:BC01: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, "IOC:LTUH:BC01:HEARTBEATE09") {
  field(FLNK, "IOC:LTUH:BC01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC01:HEARTBEATE08.B")
  field(INPB, "IOC:LTUH:BC01:HEARTBEATE09.VAL")
}

record(calc, "IOC:LTUH:BC01:HEARTBEATE08") {
  field(FLNK, "IOC:LTUH:BC01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC01:HEARTBEATE07.B")
  field(INPB, "IOC:LTUH:BC01:HEARTBEATE08.VAL")
}

record(calc, "IOC:LTUH:BC01:HEARTBEATE07") {
  field(FLNK, "IOC:LTUH:BC01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC01:HEARTBEATE06.B")
  field(INPB, "IOC:LTUH:BC01:HEARTBEATE07.VAL")
}

record(calc, "IOC:LTUH:BC01:HEARTBEATE06") {
  field(FLNK, "IOC:LTUH:BC01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC01:HEARTBEATE05.B")
  field(INPB, "IOC:LTUH:BC01:HEARTBEATE06.VAL")
}

record(calc, "IOC:LTUH:BC01:HEARTBEATE05") {
  field(FLNK, "IOC:LTUH:BC01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC01:HEARTBEATE04.B")
  field(INPB, "IOC:LTUH:BC01:HEARTBEATE05.VAL")
}

record(calc, "IOC:LTUH:BC01:HEARTBEATE04") {
  field(FLNK, "IOC:LTUH:BC01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC01:HEARTBEATE03.B")
  field(INPB, "IOC:LTUH:BC01:HEARTBEATE04.VAL")
}

record(calc, "IOC:LTUH:BC01:HEARTBEATE03") {
  field(FLNK, "IOC:LTUH:BC01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC01:HEARTBEATE02.B")
  field(INPB, "IOC:LTUH:BC01:HEARTBEATE03.VAL")
}

record(calc, "IOC:LTUH:BC01:HEARTBEATE02") {
  field(FLNK, "IOC:LTUH:BC01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC01:HEARTBEATE01.B")
  field(INPB, "IOC:LTUH:BC01:HEARTBEATE02.VAL")
}

record(calc, "IOC:LTUH:BC01:HEARTBEATE01") {
  field(FLNK, "IOC:LTUH:BC01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC01:HEARTBEATERR.VAL")
  field(INPB, "IOC:LTUH:BC01:HEARTBEATE01.VAL")
}

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

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

record(calc, "IOC:LTUH:BC01:HEARTBEATE10") {
  field(FLNK, "IOC:LTUH:BC01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC01:HEARTBEATE09.B")
  field(INPB, "IOC:LTUH:BC01:HEARTBEATE10.VAL")
}

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

record(stringin, "IOC:LTUH:BC01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "IOC:LTUH:BC01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:BC01:LOC") {
  field(PINI, "YES")
  field(VAL, "B911-2021")
  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, "IOC:LTUH:BC02:INFO") {
  field(DESC, "IOC:LTUH:BC02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:BC02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Garth Brown (gwbrown)")
  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, "IOC:LTUH:BC02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:LTUH:BC02: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, "IOC:LTUH:BC02:TODDIFF")
}

record(longin, "IOC:LTUH:BC02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "IOC:LTUH:BC02:TODCHECK.VALA MS")
  field(FLNK, "IOC:LTUH:BC02: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, "IOC:LTUH:BC02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "IOC:LTUH:BC02:TODCHECK.SEVR")
  field(INPB, "IOC:LTUH:BC02:TODCHECK.VALB")
  field(FLNK, "IOC:LTUH:BC02:TODSUM")
}

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

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

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

record(calc, "IOC:LTUH:BC02:HEARTBEATECT") {
  field(FLNK, "IOC:LTUH:BC02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "IOC:LTUH:BC02:HEARTBEATE01.VAL")
  field(INPB, "IOC:LTUH:BC02:HEARTBEATE02.VAL")
  field(INPC, "IOC:LTUH:BC02:HEARTBEATE03.VAL")
  field(INPD, "IOC:LTUH:BC02:HEARTBEATE04.VAL")
  field(INPE, "IOC:LTUH:BC02:HEARTBEATE05.VAL")
  field(INPF, "IOC:LTUH:BC02:HEARTBEATE06.VAL")
  field(INPG, "IOC:LTUH:BC02:HEARTBEATE07.VAL")
  field(INPH, "IOC:LTUH:BC02:HEARTBEATE08.VAL")
  field(INPI, "IOC:LTUH:BC02:HEARTBEATE09.VAL")
  field(INPJ, "IOC:LTUH:BC02: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, "IOC:LTUH:BC02:HEARTBEATE09") {
  field(FLNK, "IOC:LTUH:BC02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC02:HEARTBEATE08.B")
  field(INPB, "IOC:LTUH:BC02:HEARTBEATE09.VAL")
}

record(calc, "IOC:LTUH:BC02:HEARTBEATE08") {
  field(FLNK, "IOC:LTUH:BC02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC02:HEARTBEATE07.B")
  field(INPB, "IOC:LTUH:BC02:HEARTBEATE08.VAL")
}

record(calc, "IOC:LTUH:BC02:HEARTBEATE07") {
  field(FLNK, "IOC:LTUH:BC02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC02:HEARTBEATE06.B")
  field(INPB, "IOC:LTUH:BC02:HEARTBEATE07.VAL")
}

record(calc, "IOC:LTUH:BC02:HEARTBEATE06") {
  field(FLNK, "IOC:LTUH:BC02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC02:HEARTBEATE05.B")
  field(INPB, "IOC:LTUH:BC02:HEARTBEATE06.VAL")
}

record(calc, "IOC:LTUH:BC02:HEARTBEATE05") {
  field(FLNK, "IOC:LTUH:BC02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC02:HEARTBEATE04.B")
  field(INPB, "IOC:LTUH:BC02:HEARTBEATE05.VAL")
}

record(calc, "IOC:LTUH:BC02:HEARTBEATE04") {
  field(FLNK, "IOC:LTUH:BC02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC02:HEARTBEATE03.B")
  field(INPB, "IOC:LTUH:BC02:HEARTBEATE04.VAL")
}

record(calc, "IOC:LTUH:BC02:HEARTBEATE03") {
  field(FLNK, "IOC:LTUH:BC02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC02:HEARTBEATE02.B")
  field(INPB, "IOC:LTUH:BC02:HEARTBEATE03.VAL")
}

record(calc, "IOC:LTUH:BC02:HEARTBEATE02") {
  field(FLNK, "IOC:LTUH:BC02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC02:HEARTBEATE01.B")
  field(INPB, "IOC:LTUH:BC02:HEARTBEATE02.VAL")
}

record(calc, "IOC:LTUH:BC02:HEARTBEATE01") {
  field(FLNK, "IOC:LTUH:BC02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC02:HEARTBEATERR.VAL")
  field(INPB, "IOC:LTUH:BC02:HEARTBEATE01.VAL")
}

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

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

record(calc, "IOC:LTUH:BC02:HEARTBEATE10") {
  field(FLNK, "IOC:LTUH:BC02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:BC02:HEARTBEATE09.B")
  field(INPB, "IOC:LTUH:BC02:HEARTBEATE10.VAL")
}

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

record(stringin, "IOC:LTUH:BC02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "IOC:LTUH:BC02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:BC02:LOC") {
  field(PINI, "YES")
  field(VAL, "B913-2021")
  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, "IOC:LTUH:MC01:INFO") {
  field(DESC, "IOC:LTUH:MC01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:MC01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "An Le (anle)")
  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, "IOC:LTUH:MC01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:LTUH:MC01: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, "IOC:LTUH:MC01:TODDIFF")
}

record(longin, "IOC:LTUH:MC01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "IOC:LTUH:MC01:TODCHECK.VALA MS")
  field(FLNK, "IOC:LTUH:MC01: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, "IOC:LTUH:MC01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "IOC:LTUH:MC01:TODCHECK.SEVR")
  field(INPB, "IOC:LTUH:MC01:TODCHECK.VALB")
  field(FLNK, "IOC:LTUH:MC01:TODSUM")
}

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

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

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

record(calc, "IOC:LTUH:MC01:HEARTBEATECT") {
  field(FLNK, "IOC:LTUH:MC01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "IOC:LTUH:MC01:HEARTBEATE01.VAL")
  field(INPB, "IOC:LTUH:MC01:HEARTBEATE02.VAL")
  field(INPC, "IOC:LTUH:MC01:HEARTBEATE03.VAL")
  field(INPD, "IOC:LTUH:MC01:HEARTBEATE04.VAL")
  field(INPE, "IOC:LTUH:MC01:HEARTBEATE05.VAL")
  field(INPF, "IOC:LTUH:MC01:HEARTBEATE06.VAL")
  field(INPG, "IOC:LTUH:MC01:HEARTBEATE07.VAL")
  field(INPH, "IOC:LTUH:MC01:HEARTBEATE08.VAL")
  field(INPI, "IOC:LTUH:MC01:HEARTBEATE09.VAL")
  field(INPJ, "IOC:LTUH:MC01: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, "IOC:LTUH:MC01:HEARTBEATE09") {
  field(FLNK, "IOC:LTUH:MC01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC01:HEARTBEATE08.B")
  field(INPB, "IOC:LTUH:MC01:HEARTBEATE09.VAL")
}

record(calc, "IOC:LTUH:MC01:HEARTBEATE08") {
  field(FLNK, "IOC:LTUH:MC01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC01:HEARTBEATE07.B")
  field(INPB, "IOC:LTUH:MC01:HEARTBEATE08.VAL")
}

record(calc, "IOC:LTUH:MC01:HEARTBEATE07") {
  field(FLNK, "IOC:LTUH:MC01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC01:HEARTBEATE06.B")
  field(INPB, "IOC:LTUH:MC01:HEARTBEATE07.VAL")
}

record(calc, "IOC:LTUH:MC01:HEARTBEATE06") {
  field(FLNK, "IOC:LTUH:MC01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC01:HEARTBEATE05.B")
  field(INPB, "IOC:LTUH:MC01:HEARTBEATE06.VAL")
}

record(calc, "IOC:LTUH:MC01:HEARTBEATE05") {
  field(FLNK, "IOC:LTUH:MC01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC01:HEARTBEATE04.B")
  field(INPB, "IOC:LTUH:MC01:HEARTBEATE05.VAL")
}

record(calc, "IOC:LTUH:MC01:HEARTBEATE04") {
  field(FLNK, "IOC:LTUH:MC01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC01:HEARTBEATE03.B")
  field(INPB, "IOC:LTUH:MC01:HEARTBEATE04.VAL")
}

record(calc, "IOC:LTUH:MC01:HEARTBEATE03") {
  field(FLNK, "IOC:LTUH:MC01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC01:HEARTBEATE02.B")
  field(INPB, "IOC:LTUH:MC01:HEARTBEATE03.VAL")
}

record(calc, "IOC:LTUH:MC01:HEARTBEATE02") {
  field(FLNK, "IOC:LTUH:MC01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC01:HEARTBEATE01.B")
  field(INPB, "IOC:LTUH:MC01:HEARTBEATE02.VAL")
}

record(calc, "IOC:LTUH:MC01:HEARTBEATE01") {
  field(FLNK, "IOC:LTUH:MC01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC01:HEARTBEATERR.VAL")
  field(INPB, "IOC:LTUH:MC01:HEARTBEATE01.VAL")
}

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

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

record(calc, "IOC:LTUH:MC01:HEARTBEATE10") {
  field(FLNK, "IOC:LTUH:MC01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC01:HEARTBEATE09.B")
  field(INPB, "IOC:LTUH:MC01:HEARTBEATE10.VAL")
}

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

record(stringin, "IOC:LTUH:MC01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "IOC:LTUH:MC01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:MC01:LOC") {
  field(PINI, "YES")
  field(VAL, "B911-0331")
  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, "IOC:LTUH:MC02:INFO") {
  field(DESC, "IOC:LTUH:MC02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:MC02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "An Le (anle)")
  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, "IOC:LTUH:MC02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:LTUH:MC02: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, "IOC:LTUH:MC02:TODDIFF")
}

record(longin, "IOC:LTUH:MC02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "IOC:LTUH:MC02:TODCHECK.VALA MS")
  field(FLNK, "IOC:LTUH:MC02: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, "IOC:LTUH:MC02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "IOC:LTUH:MC02:TODCHECK.SEVR")
  field(INPB, "IOC:LTUH:MC02:TODCHECK.VALB")
  field(FLNK, "IOC:LTUH:MC02:TODSUM")
}

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

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

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

record(calc, "IOC:LTUH:MC02:HEARTBEATECT") {
  field(FLNK, "IOC:LTUH:MC02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "IOC:LTUH:MC02:HEARTBEATE01.VAL")
  field(INPB, "IOC:LTUH:MC02:HEARTBEATE02.VAL")
  field(INPC, "IOC:LTUH:MC02:HEARTBEATE03.VAL")
  field(INPD, "IOC:LTUH:MC02:HEARTBEATE04.VAL")
  field(INPE, "IOC:LTUH:MC02:HEARTBEATE05.VAL")
  field(INPF, "IOC:LTUH:MC02:HEARTBEATE06.VAL")
  field(INPG, "IOC:LTUH:MC02:HEARTBEATE07.VAL")
  field(INPH, "IOC:LTUH:MC02:HEARTBEATE08.VAL")
  field(INPI, "IOC:LTUH:MC02:HEARTBEATE09.VAL")
  field(INPJ, "IOC:LTUH:MC02: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, "IOC:LTUH:MC02:HEARTBEATE09") {
  field(FLNK, "IOC:LTUH:MC02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC02:HEARTBEATE08.B")
  field(INPB, "IOC:LTUH:MC02:HEARTBEATE09.VAL")
}

record(calc, "IOC:LTUH:MC02:HEARTBEATE08") {
  field(FLNK, "IOC:LTUH:MC02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC02:HEARTBEATE07.B")
  field(INPB, "IOC:LTUH:MC02:HEARTBEATE08.VAL")
}

record(calc, "IOC:LTUH:MC02:HEARTBEATE07") {
  field(FLNK, "IOC:LTUH:MC02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC02:HEARTBEATE06.B")
  field(INPB, "IOC:LTUH:MC02:HEARTBEATE07.VAL")
}

record(calc, "IOC:LTUH:MC02:HEARTBEATE06") {
  field(FLNK, "IOC:LTUH:MC02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC02:HEARTBEATE05.B")
  field(INPB, "IOC:LTUH:MC02:HEARTBEATE06.VAL")
}

record(calc, "IOC:LTUH:MC02:HEARTBEATE05") {
  field(FLNK, "IOC:LTUH:MC02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC02:HEARTBEATE04.B")
  field(INPB, "IOC:LTUH:MC02:HEARTBEATE05.VAL")
}

record(calc, "IOC:LTUH:MC02:HEARTBEATE04") {
  field(FLNK, "IOC:LTUH:MC02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC02:HEARTBEATE03.B")
  field(INPB, "IOC:LTUH:MC02:HEARTBEATE04.VAL")
}

record(calc, "IOC:LTUH:MC02:HEARTBEATE03") {
  field(FLNK, "IOC:LTUH:MC02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC02:HEARTBEATE02.B")
  field(INPB, "IOC:LTUH:MC02:HEARTBEATE03.VAL")
}

record(calc, "IOC:LTUH:MC02:HEARTBEATE02") {
  field(FLNK, "IOC:LTUH:MC02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC02:HEARTBEATE01.B")
  field(INPB, "IOC:LTUH:MC02:HEARTBEATE02.VAL")
}

record(calc, "IOC:LTUH:MC02:HEARTBEATE01") {
  field(FLNK, "IOC:LTUH:MC02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC02:HEARTBEATERR.VAL")
  field(INPB, "IOC:LTUH:MC02:HEARTBEATE01.VAL")
}

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

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

record(calc, "IOC:LTUH:MC02:HEARTBEATE10") {
  field(FLNK, "IOC:LTUH:MC02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC02:HEARTBEATE09.B")
  field(INPB, "IOC:LTUH:MC02:HEARTBEATE10.VAL")
}

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

record(stringin, "IOC:LTUH:MC02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "IOC:LTUH:MC02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:MC02:LOC") {
  field(PINI, "YES")
  field(VAL, "B913-0341")
  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, "IOC:LTUH:MC03:INFO") {
  field(DESC, "IOC:LTUH:MC03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:MC03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Namrata Balakrishnan (namrata)")
  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, "IOC:LTUH:MC03:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:LTUH:MC03: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, "IOC:LTUH:MC03:TODDIFF")
}

record(longin, "IOC:LTUH:MC03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "IOC:LTUH:MC03:TODCHECK.VALA MS")
  field(FLNK, "IOC:LTUH:MC03: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, "IOC:LTUH:MC03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "IOC:LTUH:MC03:TODCHECK.SEVR")
  field(INPB, "IOC:LTUH:MC03:TODCHECK.VALB")
  field(FLNK, "IOC:LTUH:MC03:TODSUM")
}

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

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

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

record(calc, "IOC:LTUH:MC03:HEARTBEATECT") {
  field(FLNK, "IOC:LTUH:MC03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "IOC:LTUH:MC03:HEARTBEATE01.VAL")
  field(INPB, "IOC:LTUH:MC03:HEARTBEATE02.VAL")
  field(INPC, "IOC:LTUH:MC03:HEARTBEATE03.VAL")
  field(INPD, "IOC:LTUH:MC03:HEARTBEATE04.VAL")
  field(INPE, "IOC:LTUH:MC03:HEARTBEATE05.VAL")
  field(INPF, "IOC:LTUH:MC03:HEARTBEATE06.VAL")
  field(INPG, "IOC:LTUH:MC03:HEARTBEATE07.VAL")
  field(INPH, "IOC:LTUH:MC03:HEARTBEATE08.VAL")
  field(INPI, "IOC:LTUH:MC03:HEARTBEATE09.VAL")
  field(INPJ, "IOC:LTUH:MC03: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, "IOC:LTUH:MC03:HEARTBEATE09") {
  field(FLNK, "IOC:LTUH:MC03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC03:HEARTBEATE08.B")
  field(INPB, "IOC:LTUH:MC03:HEARTBEATE09.VAL")
}

record(calc, "IOC:LTUH:MC03:HEARTBEATE08") {
  field(FLNK, "IOC:LTUH:MC03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC03:HEARTBEATE07.B")
  field(INPB, "IOC:LTUH:MC03:HEARTBEATE08.VAL")
}

record(calc, "IOC:LTUH:MC03:HEARTBEATE07") {
  field(FLNK, "IOC:LTUH:MC03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC03:HEARTBEATE06.B")
  field(INPB, "IOC:LTUH:MC03:HEARTBEATE07.VAL")
}

record(calc, "IOC:LTUH:MC03:HEARTBEATE06") {
  field(FLNK, "IOC:LTUH:MC03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC03:HEARTBEATE05.B")
  field(INPB, "IOC:LTUH:MC03:HEARTBEATE06.VAL")
}

record(calc, "IOC:LTUH:MC03:HEARTBEATE05") {
  field(FLNK, "IOC:LTUH:MC03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC03:HEARTBEATE04.B")
  field(INPB, "IOC:LTUH:MC03:HEARTBEATE05.VAL")
}

record(calc, "IOC:LTUH:MC03:HEARTBEATE04") {
  field(FLNK, "IOC:LTUH:MC03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC03:HEARTBEATE03.B")
  field(INPB, "IOC:LTUH:MC03:HEARTBEATE04.VAL")
}

record(calc, "IOC:LTUH:MC03:HEARTBEATE03") {
  field(FLNK, "IOC:LTUH:MC03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC03:HEARTBEATE02.B")
  field(INPB, "IOC:LTUH:MC03:HEARTBEATE03.VAL")
}

record(calc, "IOC:LTUH:MC03:HEARTBEATE02") {
  field(FLNK, "IOC:LTUH:MC03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC03:HEARTBEATE01.B")
  field(INPB, "IOC:LTUH:MC03:HEARTBEATE02.VAL")
}

record(calc, "IOC:LTUH:MC03:HEARTBEATE01") {
  field(FLNK, "IOC:LTUH:MC03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC03:HEARTBEATERR.VAL")
  field(INPB, "IOC:LTUH:MC03:HEARTBEATE01.VAL")
}

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

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

record(calc, "IOC:LTUH:MC03:HEARTBEATE10") {
  field(FLNK, "IOC:LTUH:MC03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:MC03:HEARTBEATE09.B")
  field(INPB, "IOC:LTUH:MC03:HEARTBEATE10.VAL")
}

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

record(stringin, "IOC:LTUH:MC03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "IOC:LTUH:MC03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:MC03:LOC") {
  field(PINI, "YES")
  field(VAL, "B913-9333")
  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, "IOC:LTUH:PP01:INFO") {
  field(DESC, "IOC:LTUH:PP01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:PP01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Garth Brown (gwbrown)")
  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, "IOC:LTUH:PP01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:LTUH:PP01: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, "IOC:LTUH:PP01:TODDIFF")
}

record(longin, "IOC:LTUH:PP01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "IOC:LTUH:PP01:TODCHECK.VALA MS")
  field(FLNK, "IOC:LTUH:PP01: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, "IOC:LTUH:PP01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "IOC:LTUH:PP01:TODCHECK.SEVR")
  field(INPB, "IOC:LTUH:PP01:TODCHECK.VALB")
  field(FLNK, "IOC:LTUH:PP01:TODSUM")
}

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

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

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

record(calc, "IOC:LTUH:PP01:HEARTBEATECT") {
  field(FLNK, "IOC:LTUH:PP01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "IOC:LTUH:PP01:HEARTBEATE01.VAL")
  field(INPB, "IOC:LTUH:PP01:HEARTBEATE02.VAL")
  field(INPC, "IOC:LTUH:PP01:HEARTBEATE03.VAL")
  field(INPD, "IOC:LTUH:PP01:HEARTBEATE04.VAL")
  field(INPE, "IOC:LTUH:PP01:HEARTBEATE05.VAL")
  field(INPF, "IOC:LTUH:PP01:HEARTBEATE06.VAL")
  field(INPG, "IOC:LTUH:PP01:HEARTBEATE07.VAL")
  field(INPH, "IOC:LTUH:PP01:HEARTBEATE08.VAL")
  field(INPI, "IOC:LTUH:PP01:HEARTBEATE09.VAL")
  field(INPJ, "IOC:LTUH:PP01: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, "IOC:LTUH:PP01:HEARTBEATE09") {
  field(FLNK, "IOC:LTUH:PP01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:PP01:HEARTBEATE08.B")
  field(INPB, "IOC:LTUH:PP01:HEARTBEATE09.VAL")
}

record(calc, "IOC:LTUH:PP01:HEARTBEATE08") {
  field(FLNK, "IOC:LTUH:PP01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:PP01:HEARTBEATE07.B")
  field(INPB, "IOC:LTUH:PP01:HEARTBEATE08.VAL")
}

record(calc, "IOC:LTUH:PP01:HEARTBEATE07") {
  field(FLNK, "IOC:LTUH:PP01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:PP01:HEARTBEATE06.B")
  field(INPB, "IOC:LTUH:PP01:HEARTBEATE07.VAL")
}

record(calc, "IOC:LTUH:PP01:HEARTBEATE06") {
  field(FLNK, "IOC:LTUH:PP01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:PP01:HEARTBEATE05.B")
  field(INPB, "IOC:LTUH:PP01:HEARTBEATE06.VAL")
}

record(calc, "IOC:LTUH:PP01:HEARTBEATE05") {
  field(FLNK, "IOC:LTUH:PP01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:PP01:HEARTBEATE04.B")
  field(INPB, "IOC:LTUH:PP01:HEARTBEATE05.VAL")
}

record(calc, "IOC:LTUH:PP01:HEARTBEATE04") {
  field(FLNK, "IOC:LTUH:PP01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:PP01:HEARTBEATE03.B")
  field(INPB, "IOC:LTUH:PP01:HEARTBEATE04.VAL")
}

record(calc, "IOC:LTUH:PP01:HEARTBEATE03") {
  field(FLNK, "IOC:LTUH:PP01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:PP01:HEARTBEATE02.B")
  field(INPB, "IOC:LTUH:PP01:HEARTBEATE03.VAL")
}

record(calc, "IOC:LTUH:PP01:HEARTBEATE02") {
  field(FLNK, "IOC:LTUH:PP01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:PP01:HEARTBEATE01.B")
  field(INPB, "IOC:LTUH:PP01:HEARTBEATE02.VAL")
}

record(calc, "IOC:LTUH:PP01:HEARTBEATE01") {
  field(FLNK, "IOC:LTUH:PP01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:PP01:HEARTBEATERR.VAL")
  field(INPB, "IOC:LTUH:PP01:HEARTBEATE01.VAL")
}

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

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

record(calc, "IOC:LTUH:PP01:HEARTBEATE10") {
  field(FLNK, "IOC:LTUH:PP01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:PP01:HEARTBEATE09.B")
  field(INPB, "IOC:LTUH:PP01:HEARTBEATE10.VAL")
}

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

record(stringin, "IOC:LTUH:PP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "IOC:LTUH:PP01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:PP01:LOC") {
  field(PINI, "YES")
  field(VAL, "B913-4443")
  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, "IOC:LTUH:IM01:INFO") {
  field(DESC, "IOC:LTUH:IM01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:IM01: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, "IOC:LTUH:IM01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:LTUH:IM01: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, "IOC:LTUH:IM01:TODDIFF")
}

record(longin, "IOC:LTUH:IM01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "IOC:LTUH:IM01:TODCHECK.VALA MS")
  field(FLNK, "IOC:LTUH:IM01: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, "IOC:LTUH:IM01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "IOC:LTUH:IM01:TODCHECK.SEVR")
  field(INPB, "IOC:LTUH:IM01:TODCHECK.VALB")
  field(FLNK, "IOC:LTUH:IM01:TODSUM")
}

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

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

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

record(calc, "IOC:LTUH:IM01:HEARTBEATECT") {
  field(FLNK, "IOC:LTUH:IM01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "IOC:LTUH:IM01:HEARTBEATE01.VAL")
  field(INPB, "IOC:LTUH:IM01:HEARTBEATE02.VAL")
  field(INPC, "IOC:LTUH:IM01:HEARTBEATE03.VAL")
  field(INPD, "IOC:LTUH:IM01:HEARTBEATE04.VAL")
  field(INPE, "IOC:LTUH:IM01:HEARTBEATE05.VAL")
  field(INPF, "IOC:LTUH:IM01:HEARTBEATE06.VAL")
  field(INPG, "IOC:LTUH:IM01:HEARTBEATE07.VAL")
  field(INPH, "IOC:LTUH:IM01:HEARTBEATE08.VAL")
  field(INPI, "IOC:LTUH:IM01:HEARTBEATE09.VAL")
  field(INPJ, "IOC:LTUH:IM01: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, "IOC:LTUH:IM01:HEARTBEATE09") {
  field(FLNK, "IOC:LTUH:IM01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM01:HEARTBEATE08.B")
  field(INPB, "IOC:LTUH:IM01:HEARTBEATE09.VAL")
}

record(calc, "IOC:LTUH:IM01:HEARTBEATE08") {
  field(FLNK, "IOC:LTUH:IM01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM01:HEARTBEATE07.B")
  field(INPB, "IOC:LTUH:IM01:HEARTBEATE08.VAL")
}

record(calc, "IOC:LTUH:IM01:HEARTBEATE07") {
  field(FLNK, "IOC:LTUH:IM01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM01:HEARTBEATE06.B")
  field(INPB, "IOC:LTUH:IM01:HEARTBEATE07.VAL")
}

record(calc, "IOC:LTUH:IM01:HEARTBEATE06") {
  field(FLNK, "IOC:LTUH:IM01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM01:HEARTBEATE05.B")
  field(INPB, "IOC:LTUH:IM01:HEARTBEATE06.VAL")
}

record(calc, "IOC:LTUH:IM01:HEARTBEATE05") {
  field(FLNK, "IOC:LTUH:IM01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM01:HEARTBEATE04.B")
  field(INPB, "IOC:LTUH:IM01:HEARTBEATE05.VAL")
}

record(calc, "IOC:LTUH:IM01:HEARTBEATE04") {
  field(FLNK, "IOC:LTUH:IM01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM01:HEARTBEATE03.B")
  field(INPB, "IOC:LTUH:IM01:HEARTBEATE04.VAL")
}

record(calc, "IOC:LTUH:IM01:HEARTBEATE03") {
  field(FLNK, "IOC:LTUH:IM01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM01:HEARTBEATE02.B")
  field(INPB, "IOC:LTUH:IM01:HEARTBEATE03.VAL")
}

record(calc, "IOC:LTUH:IM01:HEARTBEATE02") {
  field(FLNK, "IOC:LTUH:IM01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM01:HEARTBEATE01.B")
  field(INPB, "IOC:LTUH:IM01:HEARTBEATE02.VAL")
}

record(calc, "IOC:LTUH:IM01:HEARTBEATE01") {
  field(FLNK, "IOC:LTUH:IM01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM01:HEARTBEATERR.VAL")
  field(INPB, "IOC:LTUH:IM01:HEARTBEATE01.VAL")
}

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

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

record(calc, "IOC:LTUH:IM01:HEARTBEATE10") {
  field(FLNK, "IOC:LTUH:IM01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM01:HEARTBEATE09.B")
  field(INPB, "IOC:LTUH:IM01:HEARTBEATE10.VAL")
}

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

record(stringin, "IOC:LTUH:IM01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "IOC:LTUH:IM01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:IM01:LOC") {
  field(PINI, "YES")
  field(VAL, "B911-2209")
  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, "IOC:LTUH:IM02:INFO") {
  field(DESC, "IOC:LTUH:IM02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:IM02: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, "IOC:LTUH:IM02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:LTUH:IM02: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, "IOC:LTUH:IM02:TODDIFF")
}

record(longin, "IOC:LTUH:IM02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "IOC:LTUH:IM02:TODCHECK.VALA MS")
  field(FLNK, "IOC:LTUH:IM02: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, "IOC:LTUH:IM02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "IOC:LTUH:IM02:TODCHECK.SEVR")
  field(INPB, "IOC:LTUH:IM02:TODCHECK.VALB")
  field(FLNK, "IOC:LTUH:IM02:TODSUM")
}

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

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

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

record(calc, "IOC:LTUH:IM02:HEARTBEATECT") {
  field(FLNK, "IOC:LTUH:IM02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "IOC:LTUH:IM02:HEARTBEATE01.VAL")
  field(INPB, "IOC:LTUH:IM02:HEARTBEATE02.VAL")
  field(INPC, "IOC:LTUH:IM02:HEARTBEATE03.VAL")
  field(INPD, "IOC:LTUH:IM02:HEARTBEATE04.VAL")
  field(INPE, "IOC:LTUH:IM02:HEARTBEATE05.VAL")
  field(INPF, "IOC:LTUH:IM02:HEARTBEATE06.VAL")
  field(INPG, "IOC:LTUH:IM02:HEARTBEATE07.VAL")
  field(INPH, "IOC:LTUH:IM02:HEARTBEATE08.VAL")
  field(INPI, "IOC:LTUH:IM02:HEARTBEATE09.VAL")
  field(INPJ, "IOC:LTUH:IM02: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, "IOC:LTUH:IM02:HEARTBEATE09") {
  field(FLNK, "IOC:LTUH:IM02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM02:HEARTBEATE08.B")
  field(INPB, "IOC:LTUH:IM02:HEARTBEATE09.VAL")
}

record(calc, "IOC:LTUH:IM02:HEARTBEATE08") {
  field(FLNK, "IOC:LTUH:IM02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM02:HEARTBEATE07.B")
  field(INPB, "IOC:LTUH:IM02:HEARTBEATE08.VAL")
}

record(calc, "IOC:LTUH:IM02:HEARTBEATE07") {
  field(FLNK, "IOC:LTUH:IM02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM02:HEARTBEATE06.B")
  field(INPB, "IOC:LTUH:IM02:HEARTBEATE07.VAL")
}

record(calc, "IOC:LTUH:IM02:HEARTBEATE06") {
  field(FLNK, "IOC:LTUH:IM02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM02:HEARTBEATE05.B")
  field(INPB, "IOC:LTUH:IM02:HEARTBEATE06.VAL")
}

record(calc, "IOC:LTUH:IM02:HEARTBEATE05") {
  field(FLNK, "IOC:LTUH:IM02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM02:HEARTBEATE04.B")
  field(INPB, "IOC:LTUH:IM02:HEARTBEATE05.VAL")
}

record(calc, "IOC:LTUH:IM02:HEARTBEATE04") {
  field(FLNK, "IOC:LTUH:IM02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM02:HEARTBEATE03.B")
  field(INPB, "IOC:LTUH:IM02:HEARTBEATE04.VAL")
}

record(calc, "IOC:LTUH:IM02:HEARTBEATE03") {
  field(FLNK, "IOC:LTUH:IM02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM02:HEARTBEATE02.B")
  field(INPB, "IOC:LTUH:IM02:HEARTBEATE03.VAL")
}

record(calc, "IOC:LTUH:IM02:HEARTBEATE02") {
  field(FLNK, "IOC:LTUH:IM02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM02:HEARTBEATE01.B")
  field(INPB, "IOC:LTUH:IM02:HEARTBEATE02.VAL")
}

record(calc, "IOC:LTUH:IM02:HEARTBEATE01") {
  field(FLNK, "IOC:LTUH:IM02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM02:HEARTBEATERR.VAL")
  field(INPB, "IOC:LTUH:IM02:HEARTBEATE01.VAL")
}

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

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

record(calc, "IOC:LTUH:IM02:HEARTBEATE10") {
  field(FLNK, "IOC:LTUH:IM02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "IOC:LTUH:IM02:HEARTBEATE09.B")
  field(INPB, "IOC:LTUH:IM02:HEARTBEATE10.VAL")
}

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

record(stringin, "IOC:LTUH:IM02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "IOC:LTUH:IM02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "IOC:LTUH:IM02:LOC") {
  field(PINI, "YES")
  field(VAL, "B921-2309")
  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, "EIOC:LTUH:BP490:INFO") {
  field(DESC, "EIOC:LTUH:BP490 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:BP490:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "EIOC:LTUH:BP490:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:LTUH:BP490: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, "EIOC:LTUH:BP490:TODDIFF")
}

record(longin, "EIOC:LTUH:BP490:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:LTUH:BP490:TODCHECK.VALA MS")
  field(FLNK, "EIOC:LTUH:BP490: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, "EIOC:LTUH:BP490:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:LTUH:BP490:TODCHECK.SEVR")
  field(INPB, "EIOC:LTUH:BP490:TODCHECK.VALB")
  field(FLNK, "EIOC:LTUH:BP490:TODSUM")
}

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

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

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

record(calc, "EIOC:LTUH:BP490:HEARTBEATECT") {
  field(FLNK, "EIOC:LTUH:BP490:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:LTUH:BP490:HEARTBEATE01.VAL")
  field(INPB, "EIOC:LTUH:BP490:HEARTBEATE02.VAL")
  field(INPC, "EIOC:LTUH:BP490:HEARTBEATE03.VAL")
  field(INPD, "EIOC:LTUH:BP490:HEARTBEATE04.VAL")
  field(INPE, "EIOC:LTUH:BP490:HEARTBEATE05.VAL")
  field(INPF, "EIOC:LTUH:BP490:HEARTBEATE06.VAL")
  field(INPG, "EIOC:LTUH:BP490:HEARTBEATE07.VAL")
  field(INPH, "EIOC:LTUH:BP490:HEARTBEATE08.VAL")
  field(INPI, "EIOC:LTUH:BP490:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:LTUH:BP490: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, "EIOC:LTUH:BP490:HEARTBEATE09") {
  field(FLNK, "EIOC:LTUH:BP490:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP490:HEARTBEATE08.B")
  field(INPB, "EIOC:LTUH:BP490:HEARTBEATE09.VAL")
}

record(calc, "EIOC:LTUH:BP490:HEARTBEATE08") {
  field(FLNK, "EIOC:LTUH:BP490:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP490:HEARTBEATE07.B")
  field(INPB, "EIOC:LTUH:BP490:HEARTBEATE08.VAL")
}

record(calc, "EIOC:LTUH:BP490:HEARTBEATE07") {
  field(FLNK, "EIOC:LTUH:BP490:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP490:HEARTBEATE06.B")
  field(INPB, "EIOC:LTUH:BP490:HEARTBEATE07.VAL")
}

record(calc, "EIOC:LTUH:BP490:HEARTBEATE06") {
  field(FLNK, "EIOC:LTUH:BP490:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP490:HEARTBEATE05.B")
  field(INPB, "EIOC:LTUH:BP490:HEARTBEATE06.VAL")
}

record(calc, "EIOC:LTUH:BP490:HEARTBEATE05") {
  field(FLNK, "EIOC:LTUH:BP490:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP490:HEARTBEATE04.B")
  field(INPB, "EIOC:LTUH:BP490:HEARTBEATE05.VAL")
}

record(calc, "EIOC:LTUH:BP490:HEARTBEATE04") {
  field(FLNK, "EIOC:LTUH:BP490:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP490:HEARTBEATE03.B")
  field(INPB, "EIOC:LTUH:BP490:HEARTBEATE04.VAL")
}

record(calc, "EIOC:LTUH:BP490:HEARTBEATE03") {
  field(FLNK, "EIOC:LTUH:BP490:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP490:HEARTBEATE02.B")
  field(INPB, "EIOC:LTUH:BP490:HEARTBEATE03.VAL")
}

record(calc, "EIOC:LTUH:BP490:HEARTBEATE02") {
  field(FLNK, "EIOC:LTUH:BP490:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP490:HEARTBEATE01.B")
  field(INPB, "EIOC:LTUH:BP490:HEARTBEATE02.VAL")
}

record(calc, "EIOC:LTUH:BP490:HEARTBEATE01") {
  field(FLNK, "EIOC:LTUH:BP490:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP490:HEARTBEATERR.VAL")
  field(INPB, "EIOC:LTUH:BP490:HEARTBEATE01.VAL")
}

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

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

record(calc, "EIOC:LTUH:BP490:HEARTBEATE10") {
  field(FLNK, "EIOC:LTUH:BP490:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP490:HEARTBEATE09.B")
  field(INPB, "EIOC:LTUH:BP490:HEARTBEATE10.VAL")
}

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

record(stringin, "EIOC:LTUH:BP490:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:LTUH:BP490:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:BP490:LOC") {
  field(PINI, "YES")
  field(VAL, "B911-0120")
  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, "EIOC:LTUH:BP590:INFO") {
  field(DESC, "EIOC:LTUH:BP590 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:BP590:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "EIOC:LTUH:BP590:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:LTUH:BP590: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, "EIOC:LTUH:BP590:TODDIFF")
}

record(longin, "EIOC:LTUH:BP590:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:LTUH:BP590:TODCHECK.VALA MS")
  field(FLNK, "EIOC:LTUH:BP590: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, "EIOC:LTUH:BP590:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:LTUH:BP590:TODCHECK.SEVR")
  field(INPB, "EIOC:LTUH:BP590:TODCHECK.VALB")
  field(FLNK, "EIOC:LTUH:BP590:TODSUM")
}

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

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

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

record(calc, "EIOC:LTUH:BP590:HEARTBEATECT") {
  field(FLNK, "EIOC:LTUH:BP590:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:LTUH:BP590:HEARTBEATE01.VAL")
  field(INPB, "EIOC:LTUH:BP590:HEARTBEATE02.VAL")
  field(INPC, "EIOC:LTUH:BP590:HEARTBEATE03.VAL")
  field(INPD, "EIOC:LTUH:BP590:HEARTBEATE04.VAL")
  field(INPE, "EIOC:LTUH:BP590:HEARTBEATE05.VAL")
  field(INPF, "EIOC:LTUH:BP590:HEARTBEATE06.VAL")
  field(INPG, "EIOC:LTUH:BP590:HEARTBEATE07.VAL")
  field(INPH, "EIOC:LTUH:BP590:HEARTBEATE08.VAL")
  field(INPI, "EIOC:LTUH:BP590:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:LTUH:BP590: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, "EIOC:LTUH:BP590:HEARTBEATE09") {
  field(FLNK, "EIOC:LTUH:BP590:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP590:HEARTBEATE08.B")
  field(INPB, "EIOC:LTUH:BP590:HEARTBEATE09.VAL")
}

record(calc, "EIOC:LTUH:BP590:HEARTBEATE08") {
  field(FLNK, "EIOC:LTUH:BP590:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP590:HEARTBEATE07.B")
  field(INPB, "EIOC:LTUH:BP590:HEARTBEATE08.VAL")
}

record(calc, "EIOC:LTUH:BP590:HEARTBEATE07") {
  field(FLNK, "EIOC:LTUH:BP590:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP590:HEARTBEATE06.B")
  field(INPB, "EIOC:LTUH:BP590:HEARTBEATE07.VAL")
}

record(calc, "EIOC:LTUH:BP590:HEARTBEATE06") {
  field(FLNK, "EIOC:LTUH:BP590:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP590:HEARTBEATE05.B")
  field(INPB, "EIOC:LTUH:BP590:HEARTBEATE06.VAL")
}

record(calc, "EIOC:LTUH:BP590:HEARTBEATE05") {
  field(FLNK, "EIOC:LTUH:BP590:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP590:HEARTBEATE04.B")
  field(INPB, "EIOC:LTUH:BP590:HEARTBEATE05.VAL")
}

record(calc, "EIOC:LTUH:BP590:HEARTBEATE04") {
  field(FLNK, "EIOC:LTUH:BP590:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP590:HEARTBEATE03.B")
  field(INPB, "EIOC:LTUH:BP590:HEARTBEATE04.VAL")
}

record(calc, "EIOC:LTUH:BP590:HEARTBEATE03") {
  field(FLNK, "EIOC:LTUH:BP590:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP590:HEARTBEATE02.B")
  field(INPB, "EIOC:LTUH:BP590:HEARTBEATE03.VAL")
}

record(calc, "EIOC:LTUH:BP590:HEARTBEATE02") {
  field(FLNK, "EIOC:LTUH:BP590:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP590:HEARTBEATE01.B")
  field(INPB, "EIOC:LTUH:BP590:HEARTBEATE02.VAL")
}

record(calc, "EIOC:LTUH:BP590:HEARTBEATE01") {
  field(FLNK, "EIOC:LTUH:BP590:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP590:HEARTBEATERR.VAL")
  field(INPB, "EIOC:LTUH:BP590:HEARTBEATE01.VAL")
}

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

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

record(calc, "EIOC:LTUH:BP590:HEARTBEATE10") {
  field(FLNK, "EIOC:LTUH:BP590:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP590:HEARTBEATE09.B")
  field(INPB, "EIOC:LTUH:BP590:HEARTBEATE10.VAL")
}

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

record(stringin, "EIOC:LTUH:BP590:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:LTUH:BP590:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:BP590:LOC") {
  field(PINI, "YES")
  field(VAL, "B911-0116")
  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, "EIOC:LTUH:BP620:INFO") {
  field(DESC, "EIOC:LTUH:BP620 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:BP620:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "EIOC:LTUH:BP620:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:LTUH:BP620: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, "EIOC:LTUH:BP620:TODDIFF")
}

record(longin, "EIOC:LTUH:BP620:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:LTUH:BP620:TODCHECK.VALA MS")
  field(FLNK, "EIOC:LTUH:BP620: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, "EIOC:LTUH:BP620:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:LTUH:BP620:TODCHECK.SEVR")
  field(INPB, "EIOC:LTUH:BP620:TODCHECK.VALB")
  field(FLNK, "EIOC:LTUH:BP620:TODSUM")
}

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

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

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

record(calc, "EIOC:LTUH:BP620:HEARTBEATECT") {
  field(FLNK, "EIOC:LTUH:BP620:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:LTUH:BP620:HEARTBEATE01.VAL")
  field(INPB, "EIOC:LTUH:BP620:HEARTBEATE02.VAL")
  field(INPC, "EIOC:LTUH:BP620:HEARTBEATE03.VAL")
  field(INPD, "EIOC:LTUH:BP620:HEARTBEATE04.VAL")
  field(INPE, "EIOC:LTUH:BP620:HEARTBEATE05.VAL")
  field(INPF, "EIOC:LTUH:BP620:HEARTBEATE06.VAL")
  field(INPG, "EIOC:LTUH:BP620:HEARTBEATE07.VAL")
  field(INPH, "EIOC:LTUH:BP620:HEARTBEATE08.VAL")
  field(INPI, "EIOC:LTUH:BP620:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:LTUH:BP620: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, "EIOC:LTUH:BP620:HEARTBEATE09") {
  field(FLNK, "EIOC:LTUH:BP620:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP620:HEARTBEATE08.B")
  field(INPB, "EIOC:LTUH:BP620:HEARTBEATE09.VAL")
}

record(calc, "EIOC:LTUH:BP620:HEARTBEATE08") {
  field(FLNK, "EIOC:LTUH:BP620:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP620:HEARTBEATE07.B")
  field(INPB, "EIOC:LTUH:BP620:HEARTBEATE08.VAL")
}

record(calc, "EIOC:LTUH:BP620:HEARTBEATE07") {
  field(FLNK, "EIOC:LTUH:BP620:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP620:HEARTBEATE06.B")
  field(INPB, "EIOC:LTUH:BP620:HEARTBEATE07.VAL")
}

record(calc, "EIOC:LTUH:BP620:HEARTBEATE06") {
  field(FLNK, "EIOC:LTUH:BP620:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP620:HEARTBEATE05.B")
  field(INPB, "EIOC:LTUH:BP620:HEARTBEATE06.VAL")
}

record(calc, "EIOC:LTUH:BP620:HEARTBEATE05") {
  field(FLNK, "EIOC:LTUH:BP620:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP620:HEARTBEATE04.B")
  field(INPB, "EIOC:LTUH:BP620:HEARTBEATE05.VAL")
}

record(calc, "EIOC:LTUH:BP620:HEARTBEATE04") {
  field(FLNK, "EIOC:LTUH:BP620:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP620:HEARTBEATE03.B")
  field(INPB, "EIOC:LTUH:BP620:HEARTBEATE04.VAL")
}

record(calc, "EIOC:LTUH:BP620:HEARTBEATE03") {
  field(FLNK, "EIOC:LTUH:BP620:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP620:HEARTBEATE02.B")
  field(INPB, "EIOC:LTUH:BP620:HEARTBEATE03.VAL")
}

record(calc, "EIOC:LTUH:BP620:HEARTBEATE02") {
  field(FLNK, "EIOC:LTUH:BP620:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP620:HEARTBEATE01.B")
  field(INPB, "EIOC:LTUH:BP620:HEARTBEATE02.VAL")
}

record(calc, "EIOC:LTUH:BP620:HEARTBEATE01") {
  field(FLNK, "EIOC:LTUH:BP620:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP620:HEARTBEATERR.VAL")
  field(INPB, "EIOC:LTUH:BP620:HEARTBEATE01.VAL")
}

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

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

record(calc, "EIOC:LTUH:BP620:HEARTBEATE10") {
  field(FLNK, "EIOC:LTUH:BP620:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP620:HEARTBEATE09.B")
  field(INPB, "EIOC:LTUH:BP620:HEARTBEATE10.VAL")
}

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

record(stringin, "EIOC:LTUH:BP620:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:LTUH:BP620:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:BP620:LOC") {
  field(PINI, "YES")
  field(VAL, "B911-0114")
  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, "EIOC:LTUH:BP680:INFO") {
  field(DESC, "EIOC:LTUH:BP680 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:BP680:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "EIOC:LTUH:BP680:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:LTUH:BP680: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, "EIOC:LTUH:BP680:TODDIFF")
}

record(longin, "EIOC:LTUH:BP680:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:LTUH:BP680:TODCHECK.VALA MS")
  field(FLNK, "EIOC:LTUH:BP680: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, "EIOC:LTUH:BP680:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:LTUH:BP680:TODCHECK.SEVR")
  field(INPB, "EIOC:LTUH:BP680:TODCHECK.VALB")
  field(FLNK, "EIOC:LTUH:BP680:TODSUM")
}

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

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

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

record(calc, "EIOC:LTUH:BP680:HEARTBEATECT") {
  field(FLNK, "EIOC:LTUH:BP680:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:LTUH:BP680:HEARTBEATE01.VAL")
  field(INPB, "EIOC:LTUH:BP680:HEARTBEATE02.VAL")
  field(INPC, "EIOC:LTUH:BP680:HEARTBEATE03.VAL")
  field(INPD, "EIOC:LTUH:BP680:HEARTBEATE04.VAL")
  field(INPE, "EIOC:LTUH:BP680:HEARTBEATE05.VAL")
  field(INPF, "EIOC:LTUH:BP680:HEARTBEATE06.VAL")
  field(INPG, "EIOC:LTUH:BP680:HEARTBEATE07.VAL")
  field(INPH, "EIOC:LTUH:BP680:HEARTBEATE08.VAL")
  field(INPI, "EIOC:LTUH:BP680:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:LTUH:BP680: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, "EIOC:LTUH:BP680:HEARTBEATE09") {
  field(FLNK, "EIOC:LTUH:BP680:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP680:HEARTBEATE08.B")
  field(INPB, "EIOC:LTUH:BP680:HEARTBEATE09.VAL")
}

record(calc, "EIOC:LTUH:BP680:HEARTBEATE08") {
  field(FLNK, "EIOC:LTUH:BP680:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP680:HEARTBEATE07.B")
  field(INPB, "EIOC:LTUH:BP680:HEARTBEATE08.VAL")
}

record(calc, "EIOC:LTUH:BP680:HEARTBEATE07") {
  field(FLNK, "EIOC:LTUH:BP680:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP680:HEARTBEATE06.B")
  field(INPB, "EIOC:LTUH:BP680:HEARTBEATE07.VAL")
}

record(calc, "EIOC:LTUH:BP680:HEARTBEATE06") {
  field(FLNK, "EIOC:LTUH:BP680:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP680:HEARTBEATE05.B")
  field(INPB, "EIOC:LTUH:BP680:HEARTBEATE06.VAL")
}

record(calc, "EIOC:LTUH:BP680:HEARTBEATE05") {
  field(FLNK, "EIOC:LTUH:BP680:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP680:HEARTBEATE04.B")
  field(INPB, "EIOC:LTUH:BP680:HEARTBEATE05.VAL")
}

record(calc, "EIOC:LTUH:BP680:HEARTBEATE04") {
  field(FLNK, "EIOC:LTUH:BP680:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP680:HEARTBEATE03.B")
  field(INPB, "EIOC:LTUH:BP680:HEARTBEATE04.VAL")
}

record(calc, "EIOC:LTUH:BP680:HEARTBEATE03") {
  field(FLNK, "EIOC:LTUH:BP680:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP680:HEARTBEATE02.B")
  field(INPB, "EIOC:LTUH:BP680:HEARTBEATE03.VAL")
}

record(calc, "EIOC:LTUH:BP680:HEARTBEATE02") {
  field(FLNK, "EIOC:LTUH:BP680:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP680:HEARTBEATE01.B")
  field(INPB, "EIOC:LTUH:BP680:HEARTBEATE02.VAL")
}

record(calc, "EIOC:LTUH:BP680:HEARTBEATE01") {
  field(FLNK, "EIOC:LTUH:BP680:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP680:HEARTBEATERR.VAL")
  field(INPB, "EIOC:LTUH:BP680:HEARTBEATE01.VAL")
}

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

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

record(calc, "EIOC:LTUH:BP680:HEARTBEATE10") {
  field(FLNK, "EIOC:LTUH:BP680:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP680:HEARTBEATE09.B")
  field(INPB, "EIOC:LTUH:BP680:HEARTBEATE10.VAL")
}

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

record(stringin, "EIOC:LTUH:BP680:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:LTUH:BP680:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:BP680:LOC") {
  field(PINI, "YES")
  field(VAL, "B911-0108")
  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, "EIOC:LTUH:BP740:INFO") {
  field(DESC, "EIOC:LTUH:BP740 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:BP740:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "EIOC:LTUH:BP740:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:LTUH:BP740: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, "EIOC:LTUH:BP740:TODDIFF")
}

record(longin, "EIOC:LTUH:BP740:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:LTUH:BP740:TODCHECK.VALA MS")
  field(FLNK, "EIOC:LTUH:BP740: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, "EIOC:LTUH:BP740:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:LTUH:BP740:TODCHECK.SEVR")
  field(INPB, "EIOC:LTUH:BP740:TODCHECK.VALB")
  field(FLNK, "EIOC:LTUH:BP740:TODSUM")
}

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

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

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

record(calc, "EIOC:LTUH:BP740:HEARTBEATECT") {
  field(FLNK, "EIOC:LTUH:BP740:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:LTUH:BP740:HEARTBEATE01.VAL")
  field(INPB, "EIOC:LTUH:BP740:HEARTBEATE02.VAL")
  field(INPC, "EIOC:LTUH:BP740:HEARTBEATE03.VAL")
  field(INPD, "EIOC:LTUH:BP740:HEARTBEATE04.VAL")
  field(INPE, "EIOC:LTUH:BP740:HEARTBEATE05.VAL")
  field(INPF, "EIOC:LTUH:BP740:HEARTBEATE06.VAL")
  field(INPG, "EIOC:LTUH:BP740:HEARTBEATE07.VAL")
  field(INPH, "EIOC:LTUH:BP740:HEARTBEATE08.VAL")
  field(INPI, "EIOC:LTUH:BP740:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:LTUH:BP740: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, "EIOC:LTUH:BP740:HEARTBEATE09") {
  field(FLNK, "EIOC:LTUH:BP740:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP740:HEARTBEATE08.B")
  field(INPB, "EIOC:LTUH:BP740:HEARTBEATE09.VAL")
}

record(calc, "EIOC:LTUH:BP740:HEARTBEATE08") {
  field(FLNK, "EIOC:LTUH:BP740:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP740:HEARTBEATE07.B")
  field(INPB, "EIOC:LTUH:BP740:HEARTBEATE08.VAL")
}

record(calc, "EIOC:LTUH:BP740:HEARTBEATE07") {
  field(FLNK, "EIOC:LTUH:BP740:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP740:HEARTBEATE06.B")
  field(INPB, "EIOC:LTUH:BP740:HEARTBEATE07.VAL")
}

record(calc, "EIOC:LTUH:BP740:HEARTBEATE06") {
  field(FLNK, "EIOC:LTUH:BP740:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP740:HEARTBEATE05.B")
  field(INPB, "EIOC:LTUH:BP740:HEARTBEATE06.VAL")
}

record(calc, "EIOC:LTUH:BP740:HEARTBEATE05") {
  field(FLNK, "EIOC:LTUH:BP740:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP740:HEARTBEATE04.B")
  field(INPB, "EIOC:LTUH:BP740:HEARTBEATE05.VAL")
}

record(calc, "EIOC:LTUH:BP740:HEARTBEATE04") {
  field(FLNK, "EIOC:LTUH:BP740:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP740:HEARTBEATE03.B")
  field(INPB, "EIOC:LTUH:BP740:HEARTBEATE04.VAL")
}

record(calc, "EIOC:LTUH:BP740:HEARTBEATE03") {
  field(FLNK, "EIOC:LTUH:BP740:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP740:HEARTBEATE02.B")
  field(INPB, "EIOC:LTUH:BP740:HEARTBEATE03.VAL")
}

record(calc, "EIOC:LTUH:BP740:HEARTBEATE02") {
  field(FLNK, "EIOC:LTUH:BP740:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP740:HEARTBEATE01.B")
  field(INPB, "EIOC:LTUH:BP740:HEARTBEATE02.VAL")
}

record(calc, "EIOC:LTUH:BP740:HEARTBEATE01") {
  field(FLNK, "EIOC:LTUH:BP740:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP740:HEARTBEATERR.VAL")
  field(INPB, "EIOC:LTUH:BP740:HEARTBEATE01.VAL")
}

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

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

record(calc, "EIOC:LTUH:BP740:HEARTBEATE10") {
  field(FLNK, "EIOC:LTUH:BP740:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP740:HEARTBEATE09.B")
  field(INPB, "EIOC:LTUH:BP740:HEARTBEATE10.VAL")
}

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

record(stringin, "EIOC:LTUH:BP740:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:LTUH:BP740:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:BP740:LOC") {
  field(PINI, "YES")
  field(VAL, "B912-0318")
  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, "EIOC:LTUH:BP750:INFO") {
  field(DESC, "EIOC:LTUH:BP750 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:BP750:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "EIOC:LTUH:BP750:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:LTUH:BP750: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, "EIOC:LTUH:BP750:TODDIFF")
}

record(longin, "EIOC:LTUH:BP750:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:LTUH:BP750:TODCHECK.VALA MS")
  field(FLNK, "EIOC:LTUH:BP750: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, "EIOC:LTUH:BP750:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:LTUH:BP750:TODCHECK.SEVR")
  field(INPB, "EIOC:LTUH:BP750:TODCHECK.VALB")
  field(FLNK, "EIOC:LTUH:BP750:TODSUM")
}

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

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

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

record(calc, "EIOC:LTUH:BP750:HEARTBEATECT") {
  field(FLNK, "EIOC:LTUH:BP750:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:LTUH:BP750:HEARTBEATE01.VAL")
  field(INPB, "EIOC:LTUH:BP750:HEARTBEATE02.VAL")
  field(INPC, "EIOC:LTUH:BP750:HEARTBEATE03.VAL")
  field(INPD, "EIOC:LTUH:BP750:HEARTBEATE04.VAL")
  field(INPE, "EIOC:LTUH:BP750:HEARTBEATE05.VAL")
  field(INPF, "EIOC:LTUH:BP750:HEARTBEATE06.VAL")
  field(INPG, "EIOC:LTUH:BP750:HEARTBEATE07.VAL")
  field(INPH, "EIOC:LTUH:BP750:HEARTBEATE08.VAL")
  field(INPI, "EIOC:LTUH:BP750:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:LTUH:BP750: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, "EIOC:LTUH:BP750:HEARTBEATE09") {
  field(FLNK, "EIOC:LTUH:BP750:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP750:HEARTBEATE08.B")
  field(INPB, "EIOC:LTUH:BP750:HEARTBEATE09.VAL")
}

record(calc, "EIOC:LTUH:BP750:HEARTBEATE08") {
  field(FLNK, "EIOC:LTUH:BP750:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP750:HEARTBEATE07.B")
  field(INPB, "EIOC:LTUH:BP750:HEARTBEATE08.VAL")
}

record(calc, "EIOC:LTUH:BP750:HEARTBEATE07") {
  field(FLNK, "EIOC:LTUH:BP750:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP750:HEARTBEATE06.B")
  field(INPB, "EIOC:LTUH:BP750:HEARTBEATE07.VAL")
}

record(calc, "EIOC:LTUH:BP750:HEARTBEATE06") {
  field(FLNK, "EIOC:LTUH:BP750:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP750:HEARTBEATE05.B")
  field(INPB, "EIOC:LTUH:BP750:HEARTBEATE06.VAL")
}

record(calc, "EIOC:LTUH:BP750:HEARTBEATE05") {
  field(FLNK, "EIOC:LTUH:BP750:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP750:HEARTBEATE04.B")
  field(INPB, "EIOC:LTUH:BP750:HEARTBEATE05.VAL")
}

record(calc, "EIOC:LTUH:BP750:HEARTBEATE04") {
  field(FLNK, "EIOC:LTUH:BP750:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP750:HEARTBEATE03.B")
  field(INPB, "EIOC:LTUH:BP750:HEARTBEATE04.VAL")
}

record(calc, "EIOC:LTUH:BP750:HEARTBEATE03") {
  field(FLNK, "EIOC:LTUH:BP750:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP750:HEARTBEATE02.B")
  field(INPB, "EIOC:LTUH:BP750:HEARTBEATE03.VAL")
}

record(calc, "EIOC:LTUH:BP750:HEARTBEATE02") {
  field(FLNK, "EIOC:LTUH:BP750:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP750:HEARTBEATE01.B")
  field(INPB, "EIOC:LTUH:BP750:HEARTBEATE02.VAL")
}

record(calc, "EIOC:LTUH:BP750:HEARTBEATE01") {
  field(FLNK, "EIOC:LTUH:BP750:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP750:HEARTBEATERR.VAL")
  field(INPB, "EIOC:LTUH:BP750:HEARTBEATE01.VAL")
}

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

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

record(calc, "EIOC:LTUH:BP750:HEARTBEATE10") {
  field(FLNK, "EIOC:LTUH:BP750:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP750:HEARTBEATE09.B")
  field(INPB, "EIOC:LTUH:BP750:HEARTBEATE10.VAL")
}

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

record(stringin, "EIOC:LTUH:BP750:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:LTUH:BP750:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:BP750:LOC") {
  field(PINI, "YES")
  field(VAL, "B912-0316")
  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, "EIOC:LTUH:BP820:INFO") {
  field(DESC, "EIOC:LTUH:BP820 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:BP820:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "EIOC:LTUH:BP820:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:LTUH:BP820: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, "EIOC:LTUH:BP820:TODDIFF")
}

record(longin, "EIOC:LTUH:BP820:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:LTUH:BP820:TODCHECK.VALA MS")
  field(FLNK, "EIOC:LTUH:BP820: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, "EIOC:LTUH:BP820:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:LTUH:BP820:TODCHECK.SEVR")
  field(INPB, "EIOC:LTUH:BP820:TODCHECK.VALB")
  field(FLNK, "EIOC:LTUH:BP820:TODSUM")
}

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

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

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

record(calc, "EIOC:LTUH:BP820:HEARTBEATECT") {
  field(FLNK, "EIOC:LTUH:BP820:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:LTUH:BP820:HEARTBEATE01.VAL")
  field(INPB, "EIOC:LTUH:BP820:HEARTBEATE02.VAL")
  field(INPC, "EIOC:LTUH:BP820:HEARTBEATE03.VAL")
  field(INPD, "EIOC:LTUH:BP820:HEARTBEATE04.VAL")
  field(INPE, "EIOC:LTUH:BP820:HEARTBEATE05.VAL")
  field(INPF, "EIOC:LTUH:BP820:HEARTBEATE06.VAL")
  field(INPG, "EIOC:LTUH:BP820:HEARTBEATE07.VAL")
  field(INPH, "EIOC:LTUH:BP820:HEARTBEATE08.VAL")
  field(INPI, "EIOC:LTUH:BP820:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:LTUH:BP820: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, "EIOC:LTUH:BP820:HEARTBEATE09") {
  field(FLNK, "EIOC:LTUH:BP820:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP820:HEARTBEATE08.B")
  field(INPB, "EIOC:LTUH:BP820:HEARTBEATE09.VAL")
}

record(calc, "EIOC:LTUH:BP820:HEARTBEATE08") {
  field(FLNK, "EIOC:LTUH:BP820:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP820:HEARTBEATE07.B")
  field(INPB, "EIOC:LTUH:BP820:HEARTBEATE08.VAL")
}

record(calc, "EIOC:LTUH:BP820:HEARTBEATE07") {
  field(FLNK, "EIOC:LTUH:BP820:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP820:HEARTBEATE06.B")
  field(INPB, "EIOC:LTUH:BP820:HEARTBEATE07.VAL")
}

record(calc, "EIOC:LTUH:BP820:HEARTBEATE06") {
  field(FLNK, "EIOC:LTUH:BP820:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP820:HEARTBEATE05.B")
  field(INPB, "EIOC:LTUH:BP820:HEARTBEATE06.VAL")
}

record(calc, "EIOC:LTUH:BP820:HEARTBEATE05") {
  field(FLNK, "EIOC:LTUH:BP820:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP820:HEARTBEATE04.B")
  field(INPB, "EIOC:LTUH:BP820:HEARTBEATE05.VAL")
}

record(calc, "EIOC:LTUH:BP820:HEARTBEATE04") {
  field(FLNK, "EIOC:LTUH:BP820:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP820:HEARTBEATE03.B")
  field(INPB, "EIOC:LTUH:BP820:HEARTBEATE04.VAL")
}

record(calc, "EIOC:LTUH:BP820:HEARTBEATE03") {
  field(FLNK, "EIOC:LTUH:BP820:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP820:HEARTBEATE02.B")
  field(INPB, "EIOC:LTUH:BP820:HEARTBEATE03.VAL")
}

record(calc, "EIOC:LTUH:BP820:HEARTBEATE02") {
  field(FLNK, "EIOC:LTUH:BP820:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP820:HEARTBEATE01.B")
  field(INPB, "EIOC:LTUH:BP820:HEARTBEATE02.VAL")
}

record(calc, "EIOC:LTUH:BP820:HEARTBEATE01") {
  field(FLNK, "EIOC:LTUH:BP820:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP820:HEARTBEATERR.VAL")
  field(INPB, "EIOC:LTUH:BP820:HEARTBEATE01.VAL")
}

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

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

record(calc, "EIOC:LTUH:BP820:HEARTBEATE10") {
  field(FLNK, "EIOC:LTUH:BP820:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP820:HEARTBEATE09.B")
  field(INPB, "EIOC:LTUH:BP820:HEARTBEATE10.VAL")
}

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

record(stringin, "EIOC:LTUH:BP820:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:LTUH:BP820:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:BP820:LOC") {
  field(PINI, "YES")
  field(VAL, "B913-0118")
  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, "EIOC:LTUH:BP840:INFO") {
  field(DESC, "EIOC:LTUH:BP840 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:BP840:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "EIOC:LTUH:BP840:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:LTUH:BP840: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, "EIOC:LTUH:BP840:TODDIFF")
}

record(longin, "EIOC:LTUH:BP840:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:LTUH:BP840:TODCHECK.VALA MS")
  field(FLNK, "EIOC:LTUH:BP840: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, "EIOC:LTUH:BP840:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:LTUH:BP840:TODCHECK.SEVR")
  field(INPB, "EIOC:LTUH:BP840:TODCHECK.VALB")
  field(FLNK, "EIOC:LTUH:BP840:TODSUM")
}

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

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

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

record(calc, "EIOC:LTUH:BP840:HEARTBEATECT") {
  field(FLNK, "EIOC:LTUH:BP840:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:LTUH:BP840:HEARTBEATE01.VAL")
  field(INPB, "EIOC:LTUH:BP840:HEARTBEATE02.VAL")
  field(INPC, "EIOC:LTUH:BP840:HEARTBEATE03.VAL")
  field(INPD, "EIOC:LTUH:BP840:HEARTBEATE04.VAL")
  field(INPE, "EIOC:LTUH:BP840:HEARTBEATE05.VAL")
  field(INPF, "EIOC:LTUH:BP840:HEARTBEATE06.VAL")
  field(INPG, "EIOC:LTUH:BP840:HEARTBEATE07.VAL")
  field(INPH, "EIOC:LTUH:BP840:HEARTBEATE08.VAL")
  field(INPI, "EIOC:LTUH:BP840:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:LTUH:BP840: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, "EIOC:LTUH:BP840:HEARTBEATE09") {
  field(FLNK, "EIOC:LTUH:BP840:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP840:HEARTBEATE08.B")
  field(INPB, "EIOC:LTUH:BP840:HEARTBEATE09.VAL")
}

record(calc, "EIOC:LTUH:BP840:HEARTBEATE08") {
  field(FLNK, "EIOC:LTUH:BP840:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP840:HEARTBEATE07.B")
  field(INPB, "EIOC:LTUH:BP840:HEARTBEATE08.VAL")
}

record(calc, "EIOC:LTUH:BP840:HEARTBEATE07") {
  field(FLNK, "EIOC:LTUH:BP840:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP840:HEARTBEATE06.B")
  field(INPB, "EIOC:LTUH:BP840:HEARTBEATE07.VAL")
}

record(calc, "EIOC:LTUH:BP840:HEARTBEATE06") {
  field(FLNK, "EIOC:LTUH:BP840:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP840:HEARTBEATE05.B")
  field(INPB, "EIOC:LTUH:BP840:HEARTBEATE06.VAL")
}

record(calc, "EIOC:LTUH:BP840:HEARTBEATE05") {
  field(FLNK, "EIOC:LTUH:BP840:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP840:HEARTBEATE04.B")
  field(INPB, "EIOC:LTUH:BP840:HEARTBEATE05.VAL")
}

record(calc, "EIOC:LTUH:BP840:HEARTBEATE04") {
  field(FLNK, "EIOC:LTUH:BP840:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP840:HEARTBEATE03.B")
  field(INPB, "EIOC:LTUH:BP840:HEARTBEATE04.VAL")
}

record(calc, "EIOC:LTUH:BP840:HEARTBEATE03") {
  field(FLNK, "EIOC:LTUH:BP840:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP840:HEARTBEATE02.B")
  field(INPB, "EIOC:LTUH:BP840:HEARTBEATE03.VAL")
}

record(calc, "EIOC:LTUH:BP840:HEARTBEATE02") {
  field(FLNK, "EIOC:LTUH:BP840:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP840:HEARTBEATE01.B")
  field(INPB, "EIOC:LTUH:BP840:HEARTBEATE02.VAL")
}

record(calc, "EIOC:LTUH:BP840:HEARTBEATE01") {
  field(FLNK, "EIOC:LTUH:BP840:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP840:HEARTBEATERR.VAL")
  field(INPB, "EIOC:LTUH:BP840:HEARTBEATE01.VAL")
}

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

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

record(calc, "EIOC:LTUH:BP840:HEARTBEATE10") {
  field(FLNK, "EIOC:LTUH:BP840:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:BP840:HEARTBEATE09.B")
  field(INPB, "EIOC:LTUH:BP840:HEARTBEATE10.VAL")
}

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

record(stringin, "EIOC:LTUH:BP840:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:LTUH:BP840:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:BP840:LOC") {
  field(PINI, "YES")
  field(VAL, "B913-0116")
  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, "EIOC:LTUH:MP01:INFO") {
  field(DESC, "EIOC:LTUH:MP01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:MP01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  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, "EIOC:LTUH:MP01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:LTUH:MP01: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, "EIOC:LTUH:MP01:TODDIFF")
}

record(longin, "EIOC:LTUH:MP01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:LTUH:MP01:TODCHECK.VALA MS")
  field(FLNK, "EIOC:LTUH:MP01: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, "EIOC:LTUH:MP01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:LTUH:MP01:TODCHECK.SEVR")
  field(INPB, "EIOC:LTUH:MP01:TODCHECK.VALB")
  field(FLNK, "EIOC:LTUH:MP01:TODSUM")
}

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

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

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

record(calc, "EIOC:LTUH:MP01:HEARTBEATECT") {
  field(FLNK, "EIOC:LTUH:MP01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:LTUH:MP01:HEARTBEATE01.VAL")
  field(INPB, "EIOC:LTUH:MP01:HEARTBEATE02.VAL")
  field(INPC, "EIOC:LTUH:MP01:HEARTBEATE03.VAL")
  field(INPD, "EIOC:LTUH:MP01:HEARTBEATE04.VAL")
  field(INPE, "EIOC:LTUH:MP01:HEARTBEATE05.VAL")
  field(INPF, "EIOC:LTUH:MP01:HEARTBEATE06.VAL")
  field(INPG, "EIOC:LTUH:MP01:HEARTBEATE07.VAL")
  field(INPH, "EIOC:LTUH:MP01:HEARTBEATE08.VAL")
  field(INPI, "EIOC:LTUH:MP01:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:LTUH:MP01: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, "EIOC:LTUH:MP01:HEARTBEATE09") {
  field(FLNK, "EIOC:LTUH:MP01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP01:HEARTBEATE08.B")
  field(INPB, "EIOC:LTUH:MP01:HEARTBEATE09.VAL")
}

record(calc, "EIOC:LTUH:MP01:HEARTBEATE08") {
  field(FLNK, "EIOC:LTUH:MP01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP01:HEARTBEATE07.B")
  field(INPB, "EIOC:LTUH:MP01:HEARTBEATE08.VAL")
}

record(calc, "EIOC:LTUH:MP01:HEARTBEATE07") {
  field(FLNK, "EIOC:LTUH:MP01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP01:HEARTBEATE06.B")
  field(INPB, "EIOC:LTUH:MP01:HEARTBEATE07.VAL")
}

record(calc, "EIOC:LTUH:MP01:HEARTBEATE06") {
  field(FLNK, "EIOC:LTUH:MP01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP01:HEARTBEATE05.B")
  field(INPB, "EIOC:LTUH:MP01:HEARTBEATE06.VAL")
}

record(calc, "EIOC:LTUH:MP01:HEARTBEATE05") {
  field(FLNK, "EIOC:LTUH:MP01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP01:HEARTBEATE04.B")
  field(INPB, "EIOC:LTUH:MP01:HEARTBEATE05.VAL")
}

record(calc, "EIOC:LTUH:MP01:HEARTBEATE04") {
  field(FLNK, "EIOC:LTUH:MP01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP01:HEARTBEATE03.B")
  field(INPB, "EIOC:LTUH:MP01:HEARTBEATE04.VAL")
}

record(calc, "EIOC:LTUH:MP01:HEARTBEATE03") {
  field(FLNK, "EIOC:LTUH:MP01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP01:HEARTBEATE02.B")
  field(INPB, "EIOC:LTUH:MP01:HEARTBEATE03.VAL")
}

record(calc, "EIOC:LTUH:MP01:HEARTBEATE02") {
  field(FLNK, "EIOC:LTUH:MP01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP01:HEARTBEATE01.B")
  field(INPB, "EIOC:LTUH:MP01:HEARTBEATE02.VAL")
}

record(calc, "EIOC:LTUH:MP01:HEARTBEATE01") {
  field(FLNK, "EIOC:LTUH:MP01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP01:HEARTBEATERR.VAL")
  field(INPB, "EIOC:LTUH:MP01:HEARTBEATE01.VAL")
}

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

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

record(calc, "EIOC:LTUH:MP01:HEARTBEATE10") {
  field(FLNK, "EIOC:LTUH:MP01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP01:HEARTBEATE09.B")
  field(INPB, "EIOC:LTUH:MP01:HEARTBEATE10.VAL")
}

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

record(stringin, "EIOC:LTUH:MP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LN27")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:LTUH:MP01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LN27")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:MP01:LOC") {
  field(PINI, "YES")
  field(VAL, "B105-0144")
  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, "EIOC:LTUH:MP11:INFO") {
  field(DESC, "EIOC:LTUH:MP11 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:MP11:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  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, "EIOC:LTUH:MP11:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:LTUH:MP11: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, "EIOC:LTUH:MP11:TODDIFF")
}

record(longin, "EIOC:LTUH:MP11:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:LTUH:MP11:TODCHECK.VALA MS")
  field(FLNK, "EIOC:LTUH:MP11: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, "EIOC:LTUH:MP11:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:LTUH:MP11:TODCHECK.SEVR")
  field(INPB, "EIOC:LTUH:MP11:TODCHECK.VALB")
  field(FLNK, "EIOC:LTUH:MP11:TODSUM")
}

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

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

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

record(calc, "EIOC:LTUH:MP11:HEARTBEATECT") {
  field(FLNK, "EIOC:LTUH:MP11:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:LTUH:MP11:HEARTBEATE01.VAL")
  field(INPB, "EIOC:LTUH:MP11:HEARTBEATE02.VAL")
  field(INPC, "EIOC:LTUH:MP11:HEARTBEATE03.VAL")
  field(INPD, "EIOC:LTUH:MP11:HEARTBEATE04.VAL")
  field(INPE, "EIOC:LTUH:MP11:HEARTBEATE05.VAL")
  field(INPF, "EIOC:LTUH:MP11:HEARTBEATE06.VAL")
  field(INPG, "EIOC:LTUH:MP11:HEARTBEATE07.VAL")
  field(INPH, "EIOC:LTUH:MP11:HEARTBEATE08.VAL")
  field(INPI, "EIOC:LTUH:MP11:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:LTUH:MP11: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, "EIOC:LTUH:MP11:HEARTBEATE09") {
  field(FLNK, "EIOC:LTUH:MP11:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP11:HEARTBEATE08.B")
  field(INPB, "EIOC:LTUH:MP11:HEARTBEATE09.VAL")
}

record(calc, "EIOC:LTUH:MP11:HEARTBEATE08") {
  field(FLNK, "EIOC:LTUH:MP11:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP11:HEARTBEATE07.B")
  field(INPB, "EIOC:LTUH:MP11:HEARTBEATE08.VAL")
}

record(calc, "EIOC:LTUH:MP11:HEARTBEATE07") {
  field(FLNK, "EIOC:LTUH:MP11:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP11:HEARTBEATE06.B")
  field(INPB, "EIOC:LTUH:MP11:HEARTBEATE07.VAL")
}

record(calc, "EIOC:LTUH:MP11:HEARTBEATE06") {
  field(FLNK, "EIOC:LTUH:MP11:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP11:HEARTBEATE05.B")
  field(INPB, "EIOC:LTUH:MP11:HEARTBEATE06.VAL")
}

record(calc, "EIOC:LTUH:MP11:HEARTBEATE05") {
  field(FLNK, "EIOC:LTUH:MP11:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP11:HEARTBEATE04.B")
  field(INPB, "EIOC:LTUH:MP11:HEARTBEATE05.VAL")
}

record(calc, "EIOC:LTUH:MP11:HEARTBEATE04") {
  field(FLNK, "EIOC:LTUH:MP11:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP11:HEARTBEATE03.B")
  field(INPB, "EIOC:LTUH:MP11:HEARTBEATE04.VAL")
}

record(calc, "EIOC:LTUH:MP11:HEARTBEATE03") {
  field(FLNK, "EIOC:LTUH:MP11:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP11:HEARTBEATE02.B")
  field(INPB, "EIOC:LTUH:MP11:HEARTBEATE03.VAL")
}

record(calc, "EIOC:LTUH:MP11:HEARTBEATE02") {
  field(FLNK, "EIOC:LTUH:MP11:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP11:HEARTBEATE01.B")
  field(INPB, "EIOC:LTUH:MP11:HEARTBEATE02.VAL")
}

record(calc, "EIOC:LTUH:MP11:HEARTBEATE01") {
  field(FLNK, "EIOC:LTUH:MP11:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP11:HEARTBEATERR.VAL")
  field(INPB, "EIOC:LTUH:MP11:HEARTBEATE01.VAL")
}

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

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

record(calc, "EIOC:LTUH:MP11:HEARTBEATE10") {
  field(FLNK, "EIOC:LTUH:MP11:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP11:HEARTBEATE09.B")
  field(INPB, "EIOC:LTUH:MP11:HEARTBEATE10.VAL")
}

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

record(stringin, "EIOC:LTUH:MP11:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LN28")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:LTUH:MP11:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LN28")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:MP11:LOC") {
  field(PINI, "YES")
  field(VAL, "B911-2142")
  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, "EIOC:LTUH:MP21:INFO") {
  field(DESC, "EIOC:LTUH:MP21 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:MP21:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  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, "EIOC:LTUH:MP21:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:LTUH:MP21: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, "EIOC:LTUH:MP21:TODDIFF")
}

record(longin, "EIOC:LTUH:MP21:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:LTUH:MP21:TODCHECK.VALA MS")
  field(FLNK, "EIOC:LTUH:MP21: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, "EIOC:LTUH:MP21:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:LTUH:MP21:TODCHECK.SEVR")
  field(INPB, "EIOC:LTUH:MP21:TODCHECK.VALB")
  field(FLNK, "EIOC:LTUH:MP21:TODSUM")
}

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

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

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

record(calc, "EIOC:LTUH:MP21:HEARTBEATECT") {
  field(FLNK, "EIOC:LTUH:MP21:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:LTUH:MP21:HEARTBEATE01.VAL")
  field(INPB, "EIOC:LTUH:MP21:HEARTBEATE02.VAL")
  field(INPC, "EIOC:LTUH:MP21:HEARTBEATE03.VAL")
  field(INPD, "EIOC:LTUH:MP21:HEARTBEATE04.VAL")
  field(INPE, "EIOC:LTUH:MP21:HEARTBEATE05.VAL")
  field(INPF, "EIOC:LTUH:MP21:HEARTBEATE06.VAL")
  field(INPG, "EIOC:LTUH:MP21:HEARTBEATE07.VAL")
  field(INPH, "EIOC:LTUH:MP21:HEARTBEATE08.VAL")
  field(INPI, "EIOC:LTUH:MP21:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:LTUH:MP21: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, "EIOC:LTUH:MP21:HEARTBEATE09") {
  field(FLNK, "EIOC:LTUH:MP21:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP21:HEARTBEATE08.B")
  field(INPB, "EIOC:LTUH:MP21:HEARTBEATE09.VAL")
}

record(calc, "EIOC:LTUH:MP21:HEARTBEATE08") {
  field(FLNK, "EIOC:LTUH:MP21:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP21:HEARTBEATE07.B")
  field(INPB, "EIOC:LTUH:MP21:HEARTBEATE08.VAL")
}

record(calc, "EIOC:LTUH:MP21:HEARTBEATE07") {
  field(FLNK, "EIOC:LTUH:MP21:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP21:HEARTBEATE06.B")
  field(INPB, "EIOC:LTUH:MP21:HEARTBEATE07.VAL")
}

record(calc, "EIOC:LTUH:MP21:HEARTBEATE06") {
  field(FLNK, "EIOC:LTUH:MP21:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP21:HEARTBEATE05.B")
  field(INPB, "EIOC:LTUH:MP21:HEARTBEATE06.VAL")
}

record(calc, "EIOC:LTUH:MP21:HEARTBEATE05") {
  field(FLNK, "EIOC:LTUH:MP21:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP21:HEARTBEATE04.B")
  field(INPB, "EIOC:LTUH:MP21:HEARTBEATE05.VAL")
}

record(calc, "EIOC:LTUH:MP21:HEARTBEATE04") {
  field(FLNK, "EIOC:LTUH:MP21:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP21:HEARTBEATE03.B")
  field(INPB, "EIOC:LTUH:MP21:HEARTBEATE04.VAL")
}

record(calc, "EIOC:LTUH:MP21:HEARTBEATE03") {
  field(FLNK, "EIOC:LTUH:MP21:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP21:HEARTBEATE02.B")
  field(INPB, "EIOC:LTUH:MP21:HEARTBEATE03.VAL")
}

record(calc, "EIOC:LTUH:MP21:HEARTBEATE02") {
  field(FLNK, "EIOC:LTUH:MP21:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP21:HEARTBEATE01.B")
  field(INPB, "EIOC:LTUH:MP21:HEARTBEATE02.VAL")
}

record(calc, "EIOC:LTUH:MP21:HEARTBEATE01") {
  field(FLNK, "EIOC:LTUH:MP21:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP21:HEARTBEATERR.VAL")
  field(INPB, "EIOC:LTUH:MP21:HEARTBEATE01.VAL")
}

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

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

record(calc, "EIOC:LTUH:MP21:HEARTBEATE10") {
  field(FLNK, "EIOC:LTUH:MP21:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:LTUH:MP21:HEARTBEATE09.B")
  field(INPB, "EIOC:LTUH:MP21:HEARTBEATE10.VAL")
}

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

record(stringin, "EIOC:LTUH:MP21:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LN29")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:LTUH:MP21:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LN29")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:LTUH:MP21:LOC") {
  field(PINI, "YES")
  field(VAL, "B912-2142")
  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, "SIOC:LTUH:MC01:INFO") {
  field(DESC, "SIOC:LTUH:MC01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MC01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Namrata Balakrishnan (namrata)")
  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, "SIOC:LTUH:MC01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:MC01: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, "SIOC:LTUH:MC01:TODDIFF")
}

record(longin, "SIOC:LTUH:MC01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:MC01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:MC01: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, "SIOC:LTUH:MC01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:MC01:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:MC01:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:MC01:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:MC01:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:MC01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:MC01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:MC01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:MC01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:MC01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:MC01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:MC01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:MC01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:MC01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:MC01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:MC01: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, "SIOC:LTUH:MC01:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:MC01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC01:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:MC01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:MC01:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:MC01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC01:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:MC01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:MC01:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:MC01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC01:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:MC01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:MC01:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:MC01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC01:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:MC01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:MC01:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:MC01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC01:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:MC01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:MC01:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:MC01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC01:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:MC01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:MC01:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:MC01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC01:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:MC01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:MC01:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:MC01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC01:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:MC01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:MC01:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:MC01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:MC01:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:MC01:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:MC01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC01:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:MC01:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:MC01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:MC01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MC01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  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, "SIOC:LTUH:MC06:INFO") {
  field(DESC, "SIOC:LTUH:MC06 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MC06:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Namrata Balakrishnan (namrata)")
  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, "SIOC:LTUH:MC06:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:MC06: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, "SIOC:LTUH:MC06:TODDIFF")
}

record(longin, "SIOC:LTUH:MC06:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:MC06:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:MC06: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, "SIOC:LTUH:MC06:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:MC06:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:MC06:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:MC06:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:MC06:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:MC06:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:MC06:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:MC06:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:MC06:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:MC06:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:MC06:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:MC06:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:MC06:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:MC06:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:MC06:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:MC06: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, "SIOC:LTUH:MC06:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:MC06:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC06:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:MC06:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:MC06:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:MC06:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC06:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:MC06:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:MC06:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:MC06:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC06:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:MC06:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:MC06:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:MC06:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC06:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:MC06:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:MC06:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:MC06:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC06:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:MC06:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:MC06:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:MC06:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC06:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:MC06:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:MC06:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:MC06:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC06:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:MC06:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:MC06:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:MC06:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC06:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:MC06:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:MC06:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:MC06:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC06:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:MC06:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:MC06:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:MC06:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC06:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:MC06:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:MC06:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "GJET HVM")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:MC06:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "GJET HVM")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MC06:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  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, "SIOC:LTUH:MC08:INFO") {
  field(DESC, "SIOC:LTUH:MC08 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MC08:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Namrata Balakrishnan (namrata)")
  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, "SIOC:LTUH:MC08:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:MC08: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, "SIOC:LTUH:MC08:TODDIFF")
}

record(longin, "SIOC:LTUH:MC08:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:MC08:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:MC08: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, "SIOC:LTUH:MC08:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:MC08:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:MC08:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:MC08:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:MC08:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:MC08:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:MC08:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:MC08:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:MC08:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:MC08:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:MC08:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:MC08:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:MC08:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:MC08:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:MC08:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:MC08: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, "SIOC:LTUH:MC08:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:MC08:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC08:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:MC08:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:MC08:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:MC08:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC08:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:MC08:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:MC08:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:MC08:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC08:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:MC08:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:MC08:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:MC08:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC08:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:MC08:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:MC08:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:MC08:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC08:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:MC08:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:MC08:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:MC08:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC08:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:MC08:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:MC08:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:MC08:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC08:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:MC08:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:MC08:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:MC08:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC08:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:MC08:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:MC08:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:MC08:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC08:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:MC08:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:MC08:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:MC08:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC08:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:MC08:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:MC08:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Dechirper")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:MC08:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Dechirper")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MC08:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  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, "SIOC:LTU0:RM01:INFO") {
  field(DESC, "SIOC:LTU0:RM01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTU0:RM01: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, "SIOC:LTU0:RM01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTU0:RM01: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, "SIOC:LTU0:RM01:TODDIFF")
}

record(longin, "SIOC:LTU0:RM01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTU0:RM01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTU0:RM01: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, "SIOC:LTU0:RM01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTU0:RM01:TODCHECK.SEVR")
  field(INPB, "SIOC:LTU0:RM01:TODCHECK.VALB")
  field(FLNK, "SIOC:LTU0:RM01:TODSUM")
}

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

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

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

record(calc, "SIOC:LTU0:RM01:HEARTBEATECT") {
  field(FLNK, "SIOC:LTU0:RM01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTU0:RM01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTU0:RM01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTU0:RM01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTU0:RM01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTU0:RM01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTU0:RM01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTU0:RM01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTU0:RM01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTU0:RM01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTU0:RM01: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, "SIOC:LTU0:RM01:HEARTBEATE09") {
  field(FLNK, "SIOC:LTU0:RM01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:RM01:HEARTBEATE08.B")
  field(INPB, "SIOC:LTU0:RM01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTU0:RM01:HEARTBEATE08") {
  field(FLNK, "SIOC:LTU0:RM01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:RM01:HEARTBEATE07.B")
  field(INPB, "SIOC:LTU0:RM01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTU0:RM01:HEARTBEATE07") {
  field(FLNK, "SIOC:LTU0:RM01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:RM01:HEARTBEATE06.B")
  field(INPB, "SIOC:LTU0:RM01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTU0:RM01:HEARTBEATE06") {
  field(FLNK, "SIOC:LTU0:RM01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:RM01:HEARTBEATE05.B")
  field(INPB, "SIOC:LTU0:RM01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTU0:RM01:HEARTBEATE05") {
  field(FLNK, "SIOC:LTU0:RM01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:RM01:HEARTBEATE04.B")
  field(INPB, "SIOC:LTU0:RM01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTU0:RM01:HEARTBEATE04") {
  field(FLNK, "SIOC:LTU0:RM01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:RM01:HEARTBEATE03.B")
  field(INPB, "SIOC:LTU0:RM01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTU0:RM01:HEARTBEATE03") {
  field(FLNK, "SIOC:LTU0:RM01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:RM01:HEARTBEATE02.B")
  field(INPB, "SIOC:LTU0:RM01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTU0:RM01:HEARTBEATE02") {
  field(FLNK, "SIOC:LTU0:RM01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:RM01:HEARTBEATE01.B")
  field(INPB, "SIOC:LTU0:RM01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTU0:RM01:HEARTBEATE01") {
  field(FLNK, "SIOC:LTU0:RM01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:RM01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTU0:RM01:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTU0:RM01:HEARTBEATE10") {
  field(FLNK, "SIOC:LTU0:RM01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:RM01:HEARTBEATE09.B")
  field(INPB, "SIOC:LTU0:RM01:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTU0:RM01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTU0:RM01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTU0:RM01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  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, "SIOC:LTUH:TM01:INFO") {
  field(DESC, "SIOC:LTUH:TM01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:TM01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "SIOC:LTUH:TM01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:TM01: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, "SIOC:LTUH:TM01:TODDIFF")
}

record(longin, "SIOC:LTUH:TM01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:TM01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:TM01: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, "SIOC:LTUH:TM01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:TM01:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:TM01:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:TM01:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:TM01:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:TM01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:TM01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:TM01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:TM01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:TM01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:TM01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:TM01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:TM01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:TM01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:TM01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:TM01: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, "SIOC:LTUH:TM01:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:TM01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TM01:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:TM01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:TM01:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:TM01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TM01:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:TM01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:TM01:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:TM01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TM01:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:TM01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:TM01:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:TM01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TM01:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:TM01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:TM01:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:TM01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TM01:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:TM01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:TM01:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:TM01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TM01:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:TM01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:TM01:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:TM01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TM01:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:TM01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:TM01:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:TM01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TM01:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:TM01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:TM01:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:TM01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TM01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:TM01:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:TM01:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:TM01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TM01:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:TM01:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:TM01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:TM01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:TM01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  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, "SIOC:LTUH:VA01:INFO") {
  field(DESC, "SIOC:LTUH:VA01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:VA01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shawn Alverson (alverson)")
  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, "SIOC:LTUH:VA01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:VA01: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, "SIOC:LTUH:VA01:TODDIFF")
}

record(longin, "SIOC:LTUH:VA01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:VA01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:VA01: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, "SIOC:LTUH:VA01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:VA01:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:VA01:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:VA01:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:VA01:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:VA01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:VA01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:VA01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:VA01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:VA01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:VA01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:VA01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:VA01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:VA01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:VA01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:VA01: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, "SIOC:LTUH:VA01:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:VA01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA01:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:VA01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:VA01:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:VA01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA01:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:VA01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:VA01:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:VA01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA01:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:VA01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:VA01:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:VA01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA01:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:VA01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:VA01:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:VA01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA01:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:VA01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:VA01:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:VA01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA01:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:VA01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:VA01:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:VA01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA01:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:VA01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:VA01:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:VA01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA01:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:VA01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:VA01:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:VA01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:VA01:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:VA01:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:VA01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA01:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:VA01:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:VA01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:VA01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:VA01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  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, "SIOC:LTUH:VA11:INFO") {
  field(DESC, "SIOC:LTUH:VA11 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:VA11:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shawn Alverson (alverson)")
  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, "SIOC:LTUH:VA11:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:VA11: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, "SIOC:LTUH:VA11:TODDIFF")
}

record(longin, "SIOC:LTUH:VA11:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:VA11:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:VA11: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, "SIOC:LTUH:VA11:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:VA11:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:VA11:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:VA11:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:VA11:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:VA11:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:VA11:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:VA11:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:VA11:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:VA11:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:VA11:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:VA11:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:VA11:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:VA11:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:VA11:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:VA11: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, "SIOC:LTUH:VA11:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:VA11:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA11:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:VA11:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:VA11:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:VA11:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA11:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:VA11:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:VA11:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:VA11:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA11:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:VA11:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:VA11:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:VA11:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA11:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:VA11:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:VA11:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:VA11:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA11:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:VA11:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:VA11:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:VA11:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA11:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:VA11:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:VA11:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:VA11:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA11:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:VA11:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:VA11:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:VA11:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA11:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:VA11:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:VA11:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:VA11:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA11:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:VA11:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:VA11:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:VA11:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:VA11:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:VA11:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:VA11:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:VA11:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:VA11:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  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, "SIOC:LTUH:BL01:INFO") {
  field(DESC, "SIOC:LTUH:BL01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BL01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shawn Alverson (alverson)")
  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, "SIOC:LTUH:BL01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:BL01: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, "SIOC:LTUH:BL01:TODDIFF")
}

record(longin, "SIOC:LTUH:BL01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:BL01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:BL01: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, "SIOC:LTUH:BL01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:BL01:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:BL01:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:BL01:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:BL01:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:BL01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:BL01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:BL01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:BL01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:BL01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:BL01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:BL01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:BL01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:BL01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:BL01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:BL01: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, "SIOC:LTUH:BL01:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:BL01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BL01:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:BL01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:BL01:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:BL01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BL01:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:BL01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:BL01:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:BL01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BL01:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:BL01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:BL01:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:BL01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BL01:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:BL01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:BL01:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:BL01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BL01:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:BL01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:BL01:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:BL01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BL01:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:BL01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:BL01:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:BL01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BL01:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:BL01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:BL01:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:BL01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BL01:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:BL01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:BL01:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:BL01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BL01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:BL01:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:BL01:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:BL01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BL01:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:BL01:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:BL01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:BL01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BL01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  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, "SIOC:LTUH:CF01:INFO") {
  field(DESC, "SIOC:LTUH:CF01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:CF01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Garth Brown (gbrown)")
  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, "SIOC:LTUH:CF01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:CF01: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, "SIOC:LTUH:CF01:TODDIFF")
}

record(longin, "SIOC:LTUH:CF01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:CF01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:CF01: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, "SIOC:LTUH:CF01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:CF01:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:CF01:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:CF01:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:CF01:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:CF01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:CF01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:CF01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:CF01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:CF01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:CF01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:CF01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:CF01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:CF01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:CF01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:CF01: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, "SIOC:LTUH:CF01:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:CF01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:CF01:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:CF01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:CF01:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:CF01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:CF01:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:CF01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:CF01:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:CF01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:CF01:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:CF01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:CF01:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:CF01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:CF01:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:CF01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:CF01:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:CF01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:CF01:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:CF01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:CF01:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:CF01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:CF01:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:CF01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:CF01:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:CF01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:CF01:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:CF01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:CF01:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:CF01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:CF01:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:CF01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:CF01:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:CF01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:CF01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:CF01:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:CF01:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:CF01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:CF01:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:CF01:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:CF01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:CF01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:CF01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  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, "SIOC:LTU0:PP01:INFO") {
  field(DESC, "SIOC:LTU0:PP01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTU0:PP01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "M. 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, "SIOC:LTU0:PP01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTU0:PP01: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, "SIOC:LTU0:PP01:TODDIFF")
}

record(longin, "SIOC:LTU0:PP01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTU0:PP01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTU0:PP01: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, "SIOC:LTU0:PP01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTU0:PP01:TODCHECK.SEVR")
  field(INPB, "SIOC:LTU0:PP01:TODCHECK.VALB")
  field(FLNK, "SIOC:LTU0:PP01:TODSUM")
}

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

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

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

record(calc, "SIOC:LTU0:PP01:HEARTBEATECT") {
  field(FLNK, "SIOC:LTU0:PP01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTU0:PP01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTU0:PP01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTU0:PP01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTU0:PP01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTU0:PP01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTU0:PP01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTU0:PP01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTU0:PP01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTU0:PP01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTU0:PP01: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, "SIOC:LTU0:PP01:HEARTBEATE09") {
  field(FLNK, "SIOC:LTU0:PP01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:PP01:HEARTBEATE08.B")
  field(INPB, "SIOC:LTU0:PP01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTU0:PP01:HEARTBEATE08") {
  field(FLNK, "SIOC:LTU0:PP01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:PP01:HEARTBEATE07.B")
  field(INPB, "SIOC:LTU0:PP01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTU0:PP01:HEARTBEATE07") {
  field(FLNK, "SIOC:LTU0:PP01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:PP01:HEARTBEATE06.B")
  field(INPB, "SIOC:LTU0:PP01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTU0:PP01:HEARTBEATE06") {
  field(FLNK, "SIOC:LTU0:PP01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:PP01:HEARTBEATE05.B")
  field(INPB, "SIOC:LTU0:PP01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTU0:PP01:HEARTBEATE05") {
  field(FLNK, "SIOC:LTU0:PP01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:PP01:HEARTBEATE04.B")
  field(INPB, "SIOC:LTU0:PP01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTU0:PP01:HEARTBEATE04") {
  field(FLNK, "SIOC:LTU0:PP01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:PP01:HEARTBEATE03.B")
  field(INPB, "SIOC:LTU0:PP01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTU0:PP01:HEARTBEATE03") {
  field(FLNK, "SIOC:LTU0:PP01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:PP01:HEARTBEATE02.B")
  field(INPB, "SIOC:LTU0:PP01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTU0:PP01:HEARTBEATE02") {
  field(FLNK, "SIOC:LTU0:PP01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:PP01:HEARTBEATE01.B")
  field(INPB, "SIOC:LTU0:PP01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTU0:PP01:HEARTBEATE01") {
  field(FLNK, "SIOC:LTU0:PP01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:PP01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTU0:PP01:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTU0:PP01:HEARTBEATE10") {
  field(FLNK, "SIOC:LTU0:PP01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:PP01:HEARTBEATE09.B")
  field(INPB, "SIOC:LTU0:PP01:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTU0:PP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTU0:PP01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTU0:PP01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  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, "SIOC:LTU0:BC01:INFO") {
  field(DESC, "SIOC:LTU0:BC01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTU0:BC01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "M. 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, "SIOC:LTU0:BC01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTU0:BC01: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, "SIOC:LTU0:BC01:TODDIFF")
}

record(longin, "SIOC:LTU0:BC01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTU0:BC01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTU0:BC01: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, "SIOC:LTU0:BC01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTU0:BC01:TODCHECK.SEVR")
  field(INPB, "SIOC:LTU0:BC01:TODCHECK.VALB")
  field(FLNK, "SIOC:LTU0:BC01:TODSUM")
}

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

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

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

record(calc, "SIOC:LTU0:BC01:HEARTBEATECT") {
  field(FLNK, "SIOC:LTU0:BC01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTU0:BC01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTU0:BC01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTU0:BC01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTU0:BC01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTU0:BC01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTU0:BC01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTU0:BC01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTU0:BC01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTU0:BC01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTU0:BC01: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, "SIOC:LTU0:BC01:HEARTBEATE09") {
  field(FLNK, "SIOC:LTU0:BC01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:BC01:HEARTBEATE08.B")
  field(INPB, "SIOC:LTU0:BC01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTU0:BC01:HEARTBEATE08") {
  field(FLNK, "SIOC:LTU0:BC01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:BC01:HEARTBEATE07.B")
  field(INPB, "SIOC:LTU0:BC01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTU0:BC01:HEARTBEATE07") {
  field(FLNK, "SIOC:LTU0:BC01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:BC01:HEARTBEATE06.B")
  field(INPB, "SIOC:LTU0:BC01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTU0:BC01:HEARTBEATE06") {
  field(FLNK, "SIOC:LTU0:BC01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:BC01:HEARTBEATE05.B")
  field(INPB, "SIOC:LTU0:BC01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTU0:BC01:HEARTBEATE05") {
  field(FLNK, "SIOC:LTU0:BC01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:BC01:HEARTBEATE04.B")
  field(INPB, "SIOC:LTU0:BC01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTU0:BC01:HEARTBEATE04") {
  field(FLNK, "SIOC:LTU0:BC01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:BC01:HEARTBEATE03.B")
  field(INPB, "SIOC:LTU0:BC01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTU0:BC01:HEARTBEATE03") {
  field(FLNK, "SIOC:LTU0:BC01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:BC01:HEARTBEATE02.B")
  field(INPB, "SIOC:LTU0:BC01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTU0:BC01:HEARTBEATE02") {
  field(FLNK, "SIOC:LTU0:BC01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:BC01:HEARTBEATE01.B")
  field(INPB, "SIOC:LTU0:BC01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTU0:BC01:HEARTBEATE01") {
  field(FLNK, "SIOC:LTU0:BC01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:BC01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTU0:BC01:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTU0:BC01:HEARTBEATE10") {
  field(FLNK, "SIOC:LTU0:BC01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTU0:BC01:HEARTBEATE09.B")
  field(INPB, "SIOC:LTU0:BC01:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTU0:BC01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTU0:BC01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTU0:BC01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  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, "SIOC:LTUH:MC02:INFO") {
  field(DESC, "SIOC:LTUH:MC02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MC02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Namrata Balakrishnan (namrata)")
  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, "SIOC:LTUH:MC02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:MC02: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, "SIOC:LTUH:MC02:TODDIFF")
}

record(longin, "SIOC:LTUH:MC02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:MC02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:MC02: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, "SIOC:LTUH:MC02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:MC02:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:MC02:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:MC02:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:MC02:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:MC02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:MC02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:MC02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:MC02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:MC02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:MC02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:MC02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:MC02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:MC02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:MC02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:MC02: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, "SIOC:LTUH:MC02:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:MC02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC02:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:MC02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:MC02:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:MC02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC02:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:MC02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:MC02:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:MC02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC02:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:MC02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:MC02:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:MC02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC02:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:MC02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:MC02:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:MC02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC02:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:MC02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:MC02:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:MC02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC02:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:MC02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:MC02:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:MC02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC02:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:MC02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:MC02:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:MC02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC02:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:MC02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:MC02:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:MC02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:MC02:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:MC02:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:MC02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC02:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:MC02:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:MC02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "WSDL31")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:MC02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "WSDL31")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MC02:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP01")
  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, "SIOC:LTUH:MC03:INFO") {
  field(DESC, "SIOC:LTUH:MC03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MC03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Namrata Balakrishnan (namrata)")
  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, "SIOC:LTUH:MC03:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:MC03: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, "SIOC:LTUH:MC03:TODDIFF")
}

record(longin, "SIOC:LTUH:MC03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:MC03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:MC03: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, "SIOC:LTUH:MC03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:MC03:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:MC03:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:MC03:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:MC03:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:MC03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:MC03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:MC03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:MC03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:MC03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:MC03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:MC03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:MC03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:MC03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:MC03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:MC03: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, "SIOC:LTUH:MC03:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:MC03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC03:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:MC03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:MC03:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:MC03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC03:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:MC03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:MC03:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:MC03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC03:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:MC03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:MC03:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:MC03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC03:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:MC03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:MC03:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:MC03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC03:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:MC03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:MC03:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:MC03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC03:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:MC03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:MC03:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:MC03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC03:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:MC03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:MC03:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:MC03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC03:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:MC03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:MC03:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:MC03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:MC03:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:MC03:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:MC03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC03:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:MC03:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:MC03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "WSVM2")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:MC03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "WSVM2")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MC03:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-BSYH-SP01")
  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, "SIOC:LTUH:MC04:INFO") {
  field(DESC, "SIOC:LTUH:MC04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MC04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Namrata Balakrishnan (namrata)")
  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, "SIOC:LTUH:MC04:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:MC04: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, "SIOC:LTUH:MC04:TODDIFF")
}

record(longin, "SIOC:LTUH:MC04:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:MC04:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:MC04: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, "SIOC:LTUH:MC04:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:MC04:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:MC04:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:MC04:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:MC04:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:MC04:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:MC04:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:MC04:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:MC04:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:MC04:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:MC04:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:MC04:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:MC04:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:MC04:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:MC04:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:MC04: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, "SIOC:LTUH:MC04:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:MC04:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC04:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:MC04:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:MC04:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:MC04:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC04:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:MC04:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:MC04:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:MC04:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC04:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:MC04:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:MC04:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:MC04:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC04:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:MC04:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:MC04:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:MC04:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC04:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:MC04:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:MC04:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:MC04:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC04:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:MC04:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:MC04:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:MC04:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC04:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:MC04:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:MC04:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:MC04:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC04:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:MC04:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:MC04:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:MC04:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC04:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:MC04:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:MC04:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:MC04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC04:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:MC04:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:MC04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "WSDL4,WS31,WS32")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:MC04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "WSDL4,WS31,WS32")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MC04:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP02")
  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, "SIOC:LTUH:MC05:INFO") {
  field(DESC, "SIOC:LTUH:MC05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MC05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Namrata Balakrishnan (namrata)")
  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, "SIOC:LTUH:MC05:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:MC05: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, "SIOC:LTUH:MC05:TODDIFF")
}

record(longin, "SIOC:LTUH:MC05:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:MC05:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:MC05: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, "SIOC:LTUH:MC05:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:MC05:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:MC05:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:MC05:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:MC05:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:MC05:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:MC05:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:MC05:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:MC05:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:MC05:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:MC05:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:MC05:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:MC05:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:MC05:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:MC05:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:MC05: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, "SIOC:LTUH:MC05:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:MC05:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC05:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:MC05:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:MC05:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:MC05:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC05:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:MC05:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:MC05:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:MC05:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC05:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:MC05:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:MC05:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:MC05:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC05:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:MC05:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:MC05:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:MC05:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC05:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:MC05:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:MC05:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:MC05:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC05:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:MC05:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:MC05:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:MC05:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC05:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:MC05:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:MC05:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:MC05:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC05:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:MC05:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:MC05:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:MC05:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC05:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:MC05:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:MC05:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:MC05:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MC05:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:MC05:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:MC05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "WS33,W34")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:MC05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "WS33,W34")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MC05:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-UNDH-SP01")
  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, "SIOC:LTUH:MG04:INFO") {
  field(DESC, "SIOC:LTUH:MG04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MG04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "An Le (anle)")
  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, "SIOC:LTUH:MG04:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:MG04: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, "SIOC:LTUH:MG04:TODDIFF")
}

record(longin, "SIOC:LTUH:MG04:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:MG04:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:MG04: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, "SIOC:LTUH:MG04:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:MG04:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:MG04:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:MG04:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:MG04:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:MG04:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:MG04:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:MG04:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:MG04:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:MG04:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:MG04:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:MG04:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:MG04:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:MG04:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:MG04:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:MG04: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, "SIOC:LTUH:MG04:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:MG04:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG04:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:MG04:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:MG04:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:MG04:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG04:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:MG04:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:MG04:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:MG04:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG04:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:MG04:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:MG04:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:MG04:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG04:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:MG04:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:MG04:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:MG04:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG04:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:MG04:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:MG04:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:MG04:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG04:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:MG04:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:MG04:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:MG04:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG04:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:MG04:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:MG04:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:MG04:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG04:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:MG04:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:MG04:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:MG04:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG04:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:MG04:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:MG04:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:MG04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG04:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:MG04:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:MG04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:MG04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MG04:LOC") {
  field(PINI, "YES")
  field(VAL, "B911-3522")
  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, "SIOC:LTUH:MG05:INFO") {
  field(DESC, "SIOC:LTUH:MG05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MG05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "An Le (anle)")
  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, "SIOC:LTUH:MG05:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:MG05: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, "SIOC:LTUH:MG05:TODDIFF")
}

record(longin, "SIOC:LTUH:MG05:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:MG05:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:MG05: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, "SIOC:LTUH:MG05:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:MG05:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:MG05:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:MG05:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:MG05:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:MG05:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:MG05:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:MG05:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:MG05:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:MG05:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:MG05:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:MG05:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:MG05:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:MG05:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:MG05:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:MG05: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, "SIOC:LTUH:MG05:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:MG05:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG05:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:MG05:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:MG05:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:MG05:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG05:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:MG05:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:MG05:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:MG05:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG05:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:MG05:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:MG05:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:MG05:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG05:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:MG05:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:MG05:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:MG05:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG05:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:MG05:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:MG05:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:MG05:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG05:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:MG05:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:MG05:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:MG05:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG05:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:MG05:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:MG05:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:MG05:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG05:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:MG05:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:MG05:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:MG05:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG05:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:MG05:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:MG05:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:MG05:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MG05:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:MG05:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:MG05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:MG05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MG05:LOC") {
  field(PINI, "YES")
  field(VAL, "B912-1115")
  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, "SIOC:LTUH:PM01:INFO") {
  field(DESC, "SIOC:LTUH:PM01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:PM01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Courtney Curtis (curtisco)")
  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, "SIOC:LTUH:PM01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:PM01: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, "SIOC:LTUH:PM01:TODDIFF")
}

record(longin, "SIOC:LTUH:PM01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:PM01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:PM01: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, "SIOC:LTUH:PM01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:PM01:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:PM01:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:PM01:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:PM01:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:PM01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:PM01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:PM01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:PM01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:PM01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:PM01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:PM01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:PM01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:PM01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:PM01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:PM01: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, "SIOC:LTUH:PM01:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:PM01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM01:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:PM01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:PM01:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:PM01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM01:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:PM01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:PM01:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:PM01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM01:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:PM01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:PM01:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:PM01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM01:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:PM01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:PM01:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:PM01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM01:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:PM01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:PM01:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:PM01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM01:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:PM01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:PM01:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:PM01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM01:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:PM01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:PM01:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:PM01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM01:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:PM01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:PM01:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:PM01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:PM01:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:PM01:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:PM01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM01:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:PM01:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:PM01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "OTR30, OTRDL18")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:PM01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "OTR30, OTRDL18")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:PM01:LOC") {
  field(PINI, "YES")
  field(VAL, "B911-04")
  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, "SIOC:LTUH:PM02:INFO") {
  field(DESC, "SIOC:LTUH:PM02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:PM02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  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, "SIOC:LTUH:PM02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:PM02: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, "SIOC:LTUH:PM02:TODDIFF")
}

record(longin, "SIOC:LTUH:PM02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:PM02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:PM02: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, "SIOC:LTUH:PM02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:PM02:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:PM02:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:PM02:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:PM02:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:PM02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:PM02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:PM02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:PM02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:PM02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:PM02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:PM02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:PM02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:PM02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:PM02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:PM02: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, "SIOC:LTUH:PM02:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:PM02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM02:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:PM02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:PM02:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:PM02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM02:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:PM02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:PM02:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:PM02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM02:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:PM02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:PM02:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:PM02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM02:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:PM02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:PM02:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:PM02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM02:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:PM02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:PM02:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:PM02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM02:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:PM02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:PM02:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:PM02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM02:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:PM02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:PM02:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:PM02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM02:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:PM02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:PM02:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:PM02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:PM02:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:PM02:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:PM02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM02:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:PM02:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:PM02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "OTR33, YAGPSI")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:PM02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "OTR33, YAGPSI")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:PM02:LOC") {
  field(PINI, "YES")
  field(VAL, "B912-04")
  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, "SIOC:LTUH:PM03:INFO") {
  field(DESC, "SIOC:LTUH:PM03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:PM03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Courtney Curtis (curtisco)")
  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, "SIOC:LTUH:PM03:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:PM03: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, "SIOC:LTUH:PM03:TODDIFF")
}

record(longin, "SIOC:LTUH:PM03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:PM03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:PM03: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, "SIOC:LTUH:PM03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:PM03:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:PM03:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:PM03:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:PM03:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:PM03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:PM03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:PM03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:PM03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:PM03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:PM03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:PM03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:PM03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:PM03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:PM03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:PM03: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, "SIOC:LTUH:PM03:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:PM03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM03:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:PM03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:PM03:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:PM03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM03:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:PM03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:PM03:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:PM03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM03:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:PM03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:PM03:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:PM03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM03:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:PM03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:PM03:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:PM03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM03:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:PM03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:PM03:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:PM03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM03:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:PM03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:PM03:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:PM03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM03:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:PM03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:PM03:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:PM03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM03:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:PM03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:PM03:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:PM03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:PM03:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:PM03:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:PM03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM03:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:PM03:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:PM03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "OTR30")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:PM03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "OTR30")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:PM03:LOC") {
  field(PINI, "YES")
  field(VAL, "B911-04")
  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, "SIOC:LTUH:PM04:INFO") {
  field(DESC, "SIOC:LTUH:PM04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:PM04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Courtney Curtis (curtisco)")
  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, "SIOC:LTUH:PM04:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:PM04: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, "SIOC:LTUH:PM04:TODDIFF")
}

record(longin, "SIOC:LTUH:PM04:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:PM04:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:PM04: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, "SIOC:LTUH:PM04:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:PM04:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:PM04:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:PM04:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:PM04:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:PM04:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:PM04:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:PM04:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:PM04:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:PM04:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:PM04:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:PM04:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:PM04:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:PM04:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:PM04:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:PM04: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, "SIOC:LTUH:PM04:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:PM04:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM04:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:PM04:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:PM04:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:PM04:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM04:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:PM04:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:PM04:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:PM04:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM04:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:PM04:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:PM04:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:PM04:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM04:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:PM04:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:PM04:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:PM04:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM04:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:PM04:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:PM04:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:PM04:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM04:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:PM04:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:PM04:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:PM04:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM04:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:PM04:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:PM04:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:PM04:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM04:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:PM04:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:PM04:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:PM04:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM04:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:PM04:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:PM04:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:PM04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:PM04:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:PM04:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:PM04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "YAGPSI")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:PM04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "YAGPSI")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:PM04:LOC") {
  field(PINI, "YES")
  field(VAL, "B912-04")
  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, "SIOC:LTUH:BP01:INFO") {
  field(DESC, "SIOC:LTUH:BP01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "SIOC:LTUH:BP01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:BP01: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, "SIOC:LTUH:BP01:TODDIFF")
}

record(longin, "SIOC:LTUH:BP01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:BP01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:BP01: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, "SIOC:LTUH:BP01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:BP01:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:BP01:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:BP01:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:BP01:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:BP01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:BP01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:BP01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:BP01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:BP01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:BP01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:BP01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:BP01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:BP01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:BP01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:BP01: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, "SIOC:LTUH:BP01:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:BP01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP01:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:BP01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:BP01:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:BP01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP01:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:BP01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:BP01:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:BP01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP01:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:BP01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:BP01:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:BP01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP01:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:BP01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:BP01:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:BP01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP01:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:BP01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:BP01:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:BP01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP01:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:BP01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:BP01:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:BP01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP01:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:BP01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:BP01:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:BP01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP01:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:BP01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:BP01:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:BP01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:BP01:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:BP01:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:BP01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP01:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:BP01:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:BP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "110,120")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:BP01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "110,120")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP01:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP01")
  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, "SIOC:LTUH:BP02:INFO") {
  field(DESC, "SIOC:LTUH:BP02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "SIOC:LTUH:BP02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:BP02: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, "SIOC:LTUH:BP02:TODDIFF")
}

record(longin, "SIOC:LTUH:BP02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:BP02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:BP02: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, "SIOC:LTUH:BP02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:BP02:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:BP02:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:BP02:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:BP02:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:BP02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:BP02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:BP02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:BP02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:BP02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:BP02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:BP02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:BP02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:BP02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:BP02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:BP02: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, "SIOC:LTUH:BP02:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:BP02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP02:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:BP02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:BP02:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:BP02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP02:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:BP02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:BP02:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:BP02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP02:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:BP02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:BP02:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:BP02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP02:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:BP02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:BP02:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:BP02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP02:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:BP02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:BP02:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:BP02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP02:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:BP02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:BP02:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:BP02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP02:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:BP02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:BP02:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:BP02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP02:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:BP02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:BP02:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:BP02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:BP02:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:BP02:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:BP02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP02:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:BP02:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:BP02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "130,150")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:BP02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "130,150")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP02:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP01")
  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, "SIOC:LTUH:BP03:INFO") {
  field(DESC, "SIOC:LTUH:BP03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "SIOC:LTUH:BP03:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:BP03: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, "SIOC:LTUH:BP03:TODDIFF")
}

record(longin, "SIOC:LTUH:BP03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:BP03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:BP03: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, "SIOC:LTUH:BP03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:BP03:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:BP03:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:BP03:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:BP03:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:BP03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:BP03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:BP03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:BP03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:BP03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:BP03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:BP03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:BP03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:BP03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:BP03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:BP03: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, "SIOC:LTUH:BP03:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:BP03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP03:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:BP03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:BP03:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:BP03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP03:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:BP03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:BP03:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:BP03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP03:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:BP03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:BP03:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:BP03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP03:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:BP03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:BP03:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:BP03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP03:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:BP03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:BP03:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:BP03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP03:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:BP03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:BP03:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:BP03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP03:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:BP03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:BP03:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:BP03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP03:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:BP03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:BP03:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:BP03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:BP03:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:BP03:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:BP03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP03:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:BP03:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:BP03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "170,180")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:BP03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "170,180")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP03:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP01")
  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, "SIOC:LTUH:BP04:INFO") {
  field(DESC, "SIOC:LTUH:BP04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "SIOC:LTUH:BP04:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:BP04: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, "SIOC:LTUH:BP04:TODDIFF")
}

record(longin, "SIOC:LTUH:BP04:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:BP04:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:BP04: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, "SIOC:LTUH:BP04:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:BP04:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:BP04:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:BP04:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:BP04:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:BP04:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:BP04:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:BP04:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:BP04:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:BP04:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:BP04:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:BP04:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:BP04:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:BP04:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:BP04:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:BP04: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, "SIOC:LTUH:BP04:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:BP04:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP04:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:BP04:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:BP04:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:BP04:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP04:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:BP04:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:BP04:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:BP04:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP04:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:BP04:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:BP04:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:BP04:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP04:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:BP04:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:BP04:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:BP04:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP04:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:BP04:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:BP04:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:BP04:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP04:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:BP04:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:BP04:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:BP04:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP04:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:BP04:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:BP04:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:BP04:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP04:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:BP04:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:BP04:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:BP04:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP04:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:BP04:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:BP04:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:BP04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP04:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:BP04:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:BP04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "190,250")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:BP04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "190,250")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP04:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP01")
  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, "SIOC:LTUH:BP05:INFO") {
  field(DESC, "SIOC:LTUH:BP05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "SIOC:LTUH:BP05:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:BP05: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, "SIOC:LTUH:BP05:TODDIFF")
}

record(longin, "SIOC:LTUH:BP05:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:BP05:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:BP05: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, "SIOC:LTUH:BP05:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:BP05:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:BP05:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:BP05:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:BP05:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:BP05:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:BP05:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:BP05:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:BP05:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:BP05:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:BP05:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:BP05:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:BP05:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:BP05:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:BP05:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:BP05: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, "SIOC:LTUH:BP05:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:BP05:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP05:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:BP05:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:BP05:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:BP05:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP05:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:BP05:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:BP05:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:BP05:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP05:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:BP05:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:BP05:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:BP05:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP05:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:BP05:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:BP05:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:BP05:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP05:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:BP05:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:BP05:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:BP05:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP05:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:BP05:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:BP05:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:BP05:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP05:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:BP05:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:BP05:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:BP05:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP05:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:BP05:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:BP05:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:BP05:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP05:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:BP05:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:BP05:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:BP05:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP05:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:BP05:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:BP05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "290,350")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:BP05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "290,350")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP05:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP01")
  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, "SIOC:LTUH:BP06:INFO") {
  field(DESC, "SIOC:LTUH:BP06 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP06:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "SIOC:LTUH:BP06:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:BP06: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, "SIOC:LTUH:BP06:TODDIFF")
}

record(longin, "SIOC:LTUH:BP06:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:BP06:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:BP06: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, "SIOC:LTUH:BP06:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:BP06:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:BP06:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:BP06:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:BP06:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:BP06:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:BP06:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:BP06:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:BP06:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:BP06:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:BP06:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:BP06:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:BP06:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:BP06:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:BP06:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:BP06: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, "SIOC:LTUH:BP06:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:BP06:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP06:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:BP06:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:BP06:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:BP06:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP06:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:BP06:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:BP06:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:BP06:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP06:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:BP06:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:BP06:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:BP06:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP06:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:BP06:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:BP06:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:BP06:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP06:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:BP06:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:BP06:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:BP06:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP06:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:BP06:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:BP06:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:BP06:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP06:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:BP06:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:BP06:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:BP06:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP06:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:BP06:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:BP06:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:BP06:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP06:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:BP06:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:BP06:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:BP06:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP06:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:BP06:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:BP06:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "390")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:BP06:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "390")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP06:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP01")
  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, "SIOC:LTUH:BP07:INFO") {
  field(DESC, "SIOC:LTUH:BP07 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP07:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "SIOC:LTUH:BP07:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:BP07: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, "SIOC:LTUH:BP07:TODDIFF")
}

record(longin, "SIOC:LTUH:BP07:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:BP07:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:BP07: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, "SIOC:LTUH:BP07:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:BP07:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:BP07:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:BP07:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:BP07:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:BP07:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:BP07:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:BP07:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:BP07:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:BP07:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:BP07:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:BP07:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:BP07:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:BP07:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:BP07:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:BP07: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, "SIOC:LTUH:BP07:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:BP07:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP07:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:BP07:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:BP07:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:BP07:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP07:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:BP07:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:BP07:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:BP07:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP07:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:BP07:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:BP07:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:BP07:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP07:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:BP07:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:BP07:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:BP07:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP07:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:BP07:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:BP07:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:BP07:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP07:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:BP07:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:BP07:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:BP07:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP07:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:BP07:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:BP07:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:BP07:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP07:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:BP07:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:BP07:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:BP07:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP07:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:BP07:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:BP07:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:BP07:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP07:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:BP07:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:BP07:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "450")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:BP07:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "450")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP07:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP02")
  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, "SIOC:LTUH:BP08:INFO") {
  field(DESC, "SIOC:LTUH:BP08 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP08:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "SIOC:LTUH:BP08:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:BP08: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, "SIOC:LTUH:BP08:TODDIFF")
}

record(longin, "SIOC:LTUH:BP08:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:BP08:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:BP08: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, "SIOC:LTUH:BP08:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:BP08:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:BP08:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:BP08:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:BP08:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:BP08:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:BP08:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:BP08:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:BP08:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:BP08:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:BP08:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:BP08:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:BP08:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:BP08:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:BP08:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:BP08: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, "SIOC:LTUH:BP08:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:BP08:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP08:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:BP08:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:BP08:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:BP08:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP08:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:BP08:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:BP08:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:BP08:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP08:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:BP08:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:BP08:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:BP08:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP08:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:BP08:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:BP08:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:BP08:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP08:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:BP08:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:BP08:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:BP08:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP08:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:BP08:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:BP08:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:BP08:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP08:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:BP08:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:BP08:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:BP08:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP08:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:BP08:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:BP08:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:BP08:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP08:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:BP08:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:BP08:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:BP08:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP08:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:BP08:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:BP08:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "550")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:BP08:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "550")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP08:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP02")
  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, "SIOC:LTUH:BP09:INFO") {
  field(DESC, "SIOC:LTUH:BP09 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP09:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "SIOC:LTUH:BP09:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:BP09: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, "SIOC:LTUH:BP09:TODDIFF")
}

record(longin, "SIOC:LTUH:BP09:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:BP09:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:BP09: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, "SIOC:LTUH:BP09:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:BP09:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:BP09:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:BP09:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:BP09:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:BP09:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:BP09:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:BP09:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:BP09:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:BP09:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:BP09:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:BP09:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:BP09:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:BP09:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:BP09:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:BP09: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, "SIOC:LTUH:BP09:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:BP09:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP09:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:BP09:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:BP09:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:BP09:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP09:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:BP09:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:BP09:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:BP09:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP09:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:BP09:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:BP09:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:BP09:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP09:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:BP09:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:BP09:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:BP09:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP09:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:BP09:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:BP09:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:BP09:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP09:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:BP09:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:BP09:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:BP09:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP09:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:BP09:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:BP09:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:BP09:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP09:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:BP09:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:BP09:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:BP09:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP09:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:BP09:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:BP09:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:BP09:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP09:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:BP09:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:BP09:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "640")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:BP09:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "640")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP09:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP02")
  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, "SIOC:LTUH:BP10:INFO") {
  field(DESC, "SIOC:LTUH:BP10 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP10:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "SIOC:LTUH:BP10:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:BP10: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, "SIOC:LTUH:BP10:TODDIFF")
}

record(longin, "SIOC:LTUH:BP10:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:BP10:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:BP10: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, "SIOC:LTUH:BP10:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:BP10:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:BP10:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:BP10:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:BP10:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:BP10:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:BP10:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:BP10:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:BP10:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:BP10:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:BP10:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:BP10:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:BP10:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:BP10:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:BP10:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:BP10: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, "SIOC:LTUH:BP10:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:BP10:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP10:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:BP10:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:BP10:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:BP10:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP10:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:BP10:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:BP10:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:BP10:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP10:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:BP10:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:BP10:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:BP10:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP10:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:BP10:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:BP10:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:BP10:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP10:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:BP10:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:BP10:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:BP10:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP10:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:BP10:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:BP10:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:BP10:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP10:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:BP10:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:BP10:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:BP10:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP10:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:BP10:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:BP10:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:BP10:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP10:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:BP10:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:BP10:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:BP10:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP10:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:BP10:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:BP10:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "660")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:BP10:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "660")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP10:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP02")
  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, "SIOC:LTUH:BP11:INFO") {
  field(DESC, "SIOC:LTUH:BP11 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP11:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "SIOC:LTUH:BP11:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:BP11: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, "SIOC:LTUH:BP11:TODDIFF")
}

record(longin, "SIOC:LTUH:BP11:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:BP11:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:BP11: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, "SIOC:LTUH:BP11:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:BP11:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:BP11:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:BP11:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:BP11:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:BP11:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:BP11:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:BP11:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:BP11:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:BP11:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:BP11:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:BP11:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:BP11:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:BP11:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:BP11:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:BP11: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, "SIOC:LTUH:BP11:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:BP11:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP11:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:BP11:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:BP11:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:BP11:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP11:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:BP11:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:BP11:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:BP11:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP11:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:BP11:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:BP11:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:BP11:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP11:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:BP11:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:BP11:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:BP11:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP11:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:BP11:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:BP11:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:BP11:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP11:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:BP11:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:BP11:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:BP11:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP11:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:BP11:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:BP11:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:BP11:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP11:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:BP11:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:BP11:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:BP11:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP11:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:BP11:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:BP11:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:BP11:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP11:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:BP11:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:BP11:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "720,730")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:BP11:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "720,730")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP11:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP03")
  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, "SIOC:LTUH:BP13:INFO") {
  field(DESC, "SIOC:LTUH:BP13 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP13:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "SIOC:LTUH:BP13:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:BP13: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, "SIOC:LTUH:BP13:TODDIFF")
}

record(longin, "SIOC:LTUH:BP13:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:BP13:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:BP13: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, "SIOC:LTUH:BP13:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:BP13:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:BP13:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:BP13:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:BP13:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:BP13:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:BP13:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:BP13:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:BP13:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:BP13:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:BP13:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:BP13:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:BP13:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:BP13:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:BP13:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:BP13: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, "SIOC:LTUH:BP13:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:BP13:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP13:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:BP13:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:BP13:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:BP13:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP13:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:BP13:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:BP13:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:BP13:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP13:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:BP13:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:BP13:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:BP13:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP13:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:BP13:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:BP13:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:BP13:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP13:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:BP13:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:BP13:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:BP13:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP13:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:BP13:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:BP13:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:BP13:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP13:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:BP13:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:BP13:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:BP13:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP13:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:BP13:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:BP13:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:BP13:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP13:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:BP13:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:BP13:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:BP13:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP13:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:BP13:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:BP13:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "760,770")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:BP13:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "760,770")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP13:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-UNDH-SP06")
  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, "SIOC:LTUH:BP15:INFO") {
  field(DESC, "SIOC:LTUH:BP15 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP15:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  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, "SIOC:LTUH:BP15:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:BP15: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, "SIOC:LTUH:BP15:TODDIFF")
}

record(longin, "SIOC:LTUH:BP15:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:BP15:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:BP15: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, "SIOC:LTUH:BP15:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:BP15:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:BP15:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:BP15:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:BP15:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:BP15:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:BP15:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:BP15:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:BP15:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:BP15:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:BP15:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:BP15:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:BP15:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:BP15:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:BP15:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:BP15: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, "SIOC:LTUH:BP15:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:BP15:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP15:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:BP15:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:BP15:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:BP15:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP15:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:BP15:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:BP15:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:BP15:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP15:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:BP15:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:BP15:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:BP15:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP15:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:BP15:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:BP15:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:BP15:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP15:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:BP15:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:BP15:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:BP15:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP15:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:BP15:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:BP15:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:BP15:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP15:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:BP15:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:BP15:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:BP15:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP15:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:BP15:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:BP15:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:BP15:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP15:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:BP15:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:BP15:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:BP15:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:BP15:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:BP15:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:BP15:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "860,880")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:BP15:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "860,880")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:BP15:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-UNDH-SP06")
  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, "SIOC:LTUH:MP00:INFO") {
  field(DESC, "SIOC:LTUH:MP00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MP00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  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, "SIOC:LTUH:MP00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:MP00: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, "SIOC:LTUH:MP00:TODDIFF")
}

record(longin, "SIOC:LTUH:MP00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:MP00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:MP00: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, "SIOC:LTUH:MP00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:MP00:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:MP00:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:MP00:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:MP00:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:MP00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:MP00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:MP00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:MP00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:MP00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:MP00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:MP00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:MP00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:MP00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:MP00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:MP00: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, "SIOC:LTUH:MP00:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:MP00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP00:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:MP00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:MP00:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:MP00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP00:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:MP00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:MP00:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:MP00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP00:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:MP00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:MP00:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:MP00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP00:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:MP00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:MP00:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:MP00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP00:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:MP00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:MP00:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:MP00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP00:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:MP00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:MP00:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:MP00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP00:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:MP00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:MP00:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:MP00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP00:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:MP00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:MP00:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:MP00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:MP00:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:MP00:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:MP00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP00:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:MP00:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:MP00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:MP00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MP00:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-mp03")
  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, "SIOC:LTUH:MP01:INFO") {
  field(DESC, "SIOC:LTUH:MP01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MP01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  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, "SIOC:LTUH:MP01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:MP01: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, "SIOC:LTUH:MP01:TODDIFF")
}

record(longin, "SIOC:LTUH:MP01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:MP01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:MP01: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, "SIOC:LTUH:MP01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:MP01:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:MP01:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:MP01:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:MP01:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:MP01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:MP01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:MP01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:MP01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:MP01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:MP01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:MP01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:MP01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:MP01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:MP01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:MP01: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, "SIOC:LTUH:MP01:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:MP01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP01:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:MP01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:MP01:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:MP01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP01:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:MP01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:MP01:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:MP01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP01:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:MP01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:MP01:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:MP01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP01:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:MP01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:MP01:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:MP01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP01:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:MP01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:MP01:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:MP01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP01:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:MP01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:MP01:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:MP01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP01:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:MP01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:MP01:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:MP01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP01:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:MP01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:MP01:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:MP01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:MP01:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:MP01:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:MP01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP01:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:MP01:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:MP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LN130")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:MP01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LN130")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MP01:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP01")
  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, "SIOC:LTUH:MP02:INFO") {
  field(DESC, "SIOC:LTUH:MP02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MP02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  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, "SIOC:LTUH:MP02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:MP02: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, "SIOC:LTUH:MP02:TODDIFF")
}

record(longin, "SIOC:LTUH:MP02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:MP02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:MP02: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, "SIOC:LTUH:MP02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:MP02:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:MP02:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:MP02:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:MP02:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:MP02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:MP02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:MP02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:MP02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:MP02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:MP02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:MP02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:MP02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:MP02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:MP02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:MP02: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, "SIOC:LTUH:MP02:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:MP02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP02:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:MP02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:MP02:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:MP02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP02:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:MP02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:MP02:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:MP02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP02:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:MP02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:MP02:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:MP02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP02:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:MP02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:MP02:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:MP02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP02:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:MP02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:MP02:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:MP02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP02:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:MP02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:MP02:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:MP02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP02:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:MP02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:MP02:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:MP02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP02:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:MP02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:MP02:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:MP02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:MP02:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:MP02:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:MP02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP02:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:MP02:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:MP02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LN131")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:MP02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LN131")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MP02:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP01")
  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, "SIOC:LTUH:MP03:INFO") {
  field(DESC, "SIOC:LTUH:MP03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MP03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  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, "SIOC:LTUH:MP03:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:MP03: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, "SIOC:LTUH:MP03:TODDIFF")
}

record(longin, "SIOC:LTUH:MP03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:MP03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:MP03: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, "SIOC:LTUH:MP03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:MP03:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:MP03:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:MP03:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:MP03:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:MP03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:MP03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:MP03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:MP03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:MP03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:MP03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:MP03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:MP03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:MP03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:MP03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:MP03: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, "SIOC:LTUH:MP03:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:MP03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP03:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:MP03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:MP03:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:MP03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP03:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:MP03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:MP03:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:MP03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP03:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:MP03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:MP03:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:MP03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP03:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:MP03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:MP03:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:MP03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP03:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:MP03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:MP03:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:MP03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP03:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:MP03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:MP03:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:MP03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP03:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:MP03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:MP03:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:MP03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP03:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:MP03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:MP03:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:MP03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:MP03:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:MP03:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:MP03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP03:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:MP03:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:MP03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LN132")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:MP03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LN132")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MP03:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP02")
  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, "SIOC:LTUH:MP04:INFO") {
  field(DESC, "SIOC:LTUH:MP04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MP04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  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, "SIOC:LTUH:MP04:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:MP04: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, "SIOC:LTUH:MP04:TODDIFF")
}

record(longin, "SIOC:LTUH:MP04:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:MP04:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:MP04: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, "SIOC:LTUH:MP04:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:MP04:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:MP04:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:MP04:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:MP04:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:MP04:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:MP04:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:MP04:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:MP04:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:MP04:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:MP04:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:MP04:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:MP04:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:MP04:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:MP04:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:MP04: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, "SIOC:LTUH:MP04:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:MP04:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP04:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:MP04:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:MP04:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:MP04:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP04:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:MP04:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:MP04:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:MP04:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP04:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:MP04:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:MP04:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:MP04:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP04:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:MP04:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:MP04:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:MP04:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP04:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:MP04:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:MP04:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:MP04:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP04:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:MP04:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:MP04:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:MP04:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP04:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:MP04:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:MP04:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:MP04:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP04:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:MP04:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:MP04:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:MP04:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP04:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:MP04:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:MP04:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:MP04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP04:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:MP04:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:MP04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LN133")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:MP04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LN133")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MP04:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP02")
  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, "SIOC:LTUH:MP05:INFO") {
  field(DESC, "SIOC:LTUH:MP05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MP05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  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, "SIOC:LTUH:MP05:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:MP05: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, "SIOC:LTUH:MP05:TODDIFF")
}

record(longin, "SIOC:LTUH:MP05:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:MP05:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:MP05: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, "SIOC:LTUH:MP05:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:MP05:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:MP05:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:MP05:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:MP05:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:MP05:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:MP05:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:MP05:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:MP05:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:MP05:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:MP05:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:MP05:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:MP05:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:MP05:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:MP05:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:MP05: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, "SIOC:LTUH:MP05:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:MP05:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP05:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:MP05:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:MP05:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:MP05:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP05:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:MP05:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:MP05:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:MP05:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP05:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:MP05:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:MP05:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:MP05:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP05:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:MP05:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:MP05:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:MP05:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP05:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:MP05:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:MP05:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:MP05:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP05:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:MP05:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:MP05:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:MP05:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP05:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:MP05:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:MP05:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:MP05:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP05:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:MP05:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:MP05:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:MP05:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP05:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:MP05:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:MP05:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:MP05:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP05:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:MP05:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:MP05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LN134")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:MP05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LN134")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MP05:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP03")
  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, "SIOC:LTUH:MP06:INFO") {
  field(DESC, "SIOC:LTUH:MP06 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MP06:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  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, "SIOC:LTUH:MP06:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:MP06: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, "SIOC:LTUH:MP06:TODDIFF")
}

record(longin, "SIOC:LTUH:MP06:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:MP06:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:MP06: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, "SIOC:LTUH:MP06:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:MP06:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:MP06:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:MP06:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:MP06:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:MP06:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:MP06:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:MP06:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:MP06:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:MP06:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:MP06:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:MP06:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:MP06:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:MP06:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:MP06:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:MP06: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, "SIOC:LTUH:MP06:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:MP06:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP06:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:MP06:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:MP06:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:MP06:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP06:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:MP06:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:MP06:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:MP06:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP06:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:MP06:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:MP06:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:MP06:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP06:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:MP06:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:MP06:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:MP06:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP06:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:MP06:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:MP06:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:MP06:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP06:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:MP06:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:MP06:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:MP06:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP06:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:MP06:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:MP06:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:MP06:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP06:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:MP06:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:MP06:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:MP06:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP06:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:MP06:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:MP06:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:MP06:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:MP06:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:MP06:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:MP06:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:MP06:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:MP06:LOC") {
  field(PINI, "YES")
  field(VAL, "CPU-LTUH-SP03")
  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, "SIOC:LTUH:TR01:INFO") {
  field(DESC, "SIOC:LTUH:TR01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:TR01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  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, "SIOC:LTUH:TR01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:TR01: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, "SIOC:LTUH:TR01:TODDIFF")
}

record(longin, "SIOC:LTUH:TR01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:TR01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:TR01: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, "SIOC:LTUH:TR01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:TR01:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:TR01:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:TR01:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:TR01:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:TR01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:TR01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:TR01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:TR01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:TR01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:TR01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:TR01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:TR01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:TR01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:TR01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:TR01: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, "SIOC:LTUH:TR01:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:TR01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR01:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:TR01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:TR01:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:TR01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR01:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:TR01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:TR01:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:TR01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR01:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:TR01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:TR01:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:TR01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR01:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:TR01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:TR01:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:TR01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR01:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:TR01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:TR01:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:TR01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR01:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:TR01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:TR01:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:TR01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR01:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:TR01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:TR01:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:TR01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR01:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:TR01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:TR01:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:TR01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:TR01:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:TR01:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:TR01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR01:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:TR01:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:TR01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:TR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:TR01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-fb01")
  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, "SIOC:LTUH:TR02:INFO") {
  field(DESC, "SIOC:LTUH:TR02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:TR02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  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, "SIOC:LTUH:TR02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:TR02: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, "SIOC:LTUH:TR02:TODDIFF")
}

record(longin, "SIOC:LTUH:TR02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:TR02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:TR02: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, "SIOC:LTUH:TR02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:TR02:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:TR02:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:TR02:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:TR02:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:TR02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:TR02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:TR02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:TR02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:TR02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:TR02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:TR02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:TR02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:TR02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:TR02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:TR02: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, "SIOC:LTUH:TR02:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:TR02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR02:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:TR02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:TR02:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:TR02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR02:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:TR02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:TR02:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:TR02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR02:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:TR02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:TR02:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:TR02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR02:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:TR02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:TR02:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:TR02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR02:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:TR02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:TR02:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:TR02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR02:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:TR02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:TR02:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:TR02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR02:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:TR02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:TR02:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:TR02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR02:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:TR02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:TR02:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:TR02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:TR02:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:TR02:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:TR02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR02:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:TR02:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:TR02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:TR02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:TR02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-fb01")
  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, "SIOC:LTUH:TR03:INFO") {
  field(DESC, "SIOC:LTUH:TR03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:TR03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  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, "SIOC:LTUH:TR03:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:LTUH:TR03: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, "SIOC:LTUH:TR03:TODDIFF")
}

record(longin, "SIOC:LTUH:TR03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LTUH:TR03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LTUH:TR03: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, "SIOC:LTUH:TR03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LTUH:TR03:TODCHECK.SEVR")
  field(INPB, "SIOC:LTUH:TR03:TODCHECK.VALB")
  field(FLNK, "SIOC:LTUH:TR03:TODSUM")
}

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

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

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

record(calc, "SIOC:LTUH:TR03:HEARTBEATECT") {
  field(FLNK, "SIOC:LTUH:TR03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LTUH:TR03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LTUH:TR03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LTUH:TR03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LTUH:TR03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LTUH:TR03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LTUH:TR03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LTUH:TR03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LTUH:TR03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LTUH:TR03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LTUH:TR03: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, "SIOC:LTUH:TR03:HEARTBEATE09") {
  field(FLNK, "SIOC:LTUH:TR03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR03:HEARTBEATE08.B")
  field(INPB, "SIOC:LTUH:TR03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LTUH:TR03:HEARTBEATE08") {
  field(FLNK, "SIOC:LTUH:TR03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR03:HEARTBEATE07.B")
  field(INPB, "SIOC:LTUH:TR03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LTUH:TR03:HEARTBEATE07") {
  field(FLNK, "SIOC:LTUH:TR03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR03:HEARTBEATE06.B")
  field(INPB, "SIOC:LTUH:TR03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LTUH:TR03:HEARTBEATE06") {
  field(FLNK, "SIOC:LTUH:TR03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR03:HEARTBEATE05.B")
  field(INPB, "SIOC:LTUH:TR03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LTUH:TR03:HEARTBEATE05") {
  field(FLNK, "SIOC:LTUH:TR03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR03:HEARTBEATE04.B")
  field(INPB, "SIOC:LTUH:TR03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LTUH:TR03:HEARTBEATE04") {
  field(FLNK, "SIOC:LTUH:TR03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR03:HEARTBEATE03.B")
  field(INPB, "SIOC:LTUH:TR03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LTUH:TR03:HEARTBEATE03") {
  field(FLNK, "SIOC:LTUH:TR03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR03:HEARTBEATE02.B")
  field(INPB, "SIOC:LTUH:TR03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LTUH:TR03:HEARTBEATE02") {
  field(FLNK, "SIOC:LTUH:TR03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR03:HEARTBEATE01.B")
  field(INPB, "SIOC:LTUH:TR03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LTUH:TR03:HEARTBEATE01") {
  field(FLNK, "SIOC:LTUH:TR03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LTUH:TR03:HEARTBEATE01.VAL")
}

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

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

record(calc, "SIOC:LTUH:TR03:HEARTBEATE10") {
  field(FLNK, "SIOC:LTUH:TR03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LTUH:TR03:HEARTBEATE09.B")
  field(INPB, "SIOC:LTUH:TR03:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:LTUH:TR03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LTUH:TR03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LTUH:TR03:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-fb01")
  info(autosaveFields,"VAL")
}

