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

record(stringin, "IOC:B15:MG01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Kristi Luchini (luchini)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B15:MG01:LOC") {
  field(PINI, "YES")
  field(VAL, "B15-123-0433-S1")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B34:MC01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Kristi Luchini (luchini)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B34:MC01:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-MCR-0117")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B081:MC01: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, "IOC:B081:MC01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:B081:MC01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "IOC:B081:MC01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B081:MC01:LOC") {
  field(PINI, "YES")
  field(VAL, "B81-114")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B081:MC02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Kristi Luchini (luchini)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B081:MC02:LOC") {
  field(PINI, "YES")
  field(VAL, "B81-121")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B081:MC03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Ken Lauer (klauer)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(calc, "116-IOCCAMAC:HEARTBEATE08") {
  field(FLNK, "116-IOCCAMAC:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "116-IOCCAMAC:HEARTBEATE07.B")
  field(INPB, "116-IOCCAMAC:HEARTBEATE08.VAL")
}

record(calc, "116-IOCCAMAC:HEARTBEATE07") {
  field(FLNK, "116-IOCCAMAC:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "116-IOCCAMAC:HEARTBEATE06.B")
  field(INPB, "116-IOCCAMAC:HEARTBEATE07.VAL")
}

record(calc, "116-IOCCAMAC:HEARTBEATE06") {
  field(FLNK, "116-IOCCAMAC:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "116-IOCCAMAC:HEARTBEATE05.B")
  field(INPB, "116-IOCCAMAC:HEARTBEATE06.VAL")
}

record(calc, "116-IOCCAMAC:HEARTBEATE05") {
  field(FLNK, "116-IOCCAMAC:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "116-IOCCAMAC:HEARTBEATE04.B")
  field(INPB, "116-IOCCAMAC:HEARTBEATE05.VAL")
}

record(calc, "116-IOCCAMAC:HEARTBEATE04") {
  field(FLNK, "116-IOCCAMAC:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "116-IOCCAMAC:HEARTBEATE03.B")
  field(INPB, "116-IOCCAMAC:HEARTBEATE04.VAL")
}

record(calc, "116-IOCCAMAC:HEARTBEATE03") {
  field(FLNK, "116-IOCCAMAC:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "116-IOCCAMAC:HEARTBEATE02.B")
  field(INPB, "116-IOCCAMAC:HEARTBEATE03.VAL")
}

record(calc, "116-IOCCAMAC:HEARTBEATE02") {
  field(FLNK, "116-IOCCAMAC:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "116-IOCCAMAC:HEARTBEATE01.B")
  field(INPB, "116-IOCCAMAC:HEARTBEATE02.VAL")
}

record(calc, "116-IOCCAMAC:HEARTBEATE01") {
  field(FLNK, "116-IOCCAMAC:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "116-IOCCAMAC:HEARTBEATERR.VAL")
  field(INPB, "116-IOCCAMAC:HEARTBEATE01.VAL")
}

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

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

record(calc, "116-IOCCAMAC:HEARTBEATE10") {
  field(FLNK, "116-IOCCAMAC:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "116-IOCCAMAC:HEARTBEATE09.B")
  field(INPB, "116-IOCCAMAC:HEARTBEATE10.VAL")
}

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

record(stringin, "116-IOCCAMAC:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

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

record(stringin, "116-IOCCAMAC:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM251-204-15")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B34:CV01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Kristi Luchini (luchini)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

record(calc, "IOC:B34:CV01:HEARTBEATE09") {
  field(FLNK, "IOC:B34:CV01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:B34:CV01:HEARTBEATE08.B")
  field(INPB, "IOC:B34:CV01:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B34:CV01:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM251-204-15")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B34:PM01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

record(calc, "IOC:B34:PM01:HEARTBEATE09") {
  field(FLNK, "IOC:B34:PM01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:B34:PM01:HEARTBEATE08.B")
  field(INPB, "IOC:B34:PM01:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B34:PM01:LOC") {
  field(PINI, "YES")
  field(VAL, "B24-100-C")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B34:RF01: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, "IOC:B34:RF01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:B34:RF01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "IOC:B34:RF01:TODDIFF")
}

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

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

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

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

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

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

record(calc, "IOC:B34:RF01:HEARTBEATE09") {
  field(FLNK, "IOC:B34:RF01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:B34:RF01:HEARTBEATE08.B")
  field(INPB, "IOC:B34:RF01:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B34:RF01:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM252-201-10")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B44:RF01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

record(calc, "IOC:B44:RF01:HEARTBEATE09") {
  field(FLNK, "IOC:B44:RF01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:B44:RF01:HEARTBEATE08.B")
  field(INPB, "IOC:B44:RF01:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B44:RF01:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RF-LAB")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B44:RF03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

record(calc, "IOC:B44:RF03:HEARTBEATE09") {
  field(FLNK, "IOC:B44:RF03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:B44:RF03:HEARTBEATE08.B")
  field(INPB, "IOC:B44:RF03:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B44:RF03:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RF-LAB")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B34:EG01: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, "IOC:B34:EG01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:B34:EG01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "IOC:B34:EG01:TODDIFF")
}

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

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

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

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

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

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

record(calc, "IOC:B34:EG01:HEARTBEATE09") {
  field(FLNK, "IOC:B34:EG01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:B34:EG01:HEARTBEATE08.B")
  field(INPB, "IOC:B34:EG01:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B34:EG01:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM252-LAB")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B34:EV01: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, "IOC:B34:EV01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:B34:EV01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "IOC:B34:EV01:TODDIFF")
}

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

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

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

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

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

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

record(calc, "IOC:B34:EV01:HEARTBEATE09") {
  field(FLNK, "IOC:B34:EV01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:B34:EV01:HEARTBEATE08.B")
  field(INPB, "IOC:B34:EV01:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B34:EV01:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM252-201-19")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:IN20:EV01: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, "IOC:IN20:EV01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:IN20:EV01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "IOC:IN20:EV01:TODDIFF")
}

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

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

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

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

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

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

record(calc, "IOC:IN20:EV01:HEARTBEATE09") {
  field(FLNK, "IOC:IN20:EV01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:IN20:EV01:HEARTBEATE08.B")
  field(INPB, "IOC:IN20:EV01:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:EV01:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM134-212-24")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B34:EV02: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, "IOC:B34:EV02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:B34:EV02:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "IOC:B34:EV02:TODDIFF")
}

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

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

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

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

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

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

record(calc, "IOC:B34:EV02:HEARTBEATE09") {
  field(FLNK, "IOC:B34:EV02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:B34:EV02:HEARTBEATE08.B")
  field(INPB, "IOC:B34:EV02:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B34:EV02:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM252-201-24")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B34:MP01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Matt Boyes (mboyes)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

record(calc, "IOC:B34:MP01:HEARTBEATE09") {
  field(FLNK, "IOC:B34:MP01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:B34:MP01:HEARTBEATE08.B")
  field(INPB, "IOC:B34:MP01:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B34:MP01:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM252-201-34")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B34:MP05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Robert Hoffman (rhoffman)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

record(calc, "IOC:B34:MP05:HEARTBEATE09") {
  field(FLNK, "IOC:B34:MP05:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:B34:MP05:HEARTBEATE08.B")
  field(INPB, "IOC:B34:MP05:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B34:MP05:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM252-LAB")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

record(calc, "IOC:B34:BP01:HEARTBEATE09") {
  field(FLNK, "IOC:B34:BP01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:B34:BP01:HEARTBEATE08.B")
  field(INPB, "IOC:B34:BP01:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B34:BP01:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM253-202-33")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B34:BP03:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM197-LAB")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B34:BD01: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, "IOC:B34:BD01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:B34:BD01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "IOC:B34:BD01:TODDIFF")
}

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

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

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

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

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

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

record(calc, "IOC:B34:BD01:HEARTBEATE09") {
  field(FLNK, "IOC:B34:BD01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:B34:BD01:HEARTBEATE08.B")
  field(INPB, "IOC:B34:BD01:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B34:BD01:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM253-202-34")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B34:FB01: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, "IOC:B34:FB01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "IOC:B34:FB01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "IOC:B34:FB01:TODDIFF")
}

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

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

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

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

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

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

record(calc, "IOC:B34:FB01:HEARTBEATE09") {
  field(FLNK, "IOC:B34:FB01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:B34:FB01:HEARTBEATE08.B")
  field(INPB, "IOC:B34:FB01:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B34:FB01:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM253-202-32")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

record(calc, "IOC:B34:BL01:HEARTBEATE09") {
  field(FLNK, "IOC:B34:BL01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:B34:BL01:HEARTBEATE08.B")
  field(INPB, "IOC:B34:BL01:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B34:BL01:LOC") {
  field(PINI, "YES")
  field(VAL, "B034-21330")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B34:CD01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Matjaz Kobal (mkobal)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

record(calc, "IOC:B34:CD01:HEARTBEATE09") {
  field(FLNK, "IOC:B34:CD01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:B34:CD01:HEARTBEATE08.B")
  field(INPB, "IOC:B34:CD01:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B34:CD01:LOC") {
  field(PINI, "YES")
  field(VAL, "B34")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B685:CD01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Ernest Williams (ernesto)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

record(calc, "IOC:B685:CD01:HEARTBEATE09") {
  field(FLNK, "IOC:B685:CD01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:B685:CD01:HEARTBEATE08.B")
  field(INPB, "IOC:B685:CD01:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B685:CD01:LOC") {
  field(PINI, "YES")
  field(VAL, "B685-08CP-24")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:UND1:UC34:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Arturo Alarcon (alarcon)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

record(calc, "IOC:UND1:UC34:HEARTBEATE09") {
  field(FLNK, "IOC:UND1:UC34:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "IOC:UND1:UC34:HEARTBEATE08.B")
  field(INPB, "IOC:UND1:UC34:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:UND1:UC34:LOC") {
  field(PINI, "YES")
  field(VAL, "B406")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:B406:MC01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Ziga Oven (zoven)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B406:MC01:LOC") {
  field(PINI, "YES")
  field(VAL, "B034-216-24")
  info(autosaveFields,"VAL")
}

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

record(stringin, "EIOC:B34:RC11: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, "EIOC:B34:RC11:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:B34:RC11:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "EIOC:B34:RC11:TODDIFF")
}

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

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

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

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

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

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

record(calc, "EIOC:B34:RC11:HEARTBEATE09") {
  field(FLNK, "EIOC:B34:RC11:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:B34:RC11:HEARTBEATE08.B")
  field(INPB, "EIOC:B34:RC11:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:B34:RC11:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM253-202-14")
  info(autosaveFields,"VAL")
}

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

record(stringin, "EIOC:B34:RD11: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, "EIOC:B34:RD11:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:B34:RD11:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "EIOC:B34:RD11:TODDIFF")
}

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

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

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

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

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

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

record(calc, "EIOC:B34:RD11:HEARTBEATE09") {
  field(FLNK, "EIOC:B34:RD11:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:B34:RD11:HEARTBEATE08.B")
  field(INPB, "EIOC:B34:RD11:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:B34:RD11:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM253-202-10")
  info(autosaveFields,"VAL")
}

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

record(stringin, "EIOC:B34:BP233:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

record(calc, "EIOC:B34:BP233:HEARTBEATE09") {
  field(FLNK, "EIOC:B34:BP233:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:B34:BP233:HEARTBEATE08.B")
  field(INPB, "EIOC:B34:BP233:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:B34:BP233:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM253-202-30")
  info(autosaveFields,"VAL")
}

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

record(stringin, "EIOC:B34:RC08: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, "EIOC:B34:RC08:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:B34:RC08:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "EIOC:B34:RC08:TODDIFF")
}

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

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

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

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

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

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

record(calc, "EIOC:B34:RC08:HEARTBEATE09") {
  field(FLNK, "EIOC:B34:RC08:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:B34:RC08:HEARTBEATE08.B")
  field(INPB, "EIOC:B34:RC08:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:B34:RC08:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM253-202-22")
  info(autosaveFields,"VAL")
}

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

record(stringin, "EIOC:B34:RD06: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, "EIOC:B34:RD06:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:B34:RD06:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "EIOC:B34:RD06:TODDIFF")
}

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

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

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

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

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

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

record(calc, "EIOC:B34:RD06:HEARTBEATE09") {
  field(FLNK, "EIOC:B34:RD06:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:B34:RD06:HEARTBEATE08.B")
  field(INPB, "EIOC:B34:RD06:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:B34:RD06:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM253-202-18")
  info(autosaveFields,"VAL")
}

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

record(stringin, "EIOC:B34:BL01: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, "EIOC:B34:BL01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:B34:BL01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "EIOC:B34:BL01:TODDIFF")
}

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

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

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

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

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

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

record(calc, "EIOC:B34:BL01:HEARTBEATE09") {
  field(FLNK, "EIOC:B34:BL01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:B34:BL01:HEARTBEATE08.B")
  field(INPB, "EIOC:B34:BL01:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:B34:BL01:LOC") {
  field(PINI, "YES")
  field(VAL, "B034-21330")
  info(autosaveFields,"VAL")
}

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

record(stringin, "EIOC:B044:TSD01: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, "EIOC:B044:TSD01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:B044:TSD01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "EIOC:B044:TSD01:TODDIFF")
}

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

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

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

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

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

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

record(calc, "EIOC:B044:TSD01:HEARTBEATE09") {
  field(FLNK, "EIOC:B044:TSD01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:B044:TSD01:HEARTBEATE08.B")
  field(INPB, "EIOC:B044:TSD01:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:B044:TSD01:LOC") {
  field(PINI, "YES")
  field(VAL, "B44-KlysLab-TS01")
  info(autosaveFields,"VAL")
}

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

record(stringin, "EIOC:B044:TSD04: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, "EIOC:B044:TSD04:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:B044:TSD04:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "EIOC:B044:TSD04:TODDIFF")
}

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

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

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

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

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

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

record(calc, "EIOC:B044:TSD04:HEARTBEATE09") {
  field(FLNK, "EIOC:B044:TSD04:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:B044:TSD04:HEARTBEATE08.B")
  field(INPB, "EIOC:B044:TSD04:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:B044:TSD04:LOC") {
  field(PINI, "YES")
  field(VAL, "B44-KlysLab-TS04")
  info(autosaveFields,"VAL")
}

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

record(stringin, "EIOC:B044:TSD05: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, "EIOC:B044:TSD05:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:B044:TSD05:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "EIOC:B044:TSD05:TODDIFF")
}

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

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

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

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

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

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

record(calc, "EIOC:B044:TSD05:HEARTBEATE09") {
  field(FLNK, "EIOC:B044:TSD05:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:B044:TSD05:HEARTBEATE08.B")
  field(INPB, "EIOC:B044:TSD05:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:B044:TSD05:LOC") {
  field(PINI, "YES")
  field(VAL, "B44-KlysLab-TS05")
  info(autosaveFields,"VAL")
}

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

record(stringin, "EIOC:B044:TSD11: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, "EIOC:B044:TSD11:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:B044:TSD11:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "EIOC:B044:TSD11:TODDIFF")
}

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

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

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

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

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

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

record(calc, "EIOC:B044:TSD11:HEARTBEATE09") {
  field(FLNK, "EIOC:B044:TSD11:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:B044:TSD11:HEARTBEATE08.B")
  field(INPB, "EIOC:B044:TSD11:HEARTBEATE09.VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:B044:TSD11:LOC") {
  field(PINI, "YES")
  field(VAL, "B44-KlysLab-TS11")
  info(autosaveFields,"VAL")
}

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

record(stringin, "EIOC:B044:TSC11: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, "EIOC:B044:TSC11:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:B044:TSC11:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "EIOC:B044:TSC11:TODDIFF")
}

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

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

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

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

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

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

record(calc, "EIOC:B044:TSC11:HEARTBEATE09") {
  field(FLNK, "EIOC:B044:TSC11:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:B044:TSC11:HEARTBEATE08.B")
  field(INPB, "EIOC:B044:TSC11:HEARTBEATE09.VAL")
}

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

record(calc, "EIOC:B044:TSC11:HEARTBEATE07") {
  field(FLNK, "EIOC:B044:TSC11:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:B044:TSC11:HEARTBEATE06.B")
  field(INPB, "EIOC:B044:TSC11:HEARTBEATE07.VAL")
}

record(calc, "EIOC:B044:TSC11:HEARTBEATE06") {
  field(FLNK, "EIOC:B044:TSC11:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:B044:TSC11:HEARTBEATE05.B")
  field(INPB, "EIOC:B044:TSC11:HEARTBEATE06.VAL")
}

record(calc, "EIOC:B044:TSC11:HEARTBEATE05") {
  field(FLNK, "EIOC:B044:TSC11:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:B044:TSC11:HEARTBEATE04.B")
  field(INPB, "EIOC:B044:TSC11:HEARTBEATE05.VAL")
}

record(calc, "EIOC:B044:TSC11:HEARTBEATE04") {
  field(FLNK, "EIOC:B044:TSC11:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:B044:TSC11:HEARTBEATE03.B")
  field(INPB, "EIOC:B044:TSC11:HEARTBEATE04.VAL")
}

record(calc, "EIOC:B044:TSC11:HEARTBEATE03") {
  field(FLNK, "EIOC:B044:TSC11:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:B044:TSC11:HEARTBEATE02.B")
  field(INPB, "EIOC:B044:TSC11:HEARTBEATE03.VAL")
}

record(calc, "EIOC:B044:TSC11:HEARTBEATE02") {
  field(FLNK, "EIOC:B044:TSC11:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:B044:TSC11:HEARTBEATE01.B")
  field(INPB, "EIOC:B044:TSC11:HEARTBEATE02.VAL")
}

record(calc, "EIOC:B044:TSC11:HEARTBEATE01") {
  field(FLNK, "EIOC:B044:TSC11:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:B044:TSC11:HEARTBEATERR.VAL")
  field(INPB, "EIOC:B044:TSC11:HEARTBEATE01.VAL")
}

record(calc, "EIOC:B044:TSC11:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:B044:TSC11:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:B044:TSC11:HEARTBEATSUM") {
  field(FLNK, "EIOC:B044:TSC11:HEARTBEATCLC")
  field(INP, "EIOC:B044:TSC11:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:B044:TSC11:HEARTBEATE10") {
  field(FLNK, "EIOC:B044:TSC11:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:B044:TSC11:HEARTBEATE09.B")
  field(INPB, "EIOC:B044:TSC11:HEARTBEATE10.VAL")
}

record(calc, "EIOC:B044:TSC11:HEARTBEATERR") {
  field(FLNK, "EIOC:B044:TSC11:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:B044:TSC11:HEARTBEATCALC.A")
  field(INPB, "EIOC:B044:TSC11:HEARTBEATCALC.B")
}

record(stringin, "EIOC:B044:TSC11:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:B044:TSC11:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:B044:TSC11:LOC") {
  field(PINI, "YES")
  field(VAL, "B44-KlysLab-TS11")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "EIOC:UND1:MP14:INFO") {
  field(DESC, "EIOC:UND1:MP14 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:UND1:MP14:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Luciano Piccoli (lpiccoli)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:UND1:MP14:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:UND1:MP14:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "EIOC:UND1:MP14:TODDIFF")
}

record(longin, "EIOC:UND1:MP14:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:UND1:MP14:TODCHECK.VALA MS")
  field(FLNK, "EIOC:UND1:MP14:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "EIOC:UND1:MP14:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:UND1:MP14:TODCHECK.SEVR")
  field(INPB, "EIOC:UND1:MP14:TODCHECK.VALB")
  field(FLNK, "EIOC:UND1:MP14:TODSUM")
}

record(bo, "EIOC:UND1:MP14:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:UND1:MP14:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:UND1:MP14:HEARTBEATCALC") {
  field(FLNK, "EIOC:UND1:MP14:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:UND1:MP14:HEARTBEAT CA MS")
  field(INPB, "EIOC:UND1:MP14:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:UND1:MP14:HEARTBEATOK") {
  field(FLNK, "EIOC:UND1:MP14:HEARTBEATE01")
  field(INP, "EIOC:UND1:MP14:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:UND1:MP14:HEARTBEATECT") {
  field(FLNK, "EIOC:UND1:MP14:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:UND1:MP14:HEARTBEATE01.VAL")
  field(INPB, "EIOC:UND1:MP14:HEARTBEATE02.VAL")
  field(INPC, "EIOC:UND1:MP14:HEARTBEATE03.VAL")
  field(INPD, "EIOC:UND1:MP14:HEARTBEATE04.VAL")
  field(INPE, "EIOC:UND1:MP14:HEARTBEATE05.VAL")
  field(INPF, "EIOC:UND1:MP14:HEARTBEATE06.VAL")
  field(INPG, "EIOC:UND1:MP14:HEARTBEATE07.VAL")
  field(INPH, "EIOC:UND1:MP14:HEARTBEATE08.VAL")
  field(INPI, "EIOC:UND1:MP14:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:UND1:MP14:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "EIOC:UND1:MP14:HEARTBEATE09") {
  field(FLNK, "EIOC:UND1:MP14:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:UND1:MP14:HEARTBEATE08.B")
  field(INPB, "EIOC:UND1:MP14:HEARTBEATE09.VAL")
}

record(calc, "EIOC:UND1:MP14:HEARTBEATE08") {
  field(FLNK, "EIOC:UND1:MP14:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:UND1:MP14:HEARTBEATE07.B")
  field(INPB, "EIOC:UND1:MP14:HEARTBEATE08.VAL")
}

record(calc, "EIOC:UND1:MP14:HEARTBEATE07") {
  field(FLNK, "EIOC:UND1:MP14:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:UND1:MP14:HEARTBEATE06.B")
  field(INPB, "EIOC:UND1:MP14:HEARTBEATE07.VAL")
}

record(calc, "EIOC:UND1:MP14:HEARTBEATE06") {
  field(FLNK, "EIOC:UND1:MP14:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:UND1:MP14:HEARTBEATE05.B")
  field(INPB, "EIOC:UND1:MP14:HEARTBEATE06.VAL")
}

record(calc, "EIOC:UND1:MP14:HEARTBEATE05") {
  field(FLNK, "EIOC:UND1:MP14:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:UND1:MP14:HEARTBEATE04.B")
  field(INPB, "EIOC:UND1:MP14:HEARTBEATE05.VAL")
}

record(calc, "EIOC:UND1:MP14:HEARTBEATE04") {
  field(FLNK, "EIOC:UND1:MP14:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:UND1:MP14:HEARTBEATE03.B")
  field(INPB, "EIOC:UND1:MP14:HEARTBEATE04.VAL")
}

record(calc, "EIOC:UND1:MP14:HEARTBEATE03") {
  field(FLNK, "EIOC:UND1:MP14:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:UND1:MP14:HEARTBEATE02.B")
  field(INPB, "EIOC:UND1:MP14:HEARTBEATE03.VAL")
}

record(calc, "EIOC:UND1:MP14:HEARTBEATE02") {
  field(FLNK, "EIOC:UND1:MP14:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:UND1:MP14:HEARTBEATE01.B")
  field(INPB, "EIOC:UND1:MP14:HEARTBEATE02.VAL")
}

record(calc, "EIOC:UND1:MP14:HEARTBEATE01") {
  field(FLNK, "EIOC:UND1:MP14:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:UND1:MP14:HEARTBEATERR.VAL")
  field(INPB, "EIOC:UND1:MP14:HEARTBEATE01.VAL")
}

record(calc, "EIOC:UND1:MP14:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:UND1:MP14:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:UND1:MP14:HEARTBEATSUM") {
  field(FLNK, "EIOC:UND1:MP14:HEARTBEATCLC")
  field(INP, "EIOC:UND1:MP14:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:UND1:MP14:HEARTBEATE10") {
  field(FLNK, "EIOC:UND1:MP14:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:UND1:MP14:HEARTBEATE09.B")
  field(INPB, "EIOC:UND1:MP14:HEARTBEATE10.VAL")
}

record(calc, "EIOC:UND1:MP14:HEARTBEATERR") {
  field(FLNK, "EIOC:UND1:MP14:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:UND1:MP14:HEARTBEATCALC.A")
  field(INPB, "EIOC:UND1:MP14:HEARTBEATCALC.B")
}

record(stringin, "EIOC:UND1:MP14:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LN37")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:UND1:MP14:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LN37")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:UND1:MP14:LOC") {
  field(PINI, "YES")
  field(VAL, "B034-21431")
  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:B15:MG01:INFO") {
  field(DESC, "SIOC:B15:MG01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B15:MG01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Kristi Luchini (luchini)")
  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:B15:MG01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:B15:MG01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:B15:MG01:TODDIFF")
}

record(longin, "SIOC:B15:MG01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:B15:MG01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:B15:MG01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:B15:MG01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:B15:MG01:TODCHECK.SEVR")
  field(INPB, "SIOC:B15:MG01:TODCHECK.VALB")
  field(FLNK, "SIOC:B15:MG01:TODSUM")
}

record(bo, "SIOC:B15:MG01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:B15:MG01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:B15:MG01:HEARTBEATCALC") {
  field(FLNK, "SIOC:B15:MG01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG01:HEARTBEAT CA MS")
  field(INPB, "SIOC:B15:MG01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:B15:MG01:HEARTBEATOK") {
  field(FLNK, "SIOC:B15:MG01:HEARTBEATE01")
  field(INP, "SIOC:B15:MG01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:B15:MG01:HEARTBEATECT") {
  field(FLNK, "SIOC:B15:MG01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:B15:MG01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:B15:MG01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:B15:MG01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:B15:MG01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:B15:MG01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:B15:MG01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:B15:MG01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:B15:MG01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:B15:MG01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:B15:MG01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:B15:MG01:HEARTBEATE09") {
  field(FLNK, "SIOC:B15:MG01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG01:HEARTBEATE08.B")
  field(INPB, "SIOC:B15:MG01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:B15:MG01:HEARTBEATE08") {
  field(FLNK, "SIOC:B15:MG01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG01:HEARTBEATE07.B")
  field(INPB, "SIOC:B15:MG01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:B15:MG01:HEARTBEATE07") {
  field(FLNK, "SIOC:B15:MG01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG01:HEARTBEATE06.B")
  field(INPB, "SIOC:B15:MG01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:B15:MG01:HEARTBEATE06") {
  field(FLNK, "SIOC:B15:MG01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG01:HEARTBEATE05.B")
  field(INPB, "SIOC:B15:MG01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:B15:MG01:HEARTBEATE05") {
  field(FLNK, "SIOC:B15:MG01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG01:HEARTBEATE04.B")
  field(INPB, "SIOC:B15:MG01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:B15:MG01:HEARTBEATE04") {
  field(FLNK, "SIOC:B15:MG01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG01:HEARTBEATE03.B")
  field(INPB, "SIOC:B15:MG01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:B15:MG01:HEARTBEATE03") {
  field(FLNK, "SIOC:B15:MG01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG01:HEARTBEATE02.B")
  field(INPB, "SIOC:B15:MG01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:B15:MG01:HEARTBEATE02") {
  field(FLNK, "SIOC:B15:MG01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG01:HEARTBEATE01.B")
  field(INPB, "SIOC:B15:MG01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:B15:MG01:HEARTBEATE01") {
  field(FLNK, "SIOC:B15:MG01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:B15:MG01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:B15:MG01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:B15:MG01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:B15:MG01:HEARTBEATSUM") {
  field(FLNK, "SIOC:B15:MG01:HEARTBEATCLC")
  field(INP, "SIOC:B15:MG01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:B15:MG01:HEARTBEATE10") {
  field(FLNK, "SIOC:B15:MG01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG01:HEARTBEATE09.B")
  field(INPB, "SIOC:B15:MG01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:B15:MG01:HEARTBEATERR") {
  field(FLNK, "SIOC:B15:MG01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:B15:MG01:HEARTBEATCALC.A")
  field(INPB, "SIOC:B15:MG01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:B15:MG01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:B15:MG01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B15:MG01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:B34:MG01:INFO") {
  field(DESC, "SIOC:B34:MG01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B34:MG01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Kristi Luchini (luchini)")
  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:B34:MG01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:B34:MG01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:B34:MG01:TODDIFF")
}

record(longin, "SIOC:B34:MG01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:B34:MG01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:B34:MG01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:B34:MG01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:B34:MG01:TODCHECK.SEVR")
  field(INPB, "SIOC:B34:MG01:TODCHECK.VALB")
  field(FLNK, "SIOC:B34:MG01:TODSUM")
}

record(bo, "SIOC:B34:MG01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:B34:MG01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:B34:MG01:HEARTBEATCALC") {
  field(FLNK, "SIOC:B34:MG01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG01:HEARTBEAT CA MS")
  field(INPB, "SIOC:B34:MG01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:B34:MG01:HEARTBEATOK") {
  field(FLNK, "SIOC:B34:MG01:HEARTBEATE01")
  field(INP, "SIOC:B34:MG01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:B34:MG01:HEARTBEATECT") {
  field(FLNK, "SIOC:B34:MG01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:B34:MG01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:B34:MG01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:B34:MG01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:B34:MG01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:B34:MG01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:B34:MG01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:B34:MG01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:B34:MG01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:B34:MG01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:B34:MG01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:B34:MG01:HEARTBEATE09") {
  field(FLNK, "SIOC:B34:MG01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG01:HEARTBEATE08.B")
  field(INPB, "SIOC:B34:MG01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:B34:MG01:HEARTBEATE08") {
  field(FLNK, "SIOC:B34:MG01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG01:HEARTBEATE07.B")
  field(INPB, "SIOC:B34:MG01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:B34:MG01:HEARTBEATE07") {
  field(FLNK, "SIOC:B34:MG01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG01:HEARTBEATE06.B")
  field(INPB, "SIOC:B34:MG01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:B34:MG01:HEARTBEATE06") {
  field(FLNK, "SIOC:B34:MG01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG01:HEARTBEATE05.B")
  field(INPB, "SIOC:B34:MG01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:B34:MG01:HEARTBEATE05") {
  field(FLNK, "SIOC:B34:MG01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG01:HEARTBEATE04.B")
  field(INPB, "SIOC:B34:MG01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:B34:MG01:HEARTBEATE04") {
  field(FLNK, "SIOC:B34:MG01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG01:HEARTBEATE03.B")
  field(INPB, "SIOC:B34:MG01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:B34:MG01:HEARTBEATE03") {
  field(FLNK, "SIOC:B34:MG01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG01:HEARTBEATE02.B")
  field(INPB, "SIOC:B34:MG01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:B34:MG01:HEARTBEATE02") {
  field(FLNK, "SIOC:B34:MG01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG01:HEARTBEATE01.B")
  field(INPB, "SIOC:B34:MG01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:B34:MG01:HEARTBEATE01") {
  field(FLNK, "SIOC:B34:MG01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:B34:MG01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:B34:MG01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:B34:MG01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:B34:MG01:HEARTBEATSUM") {
  field(FLNK, "SIOC:B34:MG01:HEARTBEATCLC")
  field(INP, "SIOC:B34:MG01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:B34:MG01:HEARTBEATE10") {
  field(FLNK, "SIOC:B34:MG01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG01:HEARTBEATE09.B")
  field(INPB, "SIOC:B34:MG01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:B34:MG01:HEARTBEATERR") {
  field(FLNK, "SIOC:B34:MG01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:B34:MG01:HEARTBEATCALC.A")
  field(INPB, "SIOC:B34:MG01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:B34:MG01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:B34:MG01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B34:MG01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:B34:MG02:INFO") {
  field(DESC, "SIOC:B34:MG02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B34:MG02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Kristi Luchini (luchini)")
  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:B34:MG02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:B34:MG02:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:B34:MG02:TODDIFF")
}

record(longin, "SIOC:B34:MG02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:B34:MG02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:B34:MG02:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:B34:MG02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:B34:MG02:TODCHECK.SEVR")
  field(INPB, "SIOC:B34:MG02:TODCHECK.VALB")
  field(FLNK, "SIOC:B34:MG02:TODSUM")
}

record(bo, "SIOC:B34:MG02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:B34:MG02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:B34:MG02:HEARTBEATCALC") {
  field(FLNK, "SIOC:B34:MG02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG02:HEARTBEAT CA MS")
  field(INPB, "SIOC:B34:MG02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:B34:MG02:HEARTBEATOK") {
  field(FLNK, "SIOC:B34:MG02:HEARTBEATE01")
  field(INP, "SIOC:B34:MG02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:B34:MG02:HEARTBEATECT") {
  field(FLNK, "SIOC:B34:MG02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:B34:MG02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:B34:MG02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:B34:MG02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:B34:MG02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:B34:MG02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:B34:MG02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:B34:MG02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:B34:MG02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:B34:MG02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:B34:MG02:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:B34:MG02:HEARTBEATE09") {
  field(FLNK, "SIOC:B34:MG02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG02:HEARTBEATE08.B")
  field(INPB, "SIOC:B34:MG02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:B34:MG02:HEARTBEATE08") {
  field(FLNK, "SIOC:B34:MG02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG02:HEARTBEATE07.B")
  field(INPB, "SIOC:B34:MG02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:B34:MG02:HEARTBEATE07") {
  field(FLNK, "SIOC:B34:MG02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG02:HEARTBEATE06.B")
  field(INPB, "SIOC:B34:MG02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:B34:MG02:HEARTBEATE06") {
  field(FLNK, "SIOC:B34:MG02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG02:HEARTBEATE05.B")
  field(INPB, "SIOC:B34:MG02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:B34:MG02:HEARTBEATE05") {
  field(FLNK, "SIOC:B34:MG02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG02:HEARTBEATE04.B")
  field(INPB, "SIOC:B34:MG02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:B34:MG02:HEARTBEATE04") {
  field(FLNK, "SIOC:B34:MG02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG02:HEARTBEATE03.B")
  field(INPB, "SIOC:B34:MG02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:B34:MG02:HEARTBEATE03") {
  field(FLNK, "SIOC:B34:MG02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG02:HEARTBEATE02.B")
  field(INPB, "SIOC:B34:MG02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:B34:MG02:HEARTBEATE02") {
  field(FLNK, "SIOC:B34:MG02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG02:HEARTBEATE01.B")
  field(INPB, "SIOC:B34:MG02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:B34:MG02:HEARTBEATE01") {
  field(FLNK, "SIOC:B34:MG02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:B34:MG02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:B34:MG02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:B34:MG02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:B34:MG02:HEARTBEATSUM") {
  field(FLNK, "SIOC:B34:MG02:HEARTBEATCLC")
  field(INP, "SIOC:B34:MG02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:B34:MG02:HEARTBEATE10") {
  field(FLNK, "SIOC:B34:MG02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MG02:HEARTBEATE09.B")
  field(INPB, "SIOC:B34:MG02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:B34:MG02:HEARTBEATERR") {
  field(FLNK, "SIOC:B34:MG02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:B34:MG02:HEARTBEATCALC.A")
  field(INPB, "SIOC:B34:MG02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:B34:MG02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:B34:MG02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B34:MG02:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:NWDEV:INFO") {
  field(DESC, "SIOC:SYS0:NWDEV Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:NWDEV:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:NWDEV: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:NWDEV: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:NWDEV:TODDIFF")
}

record(longin, "SIOC:SYS0:NWDEV:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:NWDEV:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:NWDEV: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:NWDEV:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:NWDEV:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:NWDEV:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:NWDEV:TODSUM")
}

record(bo, "SIOC:SYS0:NWDEV:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:NWDEV:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:NWDEV:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:NWDEV:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NWDEV:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:NWDEV:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:NWDEV:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:NWDEV:HEARTBEATE01")
  field(INP, "SIOC:SYS0:NWDEV:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:NWDEV:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:NWDEV:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:NWDEV:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:NWDEV:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:NWDEV:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:NWDEV:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:NWDEV:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:NWDEV:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:NWDEV:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:NWDEV:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:NWDEV:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:NWDEV: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:NWDEV:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:NWDEV:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NWDEV:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:NWDEV:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:NWDEV:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:NWDEV:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NWDEV:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:NWDEV:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:NWDEV:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:NWDEV:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NWDEV:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:NWDEV:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:NWDEV:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:NWDEV:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NWDEV:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:NWDEV:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:NWDEV:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:NWDEV:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NWDEV:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:NWDEV:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:NWDEV:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:NWDEV:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NWDEV:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:NWDEV:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:NWDEV:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:NWDEV:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NWDEV:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:NWDEV:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:NWDEV:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:NWDEV:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NWDEV:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:NWDEV:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:NWDEV:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:NWDEV:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NWDEV:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:NWDEV:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:NWDEV:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:NWDEV:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:NWDEV:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:NWDEV:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:NWDEV: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:NWDEV:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:NWDEV:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:NWDEV:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:NWDEV:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:NWDEV:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:NWDEV:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:NWDEV:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:NWDEV:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:NWDEV:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:NWDEV:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:NWDEV:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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, "Justin Chen (justinc)")
  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-dev1")
  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:B34:PP01:INFO") {
  field(DESC, "SIOC:B34:PP01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B34:PP01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Kristi Luchini (luchini)")
  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:B34:PP01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:B34:PP01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:B34:PP01:TODDIFF")
}

record(longin, "SIOC:B34:PP01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:B34:PP01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:B34:PP01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:B34:PP01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:B34:PP01:TODCHECK.SEVR")
  field(INPB, "SIOC:B34:PP01:TODCHECK.VALB")
  field(FLNK, "SIOC:B34:PP01:TODSUM")
}

record(bo, "SIOC:B34:PP01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:B34:PP01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:B34:PP01:HEARTBEATCALC") {
  field(FLNK, "SIOC:B34:PP01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:B34:PP01:HEARTBEAT CA MS")
  field(INPB, "SIOC:B34:PP01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:B34:PP01:HEARTBEATOK") {
  field(FLNK, "SIOC:B34:PP01:HEARTBEATE01")
  field(INP, "SIOC:B34:PP01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:B34:PP01:HEARTBEATECT") {
  field(FLNK, "SIOC:B34:PP01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:B34:PP01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:B34:PP01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:B34:PP01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:B34:PP01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:B34:PP01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:B34:PP01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:B34:PP01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:B34:PP01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:B34:PP01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:B34:PP01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:B34:PP01:HEARTBEATE09") {
  field(FLNK, "SIOC:B34:PP01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:B34:PP01:HEARTBEATE08.B")
  field(INPB, "SIOC:B34:PP01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:B34:PP01:HEARTBEATE08") {
  field(FLNK, "SIOC:B34:PP01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:B34:PP01:HEARTBEATE07.B")
  field(INPB, "SIOC:B34:PP01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:B34:PP01:HEARTBEATE07") {
  field(FLNK, "SIOC:B34:PP01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:B34:PP01:HEARTBEATE06.B")
  field(INPB, "SIOC:B34:PP01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:B34:PP01:HEARTBEATE06") {
  field(FLNK, "SIOC:B34:PP01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:B34:PP01:HEARTBEATE05.B")
  field(INPB, "SIOC:B34:PP01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:B34:PP01:HEARTBEATE05") {
  field(FLNK, "SIOC:B34:PP01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:B34:PP01:HEARTBEATE04.B")
  field(INPB, "SIOC:B34:PP01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:B34:PP01:HEARTBEATE04") {
  field(FLNK, "SIOC:B34:PP01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:B34:PP01:HEARTBEATE03.B")
  field(INPB, "SIOC:B34:PP01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:B34:PP01:HEARTBEATE03") {
  field(FLNK, "SIOC:B34:PP01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:B34:PP01:HEARTBEATE02.B")
  field(INPB, "SIOC:B34:PP01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:B34:PP01:HEARTBEATE02") {
  field(FLNK, "SIOC:B34:PP01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:B34:PP01:HEARTBEATE01.B")
  field(INPB, "SIOC:B34:PP01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:B34:PP01:HEARTBEATE01") {
  field(FLNK, "SIOC:B34:PP01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:B34:PP01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:B34:PP01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:B34:PP01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:B34:PP01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:B34:PP01:HEARTBEATSUM") {
  field(FLNK, "SIOC:B34:PP01:HEARTBEATCLC")
  field(INP, "SIOC:B34:PP01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:B34:PP01:HEARTBEATE10") {
  field(FLNK, "SIOC:B34:PP01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:B34:PP01:HEARTBEATE09.B")
  field(INPB, "SIOC:B34:PP01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:B34:PP01:HEARTBEATERR") {
  field(FLNK, "SIOC:B34:PP01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:B34:PP01:HEARTBEATCALC.A")
  field(INPB, "SIOC:B34:PP01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:B34:PP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:B34:PP01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B34:PP01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:GLB0:OP00:INFO") {
  field(DESC, "SIOC:GLB0:OP00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:GLB0:OP00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Alisha Babbitt (ababbitt)")
  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:GLB0:OP00: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:GLB0:OP00: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:GLB0:OP00:TODDIFF")
}

record(longin, "SIOC:GLB0:OP00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:GLB0:OP00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:GLB0:OP00: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:GLB0:OP00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:GLB0:OP00:TODCHECK.SEVR")
  field(INPB, "SIOC:GLB0:OP00:TODCHECK.VALB")
  field(FLNK, "SIOC:GLB0:OP00:TODSUM")
}

record(bo, "SIOC:GLB0:OP00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:GLB0:OP00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:GLB0:OP00:HEARTBEATCALC") {
  field(FLNK, "SIOC:GLB0:OP00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:GLB0:OP00:HEARTBEAT CA MS")
  field(INPB, "SIOC:GLB0:OP00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:GLB0:OP00:HEARTBEATOK") {
  field(FLNK, "SIOC:GLB0:OP00:HEARTBEATE01")
  field(INP, "SIOC:GLB0:OP00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:GLB0:OP00:HEARTBEATECT") {
  field(FLNK, "SIOC:GLB0:OP00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:GLB0:OP00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:GLB0:OP00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:GLB0:OP00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:GLB0:OP00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:GLB0:OP00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:GLB0:OP00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:GLB0:OP00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:GLB0:OP00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:GLB0:OP00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:GLB0:OP00: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:GLB0:OP00:HEARTBEATE09") {
  field(FLNK, "SIOC:GLB0:OP00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:GLB0:OP00:HEARTBEATE08.B")
  field(INPB, "SIOC:GLB0:OP00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:GLB0:OP00:HEARTBEATE08") {
  field(FLNK, "SIOC:GLB0:OP00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:GLB0:OP00:HEARTBEATE07.B")
  field(INPB, "SIOC:GLB0:OP00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:GLB0:OP00:HEARTBEATE07") {
  field(FLNK, "SIOC:GLB0:OP00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:GLB0:OP00:HEARTBEATE06.B")
  field(INPB, "SIOC:GLB0:OP00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:GLB0:OP00:HEARTBEATE06") {
  field(FLNK, "SIOC:GLB0:OP00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:GLB0:OP00:HEARTBEATE05.B")
  field(INPB, "SIOC:GLB0:OP00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:GLB0:OP00:HEARTBEATE05") {
  field(FLNK, "SIOC:GLB0:OP00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:GLB0:OP00:HEARTBEATE04.B")
  field(INPB, "SIOC:GLB0:OP00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:GLB0:OP00:HEARTBEATE04") {
  field(FLNK, "SIOC:GLB0:OP00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:GLB0:OP00:HEARTBEATE03.B")
  field(INPB, "SIOC:GLB0:OP00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:GLB0:OP00:HEARTBEATE03") {
  field(FLNK, "SIOC:GLB0:OP00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:GLB0:OP00:HEARTBEATE02.B")
  field(INPB, "SIOC:GLB0:OP00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:GLB0:OP00:HEARTBEATE02") {
  field(FLNK, "SIOC:GLB0:OP00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:GLB0:OP00:HEARTBEATE01.B")
  field(INPB, "SIOC:GLB0:OP00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:GLB0:OP00:HEARTBEATE01") {
  field(FLNK, "SIOC:GLB0:OP00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:GLB0:OP00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:GLB0:OP00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:GLB0:OP00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:GLB0:OP00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:GLB0:OP00:HEARTBEATSUM") {
  field(FLNK, "SIOC:GLB0:OP00:HEARTBEATCLC")
  field(INP, "SIOC:GLB0:OP00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:GLB0:OP00:HEARTBEATE10") {
  field(FLNK, "SIOC:GLB0:OP00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:GLB0:OP00:HEARTBEATE09.B")
  field(INPB, "SIOC:GLB0:OP00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:GLB0:OP00:HEARTBEATERR") {
  field(FLNK, "SIOC:GLB0:OP00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:GLB0:OP00:HEARTBEATCALC.A")
  field(INPB, "SIOC:GLB0:OP00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:GLB0:OP00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:GLB0:OP00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:GLB0:OP00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev3")
  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:B34:MC01:INFO") {
  field(DESC, "SIOC:B34:MC01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B34:MC01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Kristi Luchini (luchini)")
  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:B34:MC01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:B34:MC01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:B34:MC01:TODDIFF")
}

record(longin, "SIOC:B34:MC01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:B34:MC01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:B34:MC01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:B34:MC01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:B34:MC01:TODCHECK.SEVR")
  field(INPB, "SIOC:B34:MC01:TODCHECK.VALB")
  field(FLNK, "SIOC:B34:MC01:TODSUM")
}

record(bo, "SIOC:B34:MC01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:B34:MC01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:B34:MC01:HEARTBEATCALC") {
  field(FLNK, "SIOC:B34:MC01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MC01:HEARTBEAT CA MS")
  field(INPB, "SIOC:B34:MC01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:B34:MC01:HEARTBEATOK") {
  field(FLNK, "SIOC:B34:MC01:HEARTBEATE01")
  field(INP, "SIOC:B34:MC01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:B34:MC01:HEARTBEATECT") {
  field(FLNK, "SIOC:B34:MC01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:B34:MC01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:B34:MC01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:B34:MC01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:B34:MC01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:B34:MC01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:B34:MC01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:B34:MC01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:B34:MC01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:B34:MC01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:B34:MC01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:B34:MC01:HEARTBEATE09") {
  field(FLNK, "SIOC:B34:MC01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MC01:HEARTBEATE08.B")
  field(INPB, "SIOC:B34:MC01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:B34:MC01:HEARTBEATE08") {
  field(FLNK, "SIOC:B34:MC01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MC01:HEARTBEATE07.B")
  field(INPB, "SIOC:B34:MC01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:B34:MC01:HEARTBEATE07") {
  field(FLNK, "SIOC:B34:MC01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MC01:HEARTBEATE06.B")
  field(INPB, "SIOC:B34:MC01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:B34:MC01:HEARTBEATE06") {
  field(FLNK, "SIOC:B34:MC01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MC01:HEARTBEATE05.B")
  field(INPB, "SIOC:B34:MC01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:B34:MC01:HEARTBEATE05") {
  field(FLNK, "SIOC:B34:MC01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MC01:HEARTBEATE04.B")
  field(INPB, "SIOC:B34:MC01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:B34:MC01:HEARTBEATE04") {
  field(FLNK, "SIOC:B34:MC01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MC01:HEARTBEATE03.B")
  field(INPB, "SIOC:B34:MC01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:B34:MC01:HEARTBEATE03") {
  field(FLNK, "SIOC:B34:MC01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MC01:HEARTBEATE02.B")
  field(INPB, "SIOC:B34:MC01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:B34:MC01:HEARTBEATE02") {
  field(FLNK, "SIOC:B34:MC01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MC01:HEARTBEATE01.B")
  field(INPB, "SIOC:B34:MC01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:B34:MC01:HEARTBEATE01") {
  field(FLNK, "SIOC:B34:MC01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MC01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:B34:MC01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:B34:MC01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:B34:MC01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:B34:MC01:HEARTBEATSUM") {
  field(FLNK, "SIOC:B34:MC01:HEARTBEATCLC")
  field(INP, "SIOC:B34:MC01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:B34:MC01:HEARTBEATE10") {
  field(FLNK, "SIOC:B34:MC01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:B34:MC01:HEARTBEATE09.B")
  field(INPB, "SIOC:B34:MC01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:B34:MC01:HEARTBEATERR") {
  field(FLNK, "SIOC:B34:MC01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:B34:MC01:HEARTBEATCALC.A")
  field(INPB, "SIOC:B34:MC01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:B34:MC01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:B34:MC01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B34:MC01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:B34:LS01:INFO") {
  field(DESC, "SIOC:B34:LS01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B34:LS01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shawn Alverson (alverson)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:B34:LS01: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:B34:LS01: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:B34:LS01:TODDIFF")
}

record(longin, "SIOC:B34:LS01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:B34:LS01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:B34:LS01: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:B34:LS01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:B34:LS01:TODCHECK.SEVR")
  field(INPB, "SIOC:B34:LS01:TODCHECK.VALB")
  field(FLNK, "SIOC:B34:LS01:TODSUM")
}

record(bo, "SIOC:B34:LS01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:B34:LS01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:B34:LS01:HEARTBEATCALC") {
  field(FLNK, "SIOC:B34:LS01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:B34:LS01:HEARTBEAT CA MS")
  field(INPB, "SIOC:B34:LS01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:B34:LS01:HEARTBEATOK") {
  field(FLNK, "SIOC:B34:LS01:HEARTBEATE01")
  field(INP, "SIOC:B34:LS01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:B34:LS01:HEARTBEATECT") {
  field(FLNK, "SIOC:B34:LS01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:B34:LS01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:B34:LS01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:B34:LS01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:B34:LS01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:B34:LS01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:B34:LS01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:B34:LS01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:B34:LS01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:B34:LS01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:B34:LS01: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:B34:LS01:HEARTBEATE09") {
  field(FLNK, "SIOC:B34:LS01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:B34:LS01:HEARTBEATE08.B")
  field(INPB, "SIOC:B34:LS01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:B34:LS01:HEARTBEATE08") {
  field(FLNK, "SIOC:B34:LS01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:B34:LS01:HEARTBEATE07.B")
  field(INPB, "SIOC:B34:LS01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:B34:LS01:HEARTBEATE07") {
  field(FLNK, "SIOC:B34:LS01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:B34:LS01:HEARTBEATE06.B")
  field(INPB, "SIOC:B34:LS01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:B34:LS01:HEARTBEATE06") {
  field(FLNK, "SIOC:B34:LS01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:B34:LS01:HEARTBEATE05.B")
  field(INPB, "SIOC:B34:LS01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:B34:LS01:HEARTBEATE05") {
  field(FLNK, "SIOC:B34:LS01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:B34:LS01:HEARTBEATE04.B")
  field(INPB, "SIOC:B34:LS01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:B34:LS01:HEARTBEATE04") {
  field(FLNK, "SIOC:B34:LS01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:B34:LS01:HEARTBEATE03.B")
  field(INPB, "SIOC:B34:LS01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:B34:LS01:HEARTBEATE03") {
  field(FLNK, "SIOC:B34:LS01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:B34:LS01:HEARTBEATE02.B")
  field(INPB, "SIOC:B34:LS01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:B34:LS01:HEARTBEATE02") {
  field(FLNK, "SIOC:B34:LS01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:B34:LS01:HEARTBEATE01.B")
  field(INPB, "SIOC:B34:LS01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:B34:LS01:HEARTBEATE01") {
  field(FLNK, "SIOC:B34:LS01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:B34:LS01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:B34:LS01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:B34:LS01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:B34:LS01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:B34:LS01:HEARTBEATSUM") {
  field(FLNK, "SIOC:B34:LS01:HEARTBEATCLC")
  field(INP, "SIOC:B34:LS01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:B34:LS01:HEARTBEATE10") {
  field(FLNK, "SIOC:B34:LS01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:B34:LS01:HEARTBEATE09.B")
  field(INPB, "SIOC:B34:LS01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:B34:LS01:HEARTBEATERR") {
  field(FLNK, "SIOC:B34:LS01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:B34:LS01:HEARTBEATCALC.A")
  field(INPB, "SIOC:B34:LS01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:B34:LS01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:B34:LS01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B34:LS01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:B15:MG02:INFO") {
  field(DESC, "SIOC:B15:MG02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B15:MG02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Kristi Luchini (luchini)")
  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:B15:MG02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:B15:MG02:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:B15:MG02:TODDIFF")
}

record(longin, "SIOC:B15:MG02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:B15:MG02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:B15:MG02:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:B15:MG02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:B15:MG02:TODCHECK.SEVR")
  field(INPB, "SIOC:B15:MG02:TODCHECK.VALB")
  field(FLNK, "SIOC:B15:MG02:TODSUM")
}

record(bo, "SIOC:B15:MG02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:B15:MG02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:B15:MG02:HEARTBEATCALC") {
  field(FLNK, "SIOC:B15:MG02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG02:HEARTBEAT CA MS")
  field(INPB, "SIOC:B15:MG02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:B15:MG02:HEARTBEATOK") {
  field(FLNK, "SIOC:B15:MG02:HEARTBEATE01")
  field(INP, "SIOC:B15:MG02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:B15:MG02:HEARTBEATECT") {
  field(FLNK, "SIOC:B15:MG02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:B15:MG02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:B15:MG02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:B15:MG02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:B15:MG02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:B15:MG02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:B15:MG02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:B15:MG02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:B15:MG02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:B15:MG02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:B15:MG02:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:B15:MG02:HEARTBEATE09") {
  field(FLNK, "SIOC:B15:MG02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG02:HEARTBEATE08.B")
  field(INPB, "SIOC:B15:MG02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:B15:MG02:HEARTBEATE08") {
  field(FLNK, "SIOC:B15:MG02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG02:HEARTBEATE07.B")
  field(INPB, "SIOC:B15:MG02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:B15:MG02:HEARTBEATE07") {
  field(FLNK, "SIOC:B15:MG02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG02:HEARTBEATE06.B")
  field(INPB, "SIOC:B15:MG02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:B15:MG02:HEARTBEATE06") {
  field(FLNK, "SIOC:B15:MG02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG02:HEARTBEATE05.B")
  field(INPB, "SIOC:B15:MG02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:B15:MG02:HEARTBEATE05") {
  field(FLNK, "SIOC:B15:MG02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG02:HEARTBEATE04.B")
  field(INPB, "SIOC:B15:MG02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:B15:MG02:HEARTBEATE04") {
  field(FLNK, "SIOC:B15:MG02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG02:HEARTBEATE03.B")
  field(INPB, "SIOC:B15:MG02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:B15:MG02:HEARTBEATE03") {
  field(FLNK, "SIOC:B15:MG02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG02:HEARTBEATE02.B")
  field(INPB, "SIOC:B15:MG02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:B15:MG02:HEARTBEATE02") {
  field(FLNK, "SIOC:B15:MG02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG02:HEARTBEATE01.B")
  field(INPB, "SIOC:B15:MG02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:B15:MG02:HEARTBEATE01") {
  field(FLNK, "SIOC:B15:MG02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:B15:MG02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:B15:MG02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:B15:MG02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:B15:MG02:HEARTBEATSUM") {
  field(FLNK, "SIOC:B15:MG02:HEARTBEATCLC")
  field(INP, "SIOC:B15:MG02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:B15:MG02:HEARTBEATE10") {
  field(FLNK, "SIOC:B15:MG02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:B15:MG02:HEARTBEATE09.B")
  field(INPB, "SIOC:B15:MG02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:B15:MG02:HEARTBEATERR") {
  field(FLNK, "SIOC:B15:MG02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:B15:MG02:HEARTBEATCALC.A")
  field(INPB, "SIOC:B15:MG02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:B15:MG02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:B15:MG02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B15:MG02:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:B15:PS01:INFO") {
  field(DESC, "SIOC:B15:PS01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B15:PS01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jerico Tagle (jtagle)")
  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:B15:PS01: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:B15:PS01: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:B15:PS01:TODDIFF")
}

record(longin, "SIOC:B15:PS01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:B15:PS01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:B15:PS01: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:B15:PS01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:B15:PS01:TODCHECK.SEVR")
  field(INPB, "SIOC:B15:PS01:TODCHECK.VALB")
  field(FLNK, "SIOC:B15:PS01:TODSUM")
}

record(bo, "SIOC:B15:PS01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:B15:PS01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:B15:PS01:HEARTBEATCALC") {
  field(FLNK, "SIOC:B15:PS01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS01:HEARTBEAT CA MS")
  field(INPB, "SIOC:B15:PS01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:B15:PS01:HEARTBEATOK") {
  field(FLNK, "SIOC:B15:PS01:HEARTBEATE01")
  field(INP, "SIOC:B15:PS01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:B15:PS01:HEARTBEATECT") {
  field(FLNK, "SIOC:B15:PS01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:B15:PS01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:B15:PS01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:B15:PS01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:B15:PS01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:B15:PS01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:B15:PS01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:B15:PS01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:B15:PS01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:B15:PS01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:B15:PS01: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:B15:PS01:HEARTBEATE09") {
  field(FLNK, "SIOC:B15:PS01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS01:HEARTBEATE08.B")
  field(INPB, "SIOC:B15:PS01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:B15:PS01:HEARTBEATE08") {
  field(FLNK, "SIOC:B15:PS01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS01:HEARTBEATE07.B")
  field(INPB, "SIOC:B15:PS01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:B15:PS01:HEARTBEATE07") {
  field(FLNK, "SIOC:B15:PS01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS01:HEARTBEATE06.B")
  field(INPB, "SIOC:B15:PS01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:B15:PS01:HEARTBEATE06") {
  field(FLNK, "SIOC:B15:PS01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS01:HEARTBEATE05.B")
  field(INPB, "SIOC:B15:PS01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:B15:PS01:HEARTBEATE05") {
  field(FLNK, "SIOC:B15:PS01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS01:HEARTBEATE04.B")
  field(INPB, "SIOC:B15:PS01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:B15:PS01:HEARTBEATE04") {
  field(FLNK, "SIOC:B15:PS01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS01:HEARTBEATE03.B")
  field(INPB, "SIOC:B15:PS01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:B15:PS01:HEARTBEATE03") {
  field(FLNK, "SIOC:B15:PS01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS01:HEARTBEATE02.B")
  field(INPB, "SIOC:B15:PS01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:B15:PS01:HEARTBEATE02") {
  field(FLNK, "SIOC:B15:PS01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS01:HEARTBEATE01.B")
  field(INPB, "SIOC:B15:PS01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:B15:PS01:HEARTBEATE01") {
  field(FLNK, "SIOC:B15:PS01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:B15:PS01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:B15:PS01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:B15:PS01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:B15:PS01:HEARTBEATSUM") {
  field(FLNK, "SIOC:B15:PS01:HEARTBEATCLC")
  field(INP, "SIOC:B15:PS01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:B15:PS01:HEARTBEATE10") {
  field(FLNK, "SIOC:B15:PS01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS01:HEARTBEATE09.B")
  field(INPB, "SIOC:B15:PS01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:B15:PS01:HEARTBEATERR") {
  field(FLNK, "SIOC:B15:PS01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:B15:PS01:HEARTBEATCALC.A")
  field(INPB, "SIOC:B15:PS01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:B15:PS01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:B15:PS01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B15:PS01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:B15:PS02:INFO") {
  field(DESC, "SIOC:B15:PS02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B15:PS02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jerico Tagle (jtagle)")
  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:B15:PS02: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:B15:PS02: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:B15:PS02:TODDIFF")
}

record(longin, "SIOC:B15:PS02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:B15:PS02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:B15:PS02: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:B15:PS02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:B15:PS02:TODCHECK.SEVR")
  field(INPB, "SIOC:B15:PS02:TODCHECK.VALB")
  field(FLNK, "SIOC:B15:PS02:TODSUM")
}

record(bo, "SIOC:B15:PS02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:B15:PS02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:B15:PS02:HEARTBEATCALC") {
  field(FLNK, "SIOC:B15:PS02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS02:HEARTBEAT CA MS")
  field(INPB, "SIOC:B15:PS02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:B15:PS02:HEARTBEATOK") {
  field(FLNK, "SIOC:B15:PS02:HEARTBEATE01")
  field(INP, "SIOC:B15:PS02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:B15:PS02:HEARTBEATECT") {
  field(FLNK, "SIOC:B15:PS02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:B15:PS02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:B15:PS02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:B15:PS02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:B15:PS02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:B15:PS02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:B15:PS02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:B15:PS02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:B15:PS02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:B15:PS02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:B15:PS02: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:B15:PS02:HEARTBEATE09") {
  field(FLNK, "SIOC:B15:PS02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS02:HEARTBEATE08.B")
  field(INPB, "SIOC:B15:PS02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:B15:PS02:HEARTBEATE08") {
  field(FLNK, "SIOC:B15:PS02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS02:HEARTBEATE07.B")
  field(INPB, "SIOC:B15:PS02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:B15:PS02:HEARTBEATE07") {
  field(FLNK, "SIOC:B15:PS02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS02:HEARTBEATE06.B")
  field(INPB, "SIOC:B15:PS02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:B15:PS02:HEARTBEATE06") {
  field(FLNK, "SIOC:B15:PS02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS02:HEARTBEATE05.B")
  field(INPB, "SIOC:B15:PS02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:B15:PS02:HEARTBEATE05") {
  field(FLNK, "SIOC:B15:PS02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS02:HEARTBEATE04.B")
  field(INPB, "SIOC:B15:PS02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:B15:PS02:HEARTBEATE04") {
  field(FLNK, "SIOC:B15:PS02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS02:HEARTBEATE03.B")
  field(INPB, "SIOC:B15:PS02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:B15:PS02:HEARTBEATE03") {
  field(FLNK, "SIOC:B15:PS02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS02:HEARTBEATE02.B")
  field(INPB, "SIOC:B15:PS02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:B15:PS02:HEARTBEATE02") {
  field(FLNK, "SIOC:B15:PS02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS02:HEARTBEATE01.B")
  field(INPB, "SIOC:B15:PS02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:B15:PS02:HEARTBEATE01") {
  field(FLNK, "SIOC:B15:PS02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:B15:PS02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:B15:PS02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:B15:PS02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:B15:PS02:HEARTBEATSUM") {
  field(FLNK, "SIOC:B15:PS02:HEARTBEATCLC")
  field(INP, "SIOC:B15:PS02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:B15:PS02:HEARTBEATE10") {
  field(FLNK, "SIOC:B15:PS02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:B15:PS02:HEARTBEATE09.B")
  field(INPB, "SIOC:B15:PS02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:B15:PS02:HEARTBEATERR") {
  field(FLNK, "SIOC:B15:PS02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:B15:PS02:HEARTBEATCALC.A")
  field(INPB, "SIOC:B15:PS02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:B15:PS02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:B15:PS02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:B15:PS02:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:CV01:INFO") {
  field(DESC, "SIOC:SYS0:CV01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:CV01: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:CV01: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:CV01: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:CV01:TODDIFF")
}

record(longin, "SIOC:SYS0:CV01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:CV01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:CV01: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:CV01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:CV01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:CV01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:CV01:TODSUM")
}

record(bo, "SIOC:SYS0:CV01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:CV01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:CV01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:CV01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:CV01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:CV01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:CV01:HEARTBEATE01")
  field(INP, "SIOC:SYS0:CV01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:CV01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:CV01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:CV01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:CV01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:CV01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:CV01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:CV01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:CV01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:CV01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:CV01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:CV01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:CV01: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:CV01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:CV01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:CV01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:CV01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:CV01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:CV01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:CV01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:CV01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:CV01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:CV01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:CV01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:CV01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:CV01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:CV01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:CV01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:CV01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:CV01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:CV01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:CV01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:CV01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:CV01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:CV01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:CV01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:CV01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:CV01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:CV01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:CV01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:CV01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:CV01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:CV01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:CV01:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:CV01: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:CV01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:CV01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:CV01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:CV01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:CV01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:CV01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:CV01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:CV01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:CV01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:CV01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:CV02:INFO") {
  field(DESC, "SIOC:SYS0:CV02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:CV02: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:CV02: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:CV02: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:CV02:TODDIFF")
}

record(longin, "SIOC:SYS0:CV02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:CV02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:CV02: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:CV02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:CV02:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:CV02:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:CV02:TODSUM")
}

record(bo, "SIOC:SYS0:CV02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:CV02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:CV02:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:CV02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV02:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:CV02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:CV02:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:CV02:HEARTBEATE01")
  field(INP, "SIOC:SYS0:CV02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:CV02:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:CV02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:CV02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:CV02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:CV02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:CV02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:CV02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:CV02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:CV02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:CV02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:CV02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:CV02: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:CV02:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:CV02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV02:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:CV02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:CV02:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:CV02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV02:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:CV02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:CV02:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:CV02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV02:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:CV02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:CV02:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:CV02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV02:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:CV02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:CV02:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:CV02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV02:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:CV02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:CV02:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:CV02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV02:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:CV02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:CV02:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:CV02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV02:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:CV02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:CV02:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:CV02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV02:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:CV02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:CV02:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:CV02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:CV02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:CV02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:CV02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:CV02:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:CV02:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:CV02: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:CV02:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:CV02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV02:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:CV02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:CV02:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:CV02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:CV02:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:CV02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:CV02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:CV02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:CV02:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:CV03:INFO") {
  field(DESC, "SIOC:SYS0:CV03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:CV03: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:CV03: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:CV03: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:CV03:TODDIFF")
}

record(longin, "SIOC:SYS0:CV03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:CV03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:CV03: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:CV03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:CV03:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:CV03:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:CV03:TODSUM")
}

record(bo, "SIOC:SYS0:CV03:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:CV03:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:CV03:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:CV03:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV03:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:CV03:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:CV03:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:CV03:HEARTBEATE01")
  field(INP, "SIOC:SYS0:CV03:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:CV03:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:CV03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:CV03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:CV03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:CV03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:CV03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:CV03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:CV03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:CV03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:CV03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:CV03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:CV03: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:CV03:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:CV03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV03:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:CV03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:CV03:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:CV03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV03:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:CV03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:CV03:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:CV03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV03:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:CV03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:CV03:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:CV03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV03:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:CV03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:CV03:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:CV03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV03:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:CV03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:CV03:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:CV03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV03:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:CV03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:CV03:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:CV03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV03:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:CV03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:CV03:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:CV03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV03:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:CV03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:CV03:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:CV03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:CV03:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:CV03:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:CV03:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:CV03:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:CV03:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:CV03: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:CV03:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:CV03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:CV03:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:CV03:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:CV03:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:CV03:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:CV03:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:CV03:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:CV03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:CV03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:CV03:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS1:CV01:INFO") {
  field(DESC, "SIOC:SYS1:CV01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS1:CV01: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:SYS1:CV01: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:SYS1:CV01: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:SYS1:CV01:TODDIFF")
}

record(longin, "SIOC:SYS1:CV01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS1:CV01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS1:CV01: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:SYS1:CV01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS1:CV01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS1:CV01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS1:CV01:TODSUM")
}

record(bo, "SIOC:SYS1:CV01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS1:CV01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS1:CV01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS1:CV01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:CV01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS1:CV01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS1:CV01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS1:CV01:HEARTBEATE01")
  field(INP, "SIOC:SYS1:CV01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS1:CV01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS1:CV01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS1:CV01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS1:CV01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS1:CV01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS1:CV01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS1:CV01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS1:CV01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS1:CV01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS1:CV01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS1:CV01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS1:CV01: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:SYS1:CV01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS1:CV01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:CV01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS1:CV01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS1:CV01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS1:CV01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:CV01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS1:CV01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS1:CV01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS1:CV01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:CV01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS1:CV01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS1:CV01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS1:CV01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:CV01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS1:CV01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS1:CV01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS1:CV01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:CV01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS1:CV01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS1:CV01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS1:CV01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:CV01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS1:CV01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS1:CV01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS1:CV01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:CV01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS1:CV01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS1:CV01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS1:CV01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:CV01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS1:CV01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS1:CV01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS1:CV01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:CV01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS1:CV01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS1:CV01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS1:CV01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS1:CV01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS1:CV01:HEARTBEATCLC")
  field(INP, "SIOC:SYS1:CV01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS1:CV01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS1:CV01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:CV01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS1:CV01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS1:CV01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS1:CV01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS1:CV01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS1:CV01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS1:CV01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS1:CV01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS1:CV01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:EV00:INFO") {
  field(DESC, "SIOC:SYS0:EV00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:EV00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:EV00: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:EV00: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:EV00:TODDIFF")
}

record(longin, "SIOC:SYS0:EV00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:EV00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:EV00: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:EV00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:EV00:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:EV00:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:EV00:TODSUM")
}

record(bo, "SIOC:SYS0:EV00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:EV00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:EV00:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:EV00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:EV00:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:EV00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:EV00:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:EV00:HEARTBEATE01")
  field(INP, "SIOC:SYS0:EV00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:EV00:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:EV00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:EV00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:EV00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:EV00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:EV00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:EV00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:EV00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:EV00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:EV00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:EV00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:EV00: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:EV00:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:EV00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:EV00:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:EV00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:EV00:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:EV00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:EV00:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:EV00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:EV00:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:EV00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:EV00:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:EV00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:EV00:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:EV00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:EV00:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:EV00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:EV00:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:EV00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:EV00:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:EV00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:EV00:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:EV00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:EV00:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:EV00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:EV00:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:EV00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:EV00:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:EV00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:EV00:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:EV00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:EV00:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:EV00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:EV00:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:EV00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:EV00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:EV00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:EV00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:EV00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:EV00:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:EV00:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:EV00: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:EV00:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:EV00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:EV00:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:EV00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:EV00:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:EV00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:EV00:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:EV00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:EV00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:EV00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:EV00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS1:PN00:INFO") {
  field(DESC, "SIOC:SYS1:PN00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS1:PN00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS1:PN00: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:SYS1:PN00: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:SYS1:PN00:TODDIFF")
}

record(longin, "SIOC:SYS1:PN00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS1:PN00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS1:PN00: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:SYS1:PN00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS1:PN00:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS1:PN00:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS1:PN00:TODSUM")
}

record(bo, "SIOC:SYS1:PN00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS1:PN00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS1:PN00:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS1:PN00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:PN00:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS1:PN00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS1:PN00:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS1:PN00:HEARTBEATE01")
  field(INP, "SIOC:SYS1:PN00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS1:PN00:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS1:PN00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS1:PN00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS1:PN00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS1:PN00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS1:PN00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS1:PN00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS1:PN00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS1:PN00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS1:PN00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS1:PN00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS1:PN00: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:SYS1:PN00:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS1:PN00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:PN00:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS1:PN00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS1:PN00:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS1:PN00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:PN00:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS1:PN00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS1:PN00:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS1:PN00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:PN00:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS1:PN00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS1:PN00:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS1:PN00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:PN00:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS1:PN00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS1:PN00:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS1:PN00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:PN00:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS1:PN00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS1:PN00:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS1:PN00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:PN00:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS1:PN00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS1:PN00:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS1:PN00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:PN00:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS1:PN00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS1:PN00:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS1:PN00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:PN00:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS1:PN00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS1:PN00:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS1:PN00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:PN00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS1:PN00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS1:PN00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS1:PN00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS1:PN00:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS1:PN00:HEARTBEATCLC")
  field(INP, "SIOC:SYS1:PN00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS1:PN00:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS1:PN00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:PN00:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS1:PN00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS1:PN00:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS1:PN00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS1:PN00:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS1:PN00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS1:PN00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS1:PN00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS1:PN00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS2:PN00:INFO") {
  field(DESC, "SIOC:SYS2:PN00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS2:PN00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS2:PN00: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:SYS2:PN00: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:SYS2:PN00:TODDIFF")
}

record(longin, "SIOC:SYS2:PN00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS2:PN00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS2:PN00: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:SYS2:PN00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS2:PN00:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS2:PN00:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS2:PN00:TODSUM")
}

record(bo, "SIOC:SYS2:PN00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS2:PN00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS2:PN00:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS2:PN00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS2:PN00:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS2:PN00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS2:PN00:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS2:PN00:HEARTBEATE01")
  field(INP, "SIOC:SYS2:PN00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS2:PN00:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS2:PN00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS2:PN00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS2:PN00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS2:PN00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS2:PN00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS2:PN00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS2:PN00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS2:PN00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS2:PN00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS2:PN00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS2:PN00: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:SYS2:PN00:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS2:PN00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS2:PN00:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS2:PN00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS2:PN00:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS2:PN00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS2:PN00:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS2:PN00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS2:PN00:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS2:PN00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS2:PN00:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS2:PN00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS2:PN00:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS2:PN00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS2:PN00:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS2:PN00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS2:PN00:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS2:PN00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS2:PN00:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS2:PN00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS2:PN00:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS2:PN00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS2:PN00:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS2:PN00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS2:PN00:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS2:PN00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS2:PN00:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS2:PN00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS2:PN00:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS2:PN00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS2:PN00:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS2:PN00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS2:PN00:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS2:PN00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS2:PN00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS2:PN00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS2:PN00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS2:PN00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS2:PN00:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS2:PN00:HEARTBEATCLC")
  field(INP, "SIOC:SYS2:PN00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS2:PN00:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS2:PN00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS2:PN00:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS2:PN00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS2:PN00:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS2:PN00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS2:PN00:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS2:PN00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS2:PN00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS2:PN00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS2:PN00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS6:PN00:INFO") {
  field(DESC, "SIOC:SYS6:PN00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS6:PN00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS6:PN00: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:SYS6:PN00: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:SYS6:PN00:TODDIFF")
}

record(longin, "SIOC:SYS6:PN00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS6:PN00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS6:PN00: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:SYS6:PN00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS6:PN00:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS6:PN00:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS6:PN00:TODSUM")
}

record(bo, "SIOC:SYS6:PN00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS6:PN00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS6:PN00:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS6:PN00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:PN00:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS6:PN00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS6:PN00:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS6:PN00:HEARTBEATE01")
  field(INP, "SIOC:SYS6:PN00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS6:PN00:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS6:PN00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS6:PN00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS6:PN00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS6:PN00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS6:PN00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS6:PN00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS6:PN00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS6:PN00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS6:PN00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS6:PN00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS6:PN00: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:SYS6:PN00:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS6:PN00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:PN00:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS6:PN00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS6:PN00:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS6:PN00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:PN00:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS6:PN00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS6:PN00:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS6:PN00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:PN00:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS6:PN00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS6:PN00:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS6:PN00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:PN00:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS6:PN00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS6:PN00:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS6:PN00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:PN00:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS6:PN00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS6:PN00:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS6:PN00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:PN00:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS6:PN00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS6:PN00:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS6:PN00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:PN00:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS6:PN00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS6:PN00:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS6:PN00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:PN00:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS6:PN00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS6:PN00:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS6:PN00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:PN00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS6:PN00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS6:PN00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS6:PN00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS6:PN00:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS6:PN00:HEARTBEATCLC")
  field(INP, "SIOC:SYS6:PN00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS6:PN00:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS6:PN00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:PN00:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS6:PN00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS6:PN00:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS6:PN00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS6:PN00:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS6:PN00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS6:PN00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS6:PN00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS6:PN00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ML00:INFO") {
  field(DESC, "SIOC:SYS0:ML00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:ML00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:ML00: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:ML00: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:ML00:TODDIFF")
}

record(longin, "SIOC:SYS0:ML00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:ML00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:ML00: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:ML00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:ML00:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:ML00:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:ML00:TODSUM")
}

record(bo, "SIOC:SYS0:ML00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:ML00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:ML00:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:ML00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML00:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:ML00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:ML00:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:ML00:HEARTBEATE01")
  field(INP, "SIOC:SYS0:ML00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:ML00:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:ML00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:ML00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:ML00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:ML00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:ML00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:ML00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:ML00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:ML00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:ML00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:ML00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:ML00: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:ML00:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:ML00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML00:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:ML00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:ML00:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:ML00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML00:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:ML00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:ML00:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:ML00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML00:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:ML00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:ML00:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:ML00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML00:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:ML00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:ML00:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:ML00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML00:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:ML00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:ML00:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:ML00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML00:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:ML00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:ML00:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:ML00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML00:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:ML00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:ML00:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:ML00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML00:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:ML00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:ML00:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:ML00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:ML00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:ML00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:ML00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:ML00:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:ML00:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:ML00: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:ML00:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:ML00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML00:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:ML00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:ML00:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:ML00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:ML00:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:ML00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:ML00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:ML00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:ML00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ML01:INFO") {
  field(DESC, "SIOC:SYS0:ML01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:ML01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:ML01: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:ML01: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:ML01:TODDIFF")
}

record(longin, "SIOC:SYS0:ML01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:ML01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:ML01: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:ML01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:ML01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:ML01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:ML01:TODSUM")
}

record(bo, "SIOC:SYS0:ML01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:ML01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:ML01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:ML01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:ML01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:ML01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:ML01:HEARTBEATE01")
  field(INP, "SIOC:SYS0:ML01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:ML01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:ML01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:ML01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:ML01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:ML01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:ML01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:ML01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:ML01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:ML01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:ML01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:ML01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:ML01: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:ML01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:ML01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:ML01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:ML01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:ML01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:ML01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:ML01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:ML01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:ML01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:ML01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:ML01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:ML01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:ML01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:ML01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:ML01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:ML01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:ML01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:ML01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:ML01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:ML01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:ML01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:ML01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:ML01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:ML01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:ML01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:ML01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:ML01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:ML01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:ML01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:ML01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:ML01:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:ML01: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:ML01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:ML01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:ML01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:ML01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:ML01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:ML01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:ML01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:ML01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:ML01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:ML01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ML02:INFO") {
  field(DESC, "SIOC:SYS0:ML02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:ML02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:ML02: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:ML02: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:ML02:TODDIFF")
}

record(longin, "SIOC:SYS0:ML02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:ML02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:ML02: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:ML02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:ML02:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:ML02:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:ML02:TODSUM")
}

record(bo, "SIOC:SYS0:ML02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:ML02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:ML02:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:ML02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML02:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:ML02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:ML02:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:ML02:HEARTBEATE01")
  field(INP, "SIOC:SYS0:ML02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:ML02:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:ML02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:ML02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:ML02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:ML02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:ML02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:ML02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:ML02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:ML02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:ML02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:ML02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:ML02: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:ML02:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:ML02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML02:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:ML02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:ML02:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:ML02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML02:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:ML02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:ML02:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:ML02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML02:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:ML02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:ML02:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:ML02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML02:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:ML02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:ML02:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:ML02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML02:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:ML02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:ML02:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:ML02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML02:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:ML02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:ML02:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:ML02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML02:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:ML02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:ML02:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:ML02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML02:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:ML02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:ML02:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:ML02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:ML02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:ML02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:ML02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:ML02:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:ML02:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:ML02: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:ML02:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:ML02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML02:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:ML02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:ML02:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:ML02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:ML02:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:ML02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:ML02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:ML02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:ML02:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ML03:INFO") {
  field(DESC, "SIOC:SYS0:ML03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:ML03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:ML03: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:ML03: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:ML03:TODDIFF")
}

record(longin, "SIOC:SYS0:ML03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:ML03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:ML03: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:ML03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:ML03:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:ML03:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:ML03:TODSUM")
}

record(bo, "SIOC:SYS0:ML03:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:ML03:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:ML03:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:ML03:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML03:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:ML03:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:ML03:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:ML03:HEARTBEATE01")
  field(INP, "SIOC:SYS0:ML03:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:ML03:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:ML03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:ML03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:ML03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:ML03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:ML03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:ML03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:ML03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:ML03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:ML03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:ML03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:ML03: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:ML03:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:ML03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML03:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:ML03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:ML03:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:ML03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML03:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:ML03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:ML03:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:ML03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML03:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:ML03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:ML03:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:ML03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML03:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:ML03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:ML03:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:ML03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML03:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:ML03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:ML03:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:ML03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML03:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:ML03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:ML03:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:ML03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML03:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:ML03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:ML03:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:ML03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML03:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:ML03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:ML03:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:ML03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:ML03:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:ML03:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:ML03:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:ML03:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:ML03:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:ML03: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:ML03:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:ML03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML03:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:ML03:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:ML03:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:ML03:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:ML03:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:ML03:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:ML03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:ML03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:ML03:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ML04:INFO") {
  field(DESC, "SIOC:SYS0:ML04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:ML04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:ML04: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:ML04: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:ML04:TODDIFF")
}

record(longin, "SIOC:SYS0:ML04:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:ML04:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:ML04: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:ML04:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:ML04:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:ML04:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:ML04:TODSUM")
}

record(bo, "SIOC:SYS0:ML04:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:ML04:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:ML04:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:ML04:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML04:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:ML04:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:ML04:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:ML04:HEARTBEATE01")
  field(INP, "SIOC:SYS0:ML04:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:ML04:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:ML04:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:ML04:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:ML04:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:ML04:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:ML04:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:ML04:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:ML04:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:ML04:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:ML04:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:ML04:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:ML04: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:ML04:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:ML04:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML04:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:ML04:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:ML04:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:ML04:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML04:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:ML04:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:ML04:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:ML04:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML04:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:ML04:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:ML04:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:ML04:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML04:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:ML04:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:ML04:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:ML04:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML04:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:ML04:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:ML04:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:ML04:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML04:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:ML04:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:ML04:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:ML04:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML04:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:ML04:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:ML04:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:ML04:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML04:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:ML04:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:ML04:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:ML04:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML04:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:ML04:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:ML04:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:ML04:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:ML04:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:ML04:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:ML04: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:ML04:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:ML04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML04:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:ML04:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:ML04:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:ML04:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:ML04:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:ML04:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:ML04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:ML04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:ML04:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ML05:INFO") {
  field(DESC, "SIOC:SYS0:ML05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:ML05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:ML05: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:ML05: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:ML05:TODDIFF")
}

record(longin, "SIOC:SYS0:ML05:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:ML05:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:ML05: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:ML05:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:ML05:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:ML05:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:ML05:TODSUM")
}

record(bo, "SIOC:SYS0:ML05:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:ML05:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:ML05:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:ML05:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML05:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:ML05:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:ML05:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:ML05:HEARTBEATE01")
  field(INP, "SIOC:SYS0:ML05:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:ML05:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:ML05:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:ML05:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:ML05:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:ML05:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:ML05:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:ML05:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:ML05:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:ML05:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:ML05:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:ML05:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:ML05: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:ML05:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:ML05:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML05:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:ML05:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:ML05:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:ML05:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML05:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:ML05:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:ML05:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:ML05:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML05:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:ML05:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:ML05:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:ML05:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML05:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:ML05:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:ML05:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:ML05:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML05:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:ML05:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:ML05:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:ML05:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML05:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:ML05:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:ML05:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:ML05:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML05:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:ML05:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:ML05:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:ML05:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML05:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:ML05:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:ML05:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:ML05:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML05:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:ML05:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:ML05:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:ML05:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:ML05:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:ML05:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:ML05: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:ML05:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:ML05:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML05:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:ML05:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:ML05:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:ML05:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:ML05:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:ML05:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:ML05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:ML05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:ML05:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ML06:INFO") {
  field(DESC, "SIOC:SYS0:ML06 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:ML06:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:ML06: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:ML06: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:ML06:TODDIFF")
}

record(longin, "SIOC:SYS0:ML06:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:ML06:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:ML06: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:ML06:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:ML06:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:ML06:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:ML06:TODSUM")
}

record(bo, "SIOC:SYS0:ML06:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:ML06:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:ML06:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:ML06:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML06:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:ML06:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:ML06:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:ML06:HEARTBEATE01")
  field(INP, "SIOC:SYS0:ML06:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:ML06:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:ML06:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:ML06:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:ML06:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:ML06:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:ML06:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:ML06:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:ML06:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:ML06:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:ML06:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:ML06:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:ML06: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:ML06:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:ML06:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML06:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:ML06:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:ML06:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:ML06:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML06:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:ML06:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:ML06:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:ML06:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML06:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:ML06:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:ML06:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:ML06:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML06:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:ML06:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:ML06:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:ML06:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML06:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:ML06:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:ML06:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:ML06:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML06:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:ML06:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:ML06:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:ML06:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML06:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:ML06:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:ML06:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:ML06:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML06:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:ML06:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:ML06:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:ML06:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML06:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:ML06:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:ML06:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:ML06:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:ML06:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:ML06:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:ML06: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:ML06:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:ML06:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML06:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:ML06:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:ML06:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:ML06:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:ML06:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:ML06:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:ML06:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:ML06:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:ML06:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ML07:INFO") {
  field(DESC, "SIOC:SYS0:ML07 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:ML07:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:ML07: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:ML07: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:ML07:TODDIFF")
}

record(longin, "SIOC:SYS0:ML07:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:ML07:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:ML07: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:ML07:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:ML07:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:ML07:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:ML07:TODSUM")
}

record(bo, "SIOC:SYS0:ML07:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:ML07:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:ML07:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:ML07:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML07:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:ML07:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:ML07:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:ML07:HEARTBEATE01")
  field(INP, "SIOC:SYS0:ML07:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:ML07:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:ML07:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:ML07:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:ML07:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:ML07:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:ML07:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:ML07:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:ML07:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:ML07:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:ML07:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:ML07:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:ML07: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:ML07:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:ML07:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML07:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:ML07:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:ML07:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:ML07:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML07:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:ML07:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:ML07:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:ML07:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML07:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:ML07:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:ML07:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:ML07:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML07:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:ML07:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:ML07:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:ML07:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML07:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:ML07:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:ML07:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:ML07:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML07:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:ML07:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:ML07:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:ML07:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML07:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:ML07:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:ML07:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:ML07:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML07:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:ML07:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:ML07:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:ML07:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML07:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:ML07:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:ML07:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:ML07:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:ML07:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:ML07:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:ML07: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:ML07:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:ML07:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:ML07:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:ML07:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:ML07:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:ML07:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:ML07:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:ML07:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:ML07:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:ML07:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:ML07:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS1:ML00:INFO") {
  field(DESC, "SIOC:SYS1:ML00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS1:ML00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS1:ML00: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:SYS1:ML00: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:SYS1:ML00:TODDIFF")
}

record(longin, "SIOC:SYS1:ML00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS1:ML00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS1:ML00: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:SYS1:ML00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS1:ML00:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS1:ML00:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS1:ML00:TODSUM")
}

record(bo, "SIOC:SYS1:ML00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS1:ML00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS1:ML00:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS1:ML00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML00:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS1:ML00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS1:ML00:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS1:ML00:HEARTBEATE01")
  field(INP, "SIOC:SYS1:ML00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS1:ML00:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS1:ML00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS1:ML00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS1:ML00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS1:ML00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS1:ML00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS1:ML00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS1:ML00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS1:ML00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS1:ML00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS1:ML00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS1:ML00: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:SYS1:ML00:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS1:ML00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML00:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS1:ML00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS1:ML00:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS1:ML00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML00:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS1:ML00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS1:ML00:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS1:ML00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML00:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS1:ML00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS1:ML00:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS1:ML00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML00:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS1:ML00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS1:ML00:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS1:ML00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML00:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS1:ML00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS1:ML00:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS1:ML00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML00:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS1:ML00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS1:ML00:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS1:ML00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML00:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS1:ML00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS1:ML00:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS1:ML00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML00:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS1:ML00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS1:ML00:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS1:ML00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS1:ML00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS1:ML00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS1:ML00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS1:ML00:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS1:ML00:HEARTBEATCLC")
  field(INP, "SIOC:SYS1:ML00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS1:ML00:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS1:ML00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML00:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS1:ML00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS1:ML00:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS1:ML00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS1:ML00:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS1:ML00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS1:ML00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS1:ML00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS1:ML00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS1:ML01:INFO") {
  field(DESC, "SIOC:SYS1:ML01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS1:ML01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS1:ML01: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:SYS1:ML01: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:SYS1:ML01:TODDIFF")
}

record(longin, "SIOC:SYS1:ML01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS1:ML01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS1:ML01: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:SYS1:ML01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS1:ML01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS1:ML01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS1:ML01:TODSUM")
}

record(bo, "SIOC:SYS1:ML01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS1:ML01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS1:ML01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS1:ML01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS1:ML01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS1:ML01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS1:ML01:HEARTBEATE01")
  field(INP, "SIOC:SYS1:ML01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS1:ML01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS1:ML01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS1:ML01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS1:ML01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS1:ML01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS1:ML01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS1:ML01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS1:ML01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS1:ML01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS1:ML01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS1:ML01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS1:ML01: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:SYS1:ML01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS1:ML01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS1:ML01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS1:ML01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS1:ML01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS1:ML01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS1:ML01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS1:ML01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS1:ML01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS1:ML01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS1:ML01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS1:ML01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS1:ML01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS1:ML01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS1:ML01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS1:ML01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS1:ML01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS1:ML01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS1:ML01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS1:ML01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS1:ML01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS1:ML01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS1:ML01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS1:ML01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS1:ML01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS1:ML01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS1:ML01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS1:ML01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS1:ML01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS1:ML01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS1:ML01:HEARTBEATCLC")
  field(INP, "SIOC:SYS1:ML01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS1:ML01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS1:ML01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS1:ML01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS1:ML01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS1:ML01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS1:ML01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS1:ML01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS1:ML01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS1:ML01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS1:ML01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS1:ML02:INFO") {
  field(DESC, "SIOC:SYS1:ML02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS1:ML02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS1:ML02: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:SYS1:ML02: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:SYS1:ML02:TODDIFF")
}

record(longin, "SIOC:SYS1:ML02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS1:ML02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS1:ML02: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:SYS1:ML02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS1:ML02:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS1:ML02:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS1:ML02:TODSUM")
}

record(bo, "SIOC:SYS1:ML02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS1:ML02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS1:ML02:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS1:ML02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML02:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS1:ML02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS1:ML02:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS1:ML02:HEARTBEATE01")
  field(INP, "SIOC:SYS1:ML02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS1:ML02:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS1:ML02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS1:ML02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS1:ML02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS1:ML02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS1:ML02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS1:ML02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS1:ML02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS1:ML02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS1:ML02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS1:ML02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS1:ML02: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:SYS1:ML02:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS1:ML02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML02:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS1:ML02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS1:ML02:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS1:ML02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML02:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS1:ML02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS1:ML02:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS1:ML02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML02:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS1:ML02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS1:ML02:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS1:ML02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML02:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS1:ML02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS1:ML02:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS1:ML02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML02:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS1:ML02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS1:ML02:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS1:ML02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML02:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS1:ML02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS1:ML02:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS1:ML02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML02:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS1:ML02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS1:ML02:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS1:ML02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML02:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS1:ML02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS1:ML02:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS1:ML02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS1:ML02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS1:ML02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS1:ML02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS1:ML02:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS1:ML02:HEARTBEATCLC")
  field(INP, "SIOC:SYS1:ML02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS1:ML02:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS1:ML02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML02:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS1:ML02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS1:ML02:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS1:ML02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS1:ML02:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS1:ML02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS1:ML02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS1:ML02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS1:ML02:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS1:ML03:INFO") {
  field(DESC, "SIOC:SYS1:ML03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS1:ML03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS1:ML03: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:SYS1:ML03: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:SYS1:ML03:TODDIFF")
}

record(longin, "SIOC:SYS1:ML03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS1:ML03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS1:ML03: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:SYS1:ML03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS1:ML03:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS1:ML03:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS1:ML03:TODSUM")
}

record(bo, "SIOC:SYS1:ML03:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS1:ML03:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS1:ML03:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS1:ML03:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML03:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS1:ML03:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS1:ML03:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS1:ML03:HEARTBEATE01")
  field(INP, "SIOC:SYS1:ML03:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS1:ML03:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS1:ML03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS1:ML03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS1:ML03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS1:ML03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS1:ML03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS1:ML03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS1:ML03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS1:ML03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS1:ML03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS1:ML03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS1:ML03: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:SYS1:ML03:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS1:ML03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML03:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS1:ML03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS1:ML03:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS1:ML03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML03:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS1:ML03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS1:ML03:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS1:ML03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML03:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS1:ML03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS1:ML03:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS1:ML03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML03:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS1:ML03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS1:ML03:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS1:ML03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML03:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS1:ML03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS1:ML03:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS1:ML03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML03:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS1:ML03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS1:ML03:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS1:ML03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML03:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS1:ML03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS1:ML03:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS1:ML03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML03:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS1:ML03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS1:ML03:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS1:ML03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS1:ML03:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS1:ML03:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS1:ML03:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS1:ML03:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS1:ML03:HEARTBEATCLC")
  field(INP, "SIOC:SYS1:ML03:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS1:ML03:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS1:ML03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS1:ML03:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS1:ML03:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS1:ML03:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS1:ML03:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS1:ML03:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS1:ML03:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS1:ML03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS1:ML03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS1:ML03:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS6:ML00:INFO") {
  field(DESC, "SIOC:SYS6:ML00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS6:ML00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS6:ML00: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:SYS6:ML00: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:SYS6:ML00:TODDIFF")
}

record(longin, "SIOC:SYS6:ML00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS6:ML00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS6:ML00: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:SYS6:ML00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS6:ML00:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS6:ML00:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS6:ML00:TODSUM")
}

record(bo, "SIOC:SYS6:ML00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS6:ML00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS6:ML00:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS6:ML00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML00:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS6:ML00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS6:ML00:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS6:ML00:HEARTBEATE01")
  field(INP, "SIOC:SYS6:ML00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS6:ML00:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS6:ML00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS6:ML00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS6:ML00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS6:ML00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS6:ML00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS6:ML00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS6:ML00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS6:ML00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS6:ML00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS6:ML00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS6:ML00: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:SYS6:ML00:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS6:ML00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML00:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS6:ML00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS6:ML00:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS6:ML00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML00:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS6:ML00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS6:ML00:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS6:ML00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML00:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS6:ML00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS6:ML00:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS6:ML00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML00:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS6:ML00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS6:ML00:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS6:ML00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML00:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS6:ML00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS6:ML00:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS6:ML00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML00:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS6:ML00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS6:ML00:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS6:ML00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML00:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS6:ML00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS6:ML00:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS6:ML00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML00:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS6:ML00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS6:ML00:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS6:ML00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS6:ML00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS6:ML00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS6:ML00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS6:ML00:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS6:ML00:HEARTBEATCLC")
  field(INP, "SIOC:SYS6:ML00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS6:ML00:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS6:ML00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML00:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS6:ML00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS6:ML00:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS6:ML00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS6:ML00:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS6:ML00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS6:ML00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS6:ML00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS6:ML00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS6:ML01:INFO") {
  field(DESC, "SIOC:SYS6:ML01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS6:ML01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS6:ML01: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:SYS6:ML01: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:SYS6:ML01:TODDIFF")
}

record(longin, "SIOC:SYS6:ML01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS6:ML01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS6:ML01: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:SYS6:ML01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS6:ML01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS6:ML01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS6:ML01:TODSUM")
}

record(bo, "SIOC:SYS6:ML01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS6:ML01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS6:ML01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS6:ML01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS6:ML01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS6:ML01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS6:ML01:HEARTBEATE01")
  field(INP, "SIOC:SYS6:ML01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS6:ML01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS6:ML01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS6:ML01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS6:ML01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS6:ML01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS6:ML01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS6:ML01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS6:ML01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS6:ML01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS6:ML01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS6:ML01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS6:ML01: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:SYS6:ML01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS6:ML01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS6:ML01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS6:ML01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS6:ML01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS6:ML01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS6:ML01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS6:ML01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS6:ML01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS6:ML01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS6:ML01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS6:ML01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS6:ML01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS6:ML01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS6:ML01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS6:ML01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS6:ML01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS6:ML01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS6:ML01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS6:ML01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS6:ML01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS6:ML01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS6:ML01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS6:ML01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS6:ML01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS6:ML01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS6:ML01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS6:ML01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS6:ML01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS6:ML01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS6:ML01:HEARTBEATCLC")
  field(INP, "SIOC:SYS6:ML01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS6:ML01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS6:ML01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS6:ML01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS6:ML01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS6:ML01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS6:ML01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS6:ML01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS6:ML01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS6:ML01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS6:ML01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS6:ML02:INFO") {
  field(DESC, "SIOC:SYS6:ML02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS6:ML02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS6:ML02: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:SYS6:ML02: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:SYS6:ML02:TODDIFF")
}

record(longin, "SIOC:SYS6:ML02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS6:ML02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS6:ML02: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:SYS6:ML02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS6:ML02:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS6:ML02:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS6:ML02:TODSUM")
}

record(bo, "SIOC:SYS6:ML02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS6:ML02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS6:ML02:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS6:ML02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML02:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS6:ML02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS6:ML02:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS6:ML02:HEARTBEATE01")
  field(INP, "SIOC:SYS6:ML02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS6:ML02:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS6:ML02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS6:ML02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS6:ML02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS6:ML02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS6:ML02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS6:ML02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS6:ML02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS6:ML02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS6:ML02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS6:ML02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS6:ML02: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:SYS6:ML02:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS6:ML02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML02:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS6:ML02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS6:ML02:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS6:ML02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML02:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS6:ML02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS6:ML02:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS6:ML02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML02:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS6:ML02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS6:ML02:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS6:ML02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML02:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS6:ML02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS6:ML02:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS6:ML02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML02:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS6:ML02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS6:ML02:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS6:ML02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML02:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS6:ML02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS6:ML02:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS6:ML02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML02:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS6:ML02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS6:ML02:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS6:ML02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML02:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS6:ML02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS6:ML02:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS6:ML02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS6:ML02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS6:ML02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS6:ML02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS6:ML02:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS6:ML02:HEARTBEATCLC")
  field(INP, "SIOC:SYS6:ML02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS6:ML02:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS6:ML02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML02:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS6:ML02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS6:ML02:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS6:ML02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS6:ML02:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS6:ML02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS6:ML02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS6:ML02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS6:ML02:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS6:ML03:INFO") {
  field(DESC, "SIOC:SYS6:ML03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS6:ML03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS6:ML03: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:SYS6:ML03: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:SYS6:ML03:TODDIFF")
}

record(longin, "SIOC:SYS6:ML03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS6:ML03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS6:ML03: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:SYS6:ML03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS6:ML03:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS6:ML03:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS6:ML03:TODSUM")
}

record(bo, "SIOC:SYS6:ML03:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS6:ML03:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS6:ML03:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS6:ML03:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML03:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS6:ML03:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS6:ML03:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS6:ML03:HEARTBEATE01")
  field(INP, "SIOC:SYS6:ML03:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS6:ML03:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS6:ML03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS6:ML03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS6:ML03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS6:ML03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS6:ML03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS6:ML03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS6:ML03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS6:ML03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS6:ML03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS6:ML03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS6:ML03: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:SYS6:ML03:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS6:ML03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML03:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS6:ML03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS6:ML03:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS6:ML03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML03:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS6:ML03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS6:ML03:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS6:ML03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML03:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS6:ML03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS6:ML03:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS6:ML03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML03:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS6:ML03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS6:ML03:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS6:ML03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML03:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS6:ML03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS6:ML03:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS6:ML03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML03:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS6:ML03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS6:ML03:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS6:ML03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML03:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS6:ML03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS6:ML03:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS6:ML03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML03:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS6:ML03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS6:ML03:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS6:ML03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS6:ML03:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS6:ML03:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS6:ML03:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS6:ML03:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS6:ML03:HEARTBEATCLC")
  field(INP, "SIOC:SYS6:ML03:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS6:ML03:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS6:ML03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS6:ML03:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS6:ML03:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS6:ML03:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS6:ML03:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS6:ML03:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS6:ML03:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS6:ML03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS6:ML03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS6:ML03:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS7:ML00:INFO") {
  field(DESC, "SIOC:SYS7:ML00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS7:ML00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS7:ML00: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:SYS7:ML00: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:SYS7:ML00:TODDIFF")
}

record(longin, "SIOC:SYS7:ML00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS7:ML00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS7:ML00: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:SYS7:ML00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS7:ML00:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS7:ML00:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS7:ML00:TODSUM")
}

record(bo, "SIOC:SYS7:ML00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS7:ML00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS7:ML00:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS7:ML00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML00:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS7:ML00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS7:ML00:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS7:ML00:HEARTBEATE01")
  field(INP, "SIOC:SYS7:ML00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS7:ML00:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS7:ML00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS7:ML00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS7:ML00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS7:ML00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS7:ML00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS7:ML00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS7:ML00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS7:ML00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS7:ML00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS7:ML00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS7:ML00: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:SYS7:ML00:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS7:ML00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML00:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS7:ML00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS7:ML00:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS7:ML00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML00:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS7:ML00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS7:ML00:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS7:ML00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML00:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS7:ML00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS7:ML00:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS7:ML00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML00:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS7:ML00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS7:ML00:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS7:ML00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML00:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS7:ML00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS7:ML00:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS7:ML00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML00:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS7:ML00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS7:ML00:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS7:ML00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML00:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS7:ML00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS7:ML00:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS7:ML00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML00:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS7:ML00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS7:ML00:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS7:ML00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS7:ML00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS7:ML00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS7:ML00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS7:ML00:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS7:ML00:HEARTBEATCLC")
  field(INP, "SIOC:SYS7:ML00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS7:ML00:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS7:ML00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML00:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS7:ML00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS7:ML00:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS7:ML00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS7:ML00:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS7:ML00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS7:ML00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS7:ML00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS7:ML00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS7:ML01:INFO") {
  field(DESC, "SIOC:SYS7:ML01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS7:ML01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS7:ML01: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:SYS7:ML01: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:SYS7:ML01:TODDIFF")
}

record(longin, "SIOC:SYS7:ML01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS7:ML01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS7:ML01: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:SYS7:ML01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS7:ML01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS7:ML01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS7:ML01:TODSUM")
}

record(bo, "SIOC:SYS7:ML01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS7:ML01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS7:ML01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS7:ML01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS7:ML01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS7:ML01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS7:ML01:HEARTBEATE01")
  field(INP, "SIOC:SYS7:ML01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS7:ML01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS7:ML01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS7:ML01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS7:ML01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS7:ML01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS7:ML01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS7:ML01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS7:ML01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS7:ML01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS7:ML01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS7:ML01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS7:ML01: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:SYS7:ML01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS7:ML01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS7:ML01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS7:ML01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS7:ML01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS7:ML01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS7:ML01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS7:ML01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS7:ML01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS7:ML01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS7:ML01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS7:ML01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS7:ML01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS7:ML01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS7:ML01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS7:ML01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS7:ML01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS7:ML01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS7:ML01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS7:ML01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS7:ML01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS7:ML01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS7:ML01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS7:ML01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS7:ML01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS7:ML01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS7:ML01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS7:ML01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS7:ML01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS7:ML01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS7:ML01:HEARTBEATCLC")
  field(INP, "SIOC:SYS7:ML01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS7:ML01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS7:ML01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS7:ML01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS7:ML01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS7:ML01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS7:ML01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS7:ML01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS7:ML01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS7:ML01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS7:ML01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS7:ML02:INFO") {
  field(DESC, "SIOC:SYS7:ML02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS7:ML02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS7:ML02: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:SYS7:ML02: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:SYS7:ML02:TODDIFF")
}

record(longin, "SIOC:SYS7:ML02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS7:ML02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS7:ML02: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:SYS7:ML02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS7:ML02:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS7:ML02:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS7:ML02:TODSUM")
}

record(bo, "SIOC:SYS7:ML02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS7:ML02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS7:ML02:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS7:ML02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML02:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS7:ML02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS7:ML02:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS7:ML02:HEARTBEATE01")
  field(INP, "SIOC:SYS7:ML02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS7:ML02:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS7:ML02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS7:ML02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS7:ML02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS7:ML02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS7:ML02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS7:ML02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS7:ML02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS7:ML02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS7:ML02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS7:ML02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS7:ML02: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:SYS7:ML02:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS7:ML02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML02:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS7:ML02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS7:ML02:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS7:ML02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML02:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS7:ML02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS7:ML02:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS7:ML02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML02:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS7:ML02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS7:ML02:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS7:ML02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML02:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS7:ML02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS7:ML02:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS7:ML02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML02:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS7:ML02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS7:ML02:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS7:ML02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML02:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS7:ML02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS7:ML02:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS7:ML02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML02:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS7:ML02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS7:ML02:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS7:ML02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML02:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS7:ML02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS7:ML02:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS7:ML02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS7:ML02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS7:ML02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS7:ML02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS7:ML02:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS7:ML02:HEARTBEATCLC")
  field(INP, "SIOC:SYS7:ML02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS7:ML02:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS7:ML02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML02:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS7:ML02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS7:ML02:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS7:ML02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS7:ML02:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS7:ML02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS7:ML02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS7:ML02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS7:ML02:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS7:ML03:INFO") {
  field(DESC, "SIOC:SYS7:ML03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS7:ML03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS7:ML03: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:SYS7:ML03: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:SYS7:ML03:TODDIFF")
}

record(longin, "SIOC:SYS7:ML03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS7:ML03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS7:ML03: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:SYS7:ML03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS7:ML03:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS7:ML03:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS7:ML03:TODSUM")
}

record(bo, "SIOC:SYS7:ML03:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS7:ML03:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS7:ML03:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS7:ML03:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML03:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS7:ML03:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS7:ML03:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS7:ML03:HEARTBEATE01")
  field(INP, "SIOC:SYS7:ML03:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS7:ML03:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS7:ML03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS7:ML03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS7:ML03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS7:ML03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS7:ML03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS7:ML03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS7:ML03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS7:ML03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS7:ML03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS7:ML03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS7:ML03: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:SYS7:ML03:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS7:ML03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML03:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS7:ML03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS7:ML03:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS7:ML03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML03:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS7:ML03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS7:ML03:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS7:ML03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML03:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS7:ML03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS7:ML03:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS7:ML03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML03:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS7:ML03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS7:ML03:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS7:ML03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML03:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS7:ML03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS7:ML03:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS7:ML03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML03:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS7:ML03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS7:ML03:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS7:ML03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML03:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS7:ML03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS7:ML03:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS7:ML03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML03:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS7:ML03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS7:ML03:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS7:ML03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS7:ML03:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS7:ML03:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS7:ML03:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS7:ML03:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS7:ML03:HEARTBEATCLC")
  field(INP, "SIOC:SYS7:ML03:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS7:ML03:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS7:ML03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS7:ML03:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS7:ML03:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS7:ML03:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS7:ML03:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS7:ML03:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS7:ML03:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS7:ML03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS7:ML03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS7:ML03:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS8:ML00:INFO") {
  field(DESC, "SIOC:SYS8:ML00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS8:ML00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS8:ML00: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:SYS8:ML00: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:SYS8:ML00:TODDIFF")
}

record(longin, "SIOC:SYS8:ML00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS8:ML00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS8:ML00: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:SYS8:ML00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS8:ML00:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS8:ML00:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS8:ML00:TODSUM")
}

record(bo, "SIOC:SYS8:ML00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS8:ML00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS8:ML00:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS8:ML00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML00:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS8:ML00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS8:ML00:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS8:ML00:HEARTBEATE01")
  field(INP, "SIOC:SYS8:ML00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS8:ML00:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS8:ML00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS8:ML00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS8:ML00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS8:ML00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS8:ML00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS8:ML00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS8:ML00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS8:ML00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS8:ML00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS8:ML00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS8:ML00: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:SYS8:ML00:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS8:ML00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML00:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS8:ML00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS8:ML00:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS8:ML00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML00:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS8:ML00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS8:ML00:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS8:ML00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML00:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS8:ML00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS8:ML00:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS8:ML00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML00:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS8:ML00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS8:ML00:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS8:ML00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML00:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS8:ML00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS8:ML00:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS8:ML00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML00:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS8:ML00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS8:ML00:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS8:ML00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML00:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS8:ML00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS8:ML00:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS8:ML00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML00:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS8:ML00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS8:ML00:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS8:ML00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS8:ML00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS8:ML00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS8:ML00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS8:ML00:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS8:ML00:HEARTBEATCLC")
  field(INP, "SIOC:SYS8:ML00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS8:ML00:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS8:ML00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML00:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS8:ML00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS8:ML00:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS8:ML00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS8:ML00:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS8:ML00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS8:ML00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS8:ML00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS8:ML00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS8:ML01:INFO") {
  field(DESC, "SIOC:SYS8:ML01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS8:ML01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS8:ML01: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:SYS8:ML01: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:SYS8:ML01:TODDIFF")
}

record(longin, "SIOC:SYS8:ML01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS8:ML01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS8:ML01: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:SYS8:ML01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS8:ML01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS8:ML01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS8:ML01:TODSUM")
}

record(bo, "SIOC:SYS8:ML01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS8:ML01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS8:ML01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS8:ML01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS8:ML01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS8:ML01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS8:ML01:HEARTBEATE01")
  field(INP, "SIOC:SYS8:ML01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS8:ML01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS8:ML01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS8:ML01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS8:ML01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS8:ML01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS8:ML01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS8:ML01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS8:ML01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS8:ML01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS8:ML01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS8:ML01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS8:ML01: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:SYS8:ML01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS8:ML01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS8:ML01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS8:ML01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS8:ML01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS8:ML01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS8:ML01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS8:ML01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS8:ML01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS8:ML01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS8:ML01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS8:ML01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS8:ML01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS8:ML01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS8:ML01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS8:ML01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS8:ML01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS8:ML01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS8:ML01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS8:ML01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS8:ML01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS8:ML01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS8:ML01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS8:ML01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS8:ML01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS8:ML01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS8:ML01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS8:ML01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS8:ML01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS8:ML01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS8:ML01:HEARTBEATCLC")
  field(INP, "SIOC:SYS8:ML01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS8:ML01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS8:ML01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS8:ML01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS8:ML01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS8:ML01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS8:ML01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS8:ML01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS8:ML01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS8:ML01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS8:ML01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS8:ML02:INFO") {
  field(DESC, "SIOC:SYS8:ML02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS8:ML02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS8:ML02: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:SYS8:ML02: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:SYS8:ML02:TODDIFF")
}

record(longin, "SIOC:SYS8:ML02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS8:ML02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS8:ML02: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:SYS8:ML02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS8:ML02:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS8:ML02:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS8:ML02:TODSUM")
}

record(bo, "SIOC:SYS8:ML02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS8:ML02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS8:ML02:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS8:ML02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML02:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS8:ML02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS8:ML02:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS8:ML02:HEARTBEATE01")
  field(INP, "SIOC:SYS8:ML02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS8:ML02:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS8:ML02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS8:ML02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS8:ML02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS8:ML02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS8:ML02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS8:ML02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS8:ML02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS8:ML02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS8:ML02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS8:ML02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS8:ML02: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:SYS8:ML02:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS8:ML02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML02:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS8:ML02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS8:ML02:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS8:ML02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML02:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS8:ML02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS8:ML02:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS8:ML02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML02:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS8:ML02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS8:ML02:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS8:ML02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML02:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS8:ML02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS8:ML02:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS8:ML02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML02:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS8:ML02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS8:ML02:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS8:ML02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML02:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS8:ML02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS8:ML02:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS8:ML02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML02:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS8:ML02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS8:ML02:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS8:ML02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML02:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS8:ML02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS8:ML02:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS8:ML02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS8:ML02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS8:ML02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS8:ML02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS8:ML02:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS8:ML02:HEARTBEATCLC")
  field(INP, "SIOC:SYS8:ML02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS8:ML02:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS8:ML02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML02:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS8:ML02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS8:ML02:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS8:ML02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS8:ML02:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS8:ML02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS8:ML02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS8:ML02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS8:ML02:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:SYS8:ML03:INFO") {
  field(DESC, "SIOC:SYS8:ML03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS8:ML03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  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:SYS8:ML03: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:SYS8:ML03: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:SYS8:ML03:TODDIFF")
}

record(longin, "SIOC:SYS8:ML03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS8:ML03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS8:ML03: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:SYS8:ML03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS8:ML03:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS8:ML03:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS8:ML03:TODSUM")
}

record(bo, "SIOC:SYS8:ML03:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS8:ML03:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS8:ML03:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS8:ML03:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML03:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS8:ML03:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS8:ML03:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS8:ML03:HEARTBEATE01")
  field(INP, "SIOC:SYS8:ML03:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS8:ML03:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS8:ML03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS8:ML03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS8:ML03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS8:ML03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS8:ML03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS8:ML03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS8:ML03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS8:ML03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS8:ML03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS8:ML03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS8:ML03: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:SYS8:ML03:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS8:ML03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML03:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS8:ML03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS8:ML03:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS8:ML03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML03:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS8:ML03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS8:ML03:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS8:ML03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML03:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS8:ML03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS8:ML03:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS8:ML03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML03:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS8:ML03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS8:ML03:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS8:ML03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML03:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS8:ML03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS8:ML03:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS8:ML03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML03:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS8:ML03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS8:ML03:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS8:ML03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML03:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS8:ML03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS8:ML03:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS8:ML03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML03:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS8:ML03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS8:ML03:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS8:ML03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS8:ML03:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS8:ML03:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS8:ML03:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS8:ML03:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS8:ML03:HEARTBEATCLC")
  field(INP, "SIOC:SYS8:ML03:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS8:ML03:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS8:ML03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS8:ML03:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS8:ML03:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS8:ML03:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS8:ML03:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS8:ML03:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS8:ML03:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS8:ML03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS8:ML03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS8:ML03:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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: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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP00:CR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP00:CR02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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: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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP08:CR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP12:CR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP12:CR02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP12:CR03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP12:CR04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP12:CR05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP12:CR06:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP12:CR07:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP12:CR08:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "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: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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP14:CR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP22:CR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP22:CR02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP22:CR03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP22:CR04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP22:CR05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP22:CR06:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP22:CR07:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP22:CR08:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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, "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: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, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:CP24:CR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  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:ALH2:NTWK00:INFO") {
  field(DESC, "SIOC:ALH2:NTWK00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH2:NTWK00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH2:NTWK00: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:ALH2:NTWK00: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:ALH2:NTWK00:TODDIFF")
}

record(longin, "SIOC:ALH2:NTWK00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH2:NTWK00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH2:NTWK00: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:ALH2:NTWK00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH2:NTWK00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH2:NTWK00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH2:NTWK00:TODSUM")
}

record(bo, "SIOC:ALH2:NTWK00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH2:NTWK00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH2:NTWK00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH2:NTWK00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH2:NTWK00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH2:NTWK00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH2:NTWK00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH2:NTWK00:HEARTBEATE01")
  field(INP, "SIOC:ALH2:NTWK00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH2:NTWK00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH2:NTWK00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH2:NTWK00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH2:NTWK00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH2:NTWK00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH2:NTWK00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH2:NTWK00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH2:NTWK00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH2:NTWK00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH2:NTWK00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH2:NTWK00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH2:NTWK00: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:ALH2:NTWK00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH2:NTWK00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH2:NTWK00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH2:NTWK00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH2:NTWK00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH2:NTWK00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH2:NTWK00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH2:NTWK00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH2:NTWK00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH2:NTWK00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH2:NTWK00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH2:NTWK00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH2:NTWK00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH2:NTWK00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH2:NTWK00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH2:NTWK00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH2:NTWK00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH2:NTWK00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH2:NTWK00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH2:NTWK00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH2:NTWK00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH2:NTWK00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH2:NTWK00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH2:NTWK00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH2:NTWK00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH2:NTWK00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH2:NTWK00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH2:NTWK00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH2:NTWK00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH2:NTWK00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH2:NTWK00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH2:NTWK00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH2:NTWK00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH2:NTWK00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH2:NTWK00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH2:NTWK00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH2:NTWK00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH2:NTWK00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH2:NTWK00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH2:NTWK00:HEARTBEATCLC")
  field(INP, "SIOC:ALH2:NTWK00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH2:NTWK00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH2:NTWK00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH2:NTWK00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH2:NTWK00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH2:NTWK00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH2:NTWK00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH2:NTWK00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH2:NTWK00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH2:NTWK00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH2:NTWK00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH2:NTWK00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:GADC00:INFO") {
  field(DESC, "SIOC:ALH0:GADC00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:GADC00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH0:GADC00: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:ALH0:GADC00: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:ALH0:GADC00:TODDIFF")
}

record(longin, "SIOC:ALH0:GADC00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:GADC00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:GADC00: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:ALH0:GADC00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:GADC00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:GADC00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:GADC00:TODSUM")
}

record(bo, "SIOC:ALH0:GADC00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:GADC00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:GADC00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:GADC00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:GADC00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:GADC00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:GADC00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:GADC00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:GADC00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:GADC00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:GADC00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:GADC00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:GADC00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:GADC00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:GADC00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:GADC00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:GADC00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:GADC00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:GADC00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:GADC00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:GADC00: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:ALH0:GADC00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:GADC00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:GADC00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:GADC00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:GADC00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:GADC00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:GADC00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:GADC00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:GADC00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:GADC00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:GADC00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:GADC00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:GADC00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:GADC00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:GADC00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:GADC00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:GADC00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:GADC00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:GADC00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:GADC00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:GADC00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:GADC00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:GADC00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:GADC00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:GADC00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:GADC00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:GADC00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:GADC00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:GADC00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:GADC00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:GADC00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:GADC00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:GADC00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:GADC00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:GADC00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:GADC00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:GADC00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:GADC00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:GADC00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:GADC00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:GADC00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:GADC00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:GADC00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:GADC00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:GADC00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:GADC00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:GADC00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:GADC00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:GADC00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:GADC00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:GADC00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:GADC00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:FBCK00:INFO") {
  field(DESC, "SIOC:ALH0:FBCK00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:FBCK00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH0:FBCK00: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:ALH0:FBCK00: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:ALH0:FBCK00:TODDIFF")
}

record(longin, "SIOC:ALH0:FBCK00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:FBCK00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:FBCK00: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:ALH0:FBCK00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:FBCK00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:FBCK00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:FBCK00:TODSUM")
}

record(bo, "SIOC:ALH0:FBCK00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:FBCK00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:FBCK00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:FBCK00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:FBCK00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:FBCK00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:FBCK00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:FBCK00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:FBCK00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:FBCK00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:FBCK00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:FBCK00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:FBCK00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:FBCK00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:FBCK00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:FBCK00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:FBCK00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:FBCK00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:FBCK00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:FBCK00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:FBCK00: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:ALH0:FBCK00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:FBCK00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:FBCK00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:FBCK00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:FBCK00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:FBCK00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:FBCK00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:FBCK00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:FBCK00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:FBCK00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:FBCK00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:FBCK00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:FBCK00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:FBCK00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:FBCK00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:FBCK00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:FBCK00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:FBCK00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:FBCK00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:FBCK00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:FBCK00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:FBCK00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:FBCK00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:FBCK00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:FBCK00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:FBCK00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:FBCK00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:FBCK00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:FBCK00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:FBCK00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:FBCK00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:FBCK00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:FBCK00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:FBCK00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:FBCK00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:FBCK00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:FBCK00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:FBCK00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:FBCK00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:FBCK00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:FBCK00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:FBCK00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:FBCK00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:FBCK00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:FBCK00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:FBCK00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:FBCK00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:FBCK00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:FBCK00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:FBCK00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:FBCK00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:FBCK00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:MGNT00:INFO") {
  field(DESC, "SIOC:ALH0:MGNT00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:MGNT00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH0:MGNT00: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:ALH0:MGNT00: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:ALH0:MGNT00:TODDIFF")
}

record(longin, "SIOC:ALH0:MGNT00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:MGNT00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:MGNT00: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:ALH0:MGNT00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:MGNT00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:MGNT00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:MGNT00:TODSUM")
}

record(bo, "SIOC:ALH0:MGNT00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:MGNT00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:MGNT00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:MGNT00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MGNT00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:MGNT00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:MGNT00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:MGNT00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:MGNT00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:MGNT00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:MGNT00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:MGNT00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:MGNT00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:MGNT00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:MGNT00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:MGNT00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:MGNT00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:MGNT00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:MGNT00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:MGNT00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:MGNT00: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:ALH0:MGNT00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:MGNT00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MGNT00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:MGNT00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:MGNT00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:MGNT00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MGNT00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:MGNT00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:MGNT00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:MGNT00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MGNT00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:MGNT00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:MGNT00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:MGNT00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MGNT00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:MGNT00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:MGNT00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:MGNT00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MGNT00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:MGNT00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:MGNT00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:MGNT00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MGNT00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:MGNT00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:MGNT00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:MGNT00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MGNT00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:MGNT00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:MGNT00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:MGNT00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MGNT00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:MGNT00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:MGNT00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:MGNT00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MGNT00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:MGNT00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:MGNT00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:MGNT00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:MGNT00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:MGNT00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:MGNT00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:MGNT00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:MGNT00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MGNT00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:MGNT00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:MGNT00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:MGNT00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:MGNT00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:MGNT00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:MGNT00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:MGNT00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:MGNT00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:PROF00:INFO") {
  field(DESC, "SIOC:ALH0:PROF00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:PROF00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH0:PROF00: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:ALH0:PROF00: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:ALH0:PROF00:TODDIFF")
}

record(longin, "SIOC:ALH0:PROF00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:PROF00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:PROF00: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:ALH0:PROF00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:PROF00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:PROF00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:PROF00:TODSUM")
}

record(bo, "SIOC:ALH0:PROF00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:PROF00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:PROF00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:PROF00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PROF00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:PROF00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:PROF00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:PROF00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:PROF00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:PROF00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:PROF00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:PROF00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:PROF00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:PROF00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:PROF00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:PROF00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:PROF00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:PROF00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:PROF00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:PROF00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:PROF00: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:ALH0:PROF00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:PROF00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PROF00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:PROF00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:PROF00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:PROF00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PROF00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:PROF00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:PROF00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:PROF00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PROF00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:PROF00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:PROF00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:PROF00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PROF00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:PROF00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:PROF00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:PROF00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PROF00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:PROF00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:PROF00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:PROF00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PROF00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:PROF00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:PROF00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:PROF00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PROF00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:PROF00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:PROF00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:PROF00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PROF00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:PROF00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:PROF00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:PROF00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PROF00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:PROF00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:PROF00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:PROF00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:PROF00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:PROF00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:PROF00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:PROF00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:PROF00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PROF00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:PROF00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:PROF00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:PROF00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:PROF00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:PROF00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:PROF00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:PROF00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:PROF00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:WS00:INFO") {
  field(DESC, "SIOC:ALH0:WS00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:WS00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH0:WS00: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:ALH0:WS00: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:ALH0:WS00:TODDIFF")
}

record(longin, "SIOC:ALH0:WS00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:WS00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:WS00: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:ALH0:WS00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:WS00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:WS00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:WS00:TODSUM")
}

record(bo, "SIOC:ALH0:WS00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:WS00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:WS00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:WS00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:WS00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:WS00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:WS00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:WS00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:WS00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:WS00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:WS00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:WS00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:WS00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:WS00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:WS00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:WS00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:WS00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:WS00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:WS00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:WS00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:WS00: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:ALH0:WS00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:WS00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:WS00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:WS00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:WS00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:WS00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:WS00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:WS00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:WS00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:WS00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:WS00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:WS00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:WS00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:WS00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:WS00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:WS00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:WS00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:WS00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:WS00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:WS00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:WS00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:WS00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:WS00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:WS00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:WS00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:WS00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:WS00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:WS00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:WS00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:WS00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:WS00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:WS00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:WS00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:WS00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:WS00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:WS00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:WS00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:WS00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:WS00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:WS00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:WS00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:WS00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:WS00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:WS00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:WS00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:WS00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:WS00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:WS00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:WS00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:WS00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:WS00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:WS00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:MC00:INFO") {
  field(DESC, "SIOC:ALH0:MC00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:MC00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH0:MC00: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:ALH0:MC00: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:ALH0:MC00:TODDIFF")
}

record(longin, "SIOC:ALH0:MC00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:MC00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:MC00: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:ALH0:MC00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:MC00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:MC00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:MC00:TODSUM")
}

record(bo, "SIOC:ALH0:MC00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:MC00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:MC00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:MC00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MC00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:MC00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:MC00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:MC00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:MC00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:MC00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:MC00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:MC00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:MC00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:MC00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:MC00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:MC00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:MC00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:MC00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:MC00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:MC00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:MC00: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:ALH0:MC00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:MC00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MC00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:MC00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:MC00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:MC00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MC00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:MC00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:MC00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:MC00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MC00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:MC00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:MC00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:MC00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MC00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:MC00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:MC00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:MC00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MC00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:MC00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:MC00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:MC00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MC00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:MC00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:MC00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:MC00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MC00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:MC00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:MC00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:MC00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MC00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:MC00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:MC00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:MC00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MC00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:MC00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:MC00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:MC00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:MC00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:MC00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:MC00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:MC00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:MC00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MC00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:MC00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:MC00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:MC00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:MC00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:MC00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:MC00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:MC00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:MC00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:LASR00:INFO") {
  field(DESC, "SIOC:ALH0:LASR00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:LASR00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH0:LASR00: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:ALH0:LASR00: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:ALH0:LASR00:TODDIFF")
}

record(longin, "SIOC:ALH0:LASR00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:LASR00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:LASR00: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:ALH0:LASR00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:LASR00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:LASR00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:LASR00:TODSUM")
}

record(bo, "SIOC:ALH0:LASR00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:LASR00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:LASR00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:LASR00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:LASR00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:LASR00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:LASR00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:LASR00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:LASR00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:LASR00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:LASR00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:LASR00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:LASR00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:LASR00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:LASR00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:LASR00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:LASR00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:LASR00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:LASR00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:LASR00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:LASR00: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:ALH0:LASR00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:LASR00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:LASR00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:LASR00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:LASR00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:LASR00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:LASR00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:LASR00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:LASR00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:LASR00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:LASR00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:LASR00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:LASR00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:LASR00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:LASR00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:LASR00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:LASR00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:LASR00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:LASR00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:LASR00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:LASR00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:LASR00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:LASR00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:LASR00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:LASR00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:LASR00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:LASR00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:LASR00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:LASR00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:LASR00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:LASR00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:LASR00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:LASR00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:LASR00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:LASR00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:LASR00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:LASR00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:LASR00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:LASR00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:LASR00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:LASR00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:LASR00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:LASR00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:LASR00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:LASR00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:LASR00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:LASR00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:LASR00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:LASR00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:LASR00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:LASR00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:LASR00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:RF00:INFO") {
  field(DESC, "SIOC:ALH0:RF00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:RF00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH0:RF00: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:ALH0:RF00: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:ALH0:RF00:TODDIFF")
}

record(longin, "SIOC:ALH0:RF00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:RF00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:RF00: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:ALH0:RF00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:RF00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:RF00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:RF00:TODSUM")
}

record(bo, "SIOC:ALH0:RF00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:RF00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:RF00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:RF00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:RF00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:RF00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:RF00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:RF00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:RF00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:RF00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:RF00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:RF00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:RF00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:RF00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:RF00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:RF00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:RF00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:RF00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:RF00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:RF00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:RF00: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:ALH0:RF00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:RF00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:RF00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:RF00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:RF00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:RF00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:RF00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:RF00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:RF00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:RF00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:RF00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:RF00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:RF00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:RF00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:RF00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:RF00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:RF00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:RF00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:RF00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:RF00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:RF00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:RF00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:RF00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:RF00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:RF00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:RF00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:RF00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:RF00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:RF00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:RF00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:RF00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:RF00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:RF00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:RF00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:RF00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:RF00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:RF00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:RF00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:RF00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:RF00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:RF00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:RF00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:RF00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:RF00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:RF00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:RF00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:RF00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:RF00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:RF00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:RF00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:RF00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:RF00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:EVNT00:INFO") {
  field(DESC, "SIOC:ALH0:EVNT00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:EVNT00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH0:EVNT00: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:ALH0:EVNT00: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:ALH0:EVNT00:TODDIFF")
}

record(longin, "SIOC:ALH0:EVNT00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:EVNT00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:EVNT00: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:ALH0:EVNT00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:EVNT00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:EVNT00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:EVNT00:TODSUM")
}

record(bo, "SIOC:ALH0:EVNT00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:EVNT00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:EVNT00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:EVNT00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:EVNT00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:EVNT00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:EVNT00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:EVNT00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:EVNT00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:EVNT00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:EVNT00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:EVNT00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:EVNT00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:EVNT00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:EVNT00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:EVNT00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:EVNT00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:EVNT00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:EVNT00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:EVNT00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:EVNT00: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:ALH0:EVNT00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:EVNT00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:EVNT00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:EVNT00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:EVNT00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:EVNT00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:EVNT00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:EVNT00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:EVNT00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:EVNT00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:EVNT00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:EVNT00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:EVNT00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:EVNT00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:EVNT00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:EVNT00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:EVNT00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:EVNT00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:EVNT00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:EVNT00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:EVNT00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:EVNT00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:EVNT00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:EVNT00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:EVNT00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:EVNT00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:EVNT00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:EVNT00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:EVNT00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:EVNT00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:EVNT00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:EVNT00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:EVNT00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:EVNT00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:EVNT00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:EVNT00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:EVNT00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:EVNT00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:EVNT00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:EVNT00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:EVNT00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:EVNT00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:EVNT00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:EVNT00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:EVNT00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:EVNT00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:EVNT00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:EVNT00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:EVNT00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:EVNT00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:EVNT00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:EVNT00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:NTWK00:INFO") {
  field(DESC, "SIOC:ALH0:NTWK00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:NTWK00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH0:NTWK00: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:ALH0:NTWK00: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:ALH0:NTWK00:TODDIFF")
}

record(longin, "SIOC:ALH0:NTWK00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:NTWK00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:NTWK00: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:ALH0:NTWK00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:NTWK00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:NTWK00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:NTWK00:TODSUM")
}

record(bo, "SIOC:ALH0:NTWK00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:NTWK00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:NTWK00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:NTWK00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:NTWK00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:NTWK00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:NTWK00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:NTWK00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:NTWK00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:NTWK00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:NTWK00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:NTWK00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:NTWK00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:NTWK00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:NTWK00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:NTWK00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:NTWK00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:NTWK00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:NTWK00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:NTWK00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:NTWK00: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:ALH0:NTWK00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:NTWK00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:NTWK00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:NTWK00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:NTWK00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:NTWK00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:NTWK00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:NTWK00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:NTWK00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:NTWK00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:NTWK00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:NTWK00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:NTWK00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:NTWK00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:NTWK00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:NTWK00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:NTWK00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:NTWK00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:NTWK00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:NTWK00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:NTWK00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:NTWK00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:NTWK00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:NTWK00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:NTWK00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:NTWK00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:NTWK00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:NTWK00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:NTWK00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:NTWK00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:NTWK00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:NTWK00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:NTWK00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:NTWK00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:NTWK00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:NTWK00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:NTWK00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:NTWK00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:NTWK00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:NTWK00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:NTWK00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:NTWK00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:NTWK00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:NTWK00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:NTWK00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:NTWK00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:NTWK00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:NTWK00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:NTWK00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:NTWK00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:NTWK00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:NTWK00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:UTIL00:INFO") {
  field(DESC, "SIOC:ALH0:UTIL00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:UTIL00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH0:UTIL00: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:ALH0:UTIL00: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:ALH0:UTIL00:TODDIFF")
}

record(longin, "SIOC:ALH0:UTIL00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:UTIL00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:UTIL00: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:ALH0:UTIL00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:UTIL00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:UTIL00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:UTIL00:TODSUM")
}

record(bo, "SIOC:ALH0:UTIL00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:UTIL00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:UTIL00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:UTIL00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:UTIL00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:UTIL00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:UTIL00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:UTIL00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:UTIL00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:UTIL00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:UTIL00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:UTIL00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:UTIL00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:UTIL00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:UTIL00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:UTIL00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:UTIL00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:UTIL00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:UTIL00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:UTIL00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:UTIL00: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:ALH0:UTIL00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:UTIL00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:UTIL00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:UTIL00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:UTIL00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:UTIL00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:UTIL00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:UTIL00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:UTIL00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:UTIL00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:UTIL00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:UTIL00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:UTIL00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:UTIL00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:UTIL00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:UTIL00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:UTIL00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:UTIL00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:UTIL00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:UTIL00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:UTIL00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:UTIL00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:UTIL00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:UTIL00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:UTIL00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:UTIL00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:UTIL00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:UTIL00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:UTIL00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:UTIL00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:UTIL00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:UTIL00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:UTIL00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:UTIL00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:UTIL00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:UTIL00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:UTIL00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:UTIL00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:UTIL00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:UTIL00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:UTIL00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:UTIL00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:UTIL00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:UTIL00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:UTIL00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:UTIL00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:UTIL00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:UTIL00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:UTIL00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:UTIL00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:UTIL00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:UTIL00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:VAC00:INFO") {
  field(DESC, "SIOC:ALH0:VAC00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:VAC00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH0:VAC00: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:ALH0:VAC00: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:ALH0:VAC00:TODDIFF")
}

record(longin, "SIOC:ALH0:VAC00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:VAC00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:VAC00: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:ALH0:VAC00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:VAC00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:VAC00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:VAC00:TODSUM")
}

record(bo, "SIOC:ALH0:VAC00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:VAC00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:VAC00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:VAC00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:VAC00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:VAC00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:VAC00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:VAC00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:VAC00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:VAC00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:VAC00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:VAC00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:VAC00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:VAC00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:VAC00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:VAC00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:VAC00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:VAC00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:VAC00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:VAC00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:VAC00: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:ALH0:VAC00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:VAC00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:VAC00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:VAC00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:VAC00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:VAC00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:VAC00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:VAC00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:VAC00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:VAC00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:VAC00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:VAC00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:VAC00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:VAC00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:VAC00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:VAC00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:VAC00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:VAC00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:VAC00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:VAC00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:VAC00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:VAC00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:VAC00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:VAC00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:VAC00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:VAC00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:VAC00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:VAC00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:VAC00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:VAC00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:VAC00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:VAC00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:VAC00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:VAC00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:VAC00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:VAC00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:VAC00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:VAC00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:VAC00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:VAC00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:VAC00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:VAC00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:VAC00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:VAC00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:VAC00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:VAC00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:VAC00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:VAC00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:VAC00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:VAC00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:VAC00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:VAC00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:TEMP00:INFO") {
  field(DESC, "SIOC:ALH0:TEMP00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:TEMP00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH0:TEMP00: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:ALH0:TEMP00: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:ALH0:TEMP00:TODDIFF")
}

record(longin, "SIOC:ALH0:TEMP00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:TEMP00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:TEMP00: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:ALH0:TEMP00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:TEMP00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:TEMP00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:TEMP00:TODSUM")
}

record(bo, "SIOC:ALH0:TEMP00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:TEMP00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:TEMP00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:TEMP00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:TEMP00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:TEMP00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:TEMP00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:TEMP00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:TEMP00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:TEMP00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:TEMP00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:TEMP00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:TEMP00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:TEMP00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:TEMP00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:TEMP00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:TEMP00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:TEMP00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:TEMP00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:TEMP00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:TEMP00: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:ALH0:TEMP00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:TEMP00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:TEMP00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:TEMP00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:TEMP00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:TEMP00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:TEMP00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:TEMP00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:TEMP00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:TEMP00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:TEMP00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:TEMP00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:TEMP00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:TEMP00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:TEMP00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:TEMP00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:TEMP00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:TEMP00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:TEMP00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:TEMP00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:TEMP00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:TEMP00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:TEMP00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:TEMP00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:TEMP00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:TEMP00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:TEMP00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:TEMP00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:TEMP00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:TEMP00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:TEMP00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:TEMP00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:TEMP00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:TEMP00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:TEMP00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:TEMP00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:TEMP00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:TEMP00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:TEMP00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:TEMP00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:TEMP00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:TEMP00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:TEMP00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:TEMP00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:TEMP00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:TEMP00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:TEMP00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:TEMP00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:TEMP00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:TEMP00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:TEMP00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:TEMP00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:MPS00:INFO") {
  field(DESC, "SIOC:ALH0:MPS00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:MPS00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH0:MPS00: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:ALH0:MPS00: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:ALH0:MPS00:TODDIFF")
}

record(longin, "SIOC:ALH0:MPS00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:MPS00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:MPS00: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:ALH0:MPS00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:MPS00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:MPS00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:MPS00:TODSUM")
}

record(bo, "SIOC:ALH0:MPS00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:MPS00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:MPS00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:MPS00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MPS00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:MPS00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:MPS00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:MPS00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:MPS00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:MPS00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:MPS00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:MPS00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:MPS00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:MPS00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:MPS00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:MPS00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:MPS00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:MPS00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:MPS00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:MPS00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:MPS00: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:ALH0:MPS00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:MPS00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MPS00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:MPS00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:MPS00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:MPS00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MPS00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:MPS00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:MPS00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:MPS00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MPS00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:MPS00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:MPS00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:MPS00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MPS00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:MPS00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:MPS00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:MPS00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MPS00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:MPS00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:MPS00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:MPS00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MPS00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:MPS00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:MPS00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:MPS00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MPS00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:MPS00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:MPS00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:MPS00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MPS00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:MPS00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:MPS00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:MPS00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MPS00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:MPS00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:MPS00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:MPS00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:MPS00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:MPS00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:MPS00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:MPS00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:MPS00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MPS00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:MPS00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:MPS00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:MPS00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:MPS00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:MPS00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:MPS00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:MPS00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:MPS00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:PPS00:INFO") {
  field(DESC, "SIOC:ALH0:PPS00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:PPS00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH0:PPS00: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:ALH0:PPS00: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:ALH0:PPS00:TODDIFF")
}

record(longin, "SIOC:ALH0:PPS00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:PPS00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:PPS00: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:ALH0:PPS00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:PPS00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:PPS00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:PPS00:TODSUM")
}

record(bo, "SIOC:ALH0:PPS00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:PPS00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:PPS00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:PPS00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PPS00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:PPS00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:PPS00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:PPS00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:PPS00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:PPS00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:PPS00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:PPS00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:PPS00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:PPS00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:PPS00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:PPS00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:PPS00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:PPS00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:PPS00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:PPS00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:PPS00: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:ALH0:PPS00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:PPS00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PPS00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:PPS00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:PPS00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:PPS00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PPS00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:PPS00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:PPS00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:PPS00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PPS00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:PPS00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:PPS00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:PPS00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PPS00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:PPS00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:PPS00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:PPS00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PPS00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:PPS00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:PPS00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:PPS00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PPS00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:PPS00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:PPS00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:PPS00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PPS00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:PPS00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:PPS00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:PPS00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PPS00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:PPS00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:PPS00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:PPS00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PPS00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:PPS00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:PPS00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:PPS00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:PPS00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:PPS00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:PPS00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:PPS00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:PPS00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:PPS00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:PPS00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:PPS00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:PPS00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:PPS00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:PPS00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:PPS00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:PPS00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:PPS00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:BCS00:INFO") {
  field(DESC, "SIOC:ALH0:BCS00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:BCS00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH0:BCS00: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:ALH0:BCS00: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:ALH0:BCS00:TODDIFF")
}

record(longin, "SIOC:ALH0:BCS00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:BCS00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:BCS00: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:ALH0:BCS00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:BCS00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:BCS00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:BCS00:TODSUM")
}

record(bo, "SIOC:ALH0:BCS00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:BCS00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:BCS00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:BCS00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:BCS00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:BCS00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:BCS00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:BCS00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:BCS00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:BCS00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:BCS00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:BCS00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:BCS00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:BCS00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:BCS00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:BCS00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:BCS00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:BCS00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:BCS00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:BCS00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:BCS00: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:ALH0:BCS00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:BCS00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:BCS00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:BCS00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:BCS00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:BCS00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:BCS00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:BCS00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:BCS00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:BCS00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:BCS00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:BCS00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:BCS00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:BCS00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:BCS00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:BCS00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:BCS00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:BCS00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:BCS00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:BCS00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:BCS00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:BCS00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:BCS00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:BCS00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:BCS00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:BCS00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:BCS00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:BCS00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:BCS00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:BCS00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:BCS00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:BCS00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:BCS00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:BCS00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:BCS00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:BCS00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:BCS00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:BCS00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:BCS00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:BCS00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:BCS00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:BCS00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:BCS00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:BCS00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:BCS00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:BCS00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:BCS00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:BCS00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:BCS00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:BCS00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:BCS00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:BCS00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:MISC00:INFO") {
  field(DESC, "SIOC:ALH0:MISC00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:MISC00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  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:ALH0:MISC00: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:ALH0:MISC00: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:ALH0:MISC00:TODDIFF")
}

record(longin, "SIOC:ALH0:MISC00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:MISC00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:MISC00: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:ALH0:MISC00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:MISC00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:MISC00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:MISC00:TODSUM")
}

record(bo, "SIOC:ALH0:MISC00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:MISC00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:MISC00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:MISC00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MISC00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:MISC00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:MISC00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:MISC00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:MISC00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:MISC00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:MISC00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:MISC00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:MISC00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:MISC00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:MISC00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:MISC00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:MISC00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:MISC00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:MISC00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:MISC00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:MISC00: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:ALH0:MISC00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:MISC00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MISC00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:MISC00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:MISC00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:MISC00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MISC00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:MISC00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:MISC00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:MISC00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MISC00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:MISC00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:MISC00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:MISC00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MISC00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:MISC00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:MISC00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:MISC00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MISC00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:MISC00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:MISC00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:MISC00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MISC00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:MISC00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:MISC00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:MISC00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MISC00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:MISC00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:MISC00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:MISC00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MISC00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:MISC00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:MISC00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:MISC00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MISC00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:MISC00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:MISC00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:MISC00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:MISC00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:MISC00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:MISC00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:MISC00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:MISC00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:MISC00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:MISC00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:MISC00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:MISC00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:MISC00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:MISC00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:MISC00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:MISC00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:MISC00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:CRYO00:INFO") {
  field(DESC, "SIOC:ALH0:CRYO00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:CRYO00: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:ALH0:CRYO00: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:ALH0:CRYO00: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:ALH0:CRYO00:TODDIFF")
}

record(longin, "SIOC:ALH0:CRYO00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:CRYO00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:CRYO00: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:ALH0:CRYO00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:CRYO00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:CRYO00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:CRYO00:TODSUM")
}

record(bo, "SIOC:ALH0:CRYO00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:CRYO00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:CRYO00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:CRYO00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:CRYO00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:CRYO00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:CRYO00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:CRYO00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:CRYO00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:CRYO00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:CRYO00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:CRYO00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:CRYO00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:CRYO00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:CRYO00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:CRYO00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:CRYO00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:CRYO00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:CRYO00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:CRYO00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:CRYO00: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:ALH0:CRYO00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:CRYO00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:CRYO00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:CRYO00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:CRYO00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:CRYO00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:CRYO00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:CRYO00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:CRYO00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:CRYO00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:CRYO00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:CRYO00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:CRYO00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:CRYO00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:CRYO00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:CRYO00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:CRYO00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:CRYO00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:CRYO00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:CRYO00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:CRYO00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:CRYO00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:CRYO00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:CRYO00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:CRYO00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:CRYO00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:CRYO00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:CRYO00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:CRYO00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:CRYO00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:CRYO00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:CRYO00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:CRYO00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:CRYO00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:CRYO00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:CRYO00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:CRYO00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:CRYO00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:CRYO00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:CRYO00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:CRYO00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:CRYO00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:CRYO00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:CRYO00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:CRYO00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:CRYO00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:CRYO00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:CRYO00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:CRYO00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:CRYO00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:CRYO00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:CRYO00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:ODM00:INFO") {
  field(DESC, "SIOC:ALH0:ODM00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:ODM00: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:ALH0:ODM00: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:ALH0:ODM00: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:ALH0:ODM00:TODDIFF")
}

record(longin, "SIOC:ALH0:ODM00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:ODM00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:ODM00: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:ALH0:ODM00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:ODM00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:ODM00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:ODM00:TODSUM")
}

record(bo, "SIOC:ALH0:ODM00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:ODM00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:ODM00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:ODM00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:ODM00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:ODM00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:ODM00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:ODM00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:ODM00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:ODM00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:ODM00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:ODM00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:ODM00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:ODM00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:ODM00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:ODM00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:ODM00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:ODM00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:ODM00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:ODM00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:ODM00: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:ALH0:ODM00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:ODM00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:ODM00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:ODM00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:ODM00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:ODM00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:ODM00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:ODM00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:ODM00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:ODM00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:ODM00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:ODM00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:ODM00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:ODM00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:ODM00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:ODM00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:ODM00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:ODM00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:ODM00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:ODM00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:ODM00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:ODM00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:ODM00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:ODM00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:ODM00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:ODM00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:ODM00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:ODM00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:ODM00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:ODM00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:ODM00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:ODM00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:ODM00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:ODM00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:ODM00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:ODM00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:ODM00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:ODM00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:ODM00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:ODM00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:ODM00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:ODM00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:ODM00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:ODM00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:ODM00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:ODM00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:ODM00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:ODM00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:ODM00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:ODM00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:ODM00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:ODM00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  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:ALH0:APP00:INFO") {
  field(DESC, "SIOC:ALH0:APP00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:APP00: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:ALH0:APP00: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:ALH0:APP00: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:ALH0:APP00:TODDIFF")
}

record(longin, "SIOC:ALH0:APP00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH0:APP00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH0:APP00: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:ALH0:APP00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH0:APP00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH0:APP00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH0:APP00:TODSUM")
}

record(bo, "SIOC:ALH0:APP00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH0:APP00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH0:APP00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH0:APP00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:APP00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH0:APP00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH0:APP00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH0:APP00:HEARTBEATE01")
  field(INP, "SIOC:ALH0:APP00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH0:APP00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH0:APP00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH0:APP00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH0:APP00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH0:APP00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH0:APP00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH0:APP00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH0:APP00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH0:APP00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH0:APP00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH0:APP00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH0:APP00: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:ALH0:APP00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH0:APP00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:APP00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH0:APP00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH0:APP00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH0:APP00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:APP00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH0:APP00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH0:APP00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH0:APP00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:APP00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH0:APP00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH0:APP00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH0:APP00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:APP00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH0:APP00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH0:APP00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH0:APP00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:APP00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH0:APP00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH0:APP00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH0:APP00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:APP00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH0:APP00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH0:APP00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH0:APP00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:APP00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH0:APP00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH0:APP00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH0:APP00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:APP00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH0:APP00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH0:APP00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH0:APP00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:APP00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH0:APP00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH0:APP00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH0:APP00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH0:APP00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH0:APP00:HEARTBEATCLC")
  field(INP, "SIOC:ALH0:APP00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH0:APP00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH0:APP00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH0:APP00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH0:APP00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH0:APP00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH0:APP00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH0:APP00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH0:APP00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH0:APP00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH0:APP00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH0:APP00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-dev1")
  info(autosaveFields,"VAL")
}

