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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:SYS1:EV01:LOC") {
  field(PINI, "YES")
  field(VAL, "FKG20-0211")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:SYS1:MP01:LOC") {
  field(PINI, "YES")
  field(VAL, "FKG10-2301")
  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:SYS1:UW01:INFO") {
  field(DESC, "SIOC:SYS1:UW01 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:UW01:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:MG01:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "Sector ctrl & Model")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:AL00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS1:AL00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:SYS1:AL00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:SYS1:AL00:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:AL02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:SYS1:AL02:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:SYS1:AL02:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:SYS1:AL02:TODDIFF")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:MK00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:MK00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:SYS1:ML00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:ML00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:SYS1:ML01:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:ML01:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:SYS1:ML02:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:ML02:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:SYS1:ML03:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:ML03:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:SYS1:MP00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Lukas Ho-Koziol (lujko)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:MP00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:BC01:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:OP00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:OP00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:SYS1:EV00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:EV00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:BP05:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

record(stringin, "SIOC:SYS1:EM00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Mike Zelazny (zelazny)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:BP00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:PM00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Patrick Nisperos (pnispero)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:PM00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:SYS1:KY00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:ALH1:APP00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:ALH1:GADC00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:ALH1:MGNT00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:ALH1:PROF00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:ALH1:FBCK00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(calc, "SIOC:ALH1:WS00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH1:WS00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:WS00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH1:WS00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH1:WS00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH1:WS00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH1:WS00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH1:WS00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH1:WS00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH1:WS00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:WS00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:ALH1:MC00:INFO") {
  field(DESC, "SIOC:ALH1:MC00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:MC00: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:ALH1:MC00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:ALH1:MC00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:ALH1:MC00:TODDIFF")
}

record(longin, "SIOC:ALH1:MC00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH1:MC00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH1:MC00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:ALH1:MC00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH1:MC00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH1:MC00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH1:MC00:TODSUM")
}

record(bo, "SIOC:ALH1:MC00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH1:MC00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH1:MC00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH1:MC00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MC00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH1:MC00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH1:MC00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH1:MC00:HEARTBEATE01")
  field(INP, "SIOC:ALH1:MC00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH1:MC00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH1:MC00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH1:MC00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH1:MC00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH1:MC00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH1:MC00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH1:MC00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH1:MC00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH1:MC00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH1:MC00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH1:MC00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH1:MC00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:ALH1:MC00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH1:MC00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MC00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH1:MC00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH1:MC00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH1:MC00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MC00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH1:MC00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH1:MC00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH1:MC00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MC00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH1:MC00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH1:MC00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH1:MC00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MC00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH1:MC00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH1:MC00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH1:MC00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MC00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH1:MC00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH1:MC00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH1:MC00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MC00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH1:MC00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH1:MC00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH1:MC00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MC00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH1:MC00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH1:MC00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH1:MC00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MC00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH1:MC00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH1:MC00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH1:MC00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MC00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH1:MC00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH1:MC00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH1:MC00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH1:MC00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH1:MC00:HEARTBEATCLC")
  field(INP, "SIOC:ALH1:MC00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH1:MC00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH1:MC00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MC00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH1:MC00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH1:MC00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH1:MC00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH1:MC00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH1:MC00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH1:MC00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH1:MC00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:MC00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:ALH1:LASR00:INFO") {
  field(DESC, "SIOC:ALH1:LASR00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:LASR00: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:ALH1:LASR00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:ALH1:LASR00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:ALH1:LASR00:TODDIFF")
}

record(longin, "SIOC:ALH1:LASR00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH1:LASR00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH1:LASR00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:ALH1:LASR00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH1:LASR00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH1:LASR00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH1:LASR00:TODSUM")
}

record(bo, "SIOC:ALH1:LASR00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH1:LASR00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH1:LASR00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH1:LASR00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:LASR00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH1:LASR00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH1:LASR00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH1:LASR00:HEARTBEATE01")
  field(INP, "SIOC:ALH1:LASR00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH1:LASR00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH1:LASR00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH1:LASR00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH1:LASR00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH1:LASR00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH1:LASR00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH1:LASR00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH1:LASR00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH1:LASR00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH1:LASR00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH1:LASR00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH1:LASR00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:ALH1:LASR00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH1:LASR00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:LASR00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH1:LASR00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH1:LASR00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH1:LASR00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:LASR00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH1:LASR00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH1:LASR00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH1:LASR00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:LASR00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH1:LASR00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH1:LASR00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH1:LASR00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:LASR00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH1:LASR00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH1:LASR00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH1:LASR00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:LASR00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH1:LASR00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH1:LASR00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH1:LASR00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:LASR00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH1:LASR00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH1:LASR00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH1:LASR00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:LASR00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH1:LASR00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH1:LASR00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH1:LASR00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:LASR00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH1:LASR00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH1:LASR00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH1:LASR00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:LASR00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH1:LASR00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH1:LASR00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH1:LASR00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH1:LASR00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH1:LASR00:HEARTBEATCLC")
  field(INP, "SIOC:ALH1:LASR00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH1:LASR00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH1:LASR00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:LASR00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH1:LASR00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH1:LASR00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH1:LASR00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH1:LASR00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH1:LASR00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH1:LASR00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH1:LASR00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:LASR00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:ALH1:RF00:INFO") {
  field(DESC, "SIOC:ALH1:RF00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:RF00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:ALH1:RF00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:ALH1:RF00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:ALH1:RF00:TODDIFF")
}

record(longin, "SIOC:ALH1:RF00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH1:RF00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH1:RF00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:ALH1:RF00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH1:RF00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH1:RF00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH1:RF00:TODSUM")
}

record(bo, "SIOC:ALH1:RF00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH1:RF00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH1:RF00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH1:RF00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:RF00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH1:RF00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH1:RF00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH1:RF00:HEARTBEATE01")
  field(INP, "SIOC:ALH1:RF00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH1:RF00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH1:RF00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH1:RF00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH1:RF00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH1:RF00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH1:RF00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH1:RF00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH1:RF00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH1:RF00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH1:RF00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH1:RF00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH1:RF00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:ALH1:RF00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH1:RF00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:RF00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH1:RF00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH1:RF00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH1:RF00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:RF00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH1:RF00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH1:RF00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH1:RF00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:RF00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH1:RF00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH1:RF00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH1:RF00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:RF00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH1:RF00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH1:RF00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH1:RF00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:RF00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH1:RF00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH1:RF00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH1:RF00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:RF00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH1:RF00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH1:RF00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH1:RF00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:RF00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH1:RF00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH1:RF00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH1:RF00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:RF00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH1:RF00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH1:RF00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH1:RF00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:RF00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH1:RF00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH1:RF00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH1:RF00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH1:RF00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH1:RF00:HEARTBEATCLC")
  field(INP, "SIOC:ALH1:RF00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH1:RF00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH1:RF00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:RF00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH1:RF00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH1:RF00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH1:RF00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH1:RF00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH1:RF00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH1:RF00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH1:RF00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:RF00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:ALH1:EVNT00:INFO") {
  field(DESC, "SIOC:ALH1:EVNT00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:EVNT00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:ALH1:EVNT00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:ALH1:EVNT00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:ALH1:EVNT00:TODDIFF")
}

record(longin, "SIOC:ALH1:EVNT00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH1:EVNT00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH1:EVNT00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:ALH1:EVNT00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH1:EVNT00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH1:EVNT00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH1:EVNT00:TODSUM")
}

record(bo, "SIOC:ALH1:EVNT00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH1:EVNT00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH1:EVNT00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH1:EVNT00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:EVNT00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH1:EVNT00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH1:EVNT00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH1:EVNT00:HEARTBEATE01")
  field(INP, "SIOC:ALH1:EVNT00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH1:EVNT00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH1:EVNT00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH1:EVNT00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH1:EVNT00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH1:EVNT00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH1:EVNT00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH1:EVNT00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH1:EVNT00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH1:EVNT00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH1:EVNT00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH1:EVNT00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH1:EVNT00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:ALH1:EVNT00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH1:EVNT00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:EVNT00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH1:EVNT00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH1:EVNT00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH1:EVNT00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:EVNT00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH1:EVNT00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH1:EVNT00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH1:EVNT00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:EVNT00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH1:EVNT00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH1:EVNT00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH1:EVNT00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:EVNT00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH1:EVNT00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH1:EVNT00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH1:EVNT00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:EVNT00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH1:EVNT00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH1:EVNT00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH1:EVNT00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:EVNT00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH1:EVNT00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH1:EVNT00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH1:EVNT00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:EVNT00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH1:EVNT00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH1:EVNT00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH1:EVNT00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:EVNT00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH1:EVNT00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH1:EVNT00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH1:EVNT00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:EVNT00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH1:EVNT00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH1:EVNT00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH1:EVNT00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH1:EVNT00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH1:EVNT00:HEARTBEATCLC")
  field(INP, "SIOC:ALH1:EVNT00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH1:EVNT00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH1:EVNT00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:EVNT00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH1:EVNT00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH1:EVNT00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH1:EVNT00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH1:EVNT00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH1:EVNT00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH1:EVNT00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH1:EVNT00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:EVNT00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:ALH1:NTWK00:INFO") {
  field(DESC, "SIOC:ALH1:NTWK00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:NTWK00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:ALH1:NTWK00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:ALH1:NTWK00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:ALH1:NTWK00:TODDIFF")
}

record(longin, "SIOC:ALH1:NTWK00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH1:NTWK00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH1:NTWK00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:ALH1:NTWK00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH1:NTWK00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH1:NTWK00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH1:NTWK00:TODSUM")
}

record(bo, "SIOC:ALH1:NTWK00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH1:NTWK00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH1:NTWK00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH1:NTWK00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:NTWK00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH1:NTWK00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH1:NTWK00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH1:NTWK00:HEARTBEATE01")
  field(INP, "SIOC:ALH1:NTWK00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH1:NTWK00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH1:NTWK00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH1:NTWK00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH1:NTWK00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH1:NTWK00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH1:NTWK00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH1:NTWK00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH1:NTWK00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH1:NTWK00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH1:NTWK00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH1:NTWK00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH1:NTWK00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:ALH1:NTWK00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH1:NTWK00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:NTWK00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH1:NTWK00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH1:NTWK00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH1:NTWK00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:NTWK00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH1:NTWK00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH1:NTWK00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH1:NTWK00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:NTWK00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH1:NTWK00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH1:NTWK00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH1:NTWK00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:NTWK00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH1:NTWK00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH1:NTWK00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH1:NTWK00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:NTWK00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH1:NTWK00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH1:NTWK00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH1:NTWK00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:NTWK00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH1:NTWK00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH1:NTWK00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH1:NTWK00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:NTWK00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH1:NTWK00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH1:NTWK00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH1:NTWK00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:NTWK00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH1:NTWK00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH1:NTWK00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH1:NTWK00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:NTWK00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH1:NTWK00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH1:NTWK00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH1:NTWK00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH1:NTWK00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH1:NTWK00:HEARTBEATCLC")
  field(INP, "SIOC:ALH1:NTWK00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH1:NTWK00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH1:NTWK00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:NTWK00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH1:NTWK00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH1:NTWK00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH1:NTWK00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH1:NTWK00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH1:NTWK00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH1:NTWK00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH1:NTWK00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:NTWK00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:ALH1:UTIL00:INFO") {
  field(DESC, "SIOC:ALH1:UTIL00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:UTIL00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:ALH1:UTIL00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:ALH1:UTIL00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:ALH1:UTIL00:TODDIFF")
}

record(longin, "SIOC:ALH1:UTIL00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH1:UTIL00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH1:UTIL00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:ALH1:UTIL00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH1:UTIL00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH1:UTIL00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH1:UTIL00:TODSUM")
}

record(bo, "SIOC:ALH1:UTIL00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH1:UTIL00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH1:UTIL00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH1:UTIL00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:UTIL00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH1:UTIL00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH1:UTIL00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH1:UTIL00:HEARTBEATE01")
  field(INP, "SIOC:ALH1:UTIL00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH1:UTIL00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH1:UTIL00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH1:UTIL00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH1:UTIL00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH1:UTIL00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH1:UTIL00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH1:UTIL00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH1:UTIL00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH1:UTIL00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH1:UTIL00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH1:UTIL00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH1:UTIL00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:ALH1:UTIL00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH1:UTIL00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:UTIL00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH1:UTIL00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH1:UTIL00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH1:UTIL00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:UTIL00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH1:UTIL00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH1:UTIL00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH1:UTIL00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:UTIL00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH1:UTIL00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH1:UTIL00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH1:UTIL00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:UTIL00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH1:UTIL00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH1:UTIL00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH1:UTIL00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:UTIL00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH1:UTIL00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH1:UTIL00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH1:UTIL00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:UTIL00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH1:UTIL00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH1:UTIL00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH1:UTIL00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:UTIL00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH1:UTIL00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH1:UTIL00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH1:UTIL00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:UTIL00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH1:UTIL00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH1:UTIL00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH1:UTIL00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:UTIL00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH1:UTIL00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH1:UTIL00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH1:UTIL00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH1:UTIL00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH1:UTIL00:HEARTBEATCLC")
  field(INP, "SIOC:ALH1:UTIL00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH1:UTIL00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH1:UTIL00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:UTIL00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH1:UTIL00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH1:UTIL00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH1:UTIL00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH1:UTIL00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH1:UTIL00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH1:UTIL00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH1:UTIL00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:UTIL00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:ALH1:VAC00:INFO") {
  field(DESC, "SIOC:ALH1:VAC00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:VAC00: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:ALH1:VAC00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:ALH1:VAC00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:ALH1:VAC00:TODDIFF")
}

record(longin, "SIOC:ALH1:VAC00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH1:VAC00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH1:VAC00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:ALH1:VAC00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH1:VAC00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH1:VAC00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH1:VAC00:TODSUM")
}

record(bo, "SIOC:ALH1:VAC00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH1:VAC00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH1:VAC00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH1:VAC00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:VAC00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH1:VAC00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH1:VAC00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH1:VAC00:HEARTBEATE01")
  field(INP, "SIOC:ALH1:VAC00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH1:VAC00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH1:VAC00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH1:VAC00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH1:VAC00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH1:VAC00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH1:VAC00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH1:VAC00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH1:VAC00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH1:VAC00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH1:VAC00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH1:VAC00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH1:VAC00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:ALH1:VAC00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH1:VAC00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:VAC00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH1:VAC00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH1:VAC00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH1:VAC00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:VAC00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH1:VAC00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH1:VAC00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH1:VAC00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:VAC00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH1:VAC00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH1:VAC00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH1:VAC00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:VAC00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH1:VAC00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH1:VAC00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH1:VAC00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:VAC00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH1:VAC00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH1:VAC00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH1:VAC00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:VAC00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH1:VAC00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH1:VAC00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH1:VAC00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:VAC00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH1:VAC00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH1:VAC00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH1:VAC00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:VAC00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH1:VAC00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH1:VAC00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH1:VAC00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:VAC00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH1:VAC00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH1:VAC00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH1:VAC00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH1:VAC00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH1:VAC00:HEARTBEATCLC")
  field(INP, "SIOC:ALH1:VAC00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH1:VAC00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH1:VAC00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:VAC00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH1:VAC00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH1:VAC00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH1:VAC00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH1:VAC00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH1:VAC00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH1:VAC00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH1:VAC00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:VAC00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:ALH1:TEMP00:INFO") {
  field(DESC, "SIOC:ALH1:TEMP00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:TEMP00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:ALH1:TEMP00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:ALH1:TEMP00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:ALH1:TEMP00:TODDIFF")
}

record(longin, "SIOC:ALH1:TEMP00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH1:TEMP00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH1:TEMP00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:ALH1:TEMP00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH1:TEMP00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH1:TEMP00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH1:TEMP00:TODSUM")
}

record(bo, "SIOC:ALH1:TEMP00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH1:TEMP00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH1:TEMP00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH1:TEMP00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:TEMP00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH1:TEMP00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH1:TEMP00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH1:TEMP00:HEARTBEATE01")
  field(INP, "SIOC:ALH1:TEMP00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH1:TEMP00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH1:TEMP00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH1:TEMP00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH1:TEMP00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH1:TEMP00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH1:TEMP00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH1:TEMP00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH1:TEMP00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH1:TEMP00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH1:TEMP00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH1:TEMP00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH1:TEMP00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:ALH1:TEMP00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH1:TEMP00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:TEMP00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH1:TEMP00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH1:TEMP00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH1:TEMP00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:TEMP00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH1:TEMP00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH1:TEMP00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH1:TEMP00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:TEMP00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH1:TEMP00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH1:TEMP00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH1:TEMP00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:TEMP00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH1:TEMP00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH1:TEMP00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH1:TEMP00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:TEMP00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH1:TEMP00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH1:TEMP00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH1:TEMP00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:TEMP00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH1:TEMP00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH1:TEMP00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH1:TEMP00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:TEMP00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH1:TEMP00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH1:TEMP00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH1:TEMP00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:TEMP00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH1:TEMP00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH1:TEMP00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH1:TEMP00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:TEMP00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH1:TEMP00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH1:TEMP00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH1:TEMP00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH1:TEMP00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH1:TEMP00:HEARTBEATCLC")
  field(INP, "SIOC:ALH1:TEMP00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH1:TEMP00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH1:TEMP00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:TEMP00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH1:TEMP00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH1:TEMP00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH1:TEMP00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH1:TEMP00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH1:TEMP00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH1:TEMP00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH1:TEMP00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:TEMP00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:ALH1:MPS00:INFO") {
  field(DESC, "SIOC:ALH1:MPS00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:MPS00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:ALH1:MPS00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:ALH1:MPS00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:ALH1:MPS00:TODDIFF")
}

record(longin, "SIOC:ALH1:MPS00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH1:MPS00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH1:MPS00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:ALH1:MPS00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH1:MPS00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH1:MPS00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH1:MPS00:TODSUM")
}

record(bo, "SIOC:ALH1:MPS00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH1:MPS00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH1:MPS00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH1:MPS00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MPS00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH1:MPS00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH1:MPS00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH1:MPS00:HEARTBEATE01")
  field(INP, "SIOC:ALH1:MPS00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH1:MPS00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH1:MPS00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH1:MPS00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH1:MPS00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH1:MPS00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH1:MPS00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH1:MPS00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH1:MPS00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH1:MPS00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH1:MPS00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH1:MPS00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH1:MPS00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:ALH1:MPS00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH1:MPS00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MPS00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH1:MPS00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH1:MPS00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH1:MPS00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MPS00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH1:MPS00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH1:MPS00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH1:MPS00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MPS00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH1:MPS00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH1:MPS00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH1:MPS00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MPS00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH1:MPS00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH1:MPS00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH1:MPS00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MPS00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH1:MPS00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH1:MPS00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH1:MPS00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MPS00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH1:MPS00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH1:MPS00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH1:MPS00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MPS00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH1:MPS00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH1:MPS00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH1:MPS00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MPS00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH1:MPS00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH1:MPS00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH1:MPS00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MPS00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH1:MPS00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH1:MPS00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH1:MPS00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH1:MPS00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH1:MPS00:HEARTBEATCLC")
  field(INP, "SIOC:ALH1:MPS00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH1:MPS00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH1:MPS00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:MPS00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH1:MPS00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH1:MPS00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH1:MPS00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH1:MPS00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH1:MPS00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH1:MPS00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH1:MPS00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:MPS00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:ALH1:PPS00:INFO") {
  field(DESC, "SIOC:ALH1:PPS00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:PPS00:CONTACT") {
  field(DESC, "IOC responsible engineer")
  field(VAL, "Judy Rock (jrock)")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

# TODCHECK and TODSUM are used to compare the 
# IOC time-of-day with IOCManager's time-of-day
# and raise an 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:ALH1:PPS00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:ALH1:PPS00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:ALH1:PPS00:TODDIFF")
}

record(longin, "SIOC:ALH1:PPS00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH1:PPS00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH1:PPS00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:ALH1:PPS00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH1:PPS00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH1:PPS00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH1:PPS00:TODSUM")
}

record(bo, "SIOC:ALH1:PPS00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH1:PPS00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH1:PPS00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH1:PPS00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:PPS00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH1:PPS00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH1:PPS00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH1:PPS00:HEARTBEATE01")
  field(INP, "SIOC:ALH1:PPS00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH1:PPS00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH1:PPS00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH1:PPS00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH1:PPS00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH1:PPS00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH1:PPS00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH1:PPS00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH1:PPS00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH1:PPS00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH1:PPS00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH1:PPS00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH1:PPS00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:ALH1:PPS00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH1:PPS00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:PPS00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH1:PPS00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH1:PPS00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH1:PPS00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:PPS00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH1:PPS00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH1:PPS00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH1:PPS00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:PPS00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH1:PPS00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH1:PPS00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH1:PPS00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:PPS00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH1:PPS00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH1:PPS00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH1:PPS00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:PPS00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH1:PPS00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH1:PPS00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH1:PPS00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:PPS00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH1:PPS00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH1:PPS00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH1:PPS00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:PPS00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH1:PPS00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH1:PPS00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH1:PPS00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:PPS00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH1:PPS00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH1:PPS00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH1:PPS00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:PPS00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH1:PPS00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH1:PPS00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH1:PPS00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH1:PPS00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH1:PPS00:HEARTBEATCLC")
  field(INP, "SIOC:ALH1:PPS00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH1:PPS00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH1:PPS00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:PPS00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH1:PPS00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH1:PPS00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH1:PPS00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH1:PPS00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH1:PPS00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH1:PPS00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH1:PPS00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:PPS00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

# String record to hold info about ioc, for example
# impact of rebooting. (Ideally we would have longer
# string for this. To be implemented later.)
record(stringout, "SIOC:ALH1:BCS00:INFO") {
  field(DESC, "SIOC:ALH1:BCS00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:BCS00: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:ALH1:BCS00:TODCHECK") {
  field(SCAN, "2 second")
  field(SNAM, "TODCheck")
  field(FTA, "STRING")
  field(FTB, "STRING")
  field(FTC, "LONG")
  field(INPA, "$(iocmanager):TOD MS")
  field(INPB, "SIOC:ALH1:BCS00:TOD CA")
  field(INPC, "10")
# VALA holds difference between A and B (in seconds)
  field(FTVA, "LONG")
# VALB is 1 for ok, 0 for not synchronized
  field(FTVB, "LONG")
  field(FLNK, "SIOC:ALH1:BCS00:TODDIFF")
}

record(longin, "SIOC:ALH1:BCS00:TODDIFF") {
  field(DESC, "TOD error in seconds")
  field(ADEL, "1")
  field(INP,  "SIOC:ALH1:BCS00:TODCHECK.VALA MS")
  field(FLNK, "SIOC:ALH1:BCS00:TODCHECKVALID")
}

# If <ioc> is offline, TODCHECK
# does not execute subroutine,
# so check TODCHECK.SEVR. If INVALID,
# assume <ioc> offline and 
# set TODSUM to "Not synchronized"
record(calc, "SIOC:ALH1:BCS00:TODCHECKVALID") {
  field(CALC, "A=3?0:B")
  field(INPA, "SIOC:ALH1:BCS00:TODCHECK.SEVR")
  field(INPB, "SIOC:ALH1:BCS00:TODCHECK.VALB")
  field(FLNK, "SIOC:ALH1:BCS00:TODSUM")
}

record(bo, "SIOC:ALH1:BCS00:TODSUM") {
  field(DESC, "IOC timeofday status")
  field(DOL, "SIOC:ALH1:BCS00:TODCHECKVALID MS")
  field(OMSL, "closed_loop")
  field(ZNAM, "Not synchronized")
  field(ONAM, "Synchronized")
  field(ZSV, "MAJOR")
  field(OSV, "NO_ALARM")
}

record(calc, "SIOC:ALH1:BCS00:HEARTBEATCALC") {
  field(FLNK, "SIOC:ALH1:BCS00:HEARTBEATERR")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:BCS00:HEARTBEAT CA MS")
  field(INPB, "SIOC:ALH1:BCS00:HEARTBEATCALC.VAL")
  field(SCAN, "2 second")
}

record(bi, "SIOC:ALH1:BCS00:HEARTBEATOK") {
  field(FLNK, "SIOC:ALH1:BCS00:HEARTBEATE01")
  field(INP, "SIOC:ALH1:BCS00:HEARTBEATERR.VAL")
  field(ZSV, "NO_ALARM")
  field(OSV, "MAJOR")
  field(ZNAM, "OK")
  field(ONAM, "FAULT")
}

record(calc, "SIOC:ALH1:BCS00:HEARTBEATECT") {
  field(FLNK, "SIOC:ALH1:BCS00:HEARTBEATSUM")
  field(CALC, "A+B+C+D+E+F+G+H+I+J")
  field(INPA, "SIOC:ALH1:BCS00:HEARTBEATE01.VAL")
  field(INPB, "SIOC:ALH1:BCS00:HEARTBEATE02.VAL")
  field(INPC, "SIOC:ALH1:BCS00:HEARTBEATE03.VAL")
  field(INPD, "SIOC:ALH1:BCS00:HEARTBEATE04.VAL")
  field(INPE, "SIOC:ALH1:BCS00:HEARTBEATE05.VAL")
  field(INPF, "SIOC:ALH1:BCS00:HEARTBEATE06.VAL")
  field(INPG, "SIOC:ALH1:BCS00:HEARTBEATE07.VAL")
  field(INPH, "SIOC:ALH1:BCS00:HEARTBEATE08.VAL")
  field(INPI, "SIOC:ALH1:BCS00:HEARTBEATE09.VAL")
  field(INPJ, "SIOC:ALH1:BCS00:HEARTBEATE10.VAL")
  field(HIHI, "3")
  field(LOLO, "-1")
  field(HIGH, "2")
  field(LOW, "-1")
  field(HHSV, "MAJOR")
  field(LLSV, "MAJOR")
  field(HSV, "MINOR")
  field(LSV, "MAJOR")
}

record(calc, "SIOC:ALH1:BCS00:HEARTBEATE09") {
  field(FLNK, "SIOC:ALH1:BCS00:HEARTBEATE10")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:BCS00:HEARTBEATE08.B")
  field(INPB, "SIOC:ALH1:BCS00:HEARTBEATE09.VAL")
}

record(calc, "SIOC:ALH1:BCS00:HEARTBEATE08") {
  field(FLNK, "SIOC:ALH1:BCS00:HEARTBEATE09")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:BCS00:HEARTBEATE07.B")
  field(INPB, "SIOC:ALH1:BCS00:HEARTBEATE08.VAL")
}

record(calc, "SIOC:ALH1:BCS00:HEARTBEATE07") {
  field(FLNK, "SIOC:ALH1:BCS00:HEARTBEATE08")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:BCS00:HEARTBEATE06.B")
  field(INPB, "SIOC:ALH1:BCS00:HEARTBEATE07.VAL")
}

record(calc, "SIOC:ALH1:BCS00:HEARTBEATE06") {
  field(FLNK, "SIOC:ALH1:BCS00:HEARTBEATE07")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:BCS00:HEARTBEATE05.B")
  field(INPB, "SIOC:ALH1:BCS00:HEARTBEATE06.VAL")
}

record(calc, "SIOC:ALH1:BCS00:HEARTBEATE05") {
  field(FLNK, "SIOC:ALH1:BCS00:HEARTBEATE06")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:BCS00:HEARTBEATE04.B")
  field(INPB, "SIOC:ALH1:BCS00:HEARTBEATE05.VAL")
}

record(calc, "SIOC:ALH1:BCS00:HEARTBEATE04") {
  field(FLNK, "SIOC:ALH1:BCS00:HEARTBEATE05")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:BCS00:HEARTBEATE03.B")
  field(INPB, "SIOC:ALH1:BCS00:HEARTBEATE04.VAL")
}

record(calc, "SIOC:ALH1:BCS00:HEARTBEATE03") {
  field(FLNK, "SIOC:ALH1:BCS00:HEARTBEATE04")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:BCS00:HEARTBEATE02.B")
  field(INPB, "SIOC:ALH1:BCS00:HEARTBEATE03.VAL")
}

record(calc, "SIOC:ALH1:BCS00:HEARTBEATE02") {
  field(FLNK, "SIOC:ALH1:BCS00:HEARTBEATE03")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:BCS00:HEARTBEATE01.B")
  field(INPB, "SIOC:ALH1:BCS00:HEARTBEATE02.VAL")
}

record(calc, "SIOC:ALH1:BCS00:HEARTBEATE01") {
  field(FLNK, "SIOC:ALH1:BCS00:HEARTBEATE02")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:BCS00:HEARTBEATERR.VAL")
  field(INPB, "SIOC:ALH1:BCS00:HEARTBEATE01.VAL")
}

record(calc, "SIOC:ALH1:BCS00:HEARTBEATCLC") {
  field(CALC, "A=0?0:A=1?0:A-2?3:A=3?3:4")
  field(INPA, "SIOC:ALH1:BCS00:HEARTBEATECT.SEVR")
  field(HIHI, "4")
  field(HHSV, "INVALID")
}

record(mbbi, "SIOC:ALH1:BCS00:HEARTBEATSUM") {
  field(FLNK, "SIOC:ALH1:BCS00:HEARTBEATCLC")
  field(INP, "SIOC:ALH1:BCS00:HEARTBEATECT.SEVR")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(ZRST, "PRESENT")
  field(ONST, "INTERMITTENT")
  field(TWST, "ABSENT")
}

record(calc, "SIOC:ALH1:BCS00:HEARTBEATE10") {
  field(FLNK, "SIOC:ALH1:BCS00:HEARTBEATECT")
  field(CALC, "A")
  field(INPA, "SIOC:ALH1:BCS00:HEARTBEATE09.B")
  field(INPB, "SIOC:ALH1:BCS00:HEARTBEATE10.VAL")
}

record(calc, "SIOC:ALH1:BCS00:HEARTBEATERR") {
  field(FLNK, "SIOC:ALH1:BCS00:HEARTBEATOK")
  field(CALC, "A=B?1:0")
  field(INPA, "SIOC:ALH1:BCS00:HEARTBEATCALC.A")
  field(INPB, "SIOC:ALH1:BCS00:HEARTBEATCALC.B")
}

record(stringin, "SIOC:ALH1:BCS00:ALIAS") {
  field(DESC, "Device")
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

# To be deprecated; replaced by ALIAS
record(stringin, "SIOC:ALH1:BCS00:SLCNAME") {
  field(PINI, "YES")
  field(VAL, "")
  info(autosaveFields,"VAL")
}

record(stringin, "SIOC:ALH1:BCS00:LOC") {
  field(PINI, "YES")
  field(VAL, "facet-daemon1")
  info(autosaveFields,"VAL")
}

