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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:HTR:BC01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "ACM test")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:HTR:BC01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b15-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:B34:LS00:INFO") {
  field(DESC, "SIOC:B34:LS00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:B34:LS00:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b34-sp04")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:B34:LS02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b34-sp04")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:B34:LS03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Shawn Alverson (alverson)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:B34:LS03:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b34-sp04")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:LI20:CS01:LOC") {
  field(PINI, "YES")
  field(VAL, "icd-pc85638")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:DEV:RF01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b15-rf01")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:DEV:RF02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b15-rf01")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:AD10:RF01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-ad10-cm01")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:L1B:RF01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Sonya Hoobler (hoobler)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:L1B: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:L1B: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:L1B:RF01:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:L1B:RF01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b15-sp03")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:LI11:KY01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b15-ky01")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:LI11:KY02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b15-ky01")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:DMP0:RF11:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "XTCAV NC")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:DMP0:RF11:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b15-rf03")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:DMP0:RF12:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "XTCAV NC diag")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:DMP0:RF12:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "XTCAV NC diag")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:DMP0:RF12:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b15-rf03")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:DMP0:RF21:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "XTCAV SC")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:DMP0:RF21:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b15-rf03")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:DMP0:RF22:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "XTCAV SC diag")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:DMP0:RF22:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "XTCAV SC diag")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:DMP0:RF22:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b15-rf03")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:B34:RF13:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b34-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:B24:KY01:INFO") {
  field(DESC, "SIOC:B24:KY01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:B24:KY01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b024-pm01")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:B34:MG02:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b34-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:B34:MG03:INFO") {
  field(DESC, "SIOC:B34:MG03 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:B34:MG03:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b34-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:B015:TS01:INFO") {
  field(DESC, "SIOC:B015:TS01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:B015:TS01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b15-sp03")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS0:TS01:LOC") {
  field(PINI, "YES")
  field(VAL, "cpu-b34-ts01")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "VIOC:B34:RF02:LOC") {
  field(PINI, "YES")
  field(VAL, "ioc-b34-cd35")
  info(autosaveFields,"VAL")
}

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

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

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

record(aSub, "VIOC:B34: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, "VIOC:B34: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, "VIOC:B34:RF11:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "VIOC:B34:RF11:LOC") {
  field(PINI, "YES")
  field(VAL, "ioc-b34-cd35")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "VIOC:B34:BP01:LOC") {
  field(PINI, "YES")
  field(VAL, "ioc-b34-cd35")
  info(autosaveFields,"VAL")
}

