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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "IOC:LR20:LS02:LOC") {
  field(PINI, "YES")
  field(VAL, "LKA-0322")
  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:LR20:LS00:INFO") {
  field(DESC, "SIOC:LR20:LS00 Info")
  field(PINI, "YES")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:LR20:LS00:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:LR20:LS01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon0")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:LR20:LS02:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:LR20:LS03:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:LR20:LS04:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:LR20:LS05:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:LR20:LS06:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:LR20:BC02:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

record(stringin, "SIOC:LR20:CF01:LOC") {
  field(PINI, "YES")
  field(VAL, "lcls-daemon1")
  info(autosaveFields,"VAL")
}

