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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:BP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "483,583")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:BP03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "883,983")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:BP04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "1083,1183")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:BP05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "1283,1383")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:RF04: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:L2B:RF04: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:L2B:RF04:TOD CA")
  field(INPC, "10")
# VALA holds 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:L2B:RF04:TODDIFF")
}

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

# If <ioc> 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:L2B:RF04:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L2B:RF04:TODCHECK.SEVR")
  field(INPB, "SIOC:L2B:RF04:TODCHECK.VALB")
  field(FLNK, "SIOC:L2B:RF04:TODSUM")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:RF04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM04")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF04:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-rf04")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF05: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:L2B:RF05: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:L2B:RF05:TOD CA")
  field(INPC, "10")
# VALA holds 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:L2B:RF05:TODDIFF")
}

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

# If <ioc> 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:L2B:RF05:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L2B:RF05:TODCHECK.SEVR")
  field(INPB, "SIOC:L2B:RF05:TODCHECK.VALB")
  field(FLNK, "SIOC:L2B:RF05:TODSUM")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:RF05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM05")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF05:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-rf05")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF06: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:L2B:RF06: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:L2B:RF06:TOD CA")
  field(INPC, "10")
# VALA holds 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:L2B:RF06:TODDIFF")
}

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

# If <ioc> 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:L2B:RF06:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L2B:RF06:TODCHECK.SEVR")
  field(INPB, "SIOC:L2B:RF06:TODCHECK.VALB")
  field(FLNK, "SIOC:L2B:RF06:TODSUM")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:RF06:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM06")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF06:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-rf06")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF07: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:L2B:RF07: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:L2B:RF07:TOD CA")
  field(INPC, "10")
# VALA holds 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:L2B:RF07:TODDIFF")
}

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

# If <ioc> 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:L2B:RF07:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L2B:RF07:TODCHECK.SEVR")
  field(INPB, "SIOC:L2B:RF07:TODCHECK.VALB")
  field(FLNK, "SIOC:L2B:RF07:TODSUM")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:RF07:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM07")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF07:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-rf07")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF08: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:L2B:RF08: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:L2B:RF08:TOD CA")
  field(INPC, "10")
# VALA holds 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:L2B:RF08:TODDIFF")
}

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

# If <ioc> 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:L2B:RF08:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L2B:RF08:TODCHECK.SEVR")
  field(INPB, "SIOC:L2B:RF08:TODCHECK.VALB")
  field(FLNK, "SIOC:L2B:RF08:TODSUM")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:RF08:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM08")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF08:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-rf08")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF09: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:L2B:RF09: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:L2B:RF09:TOD CA")
  field(INPC, "10")
# VALA holds 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:L2B:RF09:TODDIFF")
}

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

# If <ioc> 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:L2B:RF09:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L2B:RF09:TODCHECK.SEVR")
  field(INPB, "SIOC:L2B:RF09:TODCHECK.VALB")
  field(FLNK, "SIOC:L2B:RF09:TODSUM")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:RF09:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM09")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF09:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-rf09")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF10: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:L2B:RF10: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:L2B:RF10:TOD CA")
  field(INPC, "10")
# VALA holds 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:L2B:RF10:TODDIFF")
}

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

# If <ioc> 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:L2B:RF10:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L2B:RF10:TODCHECK.SEVR")
  field(INPB, "SIOC:L2B:RF10:TODCHECK.VALB")
  field(FLNK, "SIOC:L2B:RF10:TODSUM")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:RF10:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM10")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF10:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-rf10")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF11: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:L2B:RF11: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:L2B:RF11:TOD CA")
  field(INPC, "10")
# VALA holds 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:L2B:RF11:TODDIFF")
}

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

# If <ioc> 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:L2B:RF11:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L2B:RF11:TODCHECK.SEVR")
  field(INPB, "SIOC:L2B:RF11:TODCHECK.VALB")
  field(FLNK, "SIOC:L2B:RF11:TODSUM")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:RF11:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM11")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF11:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-rf11")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF12: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:L2B:RF12: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:L2B:RF12:TOD CA")
  field(INPC, "10")
# VALA holds 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:L2B:RF12:TODDIFF")
}

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

# If <ioc> 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:L2B:RF12:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L2B:RF12:TODCHECK.SEVR")
  field(INPB, "SIOC:L2B:RF12:TODCHECK.VALB")
  field(FLNK, "SIOC:L2B:RF12:TODSUM")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:RF12:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM12")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF12:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-rf12")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF13: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:L2B:RF13: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:L2B:RF13:TOD CA")
  field(INPC, "10")
# VALA holds 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:L2B:RF13:TODDIFF")
}

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

# If <ioc> 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:L2B:RF13:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L2B:RF13:TODCHECK.SEVR")
  field(INPB, "SIOC:L2B:RF13:TODCHECK.VALB")
  field(FLNK, "SIOC:L2B:RF13:TODSUM")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:RF13:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM13")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF13:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-rf13")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF14: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:L2B:RF14: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:L2B:RF14:TOD CA")
  field(INPC, "10")
# VALA holds 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:L2B:RF14:TODDIFF")
}

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

# If <ioc> 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:L2B:RF14:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L2B:RF14:TODCHECK.SEVR")
  field(INPB, "SIOC:L2B:RF14:TODCHECK.VALB")
  field(FLNK, "SIOC:L2B:RF14:TODSUM")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:RF14:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM14")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF14:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-rf14")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF15: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:L2B:RF15: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:L2B:RF15:TOD CA")
  field(INPC, "10")
# VALA holds 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:L2B:RF15:TODDIFF")
}

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

# If <ioc> 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:L2B:RF15:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:L2B:RF15:TODCHECK.SEVR")
  field(INPB, "SIOC:L2B:RF15:TODCHECK.VALB")
  field(FLNK, "SIOC:L2B:RF15:TODSUM")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:RF15:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CM15")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L2B:RF15:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-rf15")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:SP01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-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:L2B:SP02:INFO") {
  field(DESC, "SIOC:L2B:SP02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:SP02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-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:L2B:SP03:INFO") {
  field(DESC, "SIOC:L2B:SP03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:SP03:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-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:L2B:MP00:INFO") {
  field(DESC, "SIOC:L2B:MP00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:MP01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-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:L2B:MP02:INFO") {
  field(DESC, "SIOC:L2B:MP02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:MP02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-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:L2B:MP03:INFO") {
  field(DESC, "SIOC:L2B:MP03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:MP03:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-l2b-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:L2B:MP04:INFO") {
  field(DESC, "SIOC:L2B:MP04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L2B:TR01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-fb03")
  info(autosaveFields,"VAL")
}

