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

record(stringin, "SIOC:L3B:BC01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:BP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "1683,1783")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:BP03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "1983,2083")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:BP04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "2183,2283")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:BP05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "2383,2483")
  info(autosaveFields,"VAL")
}

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

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

record(stringin, "SIOC:L3B:BP06:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

record(calc, "SIOC:L3B:BP06:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:BP06:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:BP06:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:BP06:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:BP06:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "2583,2683")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:BP06:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-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:L3B:BP07:INFO") {
  field(DESC, "SIOC:L3B:BP07 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:BP07:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

record(calc, "SIOC:L3B:BP07:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:BP07:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:BP07:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:BP07:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:BP07:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "2783")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:BP07:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-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:L3B:BP08:INFO") {
  field(DESC, "SIOC:L3B:BP08 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:BP08:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

record(calc, "SIOC:L3B:BP08:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:BP08:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:BP08:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:BP08:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:BP08:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "2883,2983")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:BP08:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-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:L3B:BP09:INFO") {
  field(DESC, "SIOC:L3B:BP09 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:BP09:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

record(calc, "SIOC:L3B:BP09:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:BP09:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:BP09:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:BP09:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:BP09:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "3083,3183")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:BP09:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-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:L3B:BP10:INFO") {
  field(DESC, "SIOC:L3B:BP10 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:BP10:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

record(calc, "SIOC:L3B:BP10:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:BP10:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:BP10:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:BP10:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:BP10:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "3283,3383")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:BP10:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-sp03")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:BP11:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

record(calc, "SIOC:L3B:BP11:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:BP11:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:BP11:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:BP11:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:BP11:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "3483,3583")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:BP11:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-sp03")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF16:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM16")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF16:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf16")
  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:L3B:RF17:INFO") {
  field(DESC, "SIOC:L3B:RF17 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF17:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM17")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF17:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf17")
  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:L3B:RF18:INFO") {
  field(DESC, "SIOC:L3B:RF18 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF18:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM18")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF18:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf18")
  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:L3B:RF19:INFO") {
  field(DESC, "SIOC:L3B:RF19 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF19:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM19")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF19:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf19")
  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:L3B:RF20:INFO") {
  field(DESC, "SIOC:L3B:RF20 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF20:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM20")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF20:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf20")
  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:L3B:RF21:INFO") {
  field(DESC, "SIOC:L3B:RF21 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF21:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM21")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF21:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf21")
  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:L3B:RF22:INFO") {
  field(DESC, "SIOC:L3B:RF22 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF22:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM22")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF22:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf22")
  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:L3B:RF23:INFO") {
  field(DESC, "SIOC:L3B:RF23 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF23:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM23")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF23:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf23")
  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:L3B:RF24:INFO") {
  field(DESC, "SIOC:L3B:RF24 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF24:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM24")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF24:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf24")
  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:L3B:RF25:INFO") {
  field(DESC, "SIOC:L3B:RF25 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF25:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM25")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF25:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf25")
  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:L3B:RF26:INFO") {
  field(DESC, "SIOC:L3B:RF26 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF26:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM26")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF26:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf26")
  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:L3B:RF27:INFO") {
  field(DESC, "SIOC:L3B:RF27 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF27:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM27")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF27:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf27")
  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:L3B:RF28:INFO") {
  field(DESC, "SIOC:L3B:RF28 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF28:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM28")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF28:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf28")
  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:L3B:RF29:INFO") {
  field(DESC, "SIOC:L3B:RF29 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF29:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM29")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF29:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf29")
  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:L3B:RF30:INFO") {
  field(DESC, "SIOC:L3B:RF30 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF30:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM30")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF30:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf30")
  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:L3B:RF31:INFO") {
  field(DESC, "SIOC:L3B:RF31 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF31:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM31")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF31:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf31")
  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:L3B:RF32:INFO") {
  field(DESC, "SIOC:L3B:RF32 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF32:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM32")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF32:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf32")
  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:L3B:RF33:INFO") {
  field(DESC, "SIOC:L3B:RF33 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF33:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM33")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF33:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf33")
  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:L3B:RF34:INFO") {
  field(DESC, "SIOC:L3B:RF34 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF34:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM34")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF34:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf34")
  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:L3B:RF35:INFO") {
  field(DESC, "SIOC:L3B:RF35 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:RF35:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM35")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L3B:RF35:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-rf35")
  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:L3B:SSA01:INFO") {
  field(DESC, "SIOC:L3B:SSA01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:SSA01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

record(aSub, "SIOC:L3B:SSA01: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:L3B:SSA01: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:L3B:SSA01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:SSA02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

record(aSub, "SIOC:L3B:SSA02: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:L3B:SSA02: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:L3B:SSA02:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:SSA03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

record(aSub, "SIOC:L3B:SSA03: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:L3B:SSA03: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:L3B:SSA03:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:SSA04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

record(aSub, "SIOC:L3B:SSA04: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:L3B:SSA04: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:L3B:SSA04:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:SSA05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

record(aSub, "SIOC:L3B:SSA05: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:L3B:SSA05: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:L3B:SSA05:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:VA01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shweta Saraf (shweta)")
  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:L3B:VA01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:L3B:VA01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:L3B:VA01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L3B:VA01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

record(calc, "SIOC:L3B:SP01:HEARTBEATE08") {
  field(FLNK, "SIOC:L3B:SP01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP01:HEARTBEATE07.B")
  field(INPB, "SIOC:L3B:SP01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:L3B:SP01:HEARTBEATE07") {
  field(FLNK, "SIOC:L3B:SP01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP01:HEARTBEATE06.B")
  field(INPB, "SIOC:L3B:SP01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:L3B:SP01:HEARTBEATE06") {
  field(FLNK, "SIOC:L3B:SP01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP01:HEARTBEATE05.B")
  field(INPB, "SIOC:L3B:SP01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:L3B:SP01:HEARTBEATE05") {
  field(FLNK, "SIOC:L3B:SP01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP01:HEARTBEATE04.B")
  field(INPB, "SIOC:L3B:SP01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:L3B:SP01:HEARTBEATE04") {
  field(FLNK, "SIOC:L3B:SP01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP01:HEARTBEATE03.B")
  field(INPB, "SIOC:L3B:SP01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:L3B:SP01:HEARTBEATE03") {
  field(FLNK, "SIOC:L3B:SP01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP01:HEARTBEATE02.B")
  field(INPB, "SIOC:L3B:SP01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:L3B:SP01:HEARTBEATE02") {
  field(FLNK, "SIOC:L3B:SP01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP01:HEARTBEATE01.B")
  field(INPB, "SIOC:L3B:SP01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:L3B:SP01:HEARTBEATE01") {
  field(FLNK, "SIOC:L3B:SP01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:L3B:SP01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:L3B:SP01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:L3B:SP01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:L3B:SP01:HEARTBEATSUM") {
  field(FLNK, "SIOC:L3B:SP01:HEARTBEATCLC")
  field(INP, "SIOC:L3B:SP01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:L3B:SP01:HEARTBEATE10") {
  field(FLNK, "SIOC:L3B:SP01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP01:HEARTBEATE09.B")
  field(INPB, "SIOC:L3B:SP01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:L3B:SP01:HEARTBEATERR") {
  field(FLNK, "SIOC:L3B:SP01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:L3B:SP01:HEARTBEATCALC.A")
  field(INPB, "SIOC:L3B:SP01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:L3B:SP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:L3B:SP01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:SP01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-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:L3B:SP02:INFO") {
  field(DESC, "SIOC:L3B:SP02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:SP02: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:L3B:SP02: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:L3B:SP02: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:L3B:SP02:TODDIFF")
}

record(longin, "SIOC:L3B:SP02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:L3B:SP02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:L3B:SP02: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:L3B:SP02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L3B:SP02:TODCHECK.SEVR")
  field(INPB, "SIOC:L3B:SP02:TODCHECK.VALB")
  field(FLNK, "SIOC:L3B:SP02:TODSUM")
}

record(bo, "SIOC:L3B:SP02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:L3B:SP02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:L3B:SP02:HEARTBEATCALC") {
  field(FLNK, "SIOC:L3B:SP02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP02:HEARTBEAT CA MS")
  field(INPB, "SIOC:L3B:SP02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:L3B:SP02:HEARTBEATOK") {
  field(FLNK, "SIOC:L3B:SP02:HEARTBEATE01")
  field(INP, "SIOC:L3B:SP02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:L3B:SP02:HEARTBEATECT") {
  field(FLNK, "SIOC:L3B:SP02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:L3B:SP02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:L3B:SP02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:L3B:SP02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:L3B:SP02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:L3B:SP02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:L3B:SP02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:L3B:SP02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:L3B:SP02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:L3B:SP02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:L3B:SP02: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:L3B:SP02:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:SP02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP02:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:SP02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:L3B:SP02:HEARTBEATE08") {
  field(FLNK, "SIOC:L3B:SP02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP02:HEARTBEATE07.B")
  field(INPB, "SIOC:L3B:SP02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:L3B:SP02:HEARTBEATE07") {
  field(FLNK, "SIOC:L3B:SP02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP02:HEARTBEATE06.B")
  field(INPB, "SIOC:L3B:SP02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:L3B:SP02:HEARTBEATE06") {
  field(FLNK, "SIOC:L3B:SP02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP02:HEARTBEATE05.B")
  field(INPB, "SIOC:L3B:SP02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:L3B:SP02:HEARTBEATE05") {
  field(FLNK, "SIOC:L3B:SP02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP02:HEARTBEATE04.B")
  field(INPB, "SIOC:L3B:SP02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:L3B:SP02:HEARTBEATE04") {
  field(FLNK, "SIOC:L3B:SP02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP02:HEARTBEATE03.B")
  field(INPB, "SIOC:L3B:SP02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:L3B:SP02:HEARTBEATE03") {
  field(FLNK, "SIOC:L3B:SP02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP02:HEARTBEATE02.B")
  field(INPB, "SIOC:L3B:SP02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:L3B:SP02:HEARTBEATE02") {
  field(FLNK, "SIOC:L3B:SP02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP02:HEARTBEATE01.B")
  field(INPB, "SIOC:L3B:SP02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:L3B:SP02:HEARTBEATE01") {
  field(FLNK, "SIOC:L3B:SP02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:L3B:SP02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:L3B:SP02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:L3B:SP02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:L3B:SP02:HEARTBEATSUM") {
  field(FLNK, "SIOC:L3B:SP02:HEARTBEATCLC")
  field(INP, "SIOC:L3B:SP02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:L3B:SP02:HEARTBEATE10") {
  field(FLNK, "SIOC:L3B:SP02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP02:HEARTBEATE09.B")
  field(INPB, "SIOC:L3B:SP02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:L3B:SP02:HEARTBEATERR") {
  field(FLNK, "SIOC:L3B:SP02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:L3B:SP02:HEARTBEATCALC.A")
  field(INPB, "SIOC:L3B:SP02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:L3B:SP02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:L3B:SP02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:SP02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-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:L3B:SP03:INFO") {
  field(DESC, "SIOC:L3B:SP03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:SP03: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:L3B:SP03: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:L3B:SP03: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:L3B:SP03:TODDIFF")
}

record(longin, "SIOC:L3B:SP03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:L3B:SP03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:L3B:SP03: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:L3B:SP03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L3B:SP03:TODCHECK.SEVR")
  field(INPB, "SIOC:L3B:SP03:TODCHECK.VALB")
  field(FLNK, "SIOC:L3B:SP03:TODSUM")
}

record(bo, "SIOC:L3B:SP03:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:L3B:SP03:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:L3B:SP03:HEARTBEATCALC") {
  field(FLNK, "SIOC:L3B:SP03:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP03:HEARTBEAT CA MS")
  field(INPB, "SIOC:L3B:SP03:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:L3B:SP03:HEARTBEATOK") {
  field(FLNK, "SIOC:L3B:SP03:HEARTBEATE01")
  field(INP, "SIOC:L3B:SP03:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:L3B:SP03:HEARTBEATECT") {
  field(FLNK, "SIOC:L3B:SP03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:L3B:SP03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:L3B:SP03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:L3B:SP03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:L3B:SP03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:L3B:SP03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:L3B:SP03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:L3B:SP03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:L3B:SP03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:L3B:SP03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:L3B:SP03: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:L3B:SP03:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:SP03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP03:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:SP03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:L3B:SP03:HEARTBEATE08") {
  field(FLNK, "SIOC:L3B:SP03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP03:HEARTBEATE07.B")
  field(INPB, "SIOC:L3B:SP03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:L3B:SP03:HEARTBEATE07") {
  field(FLNK, "SIOC:L3B:SP03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP03:HEARTBEATE06.B")
  field(INPB, "SIOC:L3B:SP03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:L3B:SP03:HEARTBEATE06") {
  field(FLNK, "SIOC:L3B:SP03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP03:HEARTBEATE05.B")
  field(INPB, "SIOC:L3B:SP03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:L3B:SP03:HEARTBEATE05") {
  field(FLNK, "SIOC:L3B:SP03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP03:HEARTBEATE04.B")
  field(INPB, "SIOC:L3B:SP03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:L3B:SP03:HEARTBEATE04") {
  field(FLNK, "SIOC:L3B:SP03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP03:HEARTBEATE03.B")
  field(INPB, "SIOC:L3B:SP03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:L3B:SP03:HEARTBEATE03") {
  field(FLNK, "SIOC:L3B:SP03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP03:HEARTBEATE02.B")
  field(INPB, "SIOC:L3B:SP03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:L3B:SP03:HEARTBEATE02") {
  field(FLNK, "SIOC:L3B:SP03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP03:HEARTBEATE01.B")
  field(INPB, "SIOC:L3B:SP03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:L3B:SP03:HEARTBEATE01") {
  field(FLNK, "SIOC:L3B:SP03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:L3B:SP03:HEARTBEATE01.VAL")
}

record(calc, "SIOC:L3B:SP03:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:L3B:SP03:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:L3B:SP03:HEARTBEATSUM") {
  field(FLNK, "SIOC:L3B:SP03:HEARTBEATCLC")
  field(INP, "SIOC:L3B:SP03:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:L3B:SP03:HEARTBEATE10") {
  field(FLNK, "SIOC:L3B:SP03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP03:HEARTBEATE09.B")
  field(INPB, "SIOC:L3B:SP03:HEARTBEATE10.VAL")
}

record(calc, "SIOC:L3B:SP03:HEARTBEATERR") {
  field(FLNK, "SIOC:L3B:SP03:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:L3B:SP03:HEARTBEATCALC.A")
  field(INPB, "SIOC:L3B:SP03:HEARTBEATCALC.B")
}

record(stringin, "SIOC:L3B:SP03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:L3B:SP03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:SP03:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-sp04")
  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:L3B:SP04:INFO") {
  field(DESC, "SIOC:L3B:SP04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:SP04: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:L3B:SP04: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:L3B:SP04: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:L3B:SP04:TODDIFF")
}

record(longin, "SIOC:L3B:SP04:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:L3B:SP04:TODCHECK.VALA MS")
  field(FLNK, "SIOC:L3B:SP04: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:L3B:SP04:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L3B:SP04:TODCHECK.SEVR")
  field(INPB, "SIOC:L3B:SP04:TODCHECK.VALB")
  field(FLNK, "SIOC:L3B:SP04:TODSUM")
}

record(bo, "SIOC:L3B:SP04:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:L3B:SP04:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:L3B:SP04:HEARTBEATCALC") {
  field(FLNK, "SIOC:L3B:SP04:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP04:HEARTBEAT CA MS")
  field(INPB, "SIOC:L3B:SP04:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:L3B:SP04:HEARTBEATOK") {
  field(FLNK, "SIOC:L3B:SP04:HEARTBEATE01")
  field(INP, "SIOC:L3B:SP04:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:L3B:SP04:HEARTBEATECT") {
  field(FLNK, "SIOC:L3B:SP04:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:L3B:SP04:HEARTBEATE01.VAL")
  field(INPB, "SIOC:L3B:SP04:HEARTBEATE02.VAL")
  field(INPC, "SIOC:L3B:SP04:HEARTBEATE03.VAL")
  field(INPD, "SIOC:L3B:SP04:HEARTBEATE04.VAL")
  field(INPE, "SIOC:L3B:SP04:HEARTBEATE05.VAL")
  field(INPF, "SIOC:L3B:SP04:HEARTBEATE06.VAL")
  field(INPG, "SIOC:L3B:SP04:HEARTBEATE07.VAL")
  field(INPH, "SIOC:L3B:SP04:HEARTBEATE08.VAL")
  field(INPI, "SIOC:L3B:SP04:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:L3B:SP04: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:L3B:SP04:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:SP04:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP04:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:SP04:HEARTBEATE09.VAL")
}

record(calc, "SIOC:L3B:SP04:HEARTBEATE08") {
  field(FLNK, "SIOC:L3B:SP04:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP04:HEARTBEATE07.B")
  field(INPB, "SIOC:L3B:SP04:HEARTBEATE08.VAL")
}

record(calc, "SIOC:L3B:SP04:HEARTBEATE07") {
  field(FLNK, "SIOC:L3B:SP04:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP04:HEARTBEATE06.B")
  field(INPB, "SIOC:L3B:SP04:HEARTBEATE07.VAL")
}

record(calc, "SIOC:L3B:SP04:HEARTBEATE06") {
  field(FLNK, "SIOC:L3B:SP04:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP04:HEARTBEATE05.B")
  field(INPB, "SIOC:L3B:SP04:HEARTBEATE06.VAL")
}

record(calc, "SIOC:L3B:SP04:HEARTBEATE05") {
  field(FLNK, "SIOC:L3B:SP04:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP04:HEARTBEATE04.B")
  field(INPB, "SIOC:L3B:SP04:HEARTBEATE05.VAL")
}

record(calc, "SIOC:L3B:SP04:HEARTBEATE04") {
  field(FLNK, "SIOC:L3B:SP04:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP04:HEARTBEATE03.B")
  field(INPB, "SIOC:L3B:SP04:HEARTBEATE04.VAL")
}

record(calc, "SIOC:L3B:SP04:HEARTBEATE03") {
  field(FLNK, "SIOC:L3B:SP04:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP04:HEARTBEATE02.B")
  field(INPB, "SIOC:L3B:SP04:HEARTBEATE03.VAL")
}

record(calc, "SIOC:L3B:SP04:HEARTBEATE02") {
  field(FLNK, "SIOC:L3B:SP04:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP04:HEARTBEATE01.B")
  field(INPB, "SIOC:L3B:SP04:HEARTBEATE02.VAL")
}

record(calc, "SIOC:L3B:SP04:HEARTBEATE01") {
  field(FLNK, "SIOC:L3B:SP04:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP04:HEARTBEATERR.VAL")
  field(INPB, "SIOC:L3B:SP04:HEARTBEATE01.VAL")
}

record(calc, "SIOC:L3B:SP04:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:L3B:SP04:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:L3B:SP04:HEARTBEATSUM") {
  field(FLNK, "SIOC:L3B:SP04:HEARTBEATCLC")
  field(INP, "SIOC:L3B:SP04:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:L3B:SP04:HEARTBEATE10") {
  field(FLNK, "SIOC:L3B:SP04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP04:HEARTBEATE09.B")
  field(INPB, "SIOC:L3B:SP04:HEARTBEATE10.VAL")
}

record(calc, "SIOC:L3B:SP04:HEARTBEATERR") {
  field(FLNK, "SIOC:L3B:SP04:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:L3B:SP04:HEARTBEATCALC.A")
  field(INPB, "SIOC:L3B:SP04:HEARTBEATCALC.B")
}

record(stringin, "SIOC:L3B:SP04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:L3B:SP04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:SP04:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-sp04")
  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:L3B:SP05:INFO") {
  field(DESC, "SIOC:L3B:SP05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:SP05: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:L3B:SP05: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:L3B:SP05: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:L3B:SP05:TODDIFF")
}

record(longin, "SIOC:L3B:SP05:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:L3B:SP05:TODCHECK.VALA MS")
  field(FLNK, "SIOC:L3B:SP05: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:L3B:SP05:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L3B:SP05:TODCHECK.SEVR")
  field(INPB, "SIOC:L3B:SP05:TODCHECK.VALB")
  field(FLNK, "SIOC:L3B:SP05:TODSUM")
}

record(bo, "SIOC:L3B:SP05:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:L3B:SP05:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:L3B:SP05:HEARTBEATCALC") {
  field(FLNK, "SIOC:L3B:SP05:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP05:HEARTBEAT CA MS")
  field(INPB, "SIOC:L3B:SP05:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:L3B:SP05:HEARTBEATOK") {
  field(FLNK, "SIOC:L3B:SP05:HEARTBEATE01")
  field(INP, "SIOC:L3B:SP05:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:L3B:SP05:HEARTBEATECT") {
  field(FLNK, "SIOC:L3B:SP05:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:L3B:SP05:HEARTBEATE01.VAL")
  field(INPB, "SIOC:L3B:SP05:HEARTBEATE02.VAL")
  field(INPC, "SIOC:L3B:SP05:HEARTBEATE03.VAL")
  field(INPD, "SIOC:L3B:SP05:HEARTBEATE04.VAL")
  field(INPE, "SIOC:L3B:SP05:HEARTBEATE05.VAL")
  field(INPF, "SIOC:L3B:SP05:HEARTBEATE06.VAL")
  field(INPG, "SIOC:L3B:SP05:HEARTBEATE07.VAL")
  field(INPH, "SIOC:L3B:SP05:HEARTBEATE08.VAL")
  field(INPI, "SIOC:L3B:SP05:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:L3B:SP05: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:L3B:SP05:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:SP05:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP05:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:SP05:HEARTBEATE09.VAL")
}

record(calc, "SIOC:L3B:SP05:HEARTBEATE08") {
  field(FLNK, "SIOC:L3B:SP05:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP05:HEARTBEATE07.B")
  field(INPB, "SIOC:L3B:SP05:HEARTBEATE08.VAL")
}

record(calc, "SIOC:L3B:SP05:HEARTBEATE07") {
  field(FLNK, "SIOC:L3B:SP05:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP05:HEARTBEATE06.B")
  field(INPB, "SIOC:L3B:SP05:HEARTBEATE07.VAL")
}

record(calc, "SIOC:L3B:SP05:HEARTBEATE06") {
  field(FLNK, "SIOC:L3B:SP05:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP05:HEARTBEATE05.B")
  field(INPB, "SIOC:L3B:SP05:HEARTBEATE06.VAL")
}

record(calc, "SIOC:L3B:SP05:HEARTBEATE05") {
  field(FLNK, "SIOC:L3B:SP05:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP05:HEARTBEATE04.B")
  field(INPB, "SIOC:L3B:SP05:HEARTBEATE05.VAL")
}

record(calc, "SIOC:L3B:SP05:HEARTBEATE04") {
  field(FLNK, "SIOC:L3B:SP05:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP05:HEARTBEATE03.B")
  field(INPB, "SIOC:L3B:SP05:HEARTBEATE04.VAL")
}

record(calc, "SIOC:L3B:SP05:HEARTBEATE03") {
  field(FLNK, "SIOC:L3B:SP05:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP05:HEARTBEATE02.B")
  field(INPB, "SIOC:L3B:SP05:HEARTBEATE03.VAL")
}

record(calc, "SIOC:L3B:SP05:HEARTBEATE02") {
  field(FLNK, "SIOC:L3B:SP05:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP05:HEARTBEATE01.B")
  field(INPB, "SIOC:L3B:SP05:HEARTBEATE02.VAL")
}

record(calc, "SIOC:L3B:SP05:HEARTBEATE01") {
  field(FLNK, "SIOC:L3B:SP05:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP05:HEARTBEATERR.VAL")
  field(INPB, "SIOC:L3B:SP05:HEARTBEATE01.VAL")
}

record(calc, "SIOC:L3B:SP05:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:L3B:SP05:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:L3B:SP05:HEARTBEATSUM") {
  field(FLNK, "SIOC:L3B:SP05:HEARTBEATCLC")
  field(INP, "SIOC:L3B:SP05:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:L3B:SP05:HEARTBEATE10") {
  field(FLNK, "SIOC:L3B:SP05:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:SP05:HEARTBEATE09.B")
  field(INPB, "SIOC:L3B:SP05:HEARTBEATE10.VAL")
}

record(calc, "SIOC:L3B:SP05:HEARTBEATERR") {
  field(FLNK, "SIOC:L3B:SP05:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:L3B:SP05:HEARTBEATCALC.A")
  field(INPB, "SIOC:L3B:SP05:HEARTBEATCALC.B")
}

record(stringin, "SIOC:L3B:SP05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:L3B:SP05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:SP05:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-sp05")
  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:L3B:MP00:INFO") {
  field(DESC, "SIOC:L3B:MP00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:MP00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:L3B:MP00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:L3B:MP00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:L3B:MP00:TODDIFF")
}

record(longin, "SIOC:L3B:MP00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:L3B:MP00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:L3B:MP00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:L3B:MP00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L3B:MP00:TODCHECK.SEVR")
  field(INPB, "SIOC:L3B:MP00:TODCHECK.VALB")
  field(FLNK, "SIOC:L3B:MP00:TODSUM")
}

record(bo, "SIOC:L3B:MP00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:L3B:MP00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:L3B:MP00:HEARTBEATCALC") {
  field(FLNK, "SIOC:L3B:MP00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP00:HEARTBEAT CA MS")
  field(INPB, "SIOC:L3B:MP00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:L3B:MP00:HEARTBEATOK") {
  field(FLNK, "SIOC:L3B:MP00:HEARTBEATE01")
  field(INP, "SIOC:L3B:MP00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:L3B:MP00:HEARTBEATECT") {
  field(FLNK, "SIOC:L3B:MP00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:L3B:MP00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:L3B:MP00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:L3B:MP00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:L3B:MP00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:L3B:MP00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:L3B:MP00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:L3B:MP00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:L3B:MP00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:L3B:MP00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:L3B:MP00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:L3B:MP00:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:MP00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP00:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:MP00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:L3B:MP00:HEARTBEATE08") {
  field(FLNK, "SIOC:L3B:MP00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP00:HEARTBEATE07.B")
  field(INPB, "SIOC:L3B:MP00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:L3B:MP00:HEARTBEATE07") {
  field(FLNK, "SIOC:L3B:MP00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP00:HEARTBEATE06.B")
  field(INPB, "SIOC:L3B:MP00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:L3B:MP00:HEARTBEATE06") {
  field(FLNK, "SIOC:L3B:MP00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP00:HEARTBEATE05.B")
  field(INPB, "SIOC:L3B:MP00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:L3B:MP00:HEARTBEATE05") {
  field(FLNK, "SIOC:L3B:MP00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP00:HEARTBEATE04.B")
  field(INPB, "SIOC:L3B:MP00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:L3B:MP00:HEARTBEATE04") {
  field(FLNK, "SIOC:L3B:MP00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP00:HEARTBEATE03.B")
  field(INPB, "SIOC:L3B:MP00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:L3B:MP00:HEARTBEATE03") {
  field(FLNK, "SIOC:L3B:MP00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP00:HEARTBEATE02.B")
  field(INPB, "SIOC:L3B:MP00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:L3B:MP00:HEARTBEATE02") {
  field(FLNK, "SIOC:L3B:MP00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP00:HEARTBEATE01.B")
  field(INPB, "SIOC:L3B:MP00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:L3B:MP00:HEARTBEATE01") {
  field(FLNK, "SIOC:L3B:MP00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:L3B:MP00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:L3B:MP00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:L3B:MP00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:L3B:MP00:HEARTBEATSUM") {
  field(FLNK, "SIOC:L3B:MP00:HEARTBEATCLC")
  field(INP, "SIOC:L3B:MP00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:L3B:MP00:HEARTBEATE10") {
  field(FLNK, "SIOC:L3B:MP00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP00:HEARTBEATE09.B")
  field(INPB, "SIOC:L3B:MP00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:L3B:MP00:HEARTBEATERR") {
  field(FLNK, "SIOC:L3B:MP00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:L3B:MP00:HEARTBEATCALC.A")
  field(INPB, "SIOC:L3B:MP00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:L3B:MP00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:L3B:MP00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:MP00:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-mp03")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:L3B:MP01:INFO") {
  field(DESC, "SIOC:L3B:MP01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:MP01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:L3B:MP01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:L3B:MP01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:L3B:MP01:TODDIFF")
}

record(longin, "SIOC:L3B:MP01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:L3B:MP01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:L3B:MP01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:L3B:MP01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L3B:MP01:TODCHECK.SEVR")
  field(INPB, "SIOC:L3B:MP01:TODCHECK.VALB")
  field(FLNK, "SIOC:L3B:MP01:TODSUM")
}

record(bo, "SIOC:L3B:MP01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:L3B:MP01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:L3B:MP01:HEARTBEATCALC") {
  field(FLNK, "SIOC:L3B:MP01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP01:HEARTBEAT CA MS")
  field(INPB, "SIOC:L3B:MP01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:L3B:MP01:HEARTBEATOK") {
  field(FLNK, "SIOC:L3B:MP01:HEARTBEATE01")
  field(INP, "SIOC:L3B:MP01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:L3B:MP01:HEARTBEATECT") {
  field(FLNK, "SIOC:L3B:MP01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:L3B:MP01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:L3B:MP01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:L3B:MP01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:L3B:MP01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:L3B:MP01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:L3B:MP01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:L3B:MP01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:L3B:MP01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:L3B:MP01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:L3B:MP01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:L3B:MP01:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:MP01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP01:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:MP01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:L3B:MP01:HEARTBEATE08") {
  field(FLNK, "SIOC:L3B:MP01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP01:HEARTBEATE07.B")
  field(INPB, "SIOC:L3B:MP01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:L3B:MP01:HEARTBEATE07") {
  field(FLNK, "SIOC:L3B:MP01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP01:HEARTBEATE06.B")
  field(INPB, "SIOC:L3B:MP01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:L3B:MP01:HEARTBEATE06") {
  field(FLNK, "SIOC:L3B:MP01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP01:HEARTBEATE05.B")
  field(INPB, "SIOC:L3B:MP01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:L3B:MP01:HEARTBEATE05") {
  field(FLNK, "SIOC:L3B:MP01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP01:HEARTBEATE04.B")
  field(INPB, "SIOC:L3B:MP01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:L3B:MP01:HEARTBEATE04") {
  field(FLNK, "SIOC:L3B:MP01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP01:HEARTBEATE03.B")
  field(INPB, "SIOC:L3B:MP01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:L3B:MP01:HEARTBEATE03") {
  field(FLNK, "SIOC:L3B:MP01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP01:HEARTBEATE02.B")
  field(INPB, "SIOC:L3B:MP01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:L3B:MP01:HEARTBEATE02") {
  field(FLNK, "SIOC:L3B:MP01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP01:HEARTBEATE01.B")
  field(INPB, "SIOC:L3B:MP01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:L3B:MP01:HEARTBEATE01") {
  field(FLNK, "SIOC:L3B:MP01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:L3B:MP01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:L3B:MP01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:L3B:MP01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:L3B:MP01:HEARTBEATSUM") {
  field(FLNK, "SIOC:L3B:MP01:HEARTBEATCLC")
  field(INP, "SIOC:L3B:MP01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:L3B:MP01:HEARTBEATE10") {
  field(FLNK, "SIOC:L3B:MP01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP01:HEARTBEATE09.B")
  field(INPB, "SIOC:L3B:MP01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:L3B:MP01:HEARTBEATERR") {
  field(FLNK, "SIOC:L3B:MP01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:L3B:MP01:HEARTBEATCALC.A")
  field(INPB, "SIOC:L3B:MP01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:L3B:MP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:L3B:MP01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:MP01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-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:L3B:MP02:INFO") {
  field(DESC, "SIOC:L3B:MP02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:MP02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:L3B:MP02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:L3B:MP02:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:L3B:MP02:TODDIFF")
}

record(longin, "SIOC:L3B:MP02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:L3B:MP02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:L3B:MP02:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:L3B:MP02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L3B:MP02:TODCHECK.SEVR")
  field(INPB, "SIOC:L3B:MP02:TODCHECK.VALB")
  field(FLNK, "SIOC:L3B:MP02:TODSUM")
}

record(bo, "SIOC:L3B:MP02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:L3B:MP02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:L3B:MP02:HEARTBEATCALC") {
  field(FLNK, "SIOC:L3B:MP02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP02:HEARTBEAT CA MS")
  field(INPB, "SIOC:L3B:MP02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:L3B:MP02:HEARTBEATOK") {
  field(FLNK, "SIOC:L3B:MP02:HEARTBEATE01")
  field(INP, "SIOC:L3B:MP02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:L3B:MP02:HEARTBEATECT") {
  field(FLNK, "SIOC:L3B:MP02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:L3B:MP02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:L3B:MP02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:L3B:MP02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:L3B:MP02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:L3B:MP02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:L3B:MP02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:L3B:MP02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:L3B:MP02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:L3B:MP02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:L3B:MP02:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:L3B:MP02:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:MP02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP02:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:MP02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:L3B:MP02:HEARTBEATE08") {
  field(FLNK, "SIOC:L3B:MP02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP02:HEARTBEATE07.B")
  field(INPB, "SIOC:L3B:MP02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:L3B:MP02:HEARTBEATE07") {
  field(FLNK, "SIOC:L3B:MP02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP02:HEARTBEATE06.B")
  field(INPB, "SIOC:L3B:MP02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:L3B:MP02:HEARTBEATE06") {
  field(FLNK, "SIOC:L3B:MP02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP02:HEARTBEATE05.B")
  field(INPB, "SIOC:L3B:MP02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:L3B:MP02:HEARTBEATE05") {
  field(FLNK, "SIOC:L3B:MP02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP02:HEARTBEATE04.B")
  field(INPB, "SIOC:L3B:MP02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:L3B:MP02:HEARTBEATE04") {
  field(FLNK, "SIOC:L3B:MP02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP02:HEARTBEATE03.B")
  field(INPB, "SIOC:L3B:MP02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:L3B:MP02:HEARTBEATE03") {
  field(FLNK, "SIOC:L3B:MP02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP02:HEARTBEATE02.B")
  field(INPB, "SIOC:L3B:MP02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:L3B:MP02:HEARTBEATE02") {
  field(FLNK, "SIOC:L3B:MP02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP02:HEARTBEATE01.B")
  field(INPB, "SIOC:L3B:MP02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:L3B:MP02:HEARTBEATE01") {
  field(FLNK, "SIOC:L3B:MP02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:L3B:MP02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:L3B:MP02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:L3B:MP02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:L3B:MP02:HEARTBEATSUM") {
  field(FLNK, "SIOC:L3B:MP02:HEARTBEATCLC")
  field(INP, "SIOC:L3B:MP02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:L3B:MP02:HEARTBEATE10") {
  field(FLNK, "SIOC:L3B:MP02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP02:HEARTBEATE09.B")
  field(INPB, "SIOC:L3B:MP02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:L3B:MP02:HEARTBEATERR") {
  field(FLNK, "SIOC:L3B:MP02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:L3B:MP02:HEARTBEATCALC.A")
  field(INPB, "SIOC:L3B:MP02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:L3B:MP02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:L3B:MP02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:MP02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-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:L3B:MP03:INFO") {
  field(DESC, "SIOC:L3B:MP03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:MP03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:L3B:MP03:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:L3B:MP03:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:L3B:MP03:TODDIFF")
}

record(longin, "SIOC:L3B:MP03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:L3B:MP03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:L3B:MP03:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:L3B:MP03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L3B:MP03:TODCHECK.SEVR")
  field(INPB, "SIOC:L3B:MP03:TODCHECK.VALB")
  field(FLNK, "SIOC:L3B:MP03:TODSUM")
}

record(bo, "SIOC:L3B:MP03:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:L3B:MP03:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:L3B:MP03:HEARTBEATCALC") {
  field(FLNK, "SIOC:L3B:MP03:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP03:HEARTBEAT CA MS")
  field(INPB, "SIOC:L3B:MP03:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:L3B:MP03:HEARTBEATOK") {
  field(FLNK, "SIOC:L3B:MP03:HEARTBEATE01")
  field(INP, "SIOC:L3B:MP03:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:L3B:MP03:HEARTBEATECT") {
  field(FLNK, "SIOC:L3B:MP03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:L3B:MP03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:L3B:MP03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:L3B:MP03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:L3B:MP03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:L3B:MP03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:L3B:MP03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:L3B:MP03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:L3B:MP03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:L3B:MP03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:L3B:MP03:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:L3B:MP03:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:MP03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP03:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:MP03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:L3B:MP03:HEARTBEATE08") {
  field(FLNK, "SIOC:L3B:MP03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP03:HEARTBEATE07.B")
  field(INPB, "SIOC:L3B:MP03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:L3B:MP03:HEARTBEATE07") {
  field(FLNK, "SIOC:L3B:MP03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP03:HEARTBEATE06.B")
  field(INPB, "SIOC:L3B:MP03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:L3B:MP03:HEARTBEATE06") {
  field(FLNK, "SIOC:L3B:MP03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP03:HEARTBEATE05.B")
  field(INPB, "SIOC:L3B:MP03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:L3B:MP03:HEARTBEATE05") {
  field(FLNK, "SIOC:L3B:MP03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP03:HEARTBEATE04.B")
  field(INPB, "SIOC:L3B:MP03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:L3B:MP03:HEARTBEATE04") {
  field(FLNK, "SIOC:L3B:MP03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP03:HEARTBEATE03.B")
  field(INPB, "SIOC:L3B:MP03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:L3B:MP03:HEARTBEATE03") {
  field(FLNK, "SIOC:L3B:MP03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP03:HEARTBEATE02.B")
  field(INPB, "SIOC:L3B:MP03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:L3B:MP03:HEARTBEATE02") {
  field(FLNK, "SIOC:L3B:MP03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP03:HEARTBEATE01.B")
  field(INPB, "SIOC:L3B:MP03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:L3B:MP03:HEARTBEATE01") {
  field(FLNK, "SIOC:L3B:MP03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:L3B:MP03:HEARTBEATE01.VAL")
}

record(calc, "SIOC:L3B:MP03:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:L3B:MP03:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:L3B:MP03:HEARTBEATSUM") {
  field(FLNK, "SIOC:L3B:MP03:HEARTBEATCLC")
  field(INP, "SIOC:L3B:MP03:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:L3B:MP03:HEARTBEATE10") {
  field(FLNK, "SIOC:L3B:MP03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP03:HEARTBEATE09.B")
  field(INPB, "SIOC:L3B:MP03:HEARTBEATE10.VAL")
}

record(calc, "SIOC:L3B:MP03:HEARTBEATERR") {
  field(FLNK, "SIOC:L3B:MP03:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:L3B:MP03:HEARTBEATCALC.A")
  field(INPB, "SIOC:L3B:MP03:HEARTBEATCALC.B")
}

record(stringin, "SIOC:L3B:MP03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:L3B:MP03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:MP03:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-sp03")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:L3B:MP04:INFO") {
  field(DESC, "SIOC:L3B:MP04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:MP04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:L3B:MP04:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:L3B:MP04:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:L3B:MP04:TODDIFF")
}

record(longin, "SIOC:L3B:MP04:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:L3B:MP04:TODCHECK.VALA MS")
  field(FLNK, "SIOC:L3B:MP04:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:L3B:MP04:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L3B:MP04:TODCHECK.SEVR")
  field(INPB, "SIOC:L3B:MP04:TODCHECK.VALB")
  field(FLNK, "SIOC:L3B:MP04:TODSUM")
}

record(bo, "SIOC:L3B:MP04:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:L3B:MP04:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:L3B:MP04:HEARTBEATCALC") {
  field(FLNK, "SIOC:L3B:MP04:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP04:HEARTBEAT CA MS")
  field(INPB, "SIOC:L3B:MP04:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:L3B:MP04:HEARTBEATOK") {
  field(FLNK, "SIOC:L3B:MP04:HEARTBEATE01")
  field(INP, "SIOC:L3B:MP04:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:L3B:MP04:HEARTBEATECT") {
  field(FLNK, "SIOC:L3B:MP04:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:L3B:MP04:HEARTBEATE01.VAL")
  field(INPB, "SIOC:L3B:MP04:HEARTBEATE02.VAL")
  field(INPC, "SIOC:L3B:MP04:HEARTBEATE03.VAL")
  field(INPD, "SIOC:L3B:MP04:HEARTBEATE04.VAL")
  field(INPE, "SIOC:L3B:MP04:HEARTBEATE05.VAL")
  field(INPF, "SIOC:L3B:MP04:HEARTBEATE06.VAL")
  field(INPG, "SIOC:L3B:MP04:HEARTBEATE07.VAL")
  field(INPH, "SIOC:L3B:MP04:HEARTBEATE08.VAL")
  field(INPI, "SIOC:L3B:MP04:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:L3B:MP04:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:L3B:MP04:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:MP04:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP04:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:MP04:HEARTBEATE09.VAL")
}

record(calc, "SIOC:L3B:MP04:HEARTBEATE08") {
  field(FLNK, "SIOC:L3B:MP04:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP04:HEARTBEATE07.B")
  field(INPB, "SIOC:L3B:MP04:HEARTBEATE08.VAL")
}

record(calc, "SIOC:L3B:MP04:HEARTBEATE07") {
  field(FLNK, "SIOC:L3B:MP04:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP04:HEARTBEATE06.B")
  field(INPB, "SIOC:L3B:MP04:HEARTBEATE07.VAL")
}

record(calc, "SIOC:L3B:MP04:HEARTBEATE06") {
  field(FLNK, "SIOC:L3B:MP04:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP04:HEARTBEATE05.B")
  field(INPB, "SIOC:L3B:MP04:HEARTBEATE06.VAL")
}

record(calc, "SIOC:L3B:MP04:HEARTBEATE05") {
  field(FLNK, "SIOC:L3B:MP04:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP04:HEARTBEATE04.B")
  field(INPB, "SIOC:L3B:MP04:HEARTBEATE05.VAL")
}

record(calc, "SIOC:L3B:MP04:HEARTBEATE04") {
  field(FLNK, "SIOC:L3B:MP04:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP04:HEARTBEATE03.B")
  field(INPB, "SIOC:L3B:MP04:HEARTBEATE04.VAL")
}

record(calc, "SIOC:L3B:MP04:HEARTBEATE03") {
  field(FLNK, "SIOC:L3B:MP04:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP04:HEARTBEATE02.B")
  field(INPB, "SIOC:L3B:MP04:HEARTBEATE03.VAL")
}

record(calc, "SIOC:L3B:MP04:HEARTBEATE02") {
  field(FLNK, "SIOC:L3B:MP04:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP04:HEARTBEATE01.B")
  field(INPB, "SIOC:L3B:MP04:HEARTBEATE02.VAL")
}

record(calc, "SIOC:L3B:MP04:HEARTBEATE01") {
  field(FLNK, "SIOC:L3B:MP04:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP04:HEARTBEATERR.VAL")
  field(INPB, "SIOC:L3B:MP04:HEARTBEATE01.VAL")
}

record(calc, "SIOC:L3B:MP04:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:L3B:MP04:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:L3B:MP04:HEARTBEATSUM") {
  field(FLNK, "SIOC:L3B:MP04:HEARTBEATCLC")
  field(INP, "SIOC:L3B:MP04:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:L3B:MP04:HEARTBEATE10") {
  field(FLNK, "SIOC:L3B:MP04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP04:HEARTBEATE09.B")
  field(INPB, "SIOC:L3B:MP04:HEARTBEATE10.VAL")
}

record(calc, "SIOC:L3B:MP04:HEARTBEATERR") {
  field(FLNK, "SIOC:L3B:MP04:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:L3B:MP04:HEARTBEATCALC.A")
  field(INPB, "SIOC:L3B:MP04:HEARTBEATCALC.B")
}

record(stringin, "SIOC:L3B:MP04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:L3B:MP04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:MP04:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-sp04")
  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:L3B:MP05:INFO") {
  field(DESC, "SIOC:L3B:MP05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:MP05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:L3B:MP05:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:L3B:MP05:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:L3B:MP05:TODDIFF")
}

record(longin, "SIOC:L3B:MP05:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:L3B:MP05:TODCHECK.VALA MS")
  field(FLNK, "SIOC:L3B:MP05:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:L3B:MP05:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L3B:MP05:TODCHECK.SEVR")
  field(INPB, "SIOC:L3B:MP05:TODCHECK.VALB")
  field(FLNK, "SIOC:L3B:MP05:TODSUM")
}

record(bo, "SIOC:L3B:MP05:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:L3B:MP05:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:L3B:MP05:HEARTBEATCALC") {
  field(FLNK, "SIOC:L3B:MP05:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP05:HEARTBEAT CA MS")
  field(INPB, "SIOC:L3B:MP05:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:L3B:MP05:HEARTBEATOK") {
  field(FLNK, "SIOC:L3B:MP05:HEARTBEATE01")
  field(INP, "SIOC:L3B:MP05:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:L3B:MP05:HEARTBEATECT") {
  field(FLNK, "SIOC:L3B:MP05:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:L3B:MP05:HEARTBEATE01.VAL")
  field(INPB, "SIOC:L3B:MP05:HEARTBEATE02.VAL")
  field(INPC, "SIOC:L3B:MP05:HEARTBEATE03.VAL")
  field(INPD, "SIOC:L3B:MP05:HEARTBEATE04.VAL")
  field(INPE, "SIOC:L3B:MP05:HEARTBEATE05.VAL")
  field(INPF, "SIOC:L3B:MP05:HEARTBEATE06.VAL")
  field(INPG, "SIOC:L3B:MP05:HEARTBEATE07.VAL")
  field(INPH, "SIOC:L3B:MP05:HEARTBEATE08.VAL")
  field(INPI, "SIOC:L3B:MP05:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:L3B:MP05:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:L3B:MP05:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:MP05:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP05:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:MP05:HEARTBEATE09.VAL")
}

record(calc, "SIOC:L3B:MP05:HEARTBEATE08") {
  field(FLNK, "SIOC:L3B:MP05:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP05:HEARTBEATE07.B")
  field(INPB, "SIOC:L3B:MP05:HEARTBEATE08.VAL")
}

record(calc, "SIOC:L3B:MP05:HEARTBEATE07") {
  field(FLNK, "SIOC:L3B:MP05:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP05:HEARTBEATE06.B")
  field(INPB, "SIOC:L3B:MP05:HEARTBEATE07.VAL")
}

record(calc, "SIOC:L3B:MP05:HEARTBEATE06") {
  field(FLNK, "SIOC:L3B:MP05:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP05:HEARTBEATE05.B")
  field(INPB, "SIOC:L3B:MP05:HEARTBEATE06.VAL")
}

record(calc, "SIOC:L3B:MP05:HEARTBEATE05") {
  field(FLNK, "SIOC:L3B:MP05:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP05:HEARTBEATE04.B")
  field(INPB, "SIOC:L3B:MP05:HEARTBEATE05.VAL")
}

record(calc, "SIOC:L3B:MP05:HEARTBEATE04") {
  field(FLNK, "SIOC:L3B:MP05:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP05:HEARTBEATE03.B")
  field(INPB, "SIOC:L3B:MP05:HEARTBEATE04.VAL")
}

record(calc, "SIOC:L3B:MP05:HEARTBEATE03") {
  field(FLNK, "SIOC:L3B:MP05:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP05:HEARTBEATE02.B")
  field(INPB, "SIOC:L3B:MP05:HEARTBEATE03.VAL")
}

record(calc, "SIOC:L3B:MP05:HEARTBEATE02") {
  field(FLNK, "SIOC:L3B:MP05:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP05:HEARTBEATE01.B")
  field(INPB, "SIOC:L3B:MP05:HEARTBEATE02.VAL")
}

record(calc, "SIOC:L3B:MP05:HEARTBEATE01") {
  field(FLNK, "SIOC:L3B:MP05:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP05:HEARTBEATERR.VAL")
  field(INPB, "SIOC:L3B:MP05:HEARTBEATE01.VAL")
}

record(calc, "SIOC:L3B:MP05:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:L3B:MP05:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:L3B:MP05:HEARTBEATSUM") {
  field(FLNK, "SIOC:L3B:MP05:HEARTBEATCLC")
  field(INP, "SIOC:L3B:MP05:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:L3B:MP05:HEARTBEATE10") {
  field(FLNK, "SIOC:L3B:MP05:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP05:HEARTBEATE09.B")
  field(INPB, "SIOC:L3B:MP05:HEARTBEATE10.VAL")
}

record(calc, "SIOC:L3B:MP05:HEARTBEATERR") {
  field(FLNK, "SIOC:L3B:MP05:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:L3B:MP05:HEARTBEATCALC.A")
  field(INPB, "SIOC:L3B:MP05:HEARTBEATCALC.B")
}

record(stringin, "SIOC:L3B:MP05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:L3B:MP05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:MP05:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-sp05")
  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:L3B:MP06:INFO") {
  field(DESC, "SIOC:L3B:MP06 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:MP06:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:L3B:MP06:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:L3B:MP06:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:L3B:MP06:TODDIFF")
}

record(longin, "SIOC:L3B:MP06:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:L3B:MP06:TODCHECK.VALA MS")
  field(FLNK, "SIOC:L3B:MP06:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:L3B:MP06:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L3B:MP06:TODCHECK.SEVR")
  field(INPB, "SIOC:L3B:MP06:TODCHECK.VALB")
  field(FLNK, "SIOC:L3B:MP06:TODSUM")
}

record(bo, "SIOC:L3B:MP06:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:L3B:MP06:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:L3B:MP06:HEARTBEATCALC") {
  field(FLNK, "SIOC:L3B:MP06:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP06:HEARTBEAT CA MS")
  field(INPB, "SIOC:L3B:MP06:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:L3B:MP06:HEARTBEATOK") {
  field(FLNK, "SIOC:L3B:MP06:HEARTBEATE01")
  field(INP, "SIOC:L3B:MP06:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:L3B:MP06:HEARTBEATECT") {
  field(FLNK, "SIOC:L3B:MP06:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:L3B:MP06:HEARTBEATE01.VAL")
  field(INPB, "SIOC:L3B:MP06:HEARTBEATE02.VAL")
  field(INPC, "SIOC:L3B:MP06:HEARTBEATE03.VAL")
  field(INPD, "SIOC:L3B:MP06:HEARTBEATE04.VAL")
  field(INPE, "SIOC:L3B:MP06:HEARTBEATE05.VAL")
  field(INPF, "SIOC:L3B:MP06:HEARTBEATE06.VAL")
  field(INPG, "SIOC:L3B:MP06:HEARTBEATE07.VAL")
  field(INPH, "SIOC:L3B:MP06:HEARTBEATE08.VAL")
  field(INPI, "SIOC:L3B:MP06:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:L3B:MP06:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:L3B:MP06:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:MP06:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP06:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:MP06:HEARTBEATE09.VAL")
}

record(calc, "SIOC:L3B:MP06:HEARTBEATE08") {
  field(FLNK, "SIOC:L3B:MP06:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP06:HEARTBEATE07.B")
  field(INPB, "SIOC:L3B:MP06:HEARTBEATE08.VAL")
}

record(calc, "SIOC:L3B:MP06:HEARTBEATE07") {
  field(FLNK, "SIOC:L3B:MP06:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP06:HEARTBEATE06.B")
  field(INPB, "SIOC:L3B:MP06:HEARTBEATE07.VAL")
}

record(calc, "SIOC:L3B:MP06:HEARTBEATE06") {
  field(FLNK, "SIOC:L3B:MP06:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP06:HEARTBEATE05.B")
  field(INPB, "SIOC:L3B:MP06:HEARTBEATE06.VAL")
}

record(calc, "SIOC:L3B:MP06:HEARTBEATE05") {
  field(FLNK, "SIOC:L3B:MP06:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP06:HEARTBEATE04.B")
  field(INPB, "SIOC:L3B:MP06:HEARTBEATE05.VAL")
}

record(calc, "SIOC:L3B:MP06:HEARTBEATE04") {
  field(FLNK, "SIOC:L3B:MP06:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP06:HEARTBEATE03.B")
  field(INPB, "SIOC:L3B:MP06:HEARTBEATE04.VAL")
}

record(calc, "SIOC:L3B:MP06:HEARTBEATE03") {
  field(FLNK, "SIOC:L3B:MP06:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP06:HEARTBEATE02.B")
  field(INPB, "SIOC:L3B:MP06:HEARTBEATE03.VAL")
}

record(calc, "SIOC:L3B:MP06:HEARTBEATE02") {
  field(FLNK, "SIOC:L3B:MP06:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP06:HEARTBEATE01.B")
  field(INPB, "SIOC:L3B:MP06:HEARTBEATE02.VAL")
}

record(calc, "SIOC:L3B:MP06:HEARTBEATE01") {
  field(FLNK, "SIOC:L3B:MP06:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP06:HEARTBEATERR.VAL")
  field(INPB, "SIOC:L3B:MP06:HEARTBEATE01.VAL")
}

record(calc, "SIOC:L3B:MP06:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:L3B:MP06:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:L3B:MP06:HEARTBEATSUM") {
  field(FLNK, "SIOC:L3B:MP06:HEARTBEATCLC")
  field(INP, "SIOC:L3B:MP06:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:L3B:MP06:HEARTBEATE10") {
  field(FLNK, "SIOC:L3B:MP06:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MP06:HEARTBEATE09.B")
  field(INPB, "SIOC:L3B:MP06:HEARTBEATE10.VAL")
}

record(calc, "SIOC:L3B:MP06:HEARTBEATERR") {
  field(FLNK, "SIOC:L3B:MP06:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:L3B:MP06:HEARTBEATCALC.A")
  field(INPB, "SIOC:L3B:MP06:HEARTBEATCALC.B")
}

record(stringin, "SIOC:L3B:MP06:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:L3B:MP06:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:MP06:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-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:L3B:MC01:INFO") {
  field(DESC, "SIOC:L3B:MC01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B: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:L3B: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:L3B: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:L3B:MC01:TODDIFF")
}

record(longin, "SIOC:L3B:MC01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:L3B:MC01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:L3B: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:L3B:MC01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L3B:MC01:TODCHECK.SEVR")
  field(INPB, "SIOC:L3B:MC01:TODCHECK.VALB")
  field(FLNK, "SIOC:L3B:MC01:TODSUM")
}

record(bo, "SIOC:L3B:MC01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:L3B:MC01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:L3B:MC01:HEARTBEATCALC") {
  field(FLNK, "SIOC:L3B:MC01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MC01:HEARTBEAT CA MS")
  field(INPB, "SIOC:L3B:MC01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:L3B:MC01:HEARTBEATOK") {
  field(FLNK, "SIOC:L3B:MC01:HEARTBEATE01")
  field(INP, "SIOC:L3B:MC01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:L3B:MC01:HEARTBEATECT") {
  field(FLNK, "SIOC:L3B:MC01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:L3B:MC01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:L3B:MC01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:L3B:MC01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:L3B:MC01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:L3B:MC01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:L3B:MC01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:L3B:MC01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:L3B:MC01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:L3B:MC01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:L3B: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:L3B:MC01:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:MC01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MC01:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:MC01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:L3B:MC01:HEARTBEATE08") {
  field(FLNK, "SIOC:L3B:MC01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MC01:HEARTBEATE07.B")
  field(INPB, "SIOC:L3B:MC01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:L3B:MC01:HEARTBEATE07") {
  field(FLNK, "SIOC:L3B:MC01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MC01:HEARTBEATE06.B")
  field(INPB, "SIOC:L3B:MC01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:L3B:MC01:HEARTBEATE06") {
  field(FLNK, "SIOC:L3B:MC01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MC01:HEARTBEATE05.B")
  field(INPB, "SIOC:L3B:MC01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:L3B:MC01:HEARTBEATE05") {
  field(FLNK, "SIOC:L3B:MC01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MC01:HEARTBEATE04.B")
  field(INPB, "SIOC:L3B:MC01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:L3B:MC01:HEARTBEATE04") {
  field(FLNK, "SIOC:L3B:MC01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MC01:HEARTBEATE03.B")
  field(INPB, "SIOC:L3B:MC01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:L3B:MC01:HEARTBEATE03") {
  field(FLNK, "SIOC:L3B:MC01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MC01:HEARTBEATE02.B")
  field(INPB, "SIOC:L3B:MC01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:L3B:MC01:HEARTBEATE02") {
  field(FLNK, "SIOC:L3B:MC01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MC01:HEARTBEATE01.B")
  field(INPB, "SIOC:L3B:MC01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:L3B:MC01:HEARTBEATE01") {
  field(FLNK, "SIOC:L3B:MC01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MC01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:L3B:MC01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:L3B:MC01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:L3B:MC01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:L3B:MC01:HEARTBEATSUM") {
  field(FLNK, "SIOC:L3B:MC01:HEARTBEATCLC")
  field(INP, "SIOC:L3B: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:L3B:MC01:HEARTBEATE10") {
  field(FLNK, "SIOC:L3B:MC01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:MC01:HEARTBEATE09.B")
  field(INPB, "SIOC:L3B:MC01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:L3B:MC01:HEARTBEATERR") {
  field(FLNK, "SIOC:L3B:MC01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:L3B:MC01:HEARTBEATCALC.A")
  field(INPB, "SIOC:L3B:MC01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:L3B:MC01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:L3B:MC01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:MC01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l3b-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:L3B:TR01:INFO") {
  field(DESC, "SIOC:L3B:TR01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B: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:L3B: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:L3B: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:L3B:TR01:TODDIFF")
}

record(longin, "SIOC:L3B:TR01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:L3B:TR01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:L3B: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:L3B:TR01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L3B:TR01:TODCHECK.SEVR")
  field(INPB, "SIOC:L3B:TR01:TODCHECK.VALB")
  field(FLNK, "SIOC:L3B:TR01:TODSUM")
}

record(bo, "SIOC:L3B:TR01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:L3B:TR01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:L3B:TR01:HEARTBEATCALC") {
  field(FLNK, "SIOC:L3B:TR01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:TR01:HEARTBEAT CA MS")
  field(INPB, "SIOC:L3B:TR01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:L3B:TR01:HEARTBEATOK") {
  field(FLNK, "SIOC:L3B:TR01:HEARTBEATE01")
  field(INP, "SIOC:L3B:TR01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:L3B:TR01:HEARTBEATECT") {
  field(FLNK, "SIOC:L3B:TR01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:L3B:TR01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:L3B:TR01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:L3B:TR01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:L3B:TR01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:L3B:TR01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:L3B:TR01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:L3B:TR01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:L3B:TR01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:L3B:TR01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:L3B: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:L3B:TR01:HEARTBEATE09") {
  field(FLNK, "SIOC:L3B:TR01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:TR01:HEARTBEATE08.B")
  field(INPB, "SIOC:L3B:TR01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:L3B:TR01:HEARTBEATE08") {
  field(FLNK, "SIOC:L3B:TR01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:TR01:HEARTBEATE07.B")
  field(INPB, "SIOC:L3B:TR01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:L3B:TR01:HEARTBEATE07") {
  field(FLNK, "SIOC:L3B:TR01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:TR01:HEARTBEATE06.B")
  field(INPB, "SIOC:L3B:TR01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:L3B:TR01:HEARTBEATE06") {
  field(FLNK, "SIOC:L3B:TR01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:TR01:HEARTBEATE05.B")
  field(INPB, "SIOC:L3B:TR01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:L3B:TR01:HEARTBEATE05") {
  field(FLNK, "SIOC:L3B:TR01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:TR01:HEARTBEATE04.B")
  field(INPB, "SIOC:L3B:TR01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:L3B:TR01:HEARTBEATE04") {
  field(FLNK, "SIOC:L3B:TR01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:TR01:HEARTBEATE03.B")
  field(INPB, "SIOC:L3B:TR01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:L3B:TR01:HEARTBEATE03") {
  field(FLNK, "SIOC:L3B:TR01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:TR01:HEARTBEATE02.B")
  field(INPB, "SIOC:L3B:TR01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:L3B:TR01:HEARTBEATE02") {
  field(FLNK, "SIOC:L3B:TR01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:TR01:HEARTBEATE01.B")
  field(INPB, "SIOC:L3B:TR01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:L3B:TR01:HEARTBEATE01") {
  field(FLNK, "SIOC:L3B:TR01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:TR01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:L3B:TR01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:L3B:TR01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:L3B:TR01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:L3B:TR01:HEARTBEATSUM") {
  field(FLNK, "SIOC:L3B:TR01:HEARTBEATCLC")
  field(INP, "SIOC:L3B: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:L3B:TR01:HEARTBEATE10") {
  field(FLNK, "SIOC:L3B:TR01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:L3B:TR01:HEARTBEATE09.B")
  field(INPB, "SIOC:L3B:TR01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:L3B:TR01:HEARTBEATERR") {
  field(FLNK, "SIOC:L3B:TR01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:L3B:TR01:HEARTBEATCALC.A")
  field(INPB, "SIOC:L3B:TR01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:L3B:TR01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:L3B:TR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:L3B:TR01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-fb03")
  info(autosaveFields,"VAL")
}

