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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:AM01:LOC") {
  field(PINI, "YES")
  field(VAL, "LIT-0110")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:BC01:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-16")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:BP01:LOC") {
  field(PINI, "YES")
  field(VAL, "RF Hut LKG-2109")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:BP02:LOC") {
  field(PINI, "YES")
  field(VAL, "RF Hut LKG-2225")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:IN20:EV01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Kukhee Kim (khkim)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:EV01:LOC") {
  field(PINI, "YES")
  field(VAL, "RF Hut LKG-2121")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:IM01:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-1410")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:LS11:LOC") {
  field(PINI, "YES")
  field(VAL, "LIT-01")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:LS12:LOC") {
  field(PINI, "YES")
  field(VAL, "LIT-01")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:LS13:LOC") {
  field(PINI, "YES")
  field(VAL, "LIT-01")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:LS14:LOC") {
  field(PINI, "YES")
  field(VAL, "LIT-01")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:MC01:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-1127")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:MP01:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-15")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:PM01:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-14")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:PM02:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-14")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:PM03:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-14")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:PM04:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-13")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:PP01:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-19")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:RF01:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2508")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:RF02:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2601")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:RF03:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2701")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:VA01:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-1214")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:RF04:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2103")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:RF05:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2701")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:IN20:RF06:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2103")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:IN20:BP221:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2222")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:IN20:BP235:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2220")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:IN20:BP371:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2218")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:IN20:BP425:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2217")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:IN20:BP511:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2216")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:IN20:BP525:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2214")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:IN20:BP581:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2213")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:IN20:BP631:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2212")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:IN20:BP651:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2210")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(calc, "EIOC:IN20:BP731:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:BP731:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP731:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:BP731:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:BP731:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:BP731:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:BP731:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:BP731:HEARTBEATCLC")
  field(INP, "EIOC:IN20:BP731:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:BP731:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:BP731:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP731:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:BP731:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:BP731:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:BP731:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:BP731:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:BP731:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:BP731:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:BP731:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:BP731:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2209")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:BP771:INFO") {
  field(DESC, "EIOC:IN20:BP771 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:BP771: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:IN20:BP771: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:IN20:BP771:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:BP771:TODDIFF")
}

record(longin, "EIOC:IN20:BP771:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:BP771:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:BP771:TODCHECKVALID")
}

# If <ioc> 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:IN20:BP771:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:BP771:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:BP771:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:BP771:TODSUM")
}

record(bo, "EIOC:IN20:BP771:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:BP771:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:BP771:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:BP771:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP771:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:BP771:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:BP771:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:BP771:HEARTBEATE01")
  field(INP, "EIOC:IN20:BP771:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:BP771:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:BP771:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:BP771:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:BP771:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:BP771:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:BP771:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:BP771:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:BP771:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:BP771:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:BP771:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:BP771:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:BP771:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:BP771:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:BP771:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP771:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:BP771:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:BP771:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:BP771:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP771:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:BP771:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:BP771:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:BP771:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP771:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:BP771:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:BP771:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:BP771:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP771:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:BP771:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:BP771:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:BP771:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP771:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:BP771:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:BP771:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:BP771:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP771:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:BP771:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:BP771:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:BP771:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP771:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:BP771:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:BP771:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:BP771:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP771:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:BP771:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:BP771:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:BP771:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP771:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:BP771:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:BP771:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:BP771:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:BP771:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:BP771:HEARTBEATCLC")
  field(INP, "EIOC:IN20:BP771:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:BP771:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:BP771:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP771:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:BP771:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:BP771:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:BP771:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:BP771:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:BP771:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:BP771:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:BP771:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:BP771:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2208")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:BP781:INFO") {
  field(DESC, "EIOC:IN20:BP781 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:BP781: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:IN20:BP781: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:IN20:BP781:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:BP781:TODDIFF")
}

record(longin, "EIOC:IN20:BP781:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:BP781:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:BP781:TODCHECKVALID")
}

# If <ioc> 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:IN20:BP781:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:BP781:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:BP781:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:BP781:TODSUM")
}

record(bo, "EIOC:IN20:BP781:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:BP781:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:BP781:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:BP781:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP781:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:BP781:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:BP781:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:BP781:HEARTBEATE01")
  field(INP, "EIOC:IN20:BP781:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:BP781:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:BP781:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:BP781:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:BP781:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:BP781:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:BP781:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:BP781:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:BP781:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:BP781:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:BP781:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:BP781:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:BP781:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:BP781:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:BP781:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP781:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:BP781:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:BP781:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:BP781:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP781:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:BP781:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:BP781:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:BP781:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP781:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:BP781:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:BP781:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:BP781:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP781:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:BP781:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:BP781:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:BP781:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP781:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:BP781:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:BP781:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:BP781:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP781:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:BP781:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:BP781:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:BP781:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP781:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:BP781:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:BP781:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:BP781:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP781:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:BP781:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:BP781:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:BP781:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP781:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:BP781:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:BP781:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:BP781:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:BP781:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:BP781:HEARTBEATCLC")
  field(INP, "EIOC:IN20:BP781:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:BP781:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:BP781:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP781:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:BP781:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:BP781:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:BP781:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:BP781:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:BP781:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:BP781:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:BP781:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:BP781:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2322")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:BP821:INFO") {
  field(DESC, "EIOC:IN20:BP821 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:BP821: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:IN20:BP821: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:IN20:BP821:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:BP821:TODDIFF")
}

record(longin, "EIOC:IN20:BP821:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:BP821:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:BP821:TODCHECKVALID")
}

# If <ioc> 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:IN20:BP821:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:BP821:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:BP821:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:BP821:TODSUM")
}

record(bo, "EIOC:IN20:BP821:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:BP821:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:BP821:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:BP821:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP821:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:BP821:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:BP821:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:BP821:HEARTBEATE01")
  field(INP, "EIOC:IN20:BP821:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:BP821:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:BP821:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:BP821:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:BP821:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:BP821:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:BP821:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:BP821:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:BP821:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:BP821:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:BP821:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:BP821:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:BP821:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:BP821:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:BP821:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP821:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:BP821:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:BP821:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:BP821:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP821:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:BP821:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:BP821:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:BP821:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP821:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:BP821:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:BP821:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:BP821:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP821:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:BP821:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:BP821:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:BP821:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP821:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:BP821:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:BP821:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:BP821:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP821:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:BP821:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:BP821:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:BP821:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP821:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:BP821:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:BP821:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:BP821:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP821:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:BP821:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:BP821:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:BP821:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP821:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:BP821:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:BP821:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:BP821:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:BP821:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:BP821:HEARTBEATCLC")
  field(INP, "EIOC:IN20:BP821:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:BP821:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:BP821:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP821:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:BP821:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:BP821:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:BP821:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:BP821:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:BP821:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:BP821:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:BP821:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:BP821:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2221")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:BP925:INFO") {
  field(DESC, "EIOC:IN20:BP925 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:BP925: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:IN20:BP925: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:IN20:BP925:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:BP925:TODDIFF")
}

record(longin, "EIOC:IN20:BP925:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:BP925:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:BP925:TODCHECKVALID")
}

# If <ioc> 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:IN20:BP925:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:BP925:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:BP925:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:BP925:TODSUM")
}

record(bo, "EIOC:IN20:BP925:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:BP925:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:BP925:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:BP925:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP925:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:BP925:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:BP925:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:BP925:HEARTBEATE01")
  field(INP, "EIOC:IN20:BP925:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:BP925:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:BP925:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:BP925:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:BP925:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:BP925:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:BP925:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:BP925:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:BP925:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:BP925:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:BP925:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:BP925:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:BP925:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:BP925:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:BP925:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP925:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:BP925:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:BP925:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:BP925:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP925:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:BP925:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:BP925:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:BP925:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP925:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:BP925:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:BP925:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:BP925:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP925:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:BP925:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:BP925:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:BP925:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP925:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:BP925:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:BP925:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:BP925:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP925:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:BP925:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:BP925:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:BP925:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP925:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:BP925:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:BP925:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:BP925:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP925:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:BP925:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:BP925:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:BP925:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP925:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:BP925:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:BP925:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:BP925:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:BP925:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:BP925:HEARTBEATCLC")
  field(INP, "EIOC:IN20:BP925:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:BP925:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:BP925:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP925:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:BP925:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:BP925:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:BP925:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:BP925:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:BP925:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:BP925:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:BP925:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:BP925:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2321")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:BP945:INFO") {
  field(DESC, "EIOC:IN20:BP945 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:BP945: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:IN20:BP945: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:IN20:BP945:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:BP945:TODDIFF")
}

record(longin, "EIOC:IN20:BP945:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:BP945:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:BP945:TODCHECKVALID")
}

# If <ioc> 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:IN20:BP945:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:BP945:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:BP945:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:BP945:TODSUM")
}

record(bo, "EIOC:IN20:BP945:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:BP945:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:BP945:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:BP945:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP945:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:BP945:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:BP945:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:BP945:HEARTBEATE01")
  field(INP, "EIOC:IN20:BP945:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:BP945:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:BP945:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:BP945:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:BP945:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:BP945:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:BP945:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:BP945:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:BP945:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:BP945:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:BP945:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:BP945:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:BP945:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:BP945:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:BP945:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP945:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:BP945:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:BP945:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:BP945:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP945:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:BP945:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:BP945:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:BP945:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP945:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:BP945:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:BP945:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:BP945:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP945:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:BP945:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:BP945:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:BP945:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP945:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:BP945:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:BP945:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:BP945:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP945:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:BP945:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:BP945:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:BP945:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP945:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:BP945:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:BP945:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:BP945:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP945:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:BP945:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:BP945:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:BP945:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP945:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:BP945:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:BP945:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:BP945:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:BP945:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:BP945:HEARTBEATCLC")
  field(INP, "EIOC:IN20:BP945:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:BP945:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:BP945:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP945:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:BP945:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:BP945:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:BP945:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:BP945:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:BP945:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:BP945:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:BP945:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:BP945:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2320")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:BP981:INFO") {
  field(DESC, "EIOC:IN20:BP981 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:BP981: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:IN20:BP981: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:IN20:BP981:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:BP981:TODDIFF")
}

record(longin, "EIOC:IN20:BP981:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:BP981:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:BP981:TODCHECKVALID")
}

# If <ioc> 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:IN20:BP981:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:BP981:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:BP981:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:BP981:TODSUM")
}

record(bo, "EIOC:IN20:BP981:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:BP981:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:BP981:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:BP981:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP981:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:BP981:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:BP981:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:BP981:HEARTBEATE01")
  field(INP, "EIOC:IN20:BP981:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:BP981:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:BP981:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:BP981:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:BP981:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:BP981:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:BP981:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:BP981:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:BP981:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:BP981:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:BP981:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:BP981:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:BP981:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:BP981:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:BP981:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP981:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:BP981:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:BP981:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:BP981:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP981:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:BP981:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:BP981:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:BP981:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP981:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:BP981:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:BP981:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:BP981:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP981:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:BP981:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:BP981:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:BP981:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP981:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:BP981:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:BP981:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:BP981:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP981:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:BP981:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:BP981:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:BP981:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP981:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:BP981:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:BP981:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:BP981:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP981:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:BP981:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:BP981:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:BP981:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP981:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:BP981:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:BP981:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:BP981:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:BP981:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:BP981:HEARTBEATCLC")
  field(INP, "EIOC:IN20:BP981:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:BP981:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:BP981:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:BP981:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:BP981:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:BP981:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:BP981:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:BP981:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:BP981:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:BP981:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:BP981:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:BP981:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2318")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:IM01:INFO") {
  field(DESC, "EIOC:IN20:IM01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:IM01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Arturo Alarcon (alarcon)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:IM01: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:IN20:IM01:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:IM01:TODDIFF")
}

record(longin, "EIOC:IN20:IM01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:IM01:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:IM01:TODCHECKVALID")
}

# If <ioc> 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:IN20:IM01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:IM01:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:IM01:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:IM01:TODSUM")
}

record(bo, "EIOC:IN20:IM01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:IM01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:IM01:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:IM01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:IM01:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:IM01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:IM01:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:IM01:HEARTBEATE01")
  field(INP, "EIOC:IN20:IM01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:IM01:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:IM01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:IM01:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:IM01:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:IM01:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:IM01:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:IM01:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:IM01:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:IM01:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:IM01:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:IM01:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:IM01:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:IM01:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:IM01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:IM01:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:IM01:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:IM01:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:IM01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:IM01:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:IM01:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:IM01:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:IM01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:IM01:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:IM01:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:IM01:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:IM01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:IM01:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:IM01:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:IM01:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:IM01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:IM01:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:IM01:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:IM01:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:IM01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:IM01:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:IM01:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:IM01:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:IM01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:IM01:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:IM01:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:IM01:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:IM01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:IM01:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:IM01:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:IM01:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:IM01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:IM01:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:IM01:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:IM01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:IM01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:IM01:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:IM01:HEARTBEATCLC")
  field(INP, "EIOC:IN20:IM01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:IM01:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:IM01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:IM01:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:IM01:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:IM01:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:IM01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:IM01:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:IM01:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:IM01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:IM01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:IM01:LOC") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RC01:INFO") {
  field(DESC, "EIOC:IN20:RC01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RC01: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:IN20:RC01:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RC01:TODDIFF")
}

record(longin, "EIOC:IN20:RC01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RC01:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RC01:TODCHECKVALID")
}

# If <ioc> 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:IN20:RC01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RC01:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RC01:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RC01:TODSUM")
}

record(bo, "EIOC:IN20:RC01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RC01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RC01:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RC01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC01:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RC01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RC01:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RC01:HEARTBEATE01")
  field(INP, "EIOC:IN20:RC01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RC01:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RC01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RC01:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RC01:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RC01:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RC01:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RC01:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RC01:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RC01:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RC01:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RC01:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RC01:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RC01:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RC01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC01:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RC01:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RC01:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RC01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC01:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RC01:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RC01:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RC01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC01:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RC01:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RC01:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RC01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC01:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RC01:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RC01:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RC01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC01:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RC01:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RC01:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RC01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC01:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RC01:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RC01:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RC01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC01:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RC01:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RC01:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RC01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC01:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RC01:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RC01:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RC01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC01:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RC01:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RC01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RC01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RC01:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RC01:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RC01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RC01:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RC01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC01:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RC01:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RC01:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RC01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RC01:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RC01:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RC01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "RFR-SPAC")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RC01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "RFR-SPAC")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC01:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2736")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RC02:INFO") {
  field(DESC, "EIOC:IN20:RC02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RC02: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:IN20:RC02:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RC02:TODDIFF")
}

record(longin, "EIOC:IN20:RC02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RC02:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RC02:TODCHECKVALID")
}

# If <ioc> 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:IN20:RC02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RC02:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RC02:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RC02:TODSUM")
}

record(bo, "EIOC:IN20:RC02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RC02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RC02:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RC02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC02:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RC02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RC02:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RC02:HEARTBEATE01")
  field(INP, "EIOC:IN20:RC02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RC02:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RC02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RC02:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RC02:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RC02:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RC02:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RC02:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RC02:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RC02:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RC02:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RC02:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RC02:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RC02:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RC02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC02:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RC02:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RC02:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RC02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC02:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RC02:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RC02:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RC02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC02:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RC02:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RC02:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RC02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC02:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RC02:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RC02:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RC02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC02:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RC02:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RC02:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RC02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC02:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RC02:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RC02:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RC02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC02:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RC02:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RC02:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RC02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC02:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RC02:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RC02:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RC02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC02:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RC02:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RC02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RC02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RC02:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RC02:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RC02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RC02:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RC02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC02:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RC02:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RC02:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RC02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RC02:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RC02:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RC02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "MDL-SPAC")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RC02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "MDL-SPAC")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC02:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2633")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RC03:INFO") {
  field(DESC, "EIOC:IN20:RC03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RC03: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:IN20:RC03:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RC03:TODDIFF")
}

record(longin, "EIOC:IN20:RC03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RC03:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RC03:TODCHECKVALID")
}

# If <ioc> 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:IN20:RC03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RC03:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RC03:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RC03:TODSUM")
}

record(bo, "EIOC:IN20:RC03:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RC03:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RC03:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RC03:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC03:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RC03:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RC03:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RC03:HEARTBEATE01")
  field(INP, "EIOC:IN20:RC03:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RC03:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RC03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RC03:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RC03:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RC03:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RC03:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RC03:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RC03:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RC03:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RC03:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RC03:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RC03:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RC03:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RC03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC03:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RC03:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RC03:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RC03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC03:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RC03:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RC03:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RC03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC03:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RC03:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RC03:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RC03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC03:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RC03:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RC03:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RC03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC03:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RC03:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RC03:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RC03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC03:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RC03:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RC03:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RC03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC03:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RC03:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RC03:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RC03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC03:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RC03:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RC03:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RC03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC03:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RC03:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RC03:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RC03:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RC03:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RC03:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RC03:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RC03:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RC03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC03:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RC03:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RC03:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RC03:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RC03:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RC03:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RC03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LCL-SPAC")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RC03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LCL-SPAC")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC03:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2821")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RC04:INFO") {
  field(DESC, "EIOC:IN20:RC04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RC04: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:IN20:RC04:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RC04:TODDIFF")
}

record(longin, "EIOC:IN20:RC04:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RC04:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RC04:TODCHECKVALID")
}

# If <ioc> 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:IN20:RC04:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RC04:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RC04:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RC04:TODSUM")
}

record(bo, "EIOC:IN20:RC04:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RC04:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RC04:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RC04:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC04:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RC04:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RC04:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RC04:HEARTBEATE01")
  field(INP, "EIOC:IN20:RC04:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RC04:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RC04:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RC04:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RC04:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RC04:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RC04:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RC04:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RC04:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RC04:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RC04:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RC04:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RC04:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RC04:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RC04:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC04:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RC04:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RC04:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RC04:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC04:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RC04:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RC04:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RC04:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC04:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RC04:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RC04:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RC04:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC04:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RC04:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RC04:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RC04:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC04:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RC04:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RC04:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RC04:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC04:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RC04:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RC04:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RC04:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC04:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RC04:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RC04:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RC04:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC04:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RC04:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RC04:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RC04:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC04:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RC04:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RC04:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RC04:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RC04:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RC04:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RC04:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RC04:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RC04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC04:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RC04:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RC04:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RC04:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RC04:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RC04:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RC04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "CLK-SPAC")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RC04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "CLK-SPAC")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC04:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2727")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RC05:INFO") {
  field(DESC, "EIOC:IN20:RC05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RC05: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:IN20:RC05:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RC05:TODDIFF")
}

record(longin, "EIOC:IN20:RC05:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RC05:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RC05:TODCHECKVALID")
}

# If <ioc> 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:IN20:RC05:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RC05:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RC05:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RC05:TODSUM")
}

record(bo, "EIOC:IN20:RC05:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RC05:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RC05:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RC05:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC05:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RC05:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RC05:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RC05:HEARTBEATE01")
  field(INP, "EIOC:IN20:RC05:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RC05:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RC05:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RC05:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RC05:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RC05:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RC05:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RC05:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RC05:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RC05:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RC05:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RC05:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RC05:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RC05:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RC05:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC05:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RC05:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RC05:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RC05:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC05:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RC05:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RC05:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RC05:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC05:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RC05:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RC05:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RC05:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC05:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RC05:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RC05:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RC05:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC05:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RC05:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RC05:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RC05:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC05:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RC05:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RC05:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RC05:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC05:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RC05:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RC05:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RC05:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC05:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RC05:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RC05:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RC05:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC05:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RC05:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RC05:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RC05:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RC05:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RC05:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RC05:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RC05:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RC05:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC05:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RC05:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RC05:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RC05:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RC05:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RC05:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RC05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LSR-SPAC")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RC05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LSR-SPAC")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC05:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2533")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RC06:INFO") {
  field(DESC, "EIOC:IN20:RC06 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC06:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RC06: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:IN20:RC06:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RC06:TODDIFF")
}

record(longin, "EIOC:IN20:RC06:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RC06:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RC06:TODCHECKVALID")
}

# If <ioc> 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:IN20:RC06:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RC06:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RC06:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RC06:TODSUM")
}

record(bo, "EIOC:IN20:RC06:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RC06:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RC06:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RC06:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC06:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RC06:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RC06:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RC06:HEARTBEATE01")
  field(INP, "EIOC:IN20:RC06:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RC06:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RC06:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RC06:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RC06:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RC06:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RC06:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RC06:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RC06:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RC06:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RC06:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RC06:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RC06:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RC06:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RC06:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC06:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RC06:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RC06:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RC06:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC06:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RC06:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RC06:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RC06:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC06:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RC06:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RC06:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RC06:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC06:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RC06:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RC06:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RC06:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC06:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RC06:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RC06:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RC06:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC06:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RC06:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RC06:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RC06:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC06:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RC06:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RC06:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RC06:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC06:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RC06:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RC06:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RC06:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC06:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RC06:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RC06:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RC06:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RC06:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RC06:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RC06:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RC06:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RC06:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC06:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RC06:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RC06:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RC06:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RC06:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RC06:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RC06:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "GUN-PAC")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RC06:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "GUN-PAC")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC06:LOC") {
  field(PINI, "YES")
  field(VAL, "KF20-6A23")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RC07:INFO") {
  field(DESC, "EIOC:IN20:RC07 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC07:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RC07: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:IN20:RC07:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RC07:TODDIFF")
}

record(longin, "EIOC:IN20:RC07:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RC07:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RC07:TODCHECKVALID")
}

# If <ioc> 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:IN20:RC07:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RC07:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RC07:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RC07:TODSUM")
}

record(bo, "EIOC:IN20:RC07:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RC07:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RC07:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RC07:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC07:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RC07:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RC07:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RC07:HEARTBEATE01")
  field(INP, "EIOC:IN20:RC07:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RC07:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RC07:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RC07:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RC07:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RC07:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RC07:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RC07:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RC07:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RC07:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RC07:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RC07:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RC07:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RC07:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RC07:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC07:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RC07:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RC07:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RC07:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC07:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RC07:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RC07:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RC07:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC07:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RC07:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RC07:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RC07:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC07:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RC07:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RC07:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RC07:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC07:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RC07:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RC07:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RC07:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC07:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RC07:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RC07:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RC07:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC07:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RC07:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RC07:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RC07:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC07:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RC07:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RC07:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RC07:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC07:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RC07:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RC07:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RC07:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RC07:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RC07:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RC07:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RC07:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RC07:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC07:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RC07:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RC07:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RC07:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RC07:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RC07:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RC07:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "L0A-PAC")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RC07:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "L0A-PAC")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC07:LOC") {
  field(PINI, "YES")
  field(VAL, "KF20-7A17")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RC08:INFO") {
  field(DESC, "EIOC:IN20:RC08 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC08:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RC08:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:IN20:RC08:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "EIOC:IN20:RC08:TODDIFF")
}

record(longin, "EIOC:IN20:RC08:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RC08:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RC08:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "EIOC:IN20:RC08:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RC08:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RC08:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RC08:TODSUM")
}

record(bo, "EIOC:IN20:RC08:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RC08:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RC08:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RC08:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC08:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RC08:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RC08:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RC08:HEARTBEATE01")
  field(INP, "EIOC:IN20:RC08:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RC08:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RC08:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RC08:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RC08:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RC08:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RC08:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RC08:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RC08:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RC08:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RC08:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RC08:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RC08:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "EIOC:IN20:RC08:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RC08:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC08:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RC08:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RC08:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RC08:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC08:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RC08:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RC08:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RC08:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC08:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RC08:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RC08:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RC08:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC08:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RC08:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RC08:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RC08:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC08:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RC08:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RC08:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RC08:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC08:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RC08:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RC08:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RC08:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC08:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RC08:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RC08:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RC08:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC08:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RC08:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RC08:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RC08:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC08:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RC08:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RC08:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RC08:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RC08:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RC08:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RC08:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RC08:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RC08:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC08:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RC08:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RC08:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RC08:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RC08:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RC08:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RC08:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "L0B-PAC")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RC08:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "L0B-PAC")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC08:LOC") {
  field(PINI, "YES")
  field(VAL, "KF20-8A16")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RC09:INFO") {
  field(DESC, "EIOC:IN20:RC09 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC09:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RC09: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:IN20:RC09:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RC09:TODDIFF")
}

record(longin, "EIOC:IN20:RC09:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RC09:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RC09:TODCHECKVALID")
}

# If <ioc> 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:IN20:RC09:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RC09:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RC09:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RC09:TODSUM")
}

record(bo, "EIOC:IN20:RC09:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RC09:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RC09:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RC09:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC09:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RC09:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RC09:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RC09:HEARTBEATE01")
  field(INP, "EIOC:IN20:RC09:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RC09:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RC09:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RC09:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RC09:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RC09:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RC09:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RC09:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RC09:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RC09:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RC09:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RC09:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RC09:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RC09:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RC09:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC09:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RC09:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RC09:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RC09:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC09:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RC09:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RC09:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RC09:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC09:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RC09:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RC09:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RC09:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC09:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RC09:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RC09:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RC09:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC09:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RC09:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RC09:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RC09:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC09:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RC09:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RC09:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RC09:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC09:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RC09:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RC09:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RC09:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC09:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RC09:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RC09:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RC09:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC09:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RC09:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RC09:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RC09:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RC09:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RC09:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RC09:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RC09:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RC09:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC09:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RC09:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RC09:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RC09:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RC09:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RC09:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RC09:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "TC0-PAC")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RC09:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "TC0-PAC")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC09:LOC") {
  field(PINI, "YES")
  field(VAL, "KF20-5A18")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RC10:INFO") {
  field(DESC, "EIOC:IN20:RC10 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC10:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RC10: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:IN20:RC10:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RC10:TODDIFF")
}

record(longin, "EIOC:IN20:RC10:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RC10:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RC10:TODCHECKVALID")
}

# If <ioc> 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:IN20:RC10:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RC10:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RC10:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RC10:TODSUM")
}

record(bo, "EIOC:IN20:RC10:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RC10:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RC10:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RC10:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC10:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RC10:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RC10:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RC10:HEARTBEATE01")
  field(INP, "EIOC:IN20:RC10:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RC10:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RC10:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RC10:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RC10:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RC10:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RC10:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RC10:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RC10:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RC10:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RC10:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RC10:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RC10:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RC10:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RC10:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC10:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RC10:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RC10:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RC10:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC10:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RC10:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RC10:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RC10:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC10:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RC10:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RC10:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RC10:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC10:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RC10:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RC10:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RC10:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC10:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RC10:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RC10:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RC10:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC10:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RC10:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RC10:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RC10:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC10:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RC10:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RC10:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RC10:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC10:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RC10:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RC10:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RC10:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC10:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RC10:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RC10:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RC10:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RC10:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RC10:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RC10:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RC10:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RC10:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC10:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RC10:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RC10:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RC10:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RC10:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RC10:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RC10:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "L2-SPAC")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RC10:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "L2-SPAC")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC10:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2618")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RC11:INFO") {
  field(DESC, "EIOC:IN20:RC11 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC11:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RC11:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:IN20:RC11:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "EIOC:IN20:RC11:TODDIFF")
}

record(longin, "EIOC:IN20:RC11:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RC11:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RC11:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "EIOC:IN20:RC11:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RC11:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RC11:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RC11:TODSUM")
}

record(bo, "EIOC:IN20:RC11:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RC11:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RC11:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RC11:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC11:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RC11:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RC11:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RC11:HEARTBEATE01")
  field(INP, "EIOC:IN20:RC11:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RC11:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RC11:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RC11:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RC11:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RC11:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RC11:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RC11:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RC11:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RC11:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RC11:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RC11:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RC11:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "EIOC:IN20:RC11:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RC11:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC11:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RC11:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RC11:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RC11:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC11:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RC11:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RC11:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RC11:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC11:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RC11:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RC11:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RC11:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC11:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RC11:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RC11:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RC11:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC11:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RC11:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RC11:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RC11:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC11:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RC11:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RC11:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RC11:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC11:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RC11:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RC11:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RC11:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC11:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RC11:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RC11:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RC11:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC11:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RC11:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RC11:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RC11:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RC11:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RC11:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RC11:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RC11:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RC11:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC11:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RC11:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RC11:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RC11:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RC11:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RC11:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RC11:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "L1S-PAC")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RC11:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "L1S-PAC")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC11:LOC") {
  field(PINI, "YES")
  field(VAL, "KF21-1A27")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RC12:INFO") {
  field(DESC, "EIOC:IN20:RC12 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC12:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RC12: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:IN20:RC12:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RC12:TODDIFF")
}

record(longin, "EIOC:IN20:RC12:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RC12:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RC12:TODCHECKVALID")
}

# If <ioc> 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:IN20:RC12:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RC12:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RC12:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RC12:TODSUM")
}

record(bo, "EIOC:IN20:RC12:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RC12:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RC12:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RC12:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC12:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RC12:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RC12:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RC12:HEARTBEATE01")
  field(INP, "EIOC:IN20:RC12:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RC12:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RC12:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RC12:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RC12:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RC12:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RC12:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RC12:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RC12:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RC12:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RC12:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RC12:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RC12:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RC12:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RC12:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC12:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RC12:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RC12:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RC12:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC12:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RC12:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RC12:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RC12:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC12:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RC12:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RC12:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RC12:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC12:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RC12:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RC12:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RC12:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC12:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RC12:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RC12:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RC12:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC12:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RC12:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RC12:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RC12:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC12:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RC12:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RC12:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RC12:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC12:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RC12:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RC12:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RC12:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC12:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RC12:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RC12:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RC12:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RC12:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RC12:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RC12:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RC12:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RC12:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC12:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RC12:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RC12:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RC12:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RC12:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RC12:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RC12:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "L1X-PAC")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RC12:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "L1X-PAC")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC12:LOC") {
  field(PINI, "YES")
  field(VAL, "KF21-1B")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RC13:INFO") {
  field(DESC, "EIOC:IN20:RC13 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC13:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RC13: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:IN20:RC13:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RC13:TODDIFF")
}

record(longin, "EIOC:IN20:RC13:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RC13:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RC13:TODCHECKVALID")
}

# If <ioc> 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:IN20:RC13:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RC13:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RC13:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RC13:TODSUM")
}

record(bo, "EIOC:IN20:RC13:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RC13:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RC13:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RC13:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC13:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RC13:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RC13:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RC13:HEARTBEATE01")
  field(INP, "EIOC:IN20:RC13:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RC13:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RC13:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RC13:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RC13:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RC13:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RC13:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RC13:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RC13:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RC13:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RC13:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RC13:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RC13:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RC13:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RC13:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC13:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RC13:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RC13:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RC13:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC13:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RC13:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RC13:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RC13:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC13:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RC13:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RC13:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RC13:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC13:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RC13:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RC13:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RC13:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC13:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RC13:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RC13:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RC13:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC13:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RC13:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RC13:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RC13:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC13:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RC13:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RC13:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RC13:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC13:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RC13:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RC13:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RC13:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC13:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RC13:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RC13:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RC13:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RC13:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RC13:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RC13:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RC13:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RC13:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RC13:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RC13:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RC13:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RC13:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RC13:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RC13:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RC13:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LSR2-SPAC")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RC13:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LSR2-SPAC")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RC13:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2607")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RD01:INFO") {
  field(DESC, "EIOC:IN20:RD01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RD01: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:IN20:RD01:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RD01:TODDIFF")
}

record(longin, "EIOC:IN20:RD01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RD01:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RD01:TODCHECKVALID")
}

# If <ioc> 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:IN20:RD01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RD01:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RD01:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RD01:TODSUM")
}

record(bo, "EIOC:IN20:RD01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RD01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RD01:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RD01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD01:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RD01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RD01:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RD01:HEARTBEATE01")
  field(INP, "EIOC:IN20:RD01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RD01:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RD01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RD01:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RD01:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RD01:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RD01:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RD01:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RD01:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RD01:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RD01:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RD01:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RD01:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RD01:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RD01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD01:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RD01:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RD01:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RD01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD01:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RD01:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RD01:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RD01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD01:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RD01:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RD01:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RD01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD01:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RD01:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RD01:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RD01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD01:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RD01:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RD01:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RD01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD01:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RD01:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RD01:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RD01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD01:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RD01:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RD01:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RD01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD01:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RD01:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RD01:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RD01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD01:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RD01:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RD01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RD01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RD01:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RD01:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RD01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RD01:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RD01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD01:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RD01:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RD01:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RD01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RD01:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RD01:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RD01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "REF-PAD")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RD01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "REF-PAD")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD01:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2621")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RD02:INFO") {
  field(DESC, "EIOC:IN20:RD02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RD02: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:IN20:RD02:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RD02:TODDIFF")
}

record(longin, "EIOC:IN20:RD02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RD02:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RD02:TODCHECKVALID")
}

# If <ioc> 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:IN20:RD02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RD02:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RD02:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RD02:TODSUM")
}

record(bo, "EIOC:IN20:RD02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RD02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RD02:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RD02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD02:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RD02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RD02:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RD02:HEARTBEATE01")
  field(INP, "EIOC:IN20:RD02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RD02:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RD02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RD02:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RD02:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RD02:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RD02:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RD02:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RD02:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RD02:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RD02:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RD02:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RD02:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RD02:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RD02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD02:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RD02:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RD02:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RD02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD02:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RD02:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RD02:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RD02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD02:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RD02:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RD02:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RD02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD02:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RD02:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RD02:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RD02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD02:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RD02:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RD02:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RD02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD02:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RD02:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RD02:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RD02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD02:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RD02:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RD02:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RD02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD02:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RD02:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RD02:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RD02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD02:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RD02:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RD02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RD02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RD02:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RD02:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RD02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RD02:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RD02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD02:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RD02:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RD02:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RD02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RD02:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RD02:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RD02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LSR-PAD")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RD02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LSR-PAD")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD02:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2536")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RD03:INFO") {
  field(DESC, "EIOC:IN20:RD03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RD03: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:IN20:RD03:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RD03:TODDIFF")
}

record(longin, "EIOC:IN20:RD03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RD03:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RD03:TODCHECKVALID")
}

# If <ioc> 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:IN20:RD03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RD03:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RD03:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RD03:TODSUM")
}

record(bo, "EIOC:IN20:RD03:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RD03:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RD03:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RD03:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD03:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RD03:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RD03:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RD03:HEARTBEATE01")
  field(INP, "EIOC:IN20:RD03:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RD03:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RD03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RD03:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RD03:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RD03:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RD03:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RD03:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RD03:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RD03:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RD03:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RD03:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RD03:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RD03:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RD03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD03:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RD03:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RD03:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RD03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD03:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RD03:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RD03:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RD03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD03:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RD03:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RD03:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RD03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD03:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RD03:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RD03:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RD03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD03:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RD03:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RD03:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RD03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD03:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RD03:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RD03:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RD03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD03:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RD03:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RD03:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RD03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD03:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RD03:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RD03:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RD03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD03:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RD03:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RD03:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RD03:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RD03:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RD03:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RD03:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RD03:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RD03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD03:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RD03:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RD03:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RD03:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RD03:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RD03:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RD03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "GN1-PAD")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RD03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "GN1-PAD")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD03:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2715")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RD04:INFO") {
  field(DESC, "EIOC:IN20:RD04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RD04: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:IN20:RD04:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RD04:TODDIFF")
}

record(longin, "EIOC:IN20:RD04:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RD04:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RD04:TODCHECKVALID")
}

# If <ioc> 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:IN20:RD04:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RD04:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RD04:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RD04:TODSUM")
}

record(bo, "EIOC:IN20:RD04:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RD04:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RD04:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RD04:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD04:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RD04:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RD04:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RD04:HEARTBEATE01")
  field(INP, "EIOC:IN20:RD04:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RD04:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RD04:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RD04:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RD04:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RD04:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RD04:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RD04:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RD04:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RD04:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RD04:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RD04:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RD04:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RD04:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RD04:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD04:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RD04:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RD04:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RD04:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD04:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RD04:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RD04:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RD04:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD04:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RD04:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RD04:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RD04:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD04:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RD04:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RD04:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RD04:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD04:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RD04:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RD04:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RD04:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD04:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RD04:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RD04:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RD04:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD04:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RD04:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RD04:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RD04:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD04:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RD04:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RD04:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RD04:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD04:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RD04:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RD04:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RD04:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RD04:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RD04:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RD04:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RD04:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RD04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD04:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RD04:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RD04:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RD04:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RD04:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RD04:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RD04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "GN2-PAD")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RD04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "GN2-PAD")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD04:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2712")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RD05:INFO") {
  field(DESC, "EIOC:IN20:RD05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RD05: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:IN20:RD05:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RD05:TODDIFF")
}

record(longin, "EIOC:IN20:RD05:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RD05:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RD05:TODCHECKVALID")
}

# If <ioc> 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:IN20:RD05:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RD05:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RD05:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RD05:TODSUM")
}

record(bo, "EIOC:IN20:RD05:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RD05:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RD05:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RD05:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD05:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RD05:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RD05:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RD05:HEARTBEATE01")
  field(INP, "EIOC:IN20:RD05:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RD05:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RD05:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RD05:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RD05:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RD05:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RD05:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RD05:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RD05:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RD05:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RD05:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RD05:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RD05:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RD05:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RD05:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD05:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RD05:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RD05:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RD05:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD05:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RD05:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RD05:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RD05:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD05:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RD05:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RD05:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RD05:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD05:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RD05:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RD05:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RD05:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD05:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RD05:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RD05:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RD05:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD05:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RD05:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RD05:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RD05:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD05:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RD05:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RD05:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RD05:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD05:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RD05:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RD05:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RD05:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD05:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RD05:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RD05:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RD05:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RD05:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RD05:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RD05:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RD05:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RD05:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD05:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RD05:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RD05:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RD05:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RD05:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RD05:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RD05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "KLY20-6-PAD")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RD05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "KLY20-6-PAD")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD05:LOC") {
  field(PINI, "YES")
  field(VAL, "KF20-6A26")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RD06:INFO") {
  field(DESC, "EIOC:IN20:RD06 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD06:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RD06:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:IN20:RD06:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "EIOC:IN20:RD06:TODDIFF")
}

record(longin, "EIOC:IN20:RD06:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RD06:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RD06:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "EIOC:IN20:RD06:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RD06:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RD06:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RD06:TODSUM")
}

record(bo, "EIOC:IN20:RD06:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RD06:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RD06:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RD06:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD06:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RD06:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RD06:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RD06:HEARTBEATE01")
  field(INP, "EIOC:IN20:RD06:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RD06:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RD06:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RD06:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RD06:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RD06:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RD06:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RD06:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RD06:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RD06:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RD06:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RD06:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RD06:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "EIOC:IN20:RD06:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RD06:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD06:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RD06:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RD06:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RD06:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD06:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RD06:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RD06:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RD06:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD06:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RD06:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RD06:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RD06:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD06:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RD06:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RD06:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RD06:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD06:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RD06:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RD06:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RD06:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD06:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RD06:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RD06:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RD06:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD06:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RD06:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RD06:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RD06:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD06:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RD06:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RD06:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RD06:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD06:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RD06:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RD06:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RD06:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RD06:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RD06:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RD06:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RD06:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RD06:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD06:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RD06:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RD06:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RD06:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RD06:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RD06:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RD06:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "L0-PAD")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RD06:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "L0-PAD")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD06:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2709")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RD07:INFO") {
  field(DESC, "EIOC:IN20:RD07 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD07:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RD07: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:IN20:RD07:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RD07:TODDIFF")
}

record(longin, "EIOC:IN20:RD07:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RD07:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RD07:TODCHECKVALID")
}

# If <ioc> 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:IN20:RD07:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RD07:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RD07:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RD07:TODSUM")
}

record(bo, "EIOC:IN20:RD07:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RD07:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RD07:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RD07:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD07:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RD07:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RD07:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RD07:HEARTBEATE01")
  field(INP, "EIOC:IN20:RD07:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RD07:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RD07:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RD07:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RD07:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RD07:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RD07:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RD07:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RD07:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RD07:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RD07:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RD07:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RD07:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RD07:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RD07:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD07:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RD07:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RD07:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RD07:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD07:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RD07:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RD07:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RD07:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD07:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RD07:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RD07:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RD07:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD07:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RD07:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RD07:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RD07:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD07:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RD07:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RD07:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RD07:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD07:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RD07:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RD07:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RD07:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD07:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RD07:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RD07:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RD07:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD07:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RD07:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RD07:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RD07:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD07:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RD07:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RD07:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RD07:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RD07:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RD07:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RD07:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RD07:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RD07:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD07:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RD07:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RD07:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RD07:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RD07:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RD07:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RD07:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "KLY20-7-PAD")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RD07:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "KLY20-7-PAD")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD07:LOC") {
  field(PINI, "YES")
  field(VAL, "KA20-7A38")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RD08:INFO") {
  field(DESC, "EIOC:IN20:RD08 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD08:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RD08: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:IN20:RD08:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RD08:TODDIFF")
}

record(longin, "EIOC:IN20:RD08:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RD08:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RD08:TODCHECKVALID")
}

# If <ioc> 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:IN20:RD08:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RD08:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RD08:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RD08:TODSUM")
}

record(bo, "EIOC:IN20:RD08:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RD08:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RD08:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RD08:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD08:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RD08:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RD08:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RD08:HEARTBEATE01")
  field(INP, "EIOC:IN20:RD08:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RD08:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RD08:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RD08:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RD08:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RD08:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RD08:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RD08:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RD08:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RD08:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RD08:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RD08:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RD08:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RD08:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RD08:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD08:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RD08:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RD08:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RD08:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD08:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RD08:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RD08:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RD08:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD08:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RD08:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RD08:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RD08:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD08:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RD08:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RD08:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RD08:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD08:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RD08:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RD08:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RD08:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD08:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RD08:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RD08:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RD08:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD08:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RD08:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RD08:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RD08:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD08:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RD08:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RD08:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RD08:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD08:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RD08:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RD08:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RD08:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RD08:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RD08:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RD08:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RD08:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RD08:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD08:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RD08:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RD08:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RD08:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RD08:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RD08:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RD08:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "KLY20-8-PAD")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RD08:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "KLY20-8-PAD")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD08:LOC") {
  field(PINI, "YES")
  field(VAL, "KF20-8A19")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RD09:INFO") {
  field(DESC, "EIOC:IN20:RD09 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD09:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RD09: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:IN20:RD09:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RD09:TODDIFF")
}

record(longin, "EIOC:IN20:RD09:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RD09:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RD09:TODCHECKVALID")
}

# If <ioc> 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:IN20:RD09:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RD09:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RD09:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RD09:TODSUM")
}

record(bo, "EIOC:IN20:RD09:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RD09:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RD09:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RD09:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD09:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RD09:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RD09:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RD09:HEARTBEATE01")
  field(INP, "EIOC:IN20:RD09:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RD09:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RD09:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RD09:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RD09:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RD09:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RD09:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RD09:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RD09:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RD09:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RD09:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RD09:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RD09:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RD09:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RD09:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD09:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RD09:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RD09:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RD09:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD09:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RD09:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RD09:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RD09:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD09:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RD09:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RD09:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RD09:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD09:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RD09:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RD09:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RD09:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD09:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RD09:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RD09:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RD09:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD09:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RD09:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RD09:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RD09:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD09:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RD09:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RD09:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RD09:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD09:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RD09:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RD09:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RD09:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD09:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RD09:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RD09:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RD09:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RD09:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RD09:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RD09:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RD09:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RD09:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD09:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RD09:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RD09:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RD09:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RD09:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RD09:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RD09:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "TC0-PAD")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RD09:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "TC0-PAD")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD09:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2803")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RD10:INFO") {
  field(DESC, "EIOC:IN20:RD10 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD10:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RD10: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:IN20:RD10:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RD10:TODDIFF")
}

record(longin, "EIOC:IN20:RD10:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RD10:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RD10:TODCHECKVALID")
}

# If <ioc> 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:IN20:RD10:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RD10:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RD10:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RD10:TODSUM")
}

record(bo, "EIOC:IN20:RD10:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RD10:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RD10:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RD10:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD10:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RD10:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RD10:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RD10:HEARTBEATE01")
  field(INP, "EIOC:IN20:RD10:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RD10:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RD10:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RD10:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RD10:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RD10:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RD10:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RD10:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RD10:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RD10:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RD10:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RD10:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RD10:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RD10:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RD10:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD10:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RD10:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RD10:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RD10:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD10:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RD10:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RD10:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RD10:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD10:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RD10:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RD10:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RD10:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD10:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RD10:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RD10:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RD10:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD10:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RD10:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RD10:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RD10:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD10:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RD10:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RD10:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RD10:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD10:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RD10:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RD10:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RD10:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD10:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RD10:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RD10:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RD10:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD10:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RD10:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RD10:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RD10:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RD10:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RD10:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RD10:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RD10:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RD10:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD10:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RD10:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RD10:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RD10:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RD10:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RD10:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RD10:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "KLY20-5-PAD")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RD10:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "KLY20-5-PAD")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD10:LOC") {
  field(PINI, "YES")
  field(VAL, "KF20-5A41")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RD11:INFO") {
  field(DESC, "EIOC:IN20:RD11 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD11:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RD11:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "EIOC:IN20:RD11:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "EIOC:IN20:RD11:TODDIFF")
}

record(longin, "EIOC:IN20:RD11:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RD11:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RD11:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "EIOC:IN20:RD11:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RD11:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RD11:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RD11:TODSUM")
}

record(bo, "EIOC:IN20:RD11:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RD11:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RD11:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RD11:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD11:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RD11:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RD11:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RD11:HEARTBEATE01")
  field(INP, "EIOC:IN20:RD11:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RD11:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RD11:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RD11:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RD11:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RD11:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RD11:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RD11:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RD11:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RD11:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RD11:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RD11:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RD11:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "EIOC:IN20:RD11:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RD11:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD11:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RD11:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RD11:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RD11:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD11:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RD11:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RD11:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RD11:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD11:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RD11:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RD11:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RD11:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD11:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RD11:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RD11:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RD11:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD11:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RD11:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RD11:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RD11:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD11:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RD11:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RD11:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RD11:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD11:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RD11:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RD11:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RD11:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD11:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RD11:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RD11:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RD11:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD11:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RD11:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RD11:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RD11:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RD11:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RD11:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RD11:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RD11:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RD11:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD11:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RD11:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RD11:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RD11:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RD11:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RD11:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RD11:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "L1S-PAD")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RD11:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "L1S-PAD")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD11:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2806")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RD12:INFO") {
  field(DESC, "EIOC:IN20:RD12 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD12:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RD12: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:IN20:RD12:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RD12:TODDIFF")
}

record(longin, "EIOC:IN20:RD12:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RD12:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RD12:TODCHECKVALID")
}

# If <ioc> 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:IN20:RD12:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RD12:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RD12:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RD12:TODSUM")
}

record(bo, "EIOC:IN20:RD12:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RD12:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RD12:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RD12:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD12:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RD12:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RD12:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RD12:HEARTBEATE01")
  field(INP, "EIOC:IN20:RD12:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RD12:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RD12:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RD12:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RD12:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RD12:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RD12:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RD12:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RD12:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RD12:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RD12:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RD12:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RD12:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RD12:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RD12:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD12:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RD12:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RD12:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RD12:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD12:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RD12:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RD12:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RD12:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD12:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RD12:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RD12:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RD12:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD12:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RD12:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RD12:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RD12:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD12:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RD12:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RD12:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RD12:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD12:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RD12:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RD12:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RD12:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD12:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RD12:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RD12:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RD12:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD12:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RD12:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RD12:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RD12:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD12:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RD12:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RD12:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RD12:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RD12:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RD12:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RD12:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RD12:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RD12:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD12:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RD12:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RD12:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RD12:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RD12:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RD12:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RD12:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "KLY21-1-PAD")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RD12:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "KLY21-1-PAD")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD12:LOC") {
  field(PINI, "YES")
  field(VAL, "KF21-1A30")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RD13:INFO") {
  field(DESC, "EIOC:IN20:RD13 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD13:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RD13: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:IN20:RD13:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RD13:TODDIFF")
}

record(longin, "EIOC:IN20:RD13:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RD13:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RD13:TODCHECKVALID")
}

# If <ioc> 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:IN20:RD13:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RD13:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RD13:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RD13:TODSUM")
}

record(bo, "EIOC:IN20:RD13:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RD13:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RD13:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RD13:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD13:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RD13:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RD13:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RD13:HEARTBEATE01")
  field(INP, "EIOC:IN20:RD13:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RD13:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RD13:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RD13:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RD13:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RD13:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RD13:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RD13:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RD13:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RD13:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RD13:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RD13:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RD13:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RD13:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RD13:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD13:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RD13:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RD13:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RD13:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD13:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RD13:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RD13:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RD13:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD13:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RD13:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RD13:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RD13:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD13:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RD13:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RD13:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RD13:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD13:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RD13:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RD13:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RD13:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD13:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RD13:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RD13:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RD13:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD13:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RD13:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RD13:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RD13:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD13:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RD13:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RD13:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RD13:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD13:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RD13:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RD13:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RD13:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RD13:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RD13:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RD13:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RD13:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RD13:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD13:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RD13:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RD13:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RD13:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RD13:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RD13:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RD13:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "PH1-PAD")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RD13:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "PH1-PAD")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD13:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2809")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RD14:INFO") {
  field(DESC, "EIOC:IN20:RD14 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD14:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RD14: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:IN20:RD14:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RD14:TODDIFF")
}

record(longin, "EIOC:IN20:RD14:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RD14:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RD14:TODCHECKVALID")
}

# If <ioc> 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:IN20:RD14:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RD14:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RD14:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RD14:TODSUM")
}

record(bo, "EIOC:IN20:RD14:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RD14:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RD14:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RD14:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD14:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RD14:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RD14:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RD14:HEARTBEATE01")
  field(INP, "EIOC:IN20:RD14:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RD14:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RD14:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RD14:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RD14:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RD14:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RD14:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RD14:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RD14:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RD14:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RD14:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RD14:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RD14:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RD14:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RD14:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD14:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RD14:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RD14:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RD14:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD14:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RD14:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RD14:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RD14:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD14:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RD14:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RD14:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RD14:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD14:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RD14:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RD14:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RD14:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD14:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RD14:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RD14:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RD14:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD14:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RD14:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RD14:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RD14:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD14:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RD14:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RD14:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RD14:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD14:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RD14:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RD14:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RD14:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD14:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RD14:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RD14:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RD14:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RD14:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RD14:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RD14:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RD14:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RD14:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD14:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RD14:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RD14:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RD14:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RD14:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RD14:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RD14:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "L1X-PAD")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RD14:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "L1X-PAD")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD14:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2827")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RD15:INFO") {
  field(DESC, "EIOC:IN20:RD15 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD15:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RD15: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:IN20:RD15:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RD15:TODDIFF")
}

record(longin, "EIOC:IN20:RD15:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RD15:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RD15:TODCHECKVALID")
}

# If <ioc> 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:IN20:RD15:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RD15:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RD15:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RD15:TODSUM")
}

record(bo, "EIOC:IN20:RD15:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RD15:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RD15:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RD15:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD15:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RD15:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RD15:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RD15:HEARTBEATE01")
  field(INP, "EIOC:IN20:RD15:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RD15:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RD15:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RD15:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RD15:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RD15:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RD15:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RD15:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RD15:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RD15:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RD15:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RD15:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RD15:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RD15:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RD15:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD15:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RD15:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RD15:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RD15:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD15:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RD15:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RD15:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RD15:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD15:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RD15:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RD15:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RD15:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD15:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RD15:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RD15:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RD15:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD15:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RD15:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RD15:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RD15:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD15:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RD15:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RD15:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RD15:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD15:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RD15:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RD15:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RD15:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD15:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RD15:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RD15:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RD15:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD15:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RD15:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RD15:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RD15:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RD15:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RD15:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RD15:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RD15:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RD15:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD15:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RD15:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RD15:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RD15:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RD15:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RD15:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RD15:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "KLY21-2-PAD")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RD15:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "KLY21-2-PAD")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD15:LOC") {
  field(PINI, "YES")
  field(VAL, "KF21-1B34")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RD16:INFO") {
  field(DESC, "EIOC:IN20:RD16 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD16:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RD16: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:IN20:RD16:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RD16:TODDIFF")
}

record(longin, "EIOC:IN20:RD16:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RD16:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RD16:TODCHECKVALID")
}

# If <ioc> 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:IN20:RD16:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RD16:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RD16:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RD16:TODSUM")
}

record(bo, "EIOC:IN20:RD16:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RD16:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RD16:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RD16:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD16:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RD16:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RD16:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RD16:HEARTBEATE01")
  field(INP, "EIOC:IN20:RD16:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RD16:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RD16:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RD16:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RD16:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RD16:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RD16:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RD16:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RD16:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RD16:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RD16:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RD16:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RD16:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RD16:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RD16:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD16:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RD16:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RD16:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RD16:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD16:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RD16:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RD16:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RD16:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD16:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RD16:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RD16:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RD16:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD16:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RD16:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RD16:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RD16:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD16:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RD16:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RD16:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RD16:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD16:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RD16:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RD16:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RD16:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD16:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RD16:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RD16:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RD16:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD16:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RD16:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RD16:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RD16:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD16:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RD16:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RD16:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RD16:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RD16:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RD16:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RD16:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RD16:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RD16:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD16:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RD16:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RD16:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RD16:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RD16:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RD16:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RD16:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LSR2-PAD")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RD16:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LSR2-PAD")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD16:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-2604")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:RD17:INFO") {
  field(DESC, "EIOC:IN20:RD17 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD17:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:RD17: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:IN20:RD17:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:RD17:TODDIFF")
}

record(longin, "EIOC:IN20:RD17:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:RD17:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:RD17:TODCHECKVALID")
}

# If <ioc> 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:IN20:RD17:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:RD17:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:RD17:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:RD17:TODSUM")
}

record(bo, "EIOC:IN20:RD17:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:RD17:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:RD17:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:RD17:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD17:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:RD17:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:RD17:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:RD17:HEARTBEATE01")
  field(INP, "EIOC:IN20:RD17:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:RD17:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:RD17:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:RD17:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:RD17:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:RD17:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:RD17:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:RD17:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:RD17:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:RD17:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:RD17:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:RD17:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:RD17:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:RD17:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:RD17:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD17:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:RD17:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:RD17:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:RD17:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD17:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:RD17:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:RD17:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:RD17:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD17:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:RD17:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:RD17:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:RD17:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD17:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:RD17:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:RD17:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:RD17:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD17:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:RD17:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:RD17:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:RD17:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD17:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:RD17:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:RD17:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:RD17:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD17:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:RD17:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:RD17:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:RD17:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD17:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:RD17:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:RD17:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:RD17:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD17:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:RD17:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:RD17:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:RD17:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:RD17:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:RD17:HEARTBEATCLC")
  field(INP, "EIOC:IN20:RD17:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:RD17:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:RD17:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:RD17:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:RD17:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:RD17:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:RD17:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:RD17:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:RD17:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:RD17:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "DIAG-PAD")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:RD17:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "DIAG-PAD")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:RD17:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-28")
  info(autosaveFields,"VAL")
}

# String record 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:IN20:MP11:INFO") {
  field(DESC, "EIOC:IN20:MP11 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:MP11:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "EIOC:IN20:MP11: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:IN20:MP11:TOD CA")
  field(INPC, "10")
# VALA holds 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:IN20:MP11:TODDIFF")
}

record(longin, "EIOC:IN20:MP11:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "EIOC:IN20:MP11:TODCHECK.VALA MS")
  field(FLNK, "EIOC:IN20:MP11:TODCHECKVALID")
}

# If <ioc> 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:IN20:MP11:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "EIOC:IN20:MP11:TODCHECK.SEVR")
  field(INPB, "EIOC:IN20:MP11:TODCHECK.VALB")
  field(FLNK, "EIOC:IN20:MP11:TODSUM")
}

record(bo, "EIOC:IN20:MP11:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "EIOC:IN20:MP11:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "EIOC:IN20:MP11:HEARTBEATCALC") {
  field(FLNK, "EIOC:IN20:MP11:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:MP11:HEARTBEAT CA MS")
  field(INPB, "EIOC:IN20:MP11:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "EIOC:IN20:MP11:HEARTBEATOK") {
  field(FLNK, "EIOC:IN20:MP11:HEARTBEATE01")
  field(INP, "EIOC:IN20:MP11:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "EIOC:IN20:MP11:HEARTBEATECT") {
  field(FLNK, "EIOC:IN20:MP11:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "EIOC:IN20:MP11:HEARTBEATE01.VAL")
  field(INPB, "EIOC:IN20:MP11:HEARTBEATE02.VAL")
  field(INPC, "EIOC:IN20:MP11:HEARTBEATE03.VAL")
  field(INPD, "EIOC:IN20:MP11:HEARTBEATE04.VAL")
  field(INPE, "EIOC:IN20:MP11:HEARTBEATE05.VAL")
  field(INPF, "EIOC:IN20:MP11:HEARTBEATE06.VAL")
  field(INPG, "EIOC:IN20:MP11:HEARTBEATE07.VAL")
  field(INPH, "EIOC:IN20:MP11:HEARTBEATE08.VAL")
  field(INPI, "EIOC:IN20:MP11:HEARTBEATE09.VAL")
  field(INPJ, "EIOC:IN20:MP11:HEARTBEATE10.VAL")
  field(HIHI, "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:IN20:MP11:HEARTBEATE09") {
  field(FLNK, "EIOC:IN20:MP11:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:MP11:HEARTBEATE08.B")
  field(INPB, "EIOC:IN20:MP11:HEARTBEATE09.VAL")
}

record(calc, "EIOC:IN20:MP11:HEARTBEATE08") {
  field(FLNK, "EIOC:IN20:MP11:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:MP11:HEARTBEATE07.B")
  field(INPB, "EIOC:IN20:MP11:HEARTBEATE08.VAL")
}

record(calc, "EIOC:IN20:MP11:HEARTBEATE07") {
  field(FLNK, "EIOC:IN20:MP11:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:MP11:HEARTBEATE06.B")
  field(INPB, "EIOC:IN20:MP11:HEARTBEATE07.VAL")
}

record(calc, "EIOC:IN20:MP11:HEARTBEATE06") {
  field(FLNK, "EIOC:IN20:MP11:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:MP11:HEARTBEATE05.B")
  field(INPB, "EIOC:IN20:MP11:HEARTBEATE06.VAL")
}

record(calc, "EIOC:IN20:MP11:HEARTBEATE05") {
  field(FLNK, "EIOC:IN20:MP11:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:MP11:HEARTBEATE04.B")
  field(INPB, "EIOC:IN20:MP11:HEARTBEATE05.VAL")
}

record(calc, "EIOC:IN20:MP11:HEARTBEATE04") {
  field(FLNK, "EIOC:IN20:MP11:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:MP11:HEARTBEATE03.B")
  field(INPB, "EIOC:IN20:MP11:HEARTBEATE04.VAL")
}

record(calc, "EIOC:IN20:MP11:HEARTBEATE03") {
  field(FLNK, "EIOC:IN20:MP11:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:MP11:HEARTBEATE02.B")
  field(INPB, "EIOC:IN20:MP11:HEARTBEATE03.VAL")
}

record(calc, "EIOC:IN20:MP11:HEARTBEATE02") {
  field(FLNK, "EIOC:IN20:MP11:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:MP11:HEARTBEATE01.B")
  field(INPB, "EIOC:IN20:MP11:HEARTBEATE02.VAL")
}

record(calc, "EIOC:IN20:MP11:HEARTBEATE01") {
  field(FLNK, "EIOC:IN20:MP11:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:MP11:HEARTBEATERR.VAL")
  field(INPB, "EIOC:IN20:MP11:HEARTBEATE01.VAL")
}

record(calc, "EIOC:IN20:MP11:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "EIOC:IN20:MP11:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "EIOC:IN20:MP11:HEARTBEATSUM") {
  field(FLNK, "EIOC:IN20:MP11:HEARTBEATCLC")
  field(INP, "EIOC:IN20:MP11:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "EIOC:IN20:MP11:HEARTBEATE10") {
  field(FLNK, "EIOC:IN20:MP11:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "EIOC:IN20:MP11:HEARTBEATE09.B")
  field(INPB, "EIOC:IN20:MP11:HEARTBEATE10.VAL")
}

record(calc, "EIOC:IN20:MP11:HEARTBEATERR") {
  field(FLNK, "EIOC:IN20:MP11:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "EIOC:IN20:MP11:HEARTBEATCALC.A")
  field(INPB, "EIOC:IN20:MP11:HEARTBEATCALC.B")
}

record(stringin, "EIOC:IN20:MP11:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "LN11")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "EIOC:IN20:MP11:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "LN11")
  info(autosaveFields,"VAL")
}

record(stringin, "EIOC:IN20:MP11:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-1547")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:IN20:VA01:INFO") {
  field(DESC, "SIOC:IN20:VA01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:VA01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Matt Boyes (mboyes)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:IN20:VA01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:IN20:VA01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:IN20:VA01:TODDIFF")
}

record(longin, "SIOC:IN20:VA01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:VA01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20:VA01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:IN20:VA01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:VA01:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:VA01:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:VA01:TODSUM")
}

record(bo, "SIOC:IN20:VA01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:VA01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:VA01:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:VA01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:VA01:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:VA01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:VA01:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:VA01:HEARTBEATE01")
  field(INP, "SIOC:IN20:VA01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:VA01:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:VA01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:VA01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:VA01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:VA01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:VA01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:VA01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:VA01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:VA01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:VA01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:VA01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20:VA01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:IN20:VA01:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:VA01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:VA01:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:VA01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:VA01:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:VA01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:VA01:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:VA01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:VA01:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:VA01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:VA01:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:VA01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:VA01:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:VA01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:VA01:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:VA01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:VA01:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:VA01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:VA01:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:VA01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:VA01:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:VA01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:VA01:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:VA01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:VA01:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:VA01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:VA01:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:VA01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:VA01:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:VA01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:VA01:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:VA01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:VA01:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:VA01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:VA01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:VA01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:VA01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:VA01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:VA01:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:VA01:HEARTBEATCLC")
  field(INP, "SIOC:IN20:VA01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:IN20:VA01:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:VA01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:VA01:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:VA01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:VA01:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:VA01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:VA01:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:VA01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:VA01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:VA01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:VA01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:IN20:CF01:INFO") {
  field(DESC, "SIOC:IN20:CF01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:CF01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Matt Boyes (mboyes)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:IN20:CF01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:IN20:CF01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:IN20:CF01:TODDIFF")
}

record(longin, "SIOC:IN20:CF01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:CF01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20:CF01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:IN20:CF01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:CF01:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:CF01:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:CF01:TODSUM")
}

record(bo, "SIOC:IN20:CF01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:CF01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:CF01:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:CF01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:CF01:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:CF01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:CF01:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:CF01:HEARTBEATE01")
  field(INP, "SIOC:IN20:CF01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:CF01:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:CF01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:CF01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:CF01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:CF01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:CF01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:CF01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:CF01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:CF01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:CF01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:CF01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20:CF01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:IN20:CF01:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:CF01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:CF01:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:CF01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:CF01:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:CF01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:CF01:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:CF01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:CF01:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:CF01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:CF01:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:CF01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:CF01:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:CF01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:CF01:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:CF01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:CF01:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:CF01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:CF01:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:CF01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:CF01:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:CF01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:CF01:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:CF01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:CF01:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:CF01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:CF01:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:CF01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:CF01:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:CF01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:CF01:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:CF01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:CF01:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:CF01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:CF01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:CF01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:CF01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:CF01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:CF01:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:CF01:HEARTBEATCLC")
  field(INP, "SIOC:IN20:CF01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:IN20:CF01:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:CF01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:CF01:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:CF01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:CF01:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:CF01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:CF01:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:CF01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:CF01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:CF01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:CF01: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:IN20:FC01:INFO") {
  field(DESC, "SIOC:IN20:FC01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:FC01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:IN20:FC01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:IN20:FC01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:IN20:FC01:TODDIFF")
}

record(longin, "SIOC:IN20:FC01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:FC01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20:FC01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:IN20:FC01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:FC01:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:FC01:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:FC01:TODSUM")
}

record(bo, "SIOC:IN20:FC01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:FC01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:FC01:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:FC01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:FC01:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:FC01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:FC01:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:FC01:HEARTBEATE01")
  field(INP, "SIOC:IN20:FC01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:FC01:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:FC01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:FC01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:FC01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:FC01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:FC01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:FC01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:FC01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:FC01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:FC01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:FC01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20:FC01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:IN20:FC01:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:FC01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:FC01:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:FC01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:FC01:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:FC01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:FC01:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:FC01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:FC01:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:FC01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:FC01:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:FC01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:FC01:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:FC01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:FC01:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:FC01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:FC01:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:FC01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:FC01:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:FC01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:FC01:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:FC01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:FC01:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:FC01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:FC01:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:FC01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:FC01:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:FC01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:FC01:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:FC01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:FC01:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:FC01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:FC01:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:FC01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:FC01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:FC01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:FC01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:FC01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:FC01:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:FC01:HEARTBEATCLC")
  field(INP, "SIOC:IN20:FC01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:IN20:FC01:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:FC01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:FC01:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:FC01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:FC01:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:FC01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:FC01:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:FC01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:FC01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:FC01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:FC01: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:IN20:RF01:INFO") {
  field(DESC, "SIOC:IN20:RF01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:RF01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shantha Condamoor (scondam)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:IN20:RF01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:IN20:RF01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:IN20:RF01:TODDIFF")
}

record(longin, "SIOC:IN20:RF01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:RF01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20:RF01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:IN20:RF01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:RF01:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:RF01:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:RF01:TODSUM")
}

record(bo, "SIOC:IN20:RF01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:RF01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:RF01:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:RF01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:RF01:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:RF01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:RF01:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:RF01:HEARTBEATE01")
  field(INP, "SIOC:IN20:RF01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:RF01:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:RF01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:RF01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:RF01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:RF01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:RF01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:RF01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:RF01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:RF01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:RF01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:RF01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20:RF01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:IN20:RF01:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:RF01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:RF01:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:RF01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:RF01:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:RF01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:RF01:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:RF01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:RF01:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:RF01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:RF01:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:RF01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:RF01:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:RF01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:RF01:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:RF01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:RF01:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:RF01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:RF01:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:RF01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:RF01:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:RF01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:RF01:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:RF01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:RF01:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:RF01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:RF01:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:RF01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:RF01:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:RF01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:RF01:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:RF01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:RF01:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:RF01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:RF01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:RF01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:RF01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:RF01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:RF01:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:RF01:HEARTBEATCLC")
  field(INP, "SIOC:IN20:RF01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:IN20:RF01:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:RF01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:RF01:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:RF01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:RF01:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:RF01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:RF01:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:RF01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:RF01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:RF01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:RF01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:IN20:MG01:INFO") {
  field(DESC, "SIOC:IN20:MG01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20: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:IN20: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:IN20: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:IN20:MG01:TODDIFF")
}

record(longin, "SIOC:IN20:MG01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:MG01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20: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:IN20:MG01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:MG01:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:MG01:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:MG01:TODSUM")
}

record(bo, "SIOC:IN20:MG01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:MG01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:MG01:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:MG01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG01:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:MG01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:MG01:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:MG01:HEARTBEATE01")
  field(INP, "SIOC:IN20:MG01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:MG01:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:MG01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:MG01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:MG01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:MG01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:MG01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:MG01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:MG01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:MG01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:MG01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:MG01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20: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:IN20:MG01:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:MG01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG01:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:MG01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:MG01:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:MG01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG01:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:MG01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:MG01:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:MG01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG01:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:MG01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:MG01:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:MG01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG01:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:MG01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:MG01:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:MG01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG01:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:MG01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:MG01:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:MG01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG01:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:MG01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:MG01:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:MG01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG01:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:MG01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:MG01:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:MG01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG01:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:MG01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:MG01:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:MG01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:MG01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:MG01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:MG01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:MG01:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:MG01:HEARTBEATCLC")
  field(INP, "SIOC:IN20: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:IN20:MG01:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:MG01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG01:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:MG01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:MG01:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:MG01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:MG01:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:MG01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:MG01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:MG01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:MG01:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-0308")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:IN20:MG02:INFO") {
  field(DESC, "SIOC:IN20:MG02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20: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:IN20: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:IN20: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:IN20:MG02:TODDIFF")
}

record(longin, "SIOC:IN20:MG02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:MG02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20: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:IN20:MG02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:MG02:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:MG02:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:MG02:TODSUM")
}

record(bo, "SIOC:IN20:MG02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:MG02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:MG02:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:MG02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG02:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:MG02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:MG02:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:MG02:HEARTBEATE01")
  field(INP, "SIOC:IN20:MG02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:MG02:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:MG02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:MG02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:MG02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:MG02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:MG02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:MG02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:MG02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:MG02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:MG02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:MG02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20: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:IN20:MG02:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:MG02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG02:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:MG02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:MG02:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:MG02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG02:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:MG02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:MG02:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:MG02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG02:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:MG02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:MG02:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:MG02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG02:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:MG02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:MG02:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:MG02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG02:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:MG02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:MG02:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:MG02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG02:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:MG02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:MG02:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:MG02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG02:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:MG02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:MG02:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:MG02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG02:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:MG02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:MG02:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:MG02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:MG02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:MG02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:MG02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:MG02:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:MG02:HEARTBEATCLC")
  field(INP, "SIOC:IN20: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:IN20:MG02:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:MG02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG02:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:MG02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:MG02:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:MG02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:MG02:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:MG02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:MG02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:MG02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:MG02:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-0316")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:IN20:MG03:INFO") {
  field(DESC, "SIOC:IN20:MG03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:MG03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "An Le (anle)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:IN20:MG03:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:IN20:MG03:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:IN20:MG03:TODDIFF")
}

record(longin, "SIOC:IN20:MG03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:MG03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20:MG03:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:IN20:MG03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:MG03:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:MG03:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:MG03:TODSUM")
}

record(bo, "SIOC:IN20:MG03:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:MG03:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:MG03:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:MG03:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG03:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:MG03:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:MG03:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:MG03:HEARTBEATE01")
  field(INP, "SIOC:IN20:MG03:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:MG03:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:MG03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:MG03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:MG03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:MG03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:MG03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:MG03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:MG03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:MG03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:MG03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:MG03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20:MG03:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:IN20:MG03:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:MG03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG03:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:MG03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:MG03:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:MG03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG03:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:MG03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:MG03:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:MG03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG03:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:MG03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:MG03:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:MG03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG03:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:MG03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:MG03:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:MG03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG03:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:MG03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:MG03:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:MG03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG03:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:MG03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:MG03:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:MG03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG03:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:MG03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:MG03:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:MG03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG03:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:MG03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:MG03:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:MG03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:MG03:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:MG03:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:MG03:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:MG03:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:MG03:HEARTBEATCLC")
  field(INP, "SIOC:IN20:MG03:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:IN20:MG03:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:MG03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG03:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:MG03:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:MG03:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:MG03:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:MG03:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:MG03:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:MG03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:MG03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:MG03:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-0408")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:IN20:MG04:INFO") {
  field(DESC, "SIOC:IN20:MG04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:MG04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "An Le (anle)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:IN20:MG04:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:IN20:MG04:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:IN20:MG04:TODDIFF")
}

record(longin, "SIOC:IN20:MG04:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:MG04:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20:MG04:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:IN20:MG04:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:MG04:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:MG04:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:MG04:TODSUM")
}

record(bo, "SIOC:IN20:MG04:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:MG04:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:MG04:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:MG04:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG04:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:MG04:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:MG04:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:MG04:HEARTBEATE01")
  field(INP, "SIOC:IN20:MG04:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:MG04:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:MG04:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:MG04:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:MG04:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:MG04:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:MG04:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:MG04:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:MG04:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:MG04:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:MG04:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:MG04:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20:MG04:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:IN20:MG04:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:MG04:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG04:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:MG04:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:MG04:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:MG04:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG04:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:MG04:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:MG04:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:MG04:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG04:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:MG04:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:MG04:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:MG04:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG04:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:MG04:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:MG04:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:MG04:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG04:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:MG04:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:MG04:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:MG04:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG04:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:MG04:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:MG04:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:MG04:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG04:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:MG04:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:MG04:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:MG04:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG04:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:MG04:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:MG04:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:MG04:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG04:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:MG04:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:MG04:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:MG04:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:MG04:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:MG04:HEARTBEATCLC")
  field(INP, "SIOC:IN20:MG04:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:IN20:MG04:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:MG04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MG04:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:MG04:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:MG04:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:MG04:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:MG04:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:MG04:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:MG04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:MG04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:MG04:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-0416")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:IN20:PM01:INFO") {
  field(DESC, "SIOC:IN20:PM01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:PM01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Courtney Curtis (curtisco)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:IN20:PM01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:IN20:PM01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:IN20:PM01:TODDIFF")
}

record(longin, "SIOC:IN20:PM01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:PM01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20:PM01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:IN20:PM01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:PM01:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:PM01:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:PM01:TODSUM")
}

record(bo, "SIOC:IN20:PM01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:PM01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:PM01:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:PM01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM01:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:PM01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:PM01:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:PM01:HEARTBEATE01")
  field(INP, "SIOC:IN20:PM01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:PM01:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:PM01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:PM01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:PM01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:PM01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:PM01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:PM01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:PM01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:PM01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:PM01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:PM01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20:PM01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:IN20:PM01:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:PM01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM01:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:PM01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:PM01:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:PM01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM01:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:PM01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:PM01:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:PM01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM01:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:PM01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:PM01:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:PM01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM01:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:PM01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:PM01:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:PM01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM01:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:PM01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:PM01:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:PM01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM01:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:PM01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:PM01:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:PM01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM01:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:PM01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:PM01:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:PM01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM01:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:PM01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:PM01:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:PM01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:PM01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:PM01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:PM01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:PM01:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:PM01:HEARTBEATCLC")
  field(INP, "SIOC:IN20:PM01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:IN20:PM01:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:PM01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM01:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:PM01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:PM01:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:PM01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:PM01:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:PM01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:PM01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:PM01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:PM01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-in20-pm01")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:IN20:PM02:INFO") {
  field(DESC, "SIOC:IN20:PM02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:PM02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Courtney Curtis (curtisco)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:IN20:PM02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:IN20:PM02:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:IN20:PM02:TODDIFF")
}

record(longin, "SIOC:IN20:PM02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:PM02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20:PM02:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:IN20:PM02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:PM02:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:PM02:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:PM02:TODSUM")
}

record(bo, "SIOC:IN20:PM02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:PM02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:PM02:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:PM02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM02:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:PM02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:PM02:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:PM02:HEARTBEATE01")
  field(INP, "SIOC:IN20:PM02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:PM02:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:PM02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:PM02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:PM02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:PM02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:PM02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:PM02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:PM02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:PM02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:PM02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:PM02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20:PM02:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:IN20:PM02:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:PM02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM02:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:PM02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:PM02:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:PM02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM02:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:PM02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:PM02:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:PM02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM02:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:PM02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:PM02:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:PM02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM02:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:PM02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:PM02:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:PM02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM02:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:PM02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:PM02:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:PM02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM02:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:PM02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:PM02:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:PM02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM02:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:PM02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:PM02:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:PM02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM02:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:PM02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:PM02:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:PM02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:PM02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:PM02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:PM02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:PM02:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:PM02:HEARTBEATCLC")
  field(INP, "SIOC:IN20:PM02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:IN20:PM02:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:PM02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM02:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:PM02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:PM02:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:PM02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:PM02:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:PM02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:PM02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "OTR03")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:PM02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "OTR03")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:PM02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-in20-pm01")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:IN20:PM03:INFO") {
  field(DESC, "SIOC:IN20:PM03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:PM03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Courtney Curtis (curtisco)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:IN20:PM03:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:IN20:PM03:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:IN20:PM03:TODDIFF")
}

record(longin, "SIOC:IN20:PM03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:PM03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20:PM03:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:IN20:PM03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:PM03:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:PM03:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:PM03:TODSUM")
}

record(bo, "SIOC:IN20:PM03:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:PM03:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:PM03:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:PM03:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM03:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:PM03:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:PM03:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:PM03:HEARTBEATE01")
  field(INP, "SIOC:IN20:PM03:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:PM03:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:PM03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:PM03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:PM03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:PM03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:PM03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:PM03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:PM03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:PM03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:PM03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:PM03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20:PM03:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:IN20:PM03:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:PM03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM03:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:PM03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:PM03:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:PM03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM03:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:PM03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:PM03:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:PM03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM03:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:PM03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:PM03:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:PM03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM03:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:PM03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:PM03:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:PM03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM03:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:PM03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:PM03:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:PM03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM03:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:PM03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:PM03:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:PM03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM03:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:PM03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:PM03:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:PM03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM03:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:PM03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:PM03:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:PM03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:PM03:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:PM03:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:PM03:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:PM03:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:PM03:HEARTBEATCLC")
  field(INP, "SIOC:IN20:PM03:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:IN20:PM03:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:PM03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM03:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:PM03:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:PM03:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:PM03:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:PM03:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:PM03:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:PM03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "OTRH1")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:PM03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "OTRH1")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:PM03:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-in20-pm01")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:IN20:PM04:INFO") {
  field(DESC, "SIOC:IN20:PM04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:PM04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Courtney Curtis (curtisco)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:IN20:PM04:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:IN20:PM04:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:IN20:PM04:TODDIFF")
}

record(longin, "SIOC:IN20:PM04:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:PM04:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20:PM04:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:IN20:PM04:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:PM04:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:PM04:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:PM04:TODSUM")
}

record(bo, "SIOC:IN20:PM04:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:PM04:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:PM04:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:PM04:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM04:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:PM04:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:PM04:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:PM04:HEARTBEATE01")
  field(INP, "SIOC:IN20:PM04:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:PM04:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:PM04:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:PM04:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:PM04:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:PM04:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:PM04:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:PM04:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:PM04:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:PM04:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:PM04:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:PM04:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20:PM04:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:IN20:PM04:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:PM04:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM04:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:PM04:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:PM04:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:PM04:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM04:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:PM04:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:PM04:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:PM04:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM04:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:PM04:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:PM04:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:PM04:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM04:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:PM04:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:PM04:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:PM04:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM04:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:PM04:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:PM04:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:PM04:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM04:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:PM04:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:PM04:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:PM04:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM04:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:PM04:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:PM04:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:PM04:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM04:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:PM04:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:PM04:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:PM04:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM04:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:PM04:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:PM04:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:PM04:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:PM04:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:PM04:HEARTBEATCLC")
  field(INP, "SIOC:IN20:PM04:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:IN20:PM04:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:PM04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM04:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:PM04:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:PM04:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:PM04:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:PM04:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:PM04:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:PM04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "OTRH2")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:PM04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "OTRH2")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:PM04:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-in20-pm01")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:IN20:PM05:INFO") {
  field(DESC, "SIOC:IN20:PM05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:PM05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Courtney Curtis (curtisco)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:IN20:PM05:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:IN20:PM05:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:IN20:PM05:TODDIFF")
}

record(longin, "SIOC:IN20:PM05:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:PM05:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20:PM05:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:IN20:PM05:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:PM05:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:PM05:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:PM05:TODSUM")
}

record(bo, "SIOC:IN20:PM05:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:PM05:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:PM05:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:PM05:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM05:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:PM05:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:PM05:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:PM05:HEARTBEATE01")
  field(INP, "SIOC:IN20:PM05:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:PM05:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:PM05:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:PM05:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:PM05:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:PM05:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:PM05:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:PM05:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:PM05:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:PM05:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:PM05:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:PM05:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20:PM05:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:IN20:PM05:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:PM05:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM05:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:PM05:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:PM05:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:PM05:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM05:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:PM05:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:PM05:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:PM05:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM05:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:PM05:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:PM05:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:PM05:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM05:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:PM05:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:PM05:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:PM05:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM05:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:PM05:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:PM05:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:PM05:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM05:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:PM05:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:PM05:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:PM05:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM05:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:PM05:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:PM05:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:PM05:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM05:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:PM05:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:PM05:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:PM05:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM05:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:PM05:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:PM05:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:PM05:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:PM05:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:PM05:HEARTBEATCLC")
  field(INP, "SIOC:IN20:PM05:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:IN20:PM05:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:PM05:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:PM05:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:PM05:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:PM05:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:PM05:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:PM05:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:PM05:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:PM05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "YAG02")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:PM05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "YAG02")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:PM05:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-in20-pm01")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:IN20:MC02:INFO") {
  field(DESC, "SIOC:IN20:MC02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:MC02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Namrata Balakrishnan (namrata)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:IN20:MC02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:IN20:MC02:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:IN20:MC02:TODDIFF")
}

record(longin, "SIOC:IN20:MC02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:MC02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20:MC02:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:IN20:MC02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:MC02:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:MC02:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:MC02:TODSUM")
}

record(bo, "SIOC:IN20:MC02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:MC02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:MC02:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:MC02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MC02:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:MC02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:MC02:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:MC02:HEARTBEATE01")
  field(INP, "SIOC:IN20:MC02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:MC02:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:MC02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:MC02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:MC02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:MC02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:MC02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:MC02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:MC02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:MC02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:MC02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:MC02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20:MC02:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:IN20:MC02:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:MC02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MC02:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:MC02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:MC02:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:MC02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MC02:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:MC02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:MC02:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:MC02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MC02:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:MC02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:MC02:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:MC02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MC02:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:MC02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:MC02:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:MC02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MC02:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:MC02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:MC02:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:MC02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MC02:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:MC02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:MC02:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:MC02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MC02:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:MC02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:MC02:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:MC02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MC02:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:MC02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:MC02:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:MC02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MC02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:MC02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:MC02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:MC02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:MC02:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:MC02:HEARTBEATCLC")
  field(INP, "SIOC:IN20:MC02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:IN20:MC02:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:MC02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:MC02:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:MC02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:MC02:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:MC02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:MC02:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:MC02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:MC02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:MC02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:MC02:LOC") {
  field(PINI, "YES")
  field(VAL, "LKG-1242")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:IN20:TR01:INFO") {
  field(DESC, "SIOC:IN20:TR01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:TR01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:IN20:TR01:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:IN20:TR01:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:IN20:TR01:TODDIFF")
}

record(longin, "SIOC:IN20:TR01:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:TR01:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20:TR01:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:IN20:TR01:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:TR01:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:TR01:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:TR01:TODSUM")
}

record(bo, "SIOC:IN20:TR01:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:TR01:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:TR01:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:TR01:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR01:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:TR01:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:TR01:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:TR01:HEARTBEATE01")
  field(INP, "SIOC:IN20:TR01:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:TR01:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:TR01:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:TR01:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:TR01:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:TR01:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:TR01:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:TR01:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:TR01:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:TR01:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:TR01:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:TR01:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20:TR01:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:IN20:TR01:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:TR01:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR01:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:TR01:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:TR01:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:TR01:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR01:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:TR01:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:TR01:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:TR01:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR01:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:TR01:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:TR01:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:TR01:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR01:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:TR01:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:TR01:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:TR01:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR01:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:TR01:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:TR01:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:TR01:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR01:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:TR01:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:TR01:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:TR01:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR01:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:TR01:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:TR01:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:TR01:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR01:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:TR01:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:TR01:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:TR01:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR01:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:TR01:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:TR01:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:TR01:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:TR01:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:TR01:HEARTBEATCLC")
  field(INP, "SIOC:IN20:TR01:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:IN20:TR01:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:TR01:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR01:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:TR01:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:TR01:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:TR01:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:TR01:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:TR01:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:TR01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:TR01:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:TR01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-fb02")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:IN20:TR02:INFO") {
  field(DESC, "SIOC:IN20:TR02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:TR02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:IN20:TR02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:IN20:TR02:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:IN20:TR02:TODDIFF")
}

record(longin, "SIOC:IN20:TR02:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:TR02:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20:TR02:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:IN20:TR02:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:TR02:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:TR02:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:TR02:TODSUM")
}

record(bo, "SIOC:IN20:TR02:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:TR02:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:TR02:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:TR02:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR02:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:TR02:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:TR02:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:TR02:HEARTBEATE01")
  field(INP, "SIOC:IN20:TR02:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:TR02:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:TR02:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:TR02:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:TR02:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:TR02:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:TR02:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:TR02:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:TR02:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:TR02:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:TR02:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:TR02:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20:TR02:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:IN20:TR02:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:TR02:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR02:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:TR02:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:TR02:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:TR02:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR02:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:TR02:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:TR02:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:TR02:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR02:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:TR02:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:TR02:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:TR02:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR02:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:TR02:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:TR02:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:TR02:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR02:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:TR02:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:TR02:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:TR02:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR02:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:TR02:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:TR02:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:TR02:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR02:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:TR02:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:TR02:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:TR02:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR02:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:TR02:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:TR02:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:TR02:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR02:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:TR02:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:TR02:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:TR02:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:TR02:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:TR02:HEARTBEATCLC")
  field(INP, "SIOC:IN20:TR02:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:IN20:TR02:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:TR02:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR02:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:TR02:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:TR02:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:TR02:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:TR02:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:TR02:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:TR02:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:TR02:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:TR02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-fb02")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:IN20:TR03:INFO") {
  field(DESC, "SIOC:IN20:TR03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:TR03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:IN20:TR03:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:IN20:TR03:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:IN20:TR03:TODDIFF")
}

record(longin, "SIOC:IN20:TR03:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:TR03:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20:TR03:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:IN20:TR03:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:TR03:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:TR03:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:TR03:TODSUM")
}

record(bo, "SIOC:IN20:TR03:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:TR03:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:TR03:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:TR03:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR03:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:TR03:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:TR03:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:TR03:HEARTBEATE01")
  field(INP, "SIOC:IN20:TR03:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:TR03:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:TR03:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:TR03:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:TR03:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:TR03:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:TR03:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:TR03:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:TR03:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:TR03:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:TR03:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:TR03:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20:TR03:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:IN20:TR03:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:TR03:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR03:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:TR03:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:TR03:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:TR03:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR03:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:TR03:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:TR03:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:TR03:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR03:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:TR03:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:TR03:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:TR03:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR03:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:TR03:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:TR03:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:TR03:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR03:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:TR03:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:TR03:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:TR03:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR03:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:TR03:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:TR03:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:TR03:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR03:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:TR03:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:TR03:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:TR03:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR03:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:TR03:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:TR03:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:TR03:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR03:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:TR03:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:TR03:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:TR03:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:TR03:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:TR03:HEARTBEATCLC")
  field(INP, "SIOC:IN20:TR03:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:IN20:TR03:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:TR03:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR03:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:TR03:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:TR03:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:TR03:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:TR03:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:TR03:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:TR03:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:TR03:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:TR03:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-fb01")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:IN20:TR04:INFO") {
  field(DESC, "SIOC:IN20:TR04 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:TR04:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:IN20:TR04:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:IN20:TR04:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:IN20:TR04:TODDIFF")
}

record(longin, "SIOC:IN20:TR04:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:TR04:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20:TR04:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:IN20:TR04:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:TR04:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:TR04:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:TR04:TODSUM")
}

record(bo, "SIOC:IN20:TR04:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:TR04:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:TR04:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:TR04:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR04:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:TR04:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:TR04:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:TR04:HEARTBEATE01")
  field(INP, "SIOC:IN20:TR04:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:TR04:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:TR04:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:TR04:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:TR04:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:TR04:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:TR04:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:TR04:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:TR04:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:TR04:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:TR04:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:TR04:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20:TR04:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:IN20:TR04:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:TR04:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR04:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:TR04:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:TR04:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:TR04:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR04:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:TR04:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:TR04:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:TR04:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR04:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:TR04:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:TR04:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:TR04:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR04:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:TR04:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:TR04:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:TR04:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR04:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:TR04:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:TR04:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:TR04:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR04:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:TR04:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:TR04:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:TR04:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR04:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:TR04:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:TR04:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:TR04:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR04:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:TR04:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:TR04:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:TR04:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR04:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:TR04:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:TR04:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:TR04:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:TR04:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:TR04:HEARTBEATCLC")
  field(INP, "SIOC:IN20:TR04:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:IN20:TR04:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:TR04:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR04:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:TR04:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:TR04:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:TR04:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:TR04:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:TR04:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:TR04:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:TR04:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:TR04:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-fb01")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:IN20:TR05:INFO") {
  field(DESC, "SIOC:IN20:TR05 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:TR05:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (jmock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an alarm if the difference is 10 
# seconds or greater. See IOCManagerApp/src/todCheckSub.c
# for more details. TODDIFF stores the time difference.

record(aSub, "SIOC:IN20:TR05:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:IN20:TR05:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:IN20:TR05:TODDIFF")
}

record(longin, "SIOC:IN20:TR05:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:IN20:TR05:TODCHECK.VALA MS")
  field(FLNK, "SIOC:IN20:TR05:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:IN20:TR05:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:IN20:TR05:TODCHECK.SEVR")
  field(INPB, "SIOC:IN20:TR05:TODCHECK.VALB")
  field(FLNK, "SIOC:IN20:TR05:TODSUM")
}

record(bo, "SIOC:IN20:TR05:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:IN20:TR05:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:IN20:TR05:HEARTBEATCALC") {
  field(FLNK, "SIOC:IN20:TR05:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR05:HEARTBEAT CA MS")
  field(INPB, "SIOC:IN20:TR05:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:IN20:TR05:HEARTBEATOK") {
  field(FLNK, "SIOC:IN20:TR05:HEARTBEATE01")
  field(INP, "SIOC:IN20:TR05:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:IN20:TR05:HEARTBEATECT") {
  field(FLNK, "SIOC:IN20:TR05:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:IN20:TR05:HEARTBEATE01.VAL")
  field(INPB, "SIOC:IN20:TR05:HEARTBEATE02.VAL")
  field(INPC, "SIOC:IN20:TR05:HEARTBEATE03.VAL")
  field(INPD, "SIOC:IN20:TR05:HEARTBEATE04.VAL")
  field(INPE, "SIOC:IN20:TR05:HEARTBEATE05.VAL")
  field(INPF, "SIOC:IN20:TR05:HEARTBEATE06.VAL")
  field(INPG, "SIOC:IN20:TR05:HEARTBEATE07.VAL")
  field(INPH, "SIOC:IN20:TR05:HEARTBEATE08.VAL")
  field(INPI, "SIOC:IN20:TR05:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:IN20:TR05:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:IN20:TR05:HEARTBEATE09") {
  field(FLNK, "SIOC:IN20:TR05:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR05:HEARTBEATE08.B")
  field(INPB, "SIOC:IN20:TR05:HEARTBEATE09.VAL")
}

record(calc, "SIOC:IN20:TR05:HEARTBEATE08") {
  field(FLNK, "SIOC:IN20:TR05:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR05:HEARTBEATE07.B")
  field(INPB, "SIOC:IN20:TR05:HEARTBEATE08.VAL")
}

record(calc, "SIOC:IN20:TR05:HEARTBEATE07") {
  field(FLNK, "SIOC:IN20:TR05:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR05:HEARTBEATE06.B")
  field(INPB, "SIOC:IN20:TR05:HEARTBEATE07.VAL")
}

record(calc, "SIOC:IN20:TR05:HEARTBEATE06") {
  field(FLNK, "SIOC:IN20:TR05:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR05:HEARTBEATE05.B")
  field(INPB, "SIOC:IN20:TR05:HEARTBEATE06.VAL")
}

record(calc, "SIOC:IN20:TR05:HEARTBEATE05") {
  field(FLNK, "SIOC:IN20:TR05:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR05:HEARTBEATE04.B")
  field(INPB, "SIOC:IN20:TR05:HEARTBEATE05.VAL")
}

record(calc, "SIOC:IN20:TR05:HEARTBEATE04") {
  field(FLNK, "SIOC:IN20:TR05:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR05:HEARTBEATE03.B")
  field(INPB, "SIOC:IN20:TR05:HEARTBEATE04.VAL")
}

record(calc, "SIOC:IN20:TR05:HEARTBEATE03") {
  field(FLNK, "SIOC:IN20:TR05:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR05:HEARTBEATE02.B")
  field(INPB, "SIOC:IN20:TR05:HEARTBEATE03.VAL")
}

record(calc, "SIOC:IN20:TR05:HEARTBEATE02") {
  field(FLNK, "SIOC:IN20:TR05:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR05:HEARTBEATE01.B")
  field(INPB, "SIOC:IN20:TR05:HEARTBEATE02.VAL")
}

record(calc, "SIOC:IN20:TR05:HEARTBEATE01") {
  field(FLNK, "SIOC:IN20:TR05:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR05:HEARTBEATERR.VAL")
  field(INPB, "SIOC:IN20:TR05:HEARTBEATE01.VAL")
}

record(calc, "SIOC:IN20:TR05:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:IN20:TR05:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:IN20:TR05:HEARTBEATSUM") {
  field(FLNK, "SIOC:IN20:TR05:HEARTBEATCLC")
  field(INP, "SIOC:IN20:TR05:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:IN20:TR05:HEARTBEATE10") {
  field(FLNK, "SIOC:IN20:TR05:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:IN20:TR05:HEARTBEATE09.B")
  field(INPB, "SIOC:IN20:TR05:HEARTBEATE10.VAL")
}

record(calc, "SIOC:IN20:TR05:HEARTBEATERR") {
  field(FLNK, "SIOC:IN20:TR05:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:IN20:TR05:HEARTBEATCALC.A")
  field(INPB, "SIOC:IN20:TR05:HEARTBEATCALC.B")
}

record(stringin, "SIOC:IN20:TR05:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:IN20:TR05:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:IN20:TR05:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-sys0-fb02")
  info(autosaveFields,"VAL")
}

