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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:LI22:BP01:LOC") {
  field(PINI, "YES")
  field(VAL, "KF22-3C24")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:LI22:BP02:LOC") {
  field(PINI, "YES")
  field(VAL, "KF22-7C24")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:LI22:CV01:LOC") {
  field(PINI, "YES")
  field(VAL, "KA22-0210")
  info(autosaveFields,"VAL")
}

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

record(stringin, "EIOC:LI22:MP01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Luciano Piccoli (lpiccoli)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

record(aSub, "EIOC:LI22: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, "EIOC:LI22: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, "EIOC:LI22:MP01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:LI22:MP01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LN13")
  info(autosaveFields,"VAL")
}

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

record(stringin, "EIOC:LI22:MP01:LOC") {
  field(PINI, "YES")
  field(VAL, "KA22-0341")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:LI22:BP201:LOC") {
  field(PINI, "YES")
  field(VAL, "KF22-3C16")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:LI22:BP301:LOC") {
  field(PINI, "YES")
  field(VAL, "KF22-3C14")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:LI22:BP401:LOC") {
  field(PINI, "YES")
  field(VAL, "KF22-3C12")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:LI22:BP501:LOC") {
  field(PINI, "YES")
  field(VAL, "KF22-3C10")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:LI22:BP601:LOC") {
  field(PINI, "YES")
  field(VAL, "KF22-7C16")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:LI22:BP701:LOC") {
  field(PINI, "YES")
  field(VAL, "KF22-7C14")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:LI22:BP801:LOC") {
  field(PINI, "YES")
  field(VAL, "KF22-7C12")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:LI22:BP901:LOC") {
  field(PINI, "YES")
  field(VAL, "KF22-7C10")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:LI22:MG01:LOC") {
  field(PINI, "YES")
  field(VAL, "KA22-0127")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:LI22:MG02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-li22-mg02")
  info(autosaveFields,"VAL")
}

