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

record(stringin, "SIOC:HTR: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:HTR: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:HTR: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:HTR:BP01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(mbbi, "SIOC:HTR:BP01:HEARTBEATSUM") {
  field(FLNK, "SIOC:HTR:BP01:HEARTBEATCLC")
  field(INP, "SIOC:HTR: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:HTR:BP01:HEARTBEATE10") {
  field(FLNK, "SIOC:HTR:BP01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:HTR:BP01:HEARTBEATE09.B")
  field(INPB, "SIOC:HTR:BP01:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:HTR:BP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "120,320")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:HTR:BP01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l0b-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:HTR:BP02:INFO") {
  field(DESC, "SIOC:HTR:BP02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR: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:HTR: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:HTR: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:HTR:BP02:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(mbbi, "SIOC:HTR:BP02:HEARTBEATSUM") {
  field(FLNK, "SIOC:HTR:BP02:HEARTBEATCLC")
  field(INP, "SIOC:HTR: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:HTR:BP02:HEARTBEATE10") {
  field(FLNK, "SIOC:HTR:BP02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:HTR:BP02:HEARTBEATE09.B")
  field(INPB, "SIOC:HTR:BP02:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:HTR:BP02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "365,460")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:HTR:BP02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l0b-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:HTR:BP03:INFO") {
  field(DESC, "SIOC:HTR:BP03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR: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:HTR: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:HTR: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:HTR:BP03:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(mbbi, "SIOC:HTR:BP03:HEARTBEATSUM") {
  field(FLNK, "SIOC:HTR:BP03:HEARTBEATCLC")
  field(INP, "SIOC:HTR: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:HTR:BP03:HEARTBEATE10") {
  field(FLNK, "SIOC:HTR:BP03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:HTR:BP03:HEARTBEATE09.B")
  field(INPB, "SIOC:HTR:BP03:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:HTR:BP03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "540,760")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:HTR:BP03:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l0b-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:HTR:BP04:INFO") {
  field(DESC, "SIOC:HTR:BP04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR: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:HTR: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:HTR: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:HTR:BP04:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(mbbi, "SIOC:HTR:BP04:HEARTBEATSUM") {
  field(FLNK, "SIOC:HTR:BP04:HEARTBEATCLC")
  field(INP, "SIOC:HTR: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:HTR:BP04:HEARTBEATE10") {
  field(FLNK, "SIOC:HTR:BP04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:HTR:BP04:HEARTBEATE09.B")
  field(INPB, "SIOC:HTR:BP04:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:HTR:BP04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "830,860")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:HTR:BP04:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l0b-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:HTR:BP05:INFO") {
  field(DESC, "SIOC:HTR:BP05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR: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:HTR: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:HTR: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:HTR:BP05:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(mbbi, "SIOC:HTR:BP05:HEARTBEATSUM") {
  field(FLNK, "SIOC:HTR:BP05:HEARTBEATCLC")
  field(INP, "SIOC:HTR: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:HTR:BP05:HEARTBEATE10") {
  field(FLNK, "SIOC:HTR:BP05:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:HTR:BP05:HEARTBEATE09.B")
  field(INPB, "SIOC:HTR:BP05:HEARTBEATE10.VAL")
}

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

record(stringin, "SIOC:HTR:BP05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "960,980")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:HTR:BP05:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l0b-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:HTR:TM01:INFO") {
  field(DESC, "SIOC:HTR:TM01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR:TM01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sarah Vo (sarahvo)")
  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:HTR: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:HTR: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:HTR:TM01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(mbbi, "SIOC:HTR:TM01:HEARTBEATSUM") {
  field(FLNK, "SIOC:HTR:TM01:HEARTBEATCLC")
  field(INP, "SIOC:HTR: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:HTR:TM01:HEARTBEATE10") {
  field(FLNK, "SIOC:HTR:TM01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:HTR:TM01:HEARTBEATE09.B")
  field(INPB, "SIOC:HTR:TM01:HEARTBEATE10.VAL")
}

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

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

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

record(stringin, "SIOC:HTR: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:HTR:MG01:INFO") {
  field(DESC, "SIOC:HTR:MG01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR: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, "SIOC:HTR: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, "SIOC:HTR: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, "SIOC:HTR:MG01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:HTR:MG01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "L2KG01-5612")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:HTR:MG01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "L2KG01-5612")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR:MG01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-htr-mg01")
  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:HTR:MG02:INFO") {
  field(DESC, "SIOC:HTR:MG02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR: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, "SIOC:HTR: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, "SIOC:HTR: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, "SIOC:HTR:MG02:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:HTR:MG02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "L2KG01-5712")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:HTR:MG02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "L2KG01-5712")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR:MG02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-htr-mg02")
  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:HTR:MC01:INFO") {
  field(DESC, "SIOC:HTR:MC01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR: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:HTR: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:HTR: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:HTR:MC01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(mbbi, "SIOC:HTR:MC01:HEARTBEATSUM") {
  field(FLNK, "SIOC:HTR:MC01:HEARTBEATCLC")
  field(INP, "SIOC:HTR: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:HTR:MC01:HEARTBEATE10") {
  field(FLNK, "SIOC:HTR:MC01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:HTR:MC01:HEARTBEATE09.B")
  field(INPB, "SIOC:HTR:MC01:HEARTBEATE10.VAL")
}

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

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

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

record(stringin, "SIOC:HTR:MC01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l0b-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:HTR:MC02:INFO") {
  field(DESC, "SIOC:HTR:MC02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR:MC02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sarah Vo (sarahvo)")
  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:HTR: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:HTR: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:HTR:MC02:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(mbbi, "SIOC:HTR:MC02:HEARTBEATSUM") {
  field(FLNK, "SIOC:HTR:MC02:HEARTBEATCLC")
  field(INP, "SIOC:HTR: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:HTR:MC02:HEARTBEATE10") {
  field(FLNK, "SIOC:HTR:MC02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:HTR:MC02:HEARTBEATE09.B")
  field(INPB, "SIOC:HTR:MC02:HEARTBEATE10.VAL")
}

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

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

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

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

record(stringin, "SIOC:HTR: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:HTR: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:HTR: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:HTR:PM01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(mbbi, "SIOC:HTR:PM01:HEARTBEATSUM") {
  field(FLNK, "SIOC:HTR:PM01:HEARTBEATCLC")
  field(INP, "SIOC:HTR: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:HTR:PM01:HEARTBEATE10") {
  field(FLNK, "SIOC:HTR:PM01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:HTR:PM01:HEARTBEATE09.B")
  field(INPB, "SIOC:HTR:PM01:HEARTBEATE10.VAL")
}

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

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

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

record(stringin, "SIOC:HTR:PM01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-htr-pm02")
  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:HTR:PM02:INFO") {
  field(DESC, "SIOC:HTR:PM02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR:PM02: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:HTR: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:HTR: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:HTR:PM02:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(mbbi, "SIOC:HTR:PM02:HEARTBEATSUM") {
  field(FLNK, "SIOC:HTR:PM02:HEARTBEATCLC")
  field(INP, "SIOC:HTR: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:HTR:PM02:HEARTBEATE10") {
  field(FLNK, "SIOC:HTR:PM02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:HTR:PM02:HEARTBEATE09.B")
  field(INPB, "SIOC:HTR:PM02:HEARTBEATE10.VAL")
}

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

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

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

record(stringin, "SIOC:HTR:PM02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-htr-pm02")
  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:HTR:PM03:INFO") {
  field(DESC, "SIOC:HTR:PM03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR: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:HTR: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:HTR: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:HTR:PM03:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(mbbi, "SIOC:HTR:PM03:HEARTBEATSUM") {
  field(FLNK, "SIOC:HTR:PM03:HEARTBEATCLC")
  field(INP, "SIOC:HTR: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:HTR:PM03:HEARTBEATE10") {
  field(FLNK, "SIOC:HTR:PM03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:HTR:PM03:HEARTBEATE09.B")
  field(INPB, "SIOC:HTR:PM03:HEARTBEATE10.VAL")
}

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

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

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

record(stringin, "SIOC:HTR:PM03:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-htr-pm02")
  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:HTR:PM04:INFO") {
  field(DESC, "SIOC:HTR:PM04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR: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:HTR: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:HTR: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:HTR:PM04:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(mbbi, "SIOC:HTR:PM04:HEARTBEATSUM") {
  field(FLNK, "SIOC:HTR:PM04:HEARTBEATCLC")
  field(INP, "SIOC:HTR: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:HTR:PM04:HEARTBEATE10") {
  field(FLNK, "SIOC:HTR:PM04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:HTR:PM04:HEARTBEATE09.B")
  field(INPB, "SIOC:HTR:PM04:HEARTBEATE10.VAL")
}

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

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

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

record(stringin, "SIOC:HTR:PM04:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-htr-pm02")
  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:HTR:PM05:INFO") {
  field(DESC, "SIOC:HTR:PM05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR:PM05: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:HTR:PM05: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:HTR:PM05: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:HTR:PM05:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:HTR:PM05:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-htr-pm02")
  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:HTR:BL01:INFO") {
  field(DESC, "SIOC:HTR:BL01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR:BL01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Kyle Leleux (kleleux)")
  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:HTR: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:HTR: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:HTR:BL01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(mbbi, "SIOC:HTR:BL01:HEARTBEATSUM") {
  field(FLNK, "SIOC:HTR:BL01:HEARTBEATCLC")
  field(INP, "SIOC:HTR: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:HTR:BL01:HEARTBEATE10") {
  field(FLNK, "SIOC:HTR:BL01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:HTR:BL01:HEARTBEATE09.B")
  field(INPB, "SIOC:HTR:BL01:HEARTBEATE10.VAL")
}

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

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

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

record(stringin, "SIOC:HTR:BL01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l0b-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:HTR:TR01:INFO") {
  field(DESC, "SIOC:HTR:TR01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR: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:HTR: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:HTR: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:HTR:TR01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(mbbi, "SIOC:HTR:TR01:HEARTBEATSUM") {
  field(FLNK, "SIOC:HTR:TR01:HEARTBEATCLC")
  field(INP, "SIOC:HTR: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:HTR:TR01:HEARTBEATE10") {
  field(FLNK, "SIOC:HTR:TR01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:HTR:TR01:HEARTBEATE09.B")
  field(INPB, "SIOC:HTR:TR01:HEARTBEATE10.VAL")
}

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

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

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

record(stringin, "SIOC:HTR:TR01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-fb03")
  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:HTR:BC01:INFO") {
  field(DESC, "SIOC:HTR:BC01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR: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, "SIOC:HTR: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:HTR: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:HTR:BC01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(mbbi, "SIOC:HTR:BC01:HEARTBEATSUM") {
  field(FLNK, "SIOC:HTR:BC01:HEARTBEATCLC")
  field(INP, "SIOC:HTR: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:HTR:BC01:HEARTBEATE10") {
  field(FLNK, "SIOC:HTR:BC01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:HTR:BC01:HEARTBEATE09.B")
  field(INPB, "SIOC:HTR:BC01:HEARTBEATE10.VAL")
}

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

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

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

record(stringin, "SIOC:HTR:BC01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-htr-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:HTR:RM01:INFO") {
  field(DESC, "SIOC:HTR:RM01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:HTR:RM01: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, "SIOC:HTR: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:HTR: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:HTR:RM01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(mbbi, "SIOC:HTR:RM01:HEARTBEATSUM") {
  field(FLNK, "SIOC:HTR:RM01:HEARTBEATCLC")
  field(INP, "SIOC:HTR: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:HTR:RM01:HEARTBEATE10") {
  field(FLNK, "SIOC:HTR:RM01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:HTR:RM01:HEARTBEATE09.B")
  field(INPB, "SIOC:HTR:RM01:HEARTBEATE10.VAL")
}

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

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

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

record(stringin, "SIOC:HTR:RM01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

