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

record(stringin, "SIOC:CP00:CR01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Diane Fairley (dfairley)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP00:CR01: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:CP00:CR01:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP00:CR01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP00:CR01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant general")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:CP00:CR01:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP00:CR02:INFO") {
  field(DESC, "SIOC:CP00:CR02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP00:CR02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Tasha Summers (tsummers)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP00:CR02: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:CP00:CR02:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP00:CR02:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP00:CR02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant general")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:CP00:CR02:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP00:CR03:INFO") {
  field(DESC, "SIOC:CP00:CR03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP00:CR03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Tasha Summers (tsummers)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP00:CR03: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:CP00:CR03:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP00:CR03:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP00:CR03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant general")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:CP00:CR03:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP08:CR01:INFO") {
  field(DESC, "SIOC:CP08:CR01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP08:CR01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Diane Fairley (dfairley)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP08:CR01: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:CP08:CR01:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP08:CR01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP08:CR01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 CMP1")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP08:CR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 CMP1")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP08:CR01:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP12:CR01:INFO") {
  field(DESC, "SIOC:CP12:CR01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP12:CR01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Diane Fairley (dfairley)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP12:CR01: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:CP12:CR01:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP12:CR01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP12:CR01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 CMP2")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP12:CR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 CMP2")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP12:CR01:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP12:CR02:INFO") {
  field(DESC, "SIOC:CP12:CR02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP12:CR02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Diane Fairley (dfairley)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP12:CR02: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:CP12:CR02:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP12:CR02:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP12:CR02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 CMP3")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP12:CR02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 CMP3")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP12:CR02:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP12:CR03:INFO") {
  field(DESC, "SIOC:CP12:CR03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP12:CR03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Diane Fairley (dfairley)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP12:CR03: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:CP12:CR03:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP12:CR03:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP12:CR03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 CMP4")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP12:CR03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 CMP4")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP12:CR03:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP12:CR04:INFO") {
  field(DESC, "SIOC:CP12:CR04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP12:CR04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Diane Fairley (dfairley)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP12:CR04: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:CP12:CR04:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP12:CR04:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP12:CR04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 CMP5")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP12:CR04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 CMP5")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP12:CR04:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP12:CR05:INFO") {
  field(DESC, "SIOC:CP12:CR05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP12:CR05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Diane Fairley (dfairley)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP12:CR05: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:CP12:CR05:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP12:CR05:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP12:CR05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 CMP6")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP12:CR05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 CMP6")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP12:CR05:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP12:CR06:INFO") {
  field(DESC, "SIOC:CP12:CR06 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP12:CR06:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Diane Fairley (dfairley)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP12:CR06: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:CP12:CR06:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP12:CR06:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP12:CR06:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 CMP6")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP12:CR06:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 CMP6")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP12:CR06:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP12:CR07:INFO") {
  field(DESC, "SIOC:CP12:CR07 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP12:CR07:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Diane Fairley (dfairley)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP12:CR07: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:CP12:CR07:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP12:CR07:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP12:CR07:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 UTIL")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP12:CR07:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 UTIL")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP12:CR07:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP12:CR08:INFO") {
  field(DESC, "SIOC:CP12:CR08 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP12:CR08:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Tasha Summers (tsummers)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP12:CR08: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:CP12:CR08:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP12:CR08:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP12:CR08:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 4KCB")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP12:CR08:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 4KCB")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP12:CR08:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP14:CR01:INFO") {
  field(DESC, "SIOC:CP14:CR01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP14:CR01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Tasha Summers (tsummers)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP14:CR01: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:CP14:CR01:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP14:CR01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP14:CR01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 2KCB")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP14:CR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 1 2KCB")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP14:CR01:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP22:CR01:INFO") {
  field(DESC, "SIOC:CP22:CR01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP22:CR01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Diane Fairley (dfairley)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP22:CR01: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:CP22:CR01:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP22:CR01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP22:CR01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 CMP1")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP22:CR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 CMP1")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP22:CR01:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP22:CR02:INFO") {
  field(DESC, "SIOC:CP22:CR02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP22:CR02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Diane Fairley (dfairley)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP22:CR02: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:CP22:CR02:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP22:CR02:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP22:CR02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 CMP2")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP22:CR02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 CMP2")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP22:CR02:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP22:CR03:INFO") {
  field(DESC, "SIOC:CP22:CR03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP22:CR03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Diane Fairley (dfairley)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP22:CR03: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:CP22:CR03:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP22:CR03:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP22:CR03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 CMP3")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP22:CR03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 CMP3")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP22:CR03:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP22:CR04:INFO") {
  field(DESC, "SIOC:CP22:CR04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP22:CR04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Diane Fairley (dfairley)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP22:CR04: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:CP22:CR04:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP22:CR04:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP22:CR04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 CMP4")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP22:CR04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 CMP4")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP22:CR04:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP22:CR05:INFO") {
  field(DESC, "SIOC:CP22:CR05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP22:CR05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Diane Fairley (dfairley)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP22:CR05: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:CP22:CR05:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP22:CR05:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP22:CR05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 CMP5")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP22:CR05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 CMP5")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP22:CR05:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP22:CR06:INFO") {
  field(DESC, "SIOC:CP22:CR06 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP22:CR06:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Diane Fairley (dfairley)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP22:CR06: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:CP22:CR06:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP22:CR06:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP22:CR06:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 CMP6")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP22:CR06:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 CMP6")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP22:CR06:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP22:CR07:INFO") {
  field(DESC, "SIOC:CP22:CR07 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP22:CR07:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Diane Fairley (dfairley)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP22:CR07: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:CP22:CR07:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP22:CR07:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP22:CR07:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 UTIL")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP22:CR07:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 UTIL")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP22:CR07:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP22:CR08:INFO") {
  field(DESC, "SIOC:CP22:CR08 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP22:CR08:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Tasha Summers (tsummers)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP22:CR08: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:CP22:CR08:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP22:CR08:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP22:CR08:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 4KCB")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP22:CR08:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 4KCB")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP22:CR08:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:CP24:CR01:INFO") {
  field(DESC, "SIOC:CP24:CR01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP24:CR01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Marcus Keenan (mkeenan)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:CP24:CR01: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:CP24:CR01:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP24:CR01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:CP24:CR01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 2KCB")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP24:CR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryoplant 2 2KCB")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP24:CR01:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:DB01:CR01:INFO") {
  field(DESC, "SIOC:DB01:CR01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:DB01:CR01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Andrew Wilson (andreww)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:DB01:CR01: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:DB01:CR01:TOD CA")
  field(INPC, "10")
# VALA holds 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:DB01:CR01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:DB01:CR01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryo distribution L0-L2")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:DB01:CR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryo distribution L0-L2")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:DB01:CR01:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:DB02:CR01:INFO") {
  field(DESC, "SIOC:DB02:CR01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:DB02:CR01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Andrew Wilson (andreww)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:DB02:CR01: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:DB02:CR01:TOD CA")
  field(INPC, "10")
# VALA holds 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:DB02:CR01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:DB02:CR01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cryo distribution L3")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:DB02:CR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cryo distribution L3")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:DB02:CR01:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:SYS0:BP03:INFO") {
  field(DESC, "SIOC:SYS0:BP03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:BP03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "SC GUN charge setp")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:BP03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "SC GUN charge setp")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:NW04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "SuperConducting")
  info(autosaveFields,"VAL")
}

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

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

record(stringin, "SIOC:SYS0:SC02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Garth Brown (gwbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:SC02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Oscilloscopes")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:MG09:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "GUNB-DIAG0 Model EPCS & Bulks ")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:MG09:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "GUNB-DIAG0 Model EPCS & Bulks ")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:MG08:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "SC Model and Wildcard Func")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:MG08:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "SC Model and Wildcard Func")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:MG06:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "BC1B-BPN EPSC & Bulks")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:MG06:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "BC1B-BPN EPSC & Bulks")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:MG07:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LTUS-DMPS EPSC & Bulks")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:MG07:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LTUS-DMPS EPSC & Bulks")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:SYS0:TS00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Ryan McClanahan (rpm)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:TS00: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:SYS0:TS00:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:TS00:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:TS00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Timing Support")
  info(autosaveFields,"VAL")
}

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

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

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

record(stringin, "SIOC:SYS0:TS01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Carolina Bianchini (carolina)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:TS01: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:SYS0:TS01:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:TS01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:TS01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Timing Source")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:SYS0:TS01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-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:GUNB:TS02:INFO") {
  field(DESC, "SIOC:GUNB:TS02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:GUNB:TS02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Carolina Bianchini Mattison (carolina)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:GUNB:TS02: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:GUNB:TS02:TOD CA")
  field(INPC, "10")
# VALA holds 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:GUNB:TS02:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:GUNB:TS02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Timing Active Fanout in S2")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:GUNB:TS02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Timing Active Fanout in S2")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:GUNB:TS02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-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:SYS0:TS05:INFO") {
  field(DESC, "SIOC:SYS0:TS05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:TS05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Tyler Kabana (kabanaty)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:TS05: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:SYS0:TS05:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:TS05:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:TS05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "FACMODE and MODESWITCH HOST")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:TS05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "FACMODE and MODESWITCH HOST")
  info(autosaveFields,"VAL")
}

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

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

record(stringin, "SIOC:SYS0:TS06:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Ryan McClanahan (rpm)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:TS06: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:SYS0:TS06:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:TS06:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:TS06:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Timing Support")
  info(autosaveFields,"VAL")
}

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

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

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

record(stringin, "SIOC:SYS0:MS01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Carolina Bianchini (carolina)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:MS01: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:SYS0:MS01:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:MS01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:MS01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Master Source")
  info(autosaveFields,"VAL")
}

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

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

record(stringin, "SIOC:SYS0:MS02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Carolina Bianchini (carolina)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:MS02: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:SYS0:MS02:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:MS02:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:MS02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Master Source")
  info(autosaveFields,"VAL")
}

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

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

record(stringin, "SIOC:SYS0:MS03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Carolina Bianchini (carolina)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:MS03: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:SYS0:MS03:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:MS03:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:MS03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Master Source")
  info(autosaveFields,"VAL")
}

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

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

record(stringin, "SIOC:SYS0:MS04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Carolina Bianchini (carolina)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:MS04: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:SYS0:MS04:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:MS04:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:MS04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Master Source")
  info(autosaveFields,"VAL")
}

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

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

record(stringin, "SIOC:SYS0:MS05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Carolina Bianchini (carolina)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:MS05: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:SYS0:MS05:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:MS05:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:MS05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Master Source")
  info(autosaveFields,"VAL")
}

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

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

record(stringin, "SIOC:SYS0:MS06:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Carolina Bianchini (carolina)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:MS06: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:SYS0:MS06:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:MS06:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:MS06:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Master Source")
  info(autosaveFields,"VAL")
}

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

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

record(stringin, "SIOC:SYS0:MS07:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Kukhee Kim (khkim)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:MS07: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:SYS0:MS07:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:MS07:TODDIFF")
}

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

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

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

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

record(bi, "SIOC:SYS0:MS07:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:MS07:HEARTBEATE01")
  field(INP, "SIOC:SYS0:MS07:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:MS07:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:MS07:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:MS07:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:MS07:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:MS07:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:MS07:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:MS07:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:MS07:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:MS07:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:MS07:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:MS07:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:MS07:HEARTBEATE10.VAL")
  field(HIHI, "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:SYS0:MS07:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:MS07:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS07:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:MS07:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:MS07:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:MS07:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS07:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:MS07:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:MS07:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:MS07:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS07:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:MS07:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:MS07:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:MS07:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS07:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:MS07:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:MS07:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:MS07:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS07:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:MS07:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:MS07:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:MS07:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS07:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:MS07:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:MS07:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:MS07:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS07:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:MS07:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:MS07:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:MS07:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS07:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:MS07:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:MS07:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:MS07:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS07:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:MS07:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:MS07:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:MS07:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:MS07:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:MS07:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:MS07:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:MS07:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:MS07:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS07:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:MS07:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:MS07:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:MS07:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:MS07:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:MS07:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:MS07:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "SIM for 11.5MHz PLL")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:MS07:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "SIM for 11.5MHz PLL")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MS07:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-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:SYS0:MS08:INFO") {
  field(DESC, "SIOC:SYS0:MS08 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MS08:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Kukhee Kim (khkim)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:MS08: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:SYS0:MS08:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:MS08:TODDIFF")
}

record(longin, "SIOC:SYS0:MS08:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:MS08:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:MS08:TODCHECKVALID")
}

# If <ioc> 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:SYS0:MS08:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:MS08:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:MS08:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:MS08:TODSUM")
}

record(bo, "SIOC:SYS0:MS08:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:MS08:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:MS08:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:MS08:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS08:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:MS08:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:MS08:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:MS08:HEARTBEATE01")
  field(INP, "SIOC:SYS0:MS08:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:MS08:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:MS08:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:MS08:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:MS08:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:MS08:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:MS08:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:MS08:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:MS08:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:MS08:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:MS08:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:MS08:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:MS08:HEARTBEATE10.VAL")
  field(HIHI, "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:SYS0:MS08:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:MS08:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS08:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:MS08:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:MS08:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:MS08:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS08:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:MS08:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:MS08:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:MS08:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS08:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:MS08:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:MS08:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:MS08:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS08:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:MS08:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:MS08:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:MS08:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS08:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:MS08:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:MS08:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:MS08:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS08:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:MS08:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:MS08:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:MS08:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS08:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:MS08:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:MS08:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:MS08:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS08:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:MS08:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:MS08:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:MS08:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS08:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:MS08:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:MS08:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:MS08:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:MS08:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:MS08:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:MS08:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:MS08:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:MS08:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS08:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:MS08:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:MS08:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:MS08:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:MS08:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:MS08:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:MS08:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "SIM for 476MHz PLL")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:MS08:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "SIM for 476MHz PLL")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MS08:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-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:SYS0:MS09:INFO") {
  field(DESC, "SIOC:SYS0:MS09 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MS09:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Kukhee Kim (khkim)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:MS09: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:SYS0:MS09:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:MS09:TODDIFF")
}

record(longin, "SIOC:SYS0:MS09:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:MS09:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:MS09:TODCHECKVALID")
}

# If <ioc> 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:SYS0:MS09:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:MS09:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:MS09:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:MS09:TODSUM")
}

record(bo, "SIOC:SYS0:MS09:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:MS09:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:MS09:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:MS09:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS09:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:MS09:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:MS09:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:MS09:HEARTBEATE01")
  field(INP, "SIOC:SYS0:MS09:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:MS09:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:MS09:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:MS09:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:MS09:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:MS09:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:MS09:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:MS09:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:MS09:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:MS09:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:MS09:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:MS09:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:MS09:HEARTBEATE10.VAL")
  field(HIHI, "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:SYS0:MS09:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:MS09:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS09:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:MS09:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:MS09:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:MS09:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS09:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:MS09:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:MS09:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:MS09:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS09:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:MS09:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:MS09:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:MS09:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS09:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:MS09:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:MS09:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:MS09:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS09:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:MS09:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:MS09:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:MS09:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS09:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:MS09:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:MS09:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:MS09:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS09:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:MS09:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:MS09:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:MS09:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS09:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:MS09:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:MS09:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:MS09:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS09:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:MS09:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:MS09:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:MS09:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:MS09:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:MS09:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:MS09:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:MS09:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:MS09:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS09:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:MS09:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:MS09:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:MS09:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:MS09:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:MS09:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:MS09:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "TPR resync Chassis")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:MS09:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "TPR resync Chassis")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MS09:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-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:SYS0:MS10:INFO") {
  field(DESC, "SIOC:SYS0:MS10 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MS10:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Michael Skoufis (skoufis)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:MS10: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:SYS0:MS10:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:MS10:TODDIFF")
}

record(longin, "SIOC:SYS0:MS10:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:MS10:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:MS10:TODCHECKVALID")
}

# If <ioc> 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:SYS0:MS10:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:MS10:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:MS10:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:MS10:TODSUM")
}

record(bo, "SIOC:SYS0:MS10:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:MS10:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:MS10:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:MS10:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS10:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:MS10:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:MS10:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:MS10:HEARTBEATE01")
  field(INP, "SIOC:SYS0:MS10:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:MS10:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:MS10:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:MS10:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:MS10:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:MS10:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:MS10:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:MS10:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:MS10:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:MS10:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:MS10:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:MS10:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:MS10:HEARTBEATE10.VAL")
  field(HIHI, "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:SYS0:MS10:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:MS10:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS10:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:MS10:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:MS10:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:MS10:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS10:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:MS10:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:MS10:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:MS10:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS10:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:MS10:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:MS10:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:MS10:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS10:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:MS10:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:MS10:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:MS10:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS10:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:MS10:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:MS10:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:MS10:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS10:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:MS10:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:MS10:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:MS10:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS10:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:MS10:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:MS10:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:MS10:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS10:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:MS10:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:MS10:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:MS10:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS10:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:MS10:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:MS10:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:MS10:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:MS10:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:MS10:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:MS10:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:MS10:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:MS10:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS10:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:MS10:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:MS10:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:MS10:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:MS10:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:MS10:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:MS10:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Phase Locker")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:MS10:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Phase Locker")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MS10:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-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:SYS0:MS11:INFO") {
  field(DESC, "SIOC:SYS0:MS11 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MS11:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Michael Skoufis (skoufis)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:MS11: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:SYS0:MS11:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:MS11:TODDIFF")
}

record(longin, "SIOC:SYS0:MS11:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:MS11:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:MS11:TODCHECKVALID")
}

# If <ioc> 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:SYS0:MS11:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:MS11:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:MS11:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:MS11:TODSUM")
}

record(bo, "SIOC:SYS0:MS11:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:MS11:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:MS11:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:MS11:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS11:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:MS11:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:MS11:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:MS11:HEARTBEATE01")
  field(INP, "SIOC:SYS0:MS11:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:MS11:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:MS11:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:MS11:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:MS11:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:MS11:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:MS11:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:MS11:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:MS11:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:MS11:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:MS11:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:MS11:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:MS11:HEARTBEATE10.VAL")
  field(HIHI, "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:SYS0:MS11:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:MS11:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS11:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:MS11:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:MS11:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:MS11:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS11:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:MS11:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:MS11:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:MS11:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS11:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:MS11:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:MS11:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:MS11:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS11:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:MS11:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:MS11:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:MS11:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS11:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:MS11:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:MS11:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:MS11:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS11:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:MS11:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:MS11:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:MS11:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS11:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:MS11:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:MS11:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:MS11:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS11:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:MS11:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:MS11:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:MS11:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS11:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:MS11:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:MS11:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:MS11:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:MS11:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:MS11:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:MS11:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:MS11:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:MS11:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MS11:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:MS11:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:MS11:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:MS11:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:MS11:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:MS11:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:MS11:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "RFOF")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:MS11:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "RFOF")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MS11:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-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:CP00:OD01:INFO") {
  field(DESC, "SIOC:CP00:OD01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP00:OD01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Garth Brown (gwbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:CP00:OD01: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:CP00:OD01:TOD CA")
  field(INPC, "10")
# VALA holds 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:CP00:OD01:TODDIFF")
}

record(longin, "SIOC:CP00:OD01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:CP00:OD01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:CP00:OD01:TODCHECKVALID")
}

# If <ioc> 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:CP00:OD01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:CP00:OD01:TODCHECK.SEVR")
  field(INPB, "SIOC:CP00:OD01:TODCHECK.VALB")
  field(FLNK, "SIOC:CP00:OD01:TODSUM")
}

record(bo, "SIOC:CP00:OD01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:CP00:OD01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:CP00:OD01:HEARTBEATCALC") {
  field(FLNK, "SIOC:CP00:OD01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:CP00:OD01:HEARTBEAT CA MS")
  field(INPB, "SIOC:CP00:OD01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:CP00:OD01:HEARTBEATOK") {
  field(FLNK, "SIOC:CP00:OD01:HEARTBEATE01")
  field(INP, "SIOC:CP00:OD01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:CP00:OD01:HEARTBEATECT") {
  field(FLNK, "SIOC:CP00:OD01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:CP00:OD01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:CP00:OD01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:CP00:OD01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:CP00:OD01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:CP00:OD01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:CP00:OD01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:CP00:OD01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:CP00:OD01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:CP00:OD01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:CP00:OD01:HEARTBEATE10.VAL")
  field(HIHI, "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:CP00:OD01:HEARTBEATE09") {
  field(FLNK, "SIOC:CP00:OD01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:CP00:OD01:HEARTBEATE08.B")
  field(INPB, "SIOC:CP00:OD01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:CP00:OD01:HEARTBEATE08") {
  field(FLNK, "SIOC:CP00:OD01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:CP00:OD01:HEARTBEATE07.B")
  field(INPB, "SIOC:CP00:OD01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:CP00:OD01:HEARTBEATE07") {
  field(FLNK, "SIOC:CP00:OD01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:CP00:OD01:HEARTBEATE06.B")
  field(INPB, "SIOC:CP00:OD01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:CP00:OD01:HEARTBEATE06") {
  field(FLNK, "SIOC:CP00:OD01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:CP00:OD01:HEARTBEATE05.B")
  field(INPB, "SIOC:CP00:OD01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:CP00:OD01:HEARTBEATE05") {
  field(FLNK, "SIOC:CP00:OD01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:CP00:OD01:HEARTBEATE04.B")
  field(INPB, "SIOC:CP00:OD01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:CP00:OD01:HEARTBEATE04") {
  field(FLNK, "SIOC:CP00:OD01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:CP00:OD01:HEARTBEATE03.B")
  field(INPB, "SIOC:CP00:OD01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:CP00:OD01:HEARTBEATE03") {
  field(FLNK, "SIOC:CP00:OD01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:CP00:OD01:HEARTBEATE02.B")
  field(INPB, "SIOC:CP00:OD01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:CP00:OD01:HEARTBEATE02") {
  field(FLNK, "SIOC:CP00:OD01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:CP00:OD01:HEARTBEATE01.B")
  field(INPB, "SIOC:CP00:OD01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:CP00:OD01:HEARTBEATE01") {
  field(FLNK, "SIOC:CP00:OD01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:CP00:OD01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:CP00:OD01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:CP00:OD01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:CP00:OD01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:CP00:OD01:HEARTBEATSUM") {
  field(FLNK, "SIOC:CP00:OD01:HEARTBEATCLC")
  field(INP, "SIOC:CP00:OD01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:CP00:OD01:HEARTBEATE10") {
  field(FLNK, "SIOC:CP00:OD01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:CP00:OD01:HEARTBEATE09.B")
  field(INPB, "SIOC:CP00:OD01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:CP00:OD01:HEARTBEATERR") {
  field(FLNK, "SIOC:CP00:OD01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:CP00:OD01:HEARTBEATCALC.A")
  field(INPB, "SIOC:CP00:OD01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:CP00:OD01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP00:OD01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:CP00:OD01:LOC") {
  field(PINI, "YES")
  field(VAL, "cryo-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:SYS0:OD01:INFO") {
  field(DESC, "SIOC:SYS0:OD01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:OD01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Garth Brown (gwbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYS0:OD01: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:SYS0:OD01:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:OD01:TODDIFF")
}

record(longin, "SIOC:SYS0:OD01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:OD01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:OD01:TODCHECKVALID")
}

# If <ioc> 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:SYS0:OD01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:OD01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:OD01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:OD01:TODSUM")
}

record(bo, "SIOC:SYS0:OD01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:OD01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:OD01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:OD01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:OD01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:OD01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:OD01:HEARTBEATE01")
  field(INP, "SIOC:SYS0:OD01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:OD01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:OD01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:OD01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:OD01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:OD01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:OD01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:OD01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:OD01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:OD01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:OD01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:OD01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:OD01:HEARTBEATE10.VAL")
  field(HIHI, "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:SYS0:OD01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:OD01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:OD01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:OD01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:OD01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:OD01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:OD01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:OD01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:OD01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:OD01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:OD01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:OD01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:OD01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:OD01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:OD01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:OD01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:OD01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:OD01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:OD01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:OD01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:OD01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:OD01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:OD01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:OD01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:OD01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:OD01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:OD01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:OD01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:OD01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:OD01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:OD01:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:OD01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:OD01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:OD01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:OD01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:OD01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:OD01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:OD01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:OD01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:OD01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:OD01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:OD01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:OD02:INFO") {
  field(DESC, "SIOC:SYS0:OD02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:OD02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Garth Brown (gwbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYS0:OD02: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:SYS0:OD02:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:OD02:TODDIFF")
}

record(longin, "SIOC:SYS0:OD02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:OD02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:OD02:TODCHECKVALID")
}

# If <ioc> 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:SYS0:OD02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:OD02:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:OD02:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:OD02:TODSUM")
}

record(bo, "SIOC:SYS0:OD02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:OD02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:OD02:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:OD02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD02:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:OD02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:OD02:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:OD02:HEARTBEATE01")
  field(INP, "SIOC:SYS0:OD02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:OD02:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:OD02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:OD02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:OD02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:OD02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:OD02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:OD02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:OD02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:OD02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:OD02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:OD02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:OD02:HEARTBEATE10.VAL")
  field(HIHI, "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:SYS0:OD02:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:OD02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD02:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:OD02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:OD02:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:OD02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD02:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:OD02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:OD02:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:OD02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD02:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:OD02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:OD02:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:OD02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD02:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:OD02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:OD02:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:OD02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD02:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:OD02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:OD02:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:OD02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD02:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:OD02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:OD02:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:OD02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD02:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:OD02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:OD02:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:OD02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD02:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:OD02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:OD02:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:OD02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:OD02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:OD02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:OD02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:OD02:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:OD02:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:OD02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:OD02:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:OD02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OD02:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:OD02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:OD02:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:OD02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:OD02:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:OD02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:OD02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:OD02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:OD02:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:BC01:INFO") {
  field(DESC, "SIOC:SYS0:BC01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:BC01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Dunning (mdunning)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYS0:BC01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:SYS0:BC01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:SYS0:BC01:TODDIFF")
}

record(longin, "SIOC:SYS0:BC01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:BC01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:BC01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:SYS0:BC01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:BC01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:BC01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:BC01:TODSUM")
}

record(bo, "SIOC:SYS0:BC01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:BC01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:BC01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:BC01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BC01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:BC01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:BC01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:BC01:HEARTBEATE01")
  field(INP, "SIOC:SYS0:BC01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:BC01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:BC01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:BC01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:BC01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:BC01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:BC01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:BC01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:BC01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:BC01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:BC01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:BC01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:BC01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:SYS0:BC01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:BC01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BC01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:BC01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:BC01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:BC01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BC01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:BC01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:BC01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:BC01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BC01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:BC01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:BC01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:BC01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BC01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:BC01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:BC01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:BC01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BC01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:BC01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:BC01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:BC01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BC01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:BC01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:BC01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:BC01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BC01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:BC01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:BC01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:BC01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BC01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:BC01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:BC01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:BC01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BC01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:BC01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:BC01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:BC01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:BC01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:BC01:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:BC01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:BC01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:BC01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BC01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:BC01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:BC01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:BC01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:BC01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:BC01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:BC01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:BC01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:BC01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:MCC0:BC01:INFO") {
  field(DESC, "SIOC:MCC0:BC01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:MCC0:BC01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:MCC0:BC01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:MCC0:BC01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:MCC0:BC01:TODDIFF")
}

record(longin, "SIOC:MCC0:BC01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:MCC0:BC01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:MCC0:BC01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:MCC0:BC01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:MCC0:BC01:TODCHECK.SEVR")
  field(INPB, "SIOC:MCC0:BC01:TODCHECK.VALB")
  field(FLNK, "SIOC:MCC0:BC01:TODSUM")
}

record(bo, "SIOC:MCC0:BC01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:MCC0:BC01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:MCC0:BC01:HEARTBEATCALC") {
  field(FLNK, "SIOC:MCC0:BC01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC01:HEARTBEAT CA MS")
  field(INPB, "SIOC:MCC0:BC01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:MCC0:BC01:HEARTBEATOK") {
  field(FLNK, "SIOC:MCC0:BC01:HEARTBEATE01")
  field(INP, "SIOC:MCC0:BC01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:MCC0:BC01:HEARTBEATECT") {
  field(FLNK, "SIOC:MCC0:BC01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:MCC0:BC01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:MCC0:BC01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:MCC0:BC01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:MCC0:BC01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:MCC0:BC01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:MCC0:BC01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:MCC0:BC01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:MCC0:BC01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:MCC0:BC01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:MCC0:BC01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:MCC0:BC01:HEARTBEATE09") {
  field(FLNK, "SIOC:MCC0:BC01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC01:HEARTBEATE08.B")
  field(INPB, "SIOC:MCC0:BC01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:MCC0:BC01:HEARTBEATE08") {
  field(FLNK, "SIOC:MCC0:BC01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC01:HEARTBEATE07.B")
  field(INPB, "SIOC:MCC0:BC01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:MCC0:BC01:HEARTBEATE07") {
  field(FLNK, "SIOC:MCC0:BC01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC01:HEARTBEATE06.B")
  field(INPB, "SIOC:MCC0:BC01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:MCC0:BC01:HEARTBEATE06") {
  field(FLNK, "SIOC:MCC0:BC01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC01:HEARTBEATE05.B")
  field(INPB, "SIOC:MCC0:BC01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:MCC0:BC01:HEARTBEATE05") {
  field(FLNK, "SIOC:MCC0:BC01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC01:HEARTBEATE04.B")
  field(INPB, "SIOC:MCC0:BC01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:MCC0:BC01:HEARTBEATE04") {
  field(FLNK, "SIOC:MCC0:BC01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC01:HEARTBEATE03.B")
  field(INPB, "SIOC:MCC0:BC01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:MCC0:BC01:HEARTBEATE03") {
  field(FLNK, "SIOC:MCC0:BC01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC01:HEARTBEATE02.B")
  field(INPB, "SIOC:MCC0:BC01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:MCC0:BC01:HEARTBEATE02") {
  field(FLNK, "SIOC:MCC0:BC01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC01:HEARTBEATE01.B")
  field(INPB, "SIOC:MCC0:BC01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:MCC0:BC01:HEARTBEATE01") {
  field(FLNK, "SIOC:MCC0:BC01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:MCC0:BC01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:MCC0:BC01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:MCC0:BC01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:MCC0:BC01:HEARTBEATSUM") {
  field(FLNK, "SIOC:MCC0:BC01:HEARTBEATCLC")
  field(INP, "SIOC:MCC0:BC01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:MCC0:BC01:HEARTBEATE10") {
  field(FLNK, "SIOC:MCC0:BC01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC01:HEARTBEATE09.B")
  field(INPB, "SIOC:MCC0:BC01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:MCC0:BC01:HEARTBEATERR") {
  field(FLNK, "SIOC:MCC0:BC01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:MCC0:BC01:HEARTBEATCALC.A")
  field(INPB, "SIOC:MCC0:BC01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:MCC0:BC01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:MCC0:BC01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:MCC0:BC01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:MCC0:BC02:INFO") {
  field(DESC, "SIOC:MCC0:BC02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:MCC0:BC02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:MCC0:BC02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:MCC0:BC02:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:MCC0:BC02:TODDIFF")
}

record(longin, "SIOC:MCC0:BC02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:MCC0:BC02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:MCC0:BC02:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:MCC0:BC02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:MCC0:BC02:TODCHECK.SEVR")
  field(INPB, "SIOC:MCC0:BC02:TODCHECK.VALB")
  field(FLNK, "SIOC:MCC0:BC02:TODSUM")
}

record(bo, "SIOC:MCC0:BC02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:MCC0:BC02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:MCC0:BC02:HEARTBEATCALC") {
  field(FLNK, "SIOC:MCC0:BC02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC02:HEARTBEAT CA MS")
  field(INPB, "SIOC:MCC0:BC02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:MCC0:BC02:HEARTBEATOK") {
  field(FLNK, "SIOC:MCC0:BC02:HEARTBEATE01")
  field(INP, "SIOC:MCC0:BC02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:MCC0:BC02:HEARTBEATECT") {
  field(FLNK, "SIOC:MCC0:BC02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:MCC0:BC02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:MCC0:BC02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:MCC0:BC02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:MCC0:BC02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:MCC0:BC02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:MCC0:BC02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:MCC0:BC02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:MCC0:BC02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:MCC0:BC02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:MCC0:BC02:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:MCC0:BC02:HEARTBEATE09") {
  field(FLNK, "SIOC:MCC0:BC02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC02:HEARTBEATE08.B")
  field(INPB, "SIOC:MCC0:BC02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:MCC0:BC02:HEARTBEATE08") {
  field(FLNK, "SIOC:MCC0:BC02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC02:HEARTBEATE07.B")
  field(INPB, "SIOC:MCC0:BC02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:MCC0:BC02:HEARTBEATE07") {
  field(FLNK, "SIOC:MCC0:BC02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC02:HEARTBEATE06.B")
  field(INPB, "SIOC:MCC0:BC02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:MCC0:BC02:HEARTBEATE06") {
  field(FLNK, "SIOC:MCC0:BC02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC02:HEARTBEATE05.B")
  field(INPB, "SIOC:MCC0:BC02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:MCC0:BC02:HEARTBEATE05") {
  field(FLNK, "SIOC:MCC0:BC02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC02:HEARTBEATE04.B")
  field(INPB, "SIOC:MCC0:BC02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:MCC0:BC02:HEARTBEATE04") {
  field(FLNK, "SIOC:MCC0:BC02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC02:HEARTBEATE03.B")
  field(INPB, "SIOC:MCC0:BC02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:MCC0:BC02:HEARTBEATE03") {
  field(FLNK, "SIOC:MCC0:BC02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC02:HEARTBEATE02.B")
  field(INPB, "SIOC:MCC0:BC02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:MCC0:BC02:HEARTBEATE02") {
  field(FLNK, "SIOC:MCC0:BC02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC02:HEARTBEATE01.B")
  field(INPB, "SIOC:MCC0:BC02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:MCC0:BC02:HEARTBEATE01") {
  field(FLNK, "SIOC:MCC0:BC02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:MCC0:BC02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:MCC0:BC02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:MCC0:BC02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:MCC0:BC02:HEARTBEATSUM") {
  field(FLNK, "SIOC:MCC0:BC02:HEARTBEATCLC")
  field(INP, "SIOC:MCC0:BC02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:MCC0:BC02:HEARTBEATE10") {
  field(FLNK, "SIOC:MCC0:BC02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:MCC0:BC02:HEARTBEATE09.B")
  field(INPB, "SIOC:MCC0:BC02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:MCC0:BC02:HEARTBEATERR") {
  field(FLNK, "SIOC:MCC0:BC02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:MCC0:BC02:HEARTBEATCALC.A")
  field(INPB, "SIOC:MCC0:BC02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:MCC0:BC02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:MCC0:BC02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:MCC0:BC02:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYSW:RM01:INFO") {
  field(DESC, "SIOC:SYSW:RM01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYSW:RM01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYSW:RM01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:SYSW:RM01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:SYSW:RM01:TODDIFF")
}

record(longin, "SIOC:SYSW:RM01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYSW:RM01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYSW:RM01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:SYSW:RM01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYSW:RM01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYSW:RM01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYSW:RM01:TODSUM")
}

record(bo, "SIOC:SYSW:RM01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYSW:RM01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYSW:RM01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYSW:RM01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYSW:RM01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYSW:RM01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYSW:RM01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYSW:RM01:HEARTBEATE01")
  field(INP, "SIOC:SYSW:RM01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYSW:RM01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYSW:RM01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYSW:RM01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYSW:RM01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYSW:RM01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYSW:RM01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYSW:RM01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYSW:RM01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYSW:RM01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYSW:RM01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYSW:RM01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYSW:RM01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:SYSW:RM01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYSW:RM01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYSW:RM01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYSW:RM01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYSW:RM01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYSW:RM01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYSW:RM01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYSW:RM01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYSW:RM01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYSW:RM01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYSW:RM01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYSW:RM01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYSW:RM01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYSW:RM01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYSW:RM01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYSW:RM01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYSW:RM01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYSW:RM01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYSW:RM01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYSW:RM01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYSW:RM01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYSW:RM01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYSW:RM01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYSW:RM01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYSW:RM01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYSW:RM01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYSW:RM01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYSW:RM01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYSW:RM01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYSW:RM01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYSW:RM01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYSW:RM01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYSW:RM01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYSW:RM01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYSW:RM01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYSW:RM01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYSW:RM01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYSW:RM01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYSW:RM01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYSW:RM01:HEARTBEATCLC")
  field(INP, "SIOC:SYSW:RM01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYSW:RM01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYSW:RM01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYSW:RM01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYSW:RM01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYSW:RM01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYSW:RM01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYSW:RM01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYSW:RM01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYSW:RM01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "RDMs, BSOICs")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYSW:RM01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "RDMs, BSOICs")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYSW:RM01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:RM01:INFO") {
  field(DESC, "SIOC:SYS0:RM01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:RM01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Janice Nelson (jnelson)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:RM01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:SYS0:RM01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:SYS0:RM01:TODDIFF")
}

record(longin, "SIOC:SYS0:RM01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:RM01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:RM01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:SYS0:RM01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:RM01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:RM01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:RM01:TODSUM")
}

record(bo, "SIOC:SYS0:RM01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:RM01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:RM01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:RM01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RM01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:RM01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:RM01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:RM01:HEARTBEATE01")
  field(INP, "SIOC:SYS0:RM01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:RM01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:RM01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:RM01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:RM01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:RM01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:RM01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:RM01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:RM01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:RM01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:RM01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:RM01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:RM01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:SYS0:RM01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:RM01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RM01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:RM01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:RM01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:RM01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RM01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:RM01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:RM01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:RM01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RM01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:RM01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:RM01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:RM01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RM01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:RM01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:RM01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:RM01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RM01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:RM01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:RM01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:RM01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RM01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:RM01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:RM01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:RM01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RM01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:RM01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:RM01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:RM01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RM01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:RM01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:RM01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:RM01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RM01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:RM01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:RM01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:RM01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:RM01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:RM01:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:RM01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:RM01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:RM01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RM01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:RM01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:RM01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:RM01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:RM01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:RM01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:RM01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Decarads")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:RM01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Decarads")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:RM01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:NP01:INFO") {
  field(DESC, "SIOC:SYS0:NP01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:NP01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Alex Montironi (alexmon)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:NP01: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:SYS0:NP01:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:NP01:TODDIFF")
}

record(longin, "SIOC:SYS0:NP01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:NP01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:NP01:TODCHECKVALID")
}

# If <ioc> 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:SYS0:NP01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:NP01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:NP01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:NP01:TODSUM")
}

record(bo, "SIOC:SYS0:NP01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:NP01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:NP01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:NP01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NP01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:NP01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:NP01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:NP01:HEARTBEATE01")
  field(INP, "SIOC:SYS0:NP01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:NP01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:NP01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:NP01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:NP01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:NP01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:NP01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:NP01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:NP01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:NP01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:NP01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:NP01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:NP01:HEARTBEATE10.VAL")
  field(HIHI, "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:SYS0:NP01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:NP01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NP01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:NP01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:NP01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:NP01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NP01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:NP01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:NP01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:NP01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NP01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:NP01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:NP01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:NP01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NP01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:NP01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:NP01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:NP01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NP01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:NP01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:NP01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:NP01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NP01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:NP01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:NP01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:NP01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NP01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:NP01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:NP01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:NP01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NP01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:NP01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:NP01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:NP01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NP01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:NP01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:NP01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:NP01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:NP01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:NP01:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:NP01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:NP01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:NP01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NP01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:NP01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:NP01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:NP01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:NP01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:NP01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:NP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "NIRP")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:NP01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "NIRP")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:NP01: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:SYS0:BA21:INFO") {
  field(DESC, "SIOC:SYS0:BA21 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:BA21:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Doug Murray (dmurray)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:BA21: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:SYS0:BA21:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:BA21:TODDIFF")
}

record(longin, "SIOC:SYS0:BA21:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:BA21:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:BA21:TODCHECKVALID")
}

# If <ioc> 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:SYS0:BA21:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:BA21:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:BA21:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:BA21:TODSUM")
}

record(bo, "SIOC:SYS0:BA21:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:BA21:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:BA21:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:BA21:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA21:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:BA21:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:BA21:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:BA21:HEARTBEATE01")
  field(INP, "SIOC:SYS0:BA21:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:BA21:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:BA21:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:BA21:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:BA21:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:BA21:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:BA21:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:BA21:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:BA21:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:BA21:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:BA21:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:BA21:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:BA21:HEARTBEATE10.VAL")
  field(HIHI, "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:SYS0:BA21:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:BA21:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA21:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:BA21:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:BA21:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:BA21:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA21:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:BA21:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:BA21:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:BA21:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA21:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:BA21:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:BA21:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:BA21:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA21:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:BA21:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:BA21:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:BA21:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA21:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:BA21:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:BA21:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:BA21:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA21:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:BA21:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:BA21:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:BA21:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA21:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:BA21:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:BA21:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:BA21:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA21:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:BA21:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:BA21:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:BA21:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA21:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:BA21:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:BA21:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:BA21:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:BA21:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:BA21:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:BA21:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:BA21:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:BA21:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA21:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:BA21:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:BA21:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:BA21:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:BA21:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:BA21:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:BA21:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "BSA Service for ScHXR")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:BA21:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "BSA Service for ScHXR")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:BA21:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:BA22:INFO") {
  field(DESC, "SIOC:SYS0:BA22 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:BA22:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Doug Murray (dmurray)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:BA22: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:SYS0:BA22:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:BA22:TODDIFF")
}

record(longin, "SIOC:SYS0:BA22:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:BA22:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:BA22:TODCHECKVALID")
}

# If <ioc> 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:SYS0:BA22:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:BA22:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:BA22:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:BA22:TODSUM")
}

record(bo, "SIOC:SYS0:BA22:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:BA22:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:BA22:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:BA22:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA22:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:BA22:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:BA22:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:BA22:HEARTBEATE01")
  field(INP, "SIOC:SYS0:BA22:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:BA22:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:BA22:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:BA22:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:BA22:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:BA22:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:BA22:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:BA22:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:BA22:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:BA22:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:BA22:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:BA22:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:BA22:HEARTBEATE10.VAL")
  field(HIHI, "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:SYS0:BA22:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:BA22:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA22:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:BA22:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:BA22:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:BA22:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA22:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:BA22:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:BA22:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:BA22:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA22:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:BA22:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:BA22:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:BA22:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA22:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:BA22:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:BA22:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:BA22:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA22:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:BA22:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:BA22:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:BA22:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA22:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:BA22:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:BA22:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:BA22:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA22:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:BA22:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:BA22:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:BA22:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA22:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:BA22:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:BA22:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:BA22:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA22:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:BA22:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:BA22:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:BA22:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:BA22:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:BA22:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:BA22:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:BA22:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:BA22:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA22:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:BA22:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:BA22:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:BA22:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:BA22:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:BA22:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:BA22:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "BSA Service for ScXSR")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:BA22:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "BSA Service for ScXSR")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:BA22:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:OP05:INFO") {
  field(DESC, "SIOC:SYS0:OP05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:OP05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Tasha Summers (tsummers)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS0:OP05: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:SYS0:OP05:TOD CA")
  field(INPC, "10")
# VALA holds 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:SYS0:OP05:TODDIFF")
}

record(longin, "SIOC:SYS0:OP05:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:OP05:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:OP05:TODCHECKVALID")
}

# If <ioc> 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:SYS0:OP05:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:OP05:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:OP05:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:OP05:TODSUM")
}

record(bo, "SIOC:SYS0:OP05:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:OP05:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:OP05:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:OP05:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP05:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:OP05:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:OP05:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:OP05:HEARTBEATE01")
  field(INP, "SIOC:SYS0:OP05:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:OP05:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:OP05:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:OP05:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:OP05:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:OP05:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:OP05:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:OP05:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:OP05:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:OP05:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:OP05:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:OP05:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:OP05:HEARTBEATE10.VAL")
  field(HIHI, "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:SYS0:OP05:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:OP05:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP05:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:OP05:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:OP05:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:OP05:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP05:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:OP05:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:OP05:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:OP05:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP05:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:OP05:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:OP05:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:OP05:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP05:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:OP05:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:OP05:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:OP05:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP05:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:OP05:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:OP05:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:OP05:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP05:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:OP05:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:OP05:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:OP05:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP05:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:OP05:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:OP05:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:OP05:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP05:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:OP05:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:OP05:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:OP05:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP05:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:OP05:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:OP05:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:OP05:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:OP05:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:OP05:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:OP05:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:OP05:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:OP05:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP05:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:OP05:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:OP05:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:OP05:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:OP05:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:OP05:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:OP05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "SC Operations Support")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:OP05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "SC Operations Support")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:OP05:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

