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

record(stringin, "SIOC:AS01:LS00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shawn Alversion (alverson)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:AS01:LS00:LOC") {
  field(PINI, "YES")
  field(VAL, "testfac-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:AS01:LS01:INFO") {
  field(DESC, "SIOC:AS01:LS01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:AS01:LS01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shawn Alversion (alverson)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:AS01:LS01:LOC") {
  field(PINI, "YES")
  field(VAL, "testfac-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:AS01:LS02:INFO") {
  field(DESC, "SIOC:AS01:LS02 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:AS01:LS02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shawn Alversion (alverson)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:AS01:MG01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-as01-mg01")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:AS01:VA01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Jeremy Mock (mock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:AS01:VA01:LOC") {
  field(PINI, "YES")
  field(VAL, "testfac-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:AS01:PM01:INFO") {
  field(DESC, "SIOC:AS01:PM01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:AS01:PM01:LOC") {
  field(PINI, "YES")
  field(VAL, "testfac-asta-cs01")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:AS01:PM02:LOC") {
  field(PINI, "YES")
  field(VAL, "testfac-asta-cs01")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:AS01:PM03:LOC") {
  field(PINI, "YES")
  field(VAL, "testfac-asta-cs01")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:AS01:TM01:LOC") {
  field(PINI, "YES")
  field(VAL, "testfac-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:AS01:MC01:INFO") {
  field(DESC, "SIOC:AS01:MC01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:AS01:MC01:LOC") {
  field(PINI, "YES")
  field(VAL, "testfac-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:AS01:RF01:INFO") {
  field(DESC, "SIOC:AS01:RF01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:AS01:RF01:LOC") {
  field(PINI, "YES")
  field(VAL, "testfac-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:AS01:LS03:INFO") {
  field(DESC, "SIOC:AS01:LS03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:AS01:LS03:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-as01-sp01")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:AS01:KY01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-as01-sp02")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:AS01:KY02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-as01-sp01")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:AS01:KY03:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-as01-sp02")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:AS01:TS01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-as01-sp02")
  info(autosaveFields,"VAL")
}

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

record(stringin, "IOC:AS01:LS01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shawn Alversion (alverson)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:AS01:LS01:LOC") {
  field(PINI, "YES")
  field(VAL, "B044")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:AS01:RF01:LOC") {
  field(PINI, "YES")
  field(VAL, "B044-R152")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:AS01:RF11:LOC") {
  field(PINI, "YES")
  field(VAL, "B044-R152")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:AS01:RF12:LOC") {
  field(PINI, "YES")
  field(VAL, "B044-R152")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:AS01:RF13:LOC") {
  field(PINI, "YES")
  field(VAL, "B044-R152")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:AS01:RF14:LOC") {
  field(PINI, "YES")
  field(VAL, "B044-R152")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:AS01:RF41:LOC") {
  field(PINI, "YES")
  field(VAL, "B044-R152")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:AS01:RF42:LOC") {
  field(PINI, "YES")
  field(VAL, "B044-R152")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:AS01:RF43:LOC") {
  field(PINI, "YES")
  field(VAL, "B044-R152")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "EIOC:AS01:RF71:LOC") {
  field(PINI, "YES")
  field(VAL, "B044-R152")
  info(autosaveFields,"VAL")
}

