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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:SYS0:BD01:LOC") {
  field(PINI, "YES")
  field(VAL, "B005-2930")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:SYS0:BD02:LOC") {
  field(PINI, "YES")
  field(VAL, "B005-2930")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:B34:TEST01: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:SYS0:PP01:INFO") {
  field(DESC, "IOC:SYS0:PP01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:SYS0:PP01:LOC") {
  field(PINI, "YES")
  field(VAL, "B003-B0421")
  info(autosaveFields,"VAL")
}

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

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

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

record(aSub, "IOC:GBL0: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:GBL0: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:GBL0:EV02:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:GBL0:EV02:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG10-2704")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:ACR0:KN00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:ACR0:PP01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0: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-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0: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-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0: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-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0: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-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0: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-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0: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-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0: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-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0: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-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0: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-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:NW01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "IN20-BSY IOC/VME/ACSW")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:NW01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "IN20-BSY IOC/VME/ACSW")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:NW02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LTUH-FEH IOC/VME/ACSW")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:NW02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LTUH-FEH IOC/VME/ACSW")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:NW03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LTUS-DMPS IOC/VME/ACSW")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:NW03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LTUS-DMPS IOC/VME/ACSW")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:NW03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "GUNB-SLTD IOC/VME/ACSW")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:NW03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "GUNB-SLTD IOC/VME/ACSW")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:NW10:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "IN20-LI30 ATCA/CPU")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:NW10:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "IN20-LI30 ATCA/CPU")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:NW11:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "BSY0/H ATCA/CPU")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:NW11:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "BSY0/H ATCA/CPU")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:NW12:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LTUH ATCA/CPU")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:NW12:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LTUH ATCA/CPU")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:NW13:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "UNDH-DMPH ATCA/CPU")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:NW13:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "UNDH-DMPH ATCA/CPU")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:NW14:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "BSYS-LTUS ATCA/CPU")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:NW14:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "BSYS-LTUS ATCA/CPU")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:NW15:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "UNDS-FEES ATCA/CPU")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:NW15:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "UNDS-FEES ATCA/CPU")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:NW16:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "GUNB-BC1B ATCA/CPU")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:NW16:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "GUNB-BC1B ATCA/CPU")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:NW17:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "L2B-BC2B ATCA/CPU")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:NW17:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "L2B-BC2B ATCA/CPU")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:NW18:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "L3B-DOG ATCA/CPU")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:NW18:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "L3B-DOG ATCA/CPU")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:NW19:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "SC BYP ATCA/CPU")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:NW19:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "SC BYP ATCA/CPU")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:NW20:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "SC SP-SLTD ATCA/CPU")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:NW20:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "SC SP-SLTD ATCA/CPU")
  info(autosaveFields,"VAL")
}

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

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

record(stringin, "SIOC:SYS0:UW00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Ken Brobeck (brobeck)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:MG01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "An Le (anle)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:MG02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "An Le (anle)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:MG03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "An Le (anle)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:MG03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LI24-LI30& EPSCs & Bulks")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:MG03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LI24-LI30& EPSCs & Bulks")
  info(autosaveFields,"VAL")
}

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

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

record(stringin, "SIOC:SYS0:MG04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "An Le (anle)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:MG04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "BSY Bulks and EPSCs")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:MG04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "BSY Bulks and EPSCs")
  info(autosaveFields,"VAL")
}

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

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

record(stringin, "SIOC:SYS0:MG05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "An Le (anle)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:BP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cav cal & Cu charge setp")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:BP01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cav cal & Cu charge setp")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:BP02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Display BSA waveforms")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:BP04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Cu any dest support")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:BP04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Cu any dest support")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:BP05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "BPM ATCA/CPU info")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:BP05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "BPM ATCA/CPU info")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

record(calc, "SIOC:SYS0:MK00:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:MK00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MK00:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:MK00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:MK00:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:MK00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MK00:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:MK00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:MK00:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:MK00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MK00:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:MK00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:MK00:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:MK00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MK00:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:MK00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:MK00:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:MK00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MK00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:MK00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:MK00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:MK00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:MK00:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:MK00:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:MK00: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:MK00:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:MK00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MK00:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:MK00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:MK00:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:MK00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:MK00:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:MK00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:MK00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:MK00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MK00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:RF01:INFO") {
  field(DESC, "SIOC:SYS0:RF01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0: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, "SIOC:SYS0: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, "SIOC:SYS0: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, "SIOC:SYS0:RF01:TODDIFF")
}

record(longin, "SIOC:SYS0:RF01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:RF01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0: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, "SIOC:SYS0:RF01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:RF01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:RF01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:RF01:TODSUM")
}

record(bo, "SIOC:SYS0:RF01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:RF01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:RF01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:RF01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:RF01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:RF01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:RF01:HEARTBEATE01")
  field(INP, "SIOC:SYS0:RF01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:RF01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:RF01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:RF01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:RF01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:RF01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:RF01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:RF01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:RF01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:RF01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:RF01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:RF01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0: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, "SIOC:SYS0:RF01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:RF01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:RF01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:RF01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:RF01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:RF01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:RF01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:RF01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:RF01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:RF01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:RF01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:RF01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:RF01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:RF01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:RF01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:RF01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:RF01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:RF01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:RF01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:RF01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:RF01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:RF01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:RF01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:RF01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:RF01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:RF01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:RF01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:RF01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:RF01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:RF01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:RF01:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:RF01: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:RF01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:RF01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:RF01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:RF01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:RF01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:RF01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:RF01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:RF01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:RF01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:RF01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:RF02:INFO") {
  field(DESC, "SIOC:SYS0:RF02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:RF02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYS0:RF02: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:RF02:TOD CA")
  field(INPC, "10")
# VALA holds 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:RF02:TODDIFF")
}

record(longin, "SIOC:SYS0:RF02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:RF02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:RF02:TODCHECKVALID")
}

# If <ioc> 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:RF02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:RF02:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:RF02:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:RF02:TODSUM")
}

record(bo, "SIOC:SYS0:RF02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:RF02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:RF02:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:RF02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF02:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:RF02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:RF02:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:RF02:HEARTBEATE01")
  field(INP, "SIOC:SYS0:RF02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:RF02:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:RF02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:RF02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:RF02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:RF02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:RF02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:RF02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:RF02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:RF02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:RF02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:RF02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:RF02:HEARTBEATE10.VAL")
  field(HIHI, "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:RF02:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:RF02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF02:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:RF02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:RF02:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:RF02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF02:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:RF02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:RF02:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:RF02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF02:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:RF02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:RF02:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:RF02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF02:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:RF02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:RF02:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:RF02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF02:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:RF02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:RF02:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:RF02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF02:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:RF02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:RF02:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:RF02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF02:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:RF02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:RF02:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:RF02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF02:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:RF02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:RF02:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:RF02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:RF02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:RF02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:RF02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:RF02:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:RF02:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:RF02: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:RF02:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:RF02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF02:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:RF02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:RF02:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:RF02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:RF02:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:RF02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:RF02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:RF02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:RF02:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:OP00:INFO") {
  field(DESC, "SIOC:SYS0:OP00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:OP00: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: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:SYS0: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:SYS0:OP00:TODDIFF")
}

record(longin, "SIOC:SYS0:OP00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:OP00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0: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:SYS0:OP00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:OP00:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:OP00:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:OP00:TODSUM")
}

record(bo, "SIOC:SYS0:OP00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:OP00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:OP00:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:OP00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP00:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:OP00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:OP00:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:OP00:HEARTBEATE01")
  field(INP, "SIOC:SYS0:OP00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:OP00:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:OP00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:OP00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:OP00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:OP00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:OP00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:OP00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:OP00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:OP00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:OP00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:OP00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0: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:SYS0:OP00:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:OP00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP00:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:OP00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:OP00:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:OP00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP00:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:OP00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:OP00:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:OP00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP00:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:OP00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:OP00:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:OP00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP00:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:OP00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:OP00:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:OP00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP00:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:OP00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:OP00:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:OP00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP00:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:OP00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:OP00:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:OP00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP00:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:OP00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:OP00:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:OP00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP00:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:OP00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:OP00:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:OP00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:OP00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:OP00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:OP00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:OP00:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:OP00:HEARTBEATCLC")
  field(INP, "SIOC:SYS0: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:SYS0:OP00:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:OP00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP00:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:OP00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:OP00:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:OP00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:OP00:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:OP00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:OP00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:OP00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:OP00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:OP01:INFO") {
  field(DESC, "SIOC:SYS0:OP01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:OP01: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:OP01: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:OP01:TOD CA")
  field(INPC, "10")
# VALA holds 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:OP01:TODDIFF")
}

record(longin, "SIOC:SYS0:OP01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:OP01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:OP01:TODCHECKVALID")
}

# If <ioc> 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:OP01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:OP01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:OP01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:OP01:TODSUM")
}

record(bo, "SIOC:SYS0:OP01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:OP01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:OP01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:OP01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:OP01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:OP01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:OP01:HEARTBEATE01")
  field(INP, "SIOC:SYS0:OP01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:OP01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:OP01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:OP01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:OP01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:OP01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:OP01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:OP01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:OP01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:OP01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:OP01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:OP01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:OP01:HEARTBEATE10.VAL")
  field(HIHI, "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:OP01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:OP01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:OP01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:OP01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:OP01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:OP01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:OP01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:OP01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:OP01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:OP01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:OP01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:OP01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:OP01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:OP01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:OP01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:OP01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:OP01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:OP01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:OP01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:OP01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:OP01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:OP01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:OP01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:OP01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:OP01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:OP01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:OP01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:OP01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:OP01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:OP01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:OP01:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:OP01: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:OP01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:OP01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:OP01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:OP01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:OP01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:OP01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:OP01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:OP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:OP01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:OP01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:OP02:INFO") {
  field(DESC, "SIOC:SYS0:OP02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:OP02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Tyler Kabana (kabanaty)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYS0:OP02: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:OP02:TOD CA")
  field(INPC, "10")
# VALA holds 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:OP02:TODDIFF")
}

record(longin, "SIOC:SYS0:OP02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:OP02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:OP02:TODCHECKVALID")
}

# If <ioc> 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:OP02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:OP02:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:OP02:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:OP02:TODSUM")
}

record(bo, "SIOC:SYS0:OP02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:OP02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:OP02:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:OP02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP02:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:OP02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:OP02:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:OP02:HEARTBEATE01")
  field(INP, "SIOC:SYS0:OP02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:OP02:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:OP02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:OP02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:OP02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:OP02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:OP02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:OP02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:OP02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:OP02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:OP02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:OP02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:OP02:HEARTBEATE10.VAL")
  field(HIHI, "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:OP02:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:OP02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP02:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:OP02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:OP02:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:OP02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP02:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:OP02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:OP02:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:OP02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP02:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:OP02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:OP02:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:OP02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP02:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:OP02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:OP02:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:OP02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP02:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:OP02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:OP02:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:OP02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP02:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:OP02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:OP02:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:OP02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP02:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:OP02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:OP02:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:OP02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP02:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:OP02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:OP02:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:OP02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:OP02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:OP02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:OP02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:OP02:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:OP02:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:OP02: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:OP02:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:OP02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP02:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:OP02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:OP02:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:OP02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:OP02:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:OP02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:OP02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Mode Switch Support")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:OP02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Mode Switch Support")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:OP02:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:OP03:INFO") {
  field(DESC, "SIOC:SYS0:OP03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:OP03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Tyler Kabana (kabanaty)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYS0:OP03: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:OP03:TOD CA")
  field(INPC, "10")
# VALA holds 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:OP03:TODDIFF")
}

record(longin, "SIOC:SYS0:OP03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:OP03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:OP03:TODCHECKVALID")
}

# If <ioc> 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:OP03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:OP03:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:OP03:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:OP03:TODSUM")
}

record(bo, "SIOC:SYS0:OP03:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:OP03:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:OP03:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:OP03:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP03:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:OP03:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:OP03:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:OP03:HEARTBEATE01")
  field(INP, "SIOC:SYS0:OP03:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:OP03:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:OP03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:OP03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:OP03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:OP03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:OP03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:OP03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:OP03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:OP03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:OP03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:OP03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:OP03:HEARTBEATE10.VAL")
  field(HIHI, "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:OP03:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:OP03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP03:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:OP03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:OP03:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:OP03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP03:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:OP03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:OP03:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:OP03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP03:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:OP03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:OP03:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:OP03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP03:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:OP03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:OP03:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:OP03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP03:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:OP03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:OP03:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:OP03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP03:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:OP03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:OP03:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:OP03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP03:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:OP03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:OP03:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:OP03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP03:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:OP03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:OP03:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:OP03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:OP03:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:OP03:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:OP03:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:OP03:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:OP03:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:OP03: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:OP03:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:OP03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:OP03:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:OP03:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:OP03:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:OP03:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:OP03:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:OP03:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:OP03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:OP03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:OP03:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0: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-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0: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-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0: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-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:LM01:INFO") {
  field(DESC, "SIOC:SYS0:LM01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:LM01: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:LM01: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:LM01:TOD CA")
  field(INPC, "10")
# VALA holds 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:LM01:TODDIFF")
}

record(longin, "SIOC:SYS0:LM01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:LM01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:LM01:TODCHECKVALID")
}

# If <ioc> 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:LM01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:LM01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:LM01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:LM01:TODSUM")
}

record(bo, "SIOC:SYS0:LM01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:LM01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:LM01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:LM01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LM01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:LM01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:LM01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:LM01:HEARTBEATE01")
  field(INP, "SIOC:SYS0:LM01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:LM01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:LM01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:LM01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:LM01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:LM01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:LM01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:LM01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:LM01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:LM01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:LM01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:LM01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:LM01:HEARTBEATE10.VAL")
  field(HIHI, "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:LM01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:LM01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LM01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:LM01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:LM01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:LM01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LM01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:LM01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:LM01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:LM01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LM01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:LM01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:LM01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:LM01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LM01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:LM01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:LM01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:LM01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LM01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:LM01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:LM01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:LM01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LM01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:LM01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:LM01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:LM01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LM01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:LM01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:LM01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:LM01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LM01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:LM01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:LM01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:LM01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LM01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:LM01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:LM01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:LM01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:LM01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:LM01:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:LM01: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:LM01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:LM01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LM01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:LM01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:LM01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:LM01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:LM01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:LM01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:LM01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:LM01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:LM01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:BJ00:INFO") {
  field(DESC, "SIOC:SYS0:BJ00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:BJ00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Eric Tse (erictse)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:BJ00: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:BJ00:TOD CA")
  field(INPC, "10")
# VALA holds 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:BJ00:TODDIFF")
}

record(longin, "SIOC:SYS0:BJ00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:BJ00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:BJ00:TODCHECKVALID")
}

# If <ioc> 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:BJ00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:BJ00:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:BJ00:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:BJ00:TODSUM")
}

record(bo, "SIOC:SYS0:BJ00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:BJ00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:BJ00:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:BJ00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BJ00:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:BJ00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:BJ00:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:BJ00:HEARTBEATE01")
  field(INP, "SIOC:SYS0:BJ00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:BJ00:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:BJ00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:BJ00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:BJ00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:BJ00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:BJ00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:BJ00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:BJ00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:BJ00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:BJ00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:BJ00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:BJ00:HEARTBEATE10.VAL")
  field(HIHI, "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:BJ00:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:BJ00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BJ00:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:BJ00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:BJ00:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:BJ00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BJ00:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:BJ00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:BJ00:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:BJ00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BJ00:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:BJ00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:BJ00:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:BJ00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BJ00:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:BJ00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:BJ00:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:BJ00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BJ00:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:BJ00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:BJ00:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:BJ00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BJ00:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:BJ00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:BJ00:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:BJ00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BJ00:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:BJ00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:BJ00:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:BJ00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BJ00:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:BJ00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:BJ00:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:BJ00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BJ00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:BJ00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:BJ00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:BJ00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:BJ00:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:BJ00:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:BJ00: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:BJ00:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:BJ00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BJ00:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:BJ00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:BJ00:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:BJ00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:BJ00:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:BJ00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:BJ00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:BJ00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:BJ00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:KN00:INFO") {
  field(DESC, "SIOC:SYS0:KN00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:KN00: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:KN00: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:KN00:TOD CA")
  field(INPC, "10")
# VALA holds 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:KN00:TODDIFF")
}

record(longin, "SIOC:SYS0:KN00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:KN00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:KN00:TODCHECKVALID")
}

# If <ioc> 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:KN00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:KN00:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:KN00:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:KN00:TODSUM")
}

record(bo, "SIOC:SYS0:KN00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:KN00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:KN00:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:KN00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:KN00:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:KN00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:KN00:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:KN00:HEARTBEATE01")
  field(INP, "SIOC:SYS0:KN00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:KN00:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:KN00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:KN00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:KN00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:KN00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:KN00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:KN00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:KN00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:KN00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:KN00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:KN00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:KN00:HEARTBEATE10.VAL")
  field(HIHI, "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:KN00:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:KN00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:KN00:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:KN00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:KN00:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:KN00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:KN00:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:KN00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:KN00:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:KN00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:KN00:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:KN00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:KN00:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:KN00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:KN00:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:KN00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:KN00:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:KN00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:KN00:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:KN00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:KN00:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:KN00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:KN00:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:KN00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:KN00:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:KN00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:KN00:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:KN00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:KN00:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:KN00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:KN00:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:KN00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:KN00:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:KN00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:KN00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:KN00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:KN00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:KN00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:KN00:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:KN00:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:KN00: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:KN00:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:KN00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:KN00:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:KN00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:KN00:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:KN00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:KN00:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:KN00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:KN00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:KN00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:KN00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:UND0:MP01:INFO") {
  field(DESC, "SIOC:UND0:MP01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:UND0:MP01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:UND0:MP01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:UND0:MP01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:UND0:MP01:TODDIFF")
}

record(longin, "SIOC:UND0:MP01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:UND0:MP01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:UND0:MP01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:UND0:MP01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:UND0:MP01:TODCHECK.SEVR")
  field(INPB, "SIOC:UND0:MP01:TODCHECK.VALB")
  field(FLNK, "SIOC:UND0:MP01:TODSUM")
}

record(bo, "SIOC:UND0:MP01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:UND0:MP01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:UND0:MP01:HEARTBEATCALC") {
  field(FLNK, "SIOC:UND0:MP01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:UND0:MP01:HEARTBEAT CA MS")
  field(INPB, "SIOC:UND0:MP01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:UND0:MP01:HEARTBEATOK") {
  field(FLNK, "SIOC:UND0:MP01:HEARTBEATE01")
  field(INP, "SIOC:UND0:MP01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:UND0:MP01:HEARTBEATECT") {
  field(FLNK, "SIOC:UND0:MP01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:UND0:MP01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:UND0:MP01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:UND0:MP01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:UND0:MP01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:UND0:MP01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:UND0:MP01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:UND0:MP01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:UND0:MP01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:UND0:MP01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:UND0:MP01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:UND0:MP01:HEARTBEATE09") {
  field(FLNK, "SIOC:UND0:MP01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:UND0:MP01:HEARTBEATE08.B")
  field(INPB, "SIOC:UND0:MP01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:UND0:MP01:HEARTBEATE08") {
  field(FLNK, "SIOC:UND0:MP01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:UND0:MP01:HEARTBEATE07.B")
  field(INPB, "SIOC:UND0:MP01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:UND0:MP01:HEARTBEATE07") {
  field(FLNK, "SIOC:UND0:MP01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:UND0:MP01:HEARTBEATE06.B")
  field(INPB, "SIOC:UND0:MP01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:UND0:MP01:HEARTBEATE06") {
  field(FLNK, "SIOC:UND0:MP01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:UND0:MP01:HEARTBEATE05.B")
  field(INPB, "SIOC:UND0:MP01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:UND0:MP01:HEARTBEATE05") {
  field(FLNK, "SIOC:UND0:MP01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:UND0:MP01:HEARTBEATE04.B")
  field(INPB, "SIOC:UND0:MP01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:UND0:MP01:HEARTBEATE04") {
  field(FLNK, "SIOC:UND0:MP01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:UND0:MP01:HEARTBEATE03.B")
  field(INPB, "SIOC:UND0:MP01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:UND0:MP01:HEARTBEATE03") {
  field(FLNK, "SIOC:UND0:MP01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:UND0:MP01:HEARTBEATE02.B")
  field(INPB, "SIOC:UND0:MP01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:UND0:MP01:HEARTBEATE02") {
  field(FLNK, "SIOC:UND0:MP01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:UND0:MP01:HEARTBEATE01.B")
  field(INPB, "SIOC:UND0:MP01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:UND0:MP01:HEARTBEATE01") {
  field(FLNK, "SIOC:UND0:MP01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:UND0:MP01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:UND0:MP01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:UND0:MP01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:UND0:MP01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:UND0:MP01:HEARTBEATSUM") {
  field(FLNK, "SIOC:UND0:MP01:HEARTBEATCLC")
  field(INP, "SIOC:UND0:MP01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:UND0:MP01:HEARTBEATE10") {
  field(FLNK, "SIOC:UND0:MP01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:UND0:MP01:HEARTBEATE09.B")
  field(INPB, "SIOC:UND0:MP01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:UND0:MP01:HEARTBEATERR") {
  field(FLNK, "SIOC:UND0:MP01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:UND0:MP01:HEARTBEATCALC.A")
  field(INPB, "SIOC:UND0:MP01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:UND0:MP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:UND0:MP01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:UND0:MP01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:MP01:INFO") {
  field(DESC, "SIOC:SYS0:MP01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MP01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYS0:MP01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:SYS0:MP01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:SYS0:MP01:TODDIFF")
}

record(longin, "SIOC:SYS0:MP01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:MP01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:MP01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:SYS0:MP01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:MP01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:MP01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:MP01:TODSUM")
}

record(bo, "SIOC:SYS0:MP01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:MP01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:MP01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:MP01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:MP01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:MP01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:MP01:HEARTBEATE01")
  field(INP, "SIOC:SYS0:MP01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:MP01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:MP01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:MP01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:MP01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:MP01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:MP01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:MP01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:MP01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:MP01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:MP01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:MP01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:MP01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:SYS0:MP01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:MP01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:MP01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:MP01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:MP01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:MP01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:MP01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:MP01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:MP01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:MP01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:MP01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:MP01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:MP01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:MP01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:MP01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:MP01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:MP01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:MP01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:MP01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:MP01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:MP01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:MP01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:MP01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:MP01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:MP01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:MP01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:MP01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:MP01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:MP01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:MP01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:MP01:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:MP01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:MP01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:MP01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:MP01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:MP01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:MP01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:MP01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:MP01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:MP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:MP01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MP01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-mp01")
  info(autosaveFields,"VAL")
}

# String record 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:MP02:INFO") {
  field(DESC, "SIOC:SYS0:MP02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MP02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYS0:MP02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:SYS0:MP02:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:SYS0:MP02:TODDIFF")
}

record(longin, "SIOC:SYS0:MP02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:MP02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:MP02:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:SYS0:MP02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:MP02:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:MP02:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:MP02:TODSUM")
}

record(bo, "SIOC:SYS0:MP02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:MP02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:MP02:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:MP02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP02:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:MP02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:MP02:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:MP02:HEARTBEATE01")
  field(INP, "SIOC:SYS0:MP02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:MP02:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:MP02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:MP02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:MP02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:MP02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:MP02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:MP02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:MP02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:MP02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:MP02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:MP02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:MP02:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:SYS0:MP02:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:MP02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP02:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:MP02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:MP02:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:MP02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP02:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:MP02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:MP02:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:MP02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP02:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:MP02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:MP02:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:MP02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP02:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:MP02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:MP02:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:MP02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP02:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:MP02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:MP02:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:MP02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP02:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:MP02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:MP02:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:MP02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP02:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:MP02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:MP02:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:MP02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP02:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:MP02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:MP02:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:MP02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:MP02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:MP02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:MP02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:MP02:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:MP02:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:MP02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:MP02:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:MP02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP02:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:MP02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:MP02:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:MP02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:MP02:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:MP02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:MP02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:MP02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MP02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-mp01")
  info(autosaveFields,"VAL")
}

# String record 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:MP03:INFO") {
  field(DESC, "SIOC:SYS0:MP03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MP03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYS0:MP03:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:SYS0:MP03:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:SYS0:MP03:TODDIFF")
}

record(longin, "SIOC:SYS0:MP03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:MP03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:MP03:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:SYS0:MP03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:MP03:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:MP03:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:MP03:TODSUM")
}

record(bo, "SIOC:SYS0:MP03:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:MP03:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:MP03:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:MP03:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP03:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:MP03:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:MP03:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:MP03:HEARTBEATE01")
  field(INP, "SIOC:SYS0:MP03:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:MP03:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:MP03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:MP03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:MP03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:MP03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:MP03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:MP03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:MP03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:MP03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:MP03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:MP03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:MP03:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:SYS0:MP03:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:MP03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP03:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:MP03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:MP03:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:MP03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP03:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:MP03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:MP03:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:MP03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP03:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:MP03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:MP03:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:MP03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP03:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:MP03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:MP03:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:MP03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP03:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:MP03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:MP03:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:MP03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP03:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:MP03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:MP03:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:MP03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP03:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:MP03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:MP03:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:MP03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP03:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:MP03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:MP03:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:MP03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:MP03:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:MP03:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:MP03:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:MP03:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:MP03:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:MP03:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:MP03:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:MP03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP03:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:MP03:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:MP03:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:MP03:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:MP03:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:MP03:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:MP03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:MP03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MP03:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-mp03")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:RF11:INFO") {
  field(DESC, "SIOC:SYS0:RF11 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:RF11:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYS0:RF11:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:SYS0:RF11:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:SYS0:RF11:TODDIFF")
}

record(longin, "SIOC:SYS0:RF11:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:RF11:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:RF11:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:SYS0:RF11:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:RF11:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:RF11:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:RF11:TODSUM")
}

record(bo, "SIOC:SYS0:RF11:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:RF11:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:RF11:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:RF11:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF11:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:RF11:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:RF11:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:RF11:HEARTBEATE01")
  field(INP, "SIOC:SYS0:RF11:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:RF11:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:RF11:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:RF11:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:RF11:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:RF11:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:RF11:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:RF11:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:RF11:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:RF11:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:RF11:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:RF11:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:RF11:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:SYS0:RF11:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:RF11:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF11:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:RF11:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:RF11:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:RF11:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF11:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:RF11:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:RF11:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:RF11:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF11:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:RF11:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:RF11:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:RF11:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF11:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:RF11:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:RF11:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:RF11:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF11:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:RF11:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:RF11:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:RF11:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF11:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:RF11:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:RF11:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:RF11:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF11:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:RF11:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:RF11:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:RF11:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF11:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:RF11:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:RF11:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:RF11:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF11:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:RF11:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:RF11:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:RF11:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:RF11:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:RF11:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:RF11:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:RF11:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:RF11:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF11:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:RF11:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:RF11:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:RF11:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:RF11:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:RF11:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:RF11:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:RF11:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:RF11:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:RF12:INFO") {
  field(DESC, "SIOC:SYS0:RF12 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:RF12:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYS0:RF12:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:SYS0:RF12:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:SYS0:RF12:TODDIFF")
}

record(longin, "SIOC:SYS0:RF12:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:RF12:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:RF12:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:SYS0:RF12:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:RF12:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:RF12:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:RF12:TODSUM")
}

record(bo, "SIOC:SYS0:RF12:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:RF12:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:RF12:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:RF12:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF12:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:RF12:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:RF12:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:RF12:HEARTBEATE01")
  field(INP, "SIOC:SYS0:RF12:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:RF12:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:RF12:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:RF12:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:RF12:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:RF12:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:RF12:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:RF12:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:RF12:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:RF12:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:RF12:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:RF12:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:RF12:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:SYS0:RF12:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:RF12:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF12:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:RF12:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:RF12:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:RF12:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF12:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:RF12:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:RF12:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:RF12:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF12:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:RF12:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:RF12:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:RF12:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF12:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:RF12:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:RF12:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:RF12:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF12:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:RF12:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:RF12:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:RF12:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF12:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:RF12:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:RF12:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:RF12:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF12:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:RF12:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:RF12:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:RF12:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF12:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:RF12:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:RF12:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:RF12:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF12:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:RF12:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:RF12:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:RF12:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:RF12:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:RF12:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:RF12:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:RF12:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:RF12:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF12:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:RF12:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:RF12:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:RF12:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:RF12:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:RF12:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:RF12:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:RF12:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:RF12:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:RF15:INFO") {
  field(DESC, "SIOC:SYS0:RF15 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:RF15:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (sonya)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYS0:RF15:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:SYS0:RF15:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:SYS0:RF15:TODDIFF")
}

record(longin, "SIOC:SYS0:RF15:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:RF15:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:RF15:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:SYS0:RF15:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:RF15:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:RF15:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:RF15:TODSUM")
}

record(bo, "SIOC:SYS0:RF15:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:RF15:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:RF15:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:RF15:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF15:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:RF15:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:RF15:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:RF15:HEARTBEATE01")
  field(INP, "SIOC:SYS0:RF15:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:RF15:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:RF15:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:RF15:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:RF15:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:RF15:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:RF15:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:RF15:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:RF15:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:RF15:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:RF15:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:RF15:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:RF15:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:SYS0:RF15:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:RF15:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF15:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:RF15:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:RF15:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:RF15:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF15:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:RF15:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:RF15:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:RF15:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF15:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:RF15:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:RF15:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:RF15:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF15:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:RF15:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:RF15:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:RF15:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF15:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:RF15:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:RF15:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:RF15:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF15:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:RF15:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:RF15:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:RF15:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF15:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:RF15:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:RF15:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:RF15:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF15:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:RF15:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:RF15:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:RF15:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF15:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:RF15:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:RF15:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:RF15:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:RF15:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:RF15:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:RF15:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:RF15:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:RF15:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF15:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:RF15:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:RF15:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:RF15:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:RF15:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:RF15:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:RF15:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:RF15:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:RF15:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:PM00:INFO") {
  field(DESC, "SIOC:SYS0:PM00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:PM00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Patrick Nisperos (pnispero)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:PM00: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:PM00:TOD CA")
  field(INPC, "10")
# VALA holds 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:PM00:TODDIFF")
}

record(longin, "SIOC:SYS0:PM00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:PM00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:PM00:TODCHECKVALID")
}

# If <ioc> 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:PM00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:PM00:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:PM00:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:PM00:TODSUM")
}

record(bo, "SIOC:SYS0:PM00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:PM00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:PM00:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:PM00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:PM00:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:PM00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:PM00:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:PM00:HEARTBEATE01")
  field(INP, "SIOC:SYS0:PM00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:PM00:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:PM00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:PM00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:PM00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:PM00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:PM00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:PM00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:PM00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:PM00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:PM00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:PM00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:PM00:HEARTBEATE10.VAL")
  field(HIHI, "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:PM00:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:PM00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:PM00:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:PM00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:PM00:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:PM00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:PM00:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:PM00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:PM00:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:PM00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:PM00:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:PM00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:PM00:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:PM00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:PM00:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:PM00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:PM00:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:PM00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:PM00:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:PM00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:PM00:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:PM00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:PM00:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:PM00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:PM00:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:PM00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:PM00:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:PM00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:PM00:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:PM00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:PM00:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:PM00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:PM00:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:PM00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:PM00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:PM00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:PM00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:PM00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:PM00:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:PM00:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:PM00: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:PM00:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:PM00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:PM00:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:PM00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:PM00:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:PM00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:PM00:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:PM00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:PM00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:PM00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:PM00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:RF16:INFO") {
  field(DESC, "SIOC:SYS0:RF16 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:RF16:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Daron Chabot (dchabot)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:RF16:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:SYS0:RF16:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:SYS0:RF16:TODDIFF")
}

record(longin, "SIOC:SYS0:RF16:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:RF16:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:RF16:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:SYS0:RF16:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:RF16:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:RF16:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:RF16:TODSUM")
}

record(bo, "SIOC:SYS0:RF16:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:RF16:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:RF16:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:RF16:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF16:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:RF16:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:RF16:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:RF16:HEARTBEATE01")
  field(INP, "SIOC:SYS0:RF16:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:RF16:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:RF16:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:RF16:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:RF16:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:RF16:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:RF16:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:RF16:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:RF16:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:RF16:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:RF16:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:RF16:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:RF16:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:SYS0:RF16:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:RF16:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF16:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:RF16:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:RF16:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:RF16:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF16:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:RF16:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:RF16:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:RF16:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF16:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:RF16:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:RF16:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:RF16:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF16:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:RF16:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:RF16:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:RF16:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF16:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:RF16:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:RF16:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:RF16:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF16:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:RF16:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:RF16:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:RF16:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF16:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:RF16:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:RF16:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:RF16:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF16:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:RF16:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:RF16:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:RF16:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF16:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:RF16:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:RF16:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:RF16:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:RF16:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:RF16:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:RF16:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:RF16:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:RF16:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:RF16:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:RF16:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:RF16:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:RF16:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:RF16:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:RF16:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:RF16:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:RF16:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:RF16:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:GBL0:EV01:INFO") {
  field(DESC, "SIOC:GBL0:EV01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:GBL0:EV01: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:GBL0: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, "SIOC:GBL0: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, "SIOC:GBL0:EV01:TODDIFF")
}

record(longin, "SIOC:GBL0:EV01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:GBL0:EV01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:GBL0: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, "SIOC:GBL0:EV01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:GBL0:EV01:TODCHECK.SEVR")
  field(INPB, "SIOC:GBL0:EV01:TODCHECK.VALB")
  field(FLNK, "SIOC:GBL0:EV01:TODSUM")
}

record(bo, "SIOC:GBL0:EV01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:GBL0:EV01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:GBL0:EV01:HEARTBEATCALC") {
  field(FLNK, "SIOC:GBL0:EV01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:GBL0:EV01:HEARTBEAT CA MS")
  field(INPB, "SIOC:GBL0:EV01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:GBL0:EV01:HEARTBEATOK") {
  field(FLNK, "SIOC:GBL0:EV01:HEARTBEATE01")
  field(INP, "SIOC:GBL0:EV01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:GBL0:EV01:HEARTBEATECT") {
  field(FLNK, "SIOC:GBL0:EV01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:GBL0:EV01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:GBL0:EV01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:GBL0:EV01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:GBL0:EV01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:GBL0:EV01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:GBL0:EV01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:GBL0:EV01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:GBL0:EV01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:GBL0:EV01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:GBL0: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, "SIOC:GBL0:EV01:HEARTBEATE09") {
  field(FLNK, "SIOC:GBL0:EV01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:GBL0:EV01:HEARTBEATE08.B")
  field(INPB, "SIOC:GBL0:EV01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:GBL0:EV01:HEARTBEATE08") {
  field(FLNK, "SIOC:GBL0:EV01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:GBL0:EV01:HEARTBEATE07.B")
  field(INPB, "SIOC:GBL0:EV01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:GBL0:EV01:HEARTBEATE07") {
  field(FLNK, "SIOC:GBL0:EV01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:GBL0:EV01:HEARTBEATE06.B")
  field(INPB, "SIOC:GBL0:EV01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:GBL0:EV01:HEARTBEATE06") {
  field(FLNK, "SIOC:GBL0:EV01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:GBL0:EV01:HEARTBEATE05.B")
  field(INPB, "SIOC:GBL0:EV01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:GBL0:EV01:HEARTBEATE05") {
  field(FLNK, "SIOC:GBL0:EV01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:GBL0:EV01:HEARTBEATE04.B")
  field(INPB, "SIOC:GBL0:EV01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:GBL0:EV01:HEARTBEATE04") {
  field(FLNK, "SIOC:GBL0:EV01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:GBL0:EV01:HEARTBEATE03.B")
  field(INPB, "SIOC:GBL0:EV01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:GBL0:EV01:HEARTBEATE03") {
  field(FLNK, "SIOC:GBL0:EV01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:GBL0:EV01:HEARTBEATE02.B")
  field(INPB, "SIOC:GBL0:EV01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:GBL0:EV01:HEARTBEATE02") {
  field(FLNK, "SIOC:GBL0:EV01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:GBL0:EV01:HEARTBEATE01.B")
  field(INPB, "SIOC:GBL0:EV01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:GBL0:EV01:HEARTBEATE01") {
  field(FLNK, "SIOC:GBL0:EV01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:GBL0:EV01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:GBL0:EV01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:GBL0:EV01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:GBL0:EV01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:GBL0:EV01:HEARTBEATSUM") {
  field(FLNK, "SIOC:GBL0:EV01:HEARTBEATCLC")
  field(INP, "SIOC:GBL0:EV01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:GBL0:EV01:HEARTBEATE10") {
  field(FLNK, "SIOC:GBL0:EV01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:GBL0:EV01:HEARTBEATE09.B")
  field(INPB, "SIOC:GBL0:EV01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:GBL0:EV01:HEARTBEATERR") {
  field(FLNK, "SIOC:GBL0:EV01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:GBL0:EV01:HEARTBEATCALC.A")
  field(INPB, "SIOC:GBL0:EV01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:GBL0:EV01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:GBL0:EV01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:GBL0:EV01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC: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, "Diane Fariley (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: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, "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: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, "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: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, "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: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-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: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, "Garth Brown (gbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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-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: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, "Garth Brown (gbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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-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: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, "Garth Brown (gbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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-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: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, "Garth Brown (gbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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-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: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, "Garth Brown (gbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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-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: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, "Garth Brown (gbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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-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: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, "Garth Brown (gbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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-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: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, "Garth Brown (gbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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-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: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, "Garth Brown (gbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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-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: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, "Garth Brown (gbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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-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: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, "Garth Brown (gbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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-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: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, "Garth Brown (gbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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-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: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, "Garth Brown (gbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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-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: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, "Garth Brown (gbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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-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: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, "Garth Brown (gbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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-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: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, "Garth Brown (gbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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-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: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, "Garth Brown (gbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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-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:LIN0:PP01:INFO") {
  field(DESC, "SIOC:LIN0:PP01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LIN0:PP01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Garth Brown (gwbrown)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:LIN0: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:LIN0: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:LIN0:PP01:TODDIFF")
}

record(longin, "SIOC:LIN0:PP01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:LIN0:PP01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:LIN0: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:LIN0:PP01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:LIN0:PP01:TODCHECK.SEVR")
  field(INPB, "SIOC:LIN0:PP01:TODCHECK.VALB")
  field(FLNK, "SIOC:LIN0:PP01:TODSUM")
}

record(bo, "SIOC:LIN0:PP01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:LIN0:PP01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:LIN0:PP01:HEARTBEATCALC") {
  field(FLNK, "SIOC:LIN0:PP01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:LIN0:PP01:HEARTBEAT CA MS")
  field(INPB, "SIOC:LIN0:PP01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:LIN0:PP01:HEARTBEATOK") {
  field(FLNK, "SIOC:LIN0:PP01:HEARTBEATE01")
  field(INP, "SIOC:LIN0:PP01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:LIN0:PP01:HEARTBEATECT") {
  field(FLNK, "SIOC:LIN0:PP01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:LIN0:PP01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:LIN0:PP01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:LIN0:PP01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:LIN0:PP01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:LIN0:PP01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:LIN0:PP01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:LIN0:PP01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:LIN0:PP01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:LIN0:PP01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:LIN0: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:LIN0:PP01:HEARTBEATE09") {
  field(FLNK, "SIOC:LIN0:PP01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:LIN0:PP01:HEARTBEATE08.B")
  field(INPB, "SIOC:LIN0:PP01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:LIN0:PP01:HEARTBEATE08") {
  field(FLNK, "SIOC:LIN0:PP01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:LIN0:PP01:HEARTBEATE07.B")
  field(INPB, "SIOC:LIN0:PP01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:LIN0:PP01:HEARTBEATE07") {
  field(FLNK, "SIOC:LIN0:PP01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:LIN0:PP01:HEARTBEATE06.B")
  field(INPB, "SIOC:LIN0:PP01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:LIN0:PP01:HEARTBEATE06") {
  field(FLNK, "SIOC:LIN0:PP01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:LIN0:PP01:HEARTBEATE05.B")
  field(INPB, "SIOC:LIN0:PP01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:LIN0:PP01:HEARTBEATE05") {
  field(FLNK, "SIOC:LIN0:PP01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:LIN0:PP01:HEARTBEATE04.B")
  field(INPB, "SIOC:LIN0:PP01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:LIN0:PP01:HEARTBEATE04") {
  field(FLNK, "SIOC:LIN0:PP01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:LIN0:PP01:HEARTBEATE03.B")
  field(INPB, "SIOC:LIN0:PP01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:LIN0:PP01:HEARTBEATE03") {
  field(FLNK, "SIOC:LIN0:PP01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:LIN0:PP01:HEARTBEATE02.B")
  field(INPB, "SIOC:LIN0:PP01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:LIN0:PP01:HEARTBEATE02") {
  field(FLNK, "SIOC:LIN0:PP01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:LIN0:PP01:HEARTBEATE01.B")
  field(INPB, "SIOC:LIN0:PP01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:LIN0:PP01:HEARTBEATE01") {
  field(FLNK, "SIOC:LIN0:PP01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:LIN0:PP01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:LIN0:PP01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:LIN0:PP01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:LIN0:PP01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:LIN0:PP01:HEARTBEATSUM") {
  field(FLNK, "SIOC:LIN0:PP01:HEARTBEATCLC")
  field(INP, "SIOC:LIN0: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:LIN0:PP01:HEARTBEATE10") {
  field(FLNK, "SIOC:LIN0:PP01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:LIN0:PP01:HEARTBEATE09.B")
  field(INPB, "SIOC:LIN0:PP01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:LIN0:PP01:HEARTBEATERR") {
  field(FLNK, "SIOC:LIN0:PP01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:LIN0:PP01:HEARTBEATCALC.A")
  field(INPB, "SIOC:LIN0:PP01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:LIN0:PP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:LIN0:PP01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:LIN0:PP01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:FB01:INFO") {
  field(DESC, "SIOC:SYS0:FB01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:FB01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "James Luong (ajluong)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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: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, "SIOC:SYS0: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, "SIOC:SYS0:FB01:TODDIFF")
}

record(longin, "SIOC:SYS0:FB01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:FB01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0: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, "SIOC:SYS0:FB01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:FB01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:FB01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:FB01:TODSUM")
}

record(bo, "SIOC:SYS0:FB01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:FB01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:FB01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:FB01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:FB01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:FB01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:FB01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:FB01:HEARTBEATE01")
  field(INP, "SIOC:SYS0:FB01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:FB01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:FB01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:FB01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:FB01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:FB01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:FB01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:FB01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:FB01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:FB01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:FB01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:FB01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0: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, "SIOC:SYS0:FB01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:FB01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:FB01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:FB01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:FB01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:FB01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:FB01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:FB01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:FB01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:FB01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:FB01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:FB01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:FB01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:FB01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:FB01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:FB01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:FB01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:FB01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:FB01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:FB01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:FB01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:FB01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:FB01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:FB01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:FB01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:FB01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:FB01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:FB01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:FB01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:FB01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:FB01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:FB01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:FB01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:FB01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:FB01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:FB01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:FB01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:FB01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:FB01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:FB01:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:FB01: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:FB01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:FB01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:FB01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:FB01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:FB01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:FB01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:FB01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:FB01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:FB01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:FB01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:FB01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-fb01")
  info(autosaveFields,"VAL")
}

# String record 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:LG01:INFO") {
  field(DESC, "SIOC:SYS0:LG01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:LG01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYS0:LG01: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:LG01:TOD CA")
  field(INPC, "10")
# VALA holds 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:LG01:TODDIFF")
}

record(longin, "SIOC:SYS0:LG01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:LG01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:LG01:TODCHECKVALID")
}

# If <ioc> 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:LG01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:LG01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:LG01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:LG01:TODSUM")
}

record(bo, "SIOC:SYS0:LG01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:LG01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:LG01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:LG01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LG01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:LG01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:LG01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:LG01:HEARTBEATE01")
  field(INP, "SIOC:SYS0:LG01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:LG01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:LG01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:LG01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:LG01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:LG01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:LG01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:LG01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:LG01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:LG01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:LG01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:LG01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:LG01:HEARTBEATE10.VAL")
  field(HIHI, "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:LG01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:LG01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LG01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:LG01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:LG01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:LG01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LG01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:LG01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:LG01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:LG01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LG01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:LG01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:LG01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:LG01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LG01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:LG01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:LG01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:LG01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LG01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:LG01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:LG01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:LG01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LG01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:LG01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:LG01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:LG01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LG01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:LG01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:LG01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:LG01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LG01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:LG01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:LG01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:LG01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LG01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:LG01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:LG01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:LG01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:LG01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:LG01:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:LG01: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:LG01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:LG01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:LG01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:LG01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:LG01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:LG01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:LG01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:LG01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:LG01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:LG01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:LG01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-fb02")
  info(autosaveFields,"VAL")
}

# String record 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:GN01:INFO") {
  field(DESC, "SIOC:SYS0:GN01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:GN01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYS0:GN01: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:GN01:TOD CA")
  field(INPC, "10")
# VALA holds 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:GN01:TODDIFF")
}

record(longin, "SIOC:SYS0:GN01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:GN01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:GN01:TODCHECKVALID")
}

# If <ioc> 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:GN01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:GN01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:GN01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:GN01:TODSUM")
}

record(bo, "SIOC:SYS0:GN01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:GN01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:GN01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:GN01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:GN01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:GN01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:GN01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:GN01:HEARTBEATE01")
  field(INP, "SIOC:SYS0:GN01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:GN01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:GN01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:GN01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:GN01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:GN01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:GN01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:GN01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:GN01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:GN01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:GN01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:GN01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:GN01:HEARTBEATE10.VAL")
  field(HIHI, "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:GN01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:GN01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:GN01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:GN01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:GN01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:GN01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:GN01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:GN01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:GN01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:GN01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:GN01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:GN01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:GN01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:GN01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:GN01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:GN01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:GN01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:GN01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:GN01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:GN01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:GN01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:GN01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:GN01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:GN01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:GN01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:GN01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:GN01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:GN01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:GN01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:GN01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:GN01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:GN01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:GN01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:GN01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:GN01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:GN01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:GN01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:GN01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:GN01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:GN01:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:GN01: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:GN01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:GN01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:GN01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:GN01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:GN01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:GN01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:GN01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:GN01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:GN01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:GN01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:GN01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-fb02")
  info(autosaveFields,"VAL")
}

# String record 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:AS01:INFO") {
  field(DESC, "SIOC:SYS0:AS01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:AS01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Daron Chabot (dchabot)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:AS01: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:AS01:TOD CA")
  field(INPC, "10")
# VALA holds 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:AS01:TODDIFF")
}

record(longin, "SIOC:SYS0:AS01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:AS01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:AS01:TODCHECKVALID")
}

# If <ioc> 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:AS01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:AS01:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:AS01:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:AS01:TODSUM")
}

record(bo, "SIOC:SYS0:AS01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:AS01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:AS01:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:AS01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS01:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:AS01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:AS01:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:AS01:HEARTBEATE01")
  field(INP, "SIOC:SYS0:AS01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:AS01:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:AS01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:AS01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:AS01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:AS01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:AS01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:AS01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:AS01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:AS01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:AS01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:AS01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:AS01:HEARTBEATE10.VAL")
  field(HIHI, "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:AS01:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:AS01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS01:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:AS01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:AS01:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:AS01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS01:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:AS01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:AS01:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:AS01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS01:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:AS01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:AS01:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:AS01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS01:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:AS01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:AS01:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:AS01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS01:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:AS01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:AS01:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:AS01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS01:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:AS01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:AS01:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:AS01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS01:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:AS01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:AS01:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:AS01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS01:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:AS01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:AS01:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:AS01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:AS01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:AS01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:AS01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:AS01:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:AS01:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:AS01: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:AS01:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:AS01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS01:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:AS01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:AS01:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:AS01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:AS01:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:AS01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:AS01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Access Security - Global")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:AS01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Access Security - Global")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:AS01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:AS02:INFO") {
  field(DESC, "SIOC:SYS0:AS02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:AS02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Daron Chabot (dchabot)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:AS02: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:AS02:TOD CA")
  field(INPC, "10")
# VALA holds 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:AS02:TODDIFF")
}

record(longin, "SIOC:SYS0:AS02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:AS02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:AS02:TODCHECKVALID")
}

# If <ioc> 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:AS02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:AS02:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:AS02:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:AS02:TODSUM")
}

record(bo, "SIOC:SYS0:AS02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:AS02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:AS02:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:AS02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS02:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:AS02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:AS02:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:AS02:HEARTBEATE01")
  field(INP, "SIOC:SYS0:AS02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:AS02:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:AS02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:AS02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:AS02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:AS02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:AS02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:AS02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:AS02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:AS02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:AS02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:AS02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:AS02:HEARTBEATE10.VAL")
  field(HIHI, "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:AS02:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:AS02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS02:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:AS02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:AS02:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:AS02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS02:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:AS02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:AS02:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:AS02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS02:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:AS02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:AS02:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:AS02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS02:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:AS02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:AS02:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:AS02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS02:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:AS02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:AS02:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:AS02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS02:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:AS02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:AS02:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:AS02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS02:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:AS02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:AS02:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:AS02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS02:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:AS02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:AS02:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:AS02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:AS02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:AS02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:AS02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:AS02:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:AS02:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:AS02: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:AS02:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:AS02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS02:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:AS02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:AS02:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:AS02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:AS02:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:AS02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:AS02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Access Security - Timed")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:AS02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Access Security - Timed")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:AS02:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:AS03:INFO") {
  field(DESC, "SIOC:SYS0:AS03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:AS03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Daron Chabot (dchabot)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:AS03: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:AS03:TOD CA")
  field(INPC, "10")
# VALA holds 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:AS03:TODDIFF")
}

record(longin, "SIOC:SYS0:AS03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:AS03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:AS03:TODCHECKVALID")
}

# If <ioc> 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:AS03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:AS03:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:AS03:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:AS03:TODSUM")
}

record(bo, "SIOC:SYS0:AS03:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:AS03:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:AS03:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:AS03:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS03:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:AS03:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:AS03:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:AS03:HEARTBEATE01")
  field(INP, "SIOC:SYS0:AS03:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:AS03:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:AS03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:AS03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:AS03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:AS03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:AS03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:AS03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:AS03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:AS03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:AS03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:AS03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:AS03:HEARTBEATE10.VAL")
  field(HIHI, "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:AS03:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:AS03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS03:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:AS03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:AS03:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:AS03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS03:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:AS03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:AS03:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:AS03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS03:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:AS03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:AS03:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:AS03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS03:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:AS03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:AS03:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:AS03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS03:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:AS03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:AS03:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:AS03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS03:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:AS03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:AS03:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:AS03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS03:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:AS03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:AS03:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:AS03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS03:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:AS03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:AS03:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:AS03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:AS03:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:AS03:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:AS03:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:AS03:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:AS03:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:AS03: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:AS03:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:AS03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:AS03:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:AS03:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:AS03:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:AS03:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:AS03:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:AS03:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:AS03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Access Security - Test")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:AS03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "Access Security - Test")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:AS03:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:MP04:INFO") {
  field(DESC, "SIOC:SYS0:MP04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MP04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Kyle Leleux (kleleux)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYS0:MP04:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:SYS0:MP04:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:SYS0:MP04:TODDIFF")
}

record(longin, "SIOC:SYS0:MP04:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:MP04:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:MP04:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:SYS0:MP04:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:MP04:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:MP04:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:MP04:TODSUM")
}

record(bo, "SIOC:SYS0:MP04:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:MP04:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:MP04:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:MP04:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP04:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:MP04:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:MP04:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:MP04:HEARTBEATE01")
  field(INP, "SIOC:SYS0:MP04:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:MP04:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:MP04:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:MP04:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:MP04:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:MP04:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:MP04:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:MP04:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:MP04:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:MP04:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:MP04:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:MP04:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:MP04:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:SYS0:MP04:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:MP04:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP04:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:MP04:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:MP04:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:MP04:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP04:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:MP04:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:MP04:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:MP04:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP04:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:MP04:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:MP04:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:MP04:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP04:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:MP04:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:MP04:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:MP04:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP04:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:MP04:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:MP04:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:MP04:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP04:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:MP04:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:MP04:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:MP04:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP04:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:MP04:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:MP04:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:MP04:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP04:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:MP04:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:MP04:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:MP04:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP04:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:MP04:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:MP04:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:MP04:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:MP04:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:MP04:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:MP04:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:SYS0:MP04:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:MP04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:MP04:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:MP04:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:MP04:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:MP04:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:MP04:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:MP04:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:MP04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:MP04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:MP04:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:BA11:INFO") {
  field(DESC, "SIOC:SYS0:BA11 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:BA11:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Doug Murray (dmurray)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYS0:BA11: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:BA11:TOD CA")
  field(INPC, "10")
# VALA holds 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:BA11:TODDIFF")
}

record(longin, "SIOC:SYS0:BA11:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:BA11:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:BA11:TODCHECKVALID")
}

# If <ioc> 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:BA11:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:BA11:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:BA11:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:BA11:TODSUM")
}

record(bo, "SIOC:SYS0:BA11:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:BA11:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:BA11:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:BA11:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA11:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:BA11:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:BA11:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:BA11:HEARTBEATE01")
  field(INP, "SIOC:SYS0:BA11:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:BA11:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:BA11:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:BA11:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:BA11:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:BA11:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:BA11:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:BA11:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:BA11:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:BA11:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:BA11:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:BA11:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:BA11:HEARTBEATE10.VAL")
  field(HIHI, "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:BA11:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:BA11:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA11:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:BA11:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:BA11:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:BA11:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA11:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:BA11:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:BA11:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:BA11:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA11:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:BA11:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:BA11:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:BA11:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA11:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:BA11:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:BA11:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:BA11:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA11:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:BA11:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:BA11:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:BA11:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA11:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:BA11:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:BA11:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:BA11:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA11:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:BA11:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:BA11:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:BA11:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA11:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:BA11:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:BA11:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:BA11:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA11:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:BA11:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:BA11:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:BA11:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:BA11:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:BA11:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:BA11: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:BA11:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:BA11:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA11:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:BA11:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:BA11:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:BA11:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:BA11:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:BA11:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:BA11:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "BSA Service for CuHXR")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:BA11:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "BSA Service for CuHXR")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:BA11:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:SYS0:BA12:INFO") {
  field(DESC, "SIOC:SYS0:BA12 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:BA12:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Doug Murray (dmurray)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:SYS0:BA12: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:BA12:TOD CA")
  field(INPC, "10")
# VALA holds 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:BA12:TODDIFF")
}

record(longin, "SIOC:SYS0:BA12:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:SYS0:BA12:TODCHECK.VALA MS")
  field(FLNK, "SIOC:SYS0:BA12:TODCHECKVALID")
}

# If <ioc> 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:BA12:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:SYS0:BA12:TODCHECK.SEVR")
  field(INPB, "SIOC:SYS0:BA12:TODCHECK.VALB")
  field(FLNK, "SIOC:SYS0:BA12:TODSUM")
}

record(bo, "SIOC:SYS0:BA12:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:SYS0:BA12:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:SYS0:BA12:HEARTBEATCALC") {
  field(FLNK, "SIOC:SYS0:BA12:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA12:HEARTBEAT CA MS")
  field(INPB, "SIOC:SYS0:BA12:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:SYS0:BA12:HEARTBEATOK") {
  field(FLNK, "SIOC:SYS0:BA12:HEARTBEATE01")
  field(INP, "SIOC:SYS0:BA12:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:SYS0:BA12:HEARTBEATECT") {
  field(FLNK, "SIOC:SYS0:BA12:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:SYS0:BA12:HEARTBEATE01.VAL")
  field(INPB, "SIOC:SYS0:BA12:HEARTBEATE02.VAL")
  field(INPC, "SIOC:SYS0:BA12:HEARTBEATE03.VAL")
  field(INPD, "SIOC:SYS0:BA12:HEARTBEATE04.VAL")
  field(INPE, "SIOC:SYS0:BA12:HEARTBEATE05.VAL")
  field(INPF, "SIOC:SYS0:BA12:HEARTBEATE06.VAL")
  field(INPG, "SIOC:SYS0:BA12:HEARTBEATE07.VAL")
  field(INPH, "SIOC:SYS0:BA12:HEARTBEATE08.VAL")
  field(INPI, "SIOC:SYS0:BA12:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:SYS0:BA12:HEARTBEATE10.VAL")
  field(HIHI, "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:BA12:HEARTBEATE09") {
  field(FLNK, "SIOC:SYS0:BA12:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA12:HEARTBEATE08.B")
  field(INPB, "SIOC:SYS0:BA12:HEARTBEATE09.VAL")
}

record(calc, "SIOC:SYS0:BA12:HEARTBEATE08") {
  field(FLNK, "SIOC:SYS0:BA12:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA12:HEARTBEATE07.B")
  field(INPB, "SIOC:SYS0:BA12:HEARTBEATE08.VAL")
}

record(calc, "SIOC:SYS0:BA12:HEARTBEATE07") {
  field(FLNK, "SIOC:SYS0:BA12:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA12:HEARTBEATE06.B")
  field(INPB, "SIOC:SYS0:BA12:HEARTBEATE07.VAL")
}

record(calc, "SIOC:SYS0:BA12:HEARTBEATE06") {
  field(FLNK, "SIOC:SYS0:BA12:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA12:HEARTBEATE05.B")
  field(INPB, "SIOC:SYS0:BA12:HEARTBEATE06.VAL")
}

record(calc, "SIOC:SYS0:BA12:HEARTBEATE05") {
  field(FLNK, "SIOC:SYS0:BA12:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA12:HEARTBEATE04.B")
  field(INPB, "SIOC:SYS0:BA12:HEARTBEATE05.VAL")
}

record(calc, "SIOC:SYS0:BA12:HEARTBEATE04") {
  field(FLNK, "SIOC:SYS0:BA12:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA12:HEARTBEATE03.B")
  field(INPB, "SIOC:SYS0:BA12:HEARTBEATE04.VAL")
}

record(calc, "SIOC:SYS0:BA12:HEARTBEATE03") {
  field(FLNK, "SIOC:SYS0:BA12:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA12:HEARTBEATE02.B")
  field(INPB, "SIOC:SYS0:BA12:HEARTBEATE03.VAL")
}

record(calc, "SIOC:SYS0:BA12:HEARTBEATE02") {
  field(FLNK, "SIOC:SYS0:BA12:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA12:HEARTBEATE01.B")
  field(INPB, "SIOC:SYS0:BA12:HEARTBEATE02.VAL")
}

record(calc, "SIOC:SYS0:BA12:HEARTBEATE01") {
  field(FLNK, "SIOC:SYS0:BA12:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA12:HEARTBEATERR.VAL")
  field(INPB, "SIOC:SYS0:BA12:HEARTBEATE01.VAL")
}

record(calc, "SIOC:SYS0:BA12:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:SYS0:BA12:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:SYS0:BA12:HEARTBEATSUM") {
  field(FLNK, "SIOC:SYS0:BA12:HEARTBEATCLC")
  field(INP, "SIOC:SYS0:BA12: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:BA12:HEARTBEATE10") {
  field(FLNK, "SIOC:SYS0:BA12:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:SYS0:BA12:HEARTBEATE09.B")
  field(INPB, "SIOC:SYS0:BA12:HEARTBEATE10.VAL")
}

record(calc, "SIOC:SYS0:BA12:HEARTBEATERR") {
  field(FLNK, "SIOC:SYS0:BA12:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:SYS0:BA12:HEARTBEATCALC.A")
  field(INPB, "SIOC:SYS0:BA12:HEARTBEATCALC.B")
}

record(stringin, "SIOC:SYS0:BA12:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "BSA Service for CuSXR")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:SYS0:BA12:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "BSA Service for CuSXR")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:SYS0:BA12:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

