record(stringin, "ACSW:B15:NW01:LOGIN") {
  field(PINI, "YES")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db setLogin(ACSW:B15:NW01) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINFO")
}

record(stringin, "ACSW:B15:NW01:GETINFO") {
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getInfo(ACSW:B15:NW01) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINIT")
}

record(stringin, "ACSW:B15:NW01:FWVERSION") {
  field(SCAN, "10 second")
  field(FLNK, "ACSW:B15:NW01:NETFWVERSION")
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B15:NW01:NETFWVERSION") {
  field(DESC, "Network adapter fw vers")
  field(FLNK, "ACSW:B15:NW01:SITEID")
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B15:NW01:SITEID") {
  field(DESC, "ACSW node name")
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")

}

record(bo, "ACSW:B15:NW01:GETINIT") {
  field(DESC, "Get outlet init states")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db getOutletInitState8(ACSW:B15:NW01) acsw-b15-nw01")
}

record(stringin, "ACSW:B15:NW01:GETSTATUS") {
  field(SCAN, "2 second")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getOutletState8(ACSW:B15:NW01) acsw-b15-nw01")
}

record(ai, "ACSW:B15:NW01:TYPE") {
  field(DESC, "APC 8 Port AC Power Switch")
  field(PINI, "YES")
  field(VAL, "10")
}

record(stringin, "ACSW:B15:NW01:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-123-0433-J7")
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
  info(autosaveFields,"VAL")
}

record(bo, "ACSW:B15:NW01:DISCONN") {
  field(DESC, "Disconn to allow access")
  field(DISA, "1")
  field(DISS, "NO_ALARM")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setDisconnect acsw-b15-nw01")
}

record(calcout, "ACSW:B15:NW01:CONNCALC") {
  field(CALC, "A=B && C#D")
  field(SCAN, "2 second")
  field(INPA, "ACSW:B15:NW01:DISCONN.DISA")
  field(INPB, "ACSW:B15:NW01:DISCONN.DISV")
  field(INPC, "ACSW:B15:NW01:GETSTATUS.DISA")
  field(INPD, "ACSW:B15:NW01:GETSTATUS.DISV")
  field(OOPT, "On Change")
  field(OUT, "ACSW:B15:NW01:CONNSTA PP")
}

record(bi, "ACSW:B15:NW01:CONNSTA") {
  field(ZNAM, "Not connected")
  field(ONAM, "Connected")
  field(ZSV, "MINOR")
  field(OSV, "NO_ALARM")
}

# Disconnect from ACSW to allow
# other clients access to ACSW
record(seq, "ACSW:B15:NW01:ACCSTART") {
  field(SELM, "All")
  field(DOL1, "1")
  field(LNK1, "ACSW:B15:NW01:GETSTATUS.DISA")
  field(DOL2, "0")
  field(LNK2, "ACSW:B15:NW01:DISCONN.DISA PP")
}

# Reconnect to ACSW
record(seq, "ACSW:B15:NW01:ACCSTOP") {
  field(SELM, "All")
  field(DOL1, "0")
  field(LNK1, "ACSW:B15:NW01:GETSTATUS.DISA")
  field(DOL2, "1")
  field(LNK2, "ACSW:B15:NW01:DISCONN.DISA")
}

#Not in use since using CLI
record(ai, "ACSW:B15:NW01:UPTIMEHOUR") {
  field(FLNK, "ACSW:B15:NW01:UPTIMEMINUTE")
  field(EGU, "Hours")
}
record(ai, "ACSW:B15:NW01:UPTIMEDAY") {
  field(FLNK, "ACSW:B15:NW01:UPTIMEHOUR")
  field(EGU, "Days")
}
record(ai, "ACSW:B15:NW01:UPTIMEMINUTE") {
  field(FLNK, "ACSW:B15:NW01:1NAME")
  field(EGU, "Minutes")
}

record(stringin, "ACSW:B15:NW01:1NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B15:NW01:1POWERSTATEIN")
}

record(stringin, "ACSW:B15:NW01:1POWERSTATEIN") {
  field(FLNK, "ACSW:B15:NW01:1POWERSTATESV")
}

record(scalcout, "ACSW:B15:NW01:1POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B15:NW01:1POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B15:NW01:1POWERSTATE")
}

record(mbbi, "ACSW:B15:NW01:1POWERSTATE") {
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B15:NW01:1POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B15:NW01:1POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(1) acsw-b15-nw01")
}

record(bo, "ACSW:B15:NW01:1POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(1) acsw-b15-nw01")
}

record(bo, "ACSW:B15:NW01:1HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(1) acsw-b15-nw01")
}

record(stringin, "ACSW:B15:NW01:1NAMESET") {
  field(FLNK, "ACSW:B15:NW01:1NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B15:NW01:1NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(1) acsw-b15-nw01")
  field(DOL, "ACSW:B15:NW01:1NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B15:NW01:1SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(1) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINIT")
}

record(bo, "ACSW:B15:NW01:1SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(1) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINIT")
}

record(stringin, "ACSW:B15:NW01:1INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B15:NW01:1INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B15:NW01:1INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B15:NW01:1INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B15:NW01:1INITSTATE")
}

record(mbbi, "ACSW:B15:NW01:1INITSTATE") {
#  field(SDIS, "ACSW:B15:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B15:NW01:1INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B15:NW01:2NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B15:NW01:2POWERSTATEIN")
}

record(stringin, "ACSW:B15:NW01:2POWERSTATEIN") {
  field(FLNK, "ACSW:B15:NW01:2POWERSTATESV")
}

record(scalcout, "ACSW:B15:NW01:2POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B15:NW01:2POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B15:NW01:2POWERSTATE")
}

record(mbbi, "ACSW:B15:NW01:2POWERSTATE") {
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B15:NW01:2POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B15:NW01:2POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(2) acsw-b15-nw01")
}

record(bo, "ACSW:B15:NW01:2POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(2) acsw-b15-nw01")
}

record(bo, "ACSW:B15:NW01:2HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(2) acsw-b15-nw01")
}

record(stringin, "ACSW:B15:NW01:2NAMESET") {
  field(FLNK, "ACSW:B15:NW01:2NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B15:NW01:2NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(2) acsw-b15-nw01")
  field(DOL, "ACSW:B15:NW01:2NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B15:NW01:2SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(2) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINIT")
}

record(bo, "ACSW:B15:NW01:2SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(2) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINIT")
}

record(stringin, "ACSW:B15:NW01:2INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B15:NW01:2INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B15:NW01:2INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B15:NW01:2INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B15:NW01:2INITSTATE")
}

record(mbbi, "ACSW:B15:NW01:2INITSTATE") {
#  field(SDIS, "ACSW:B15:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B15:NW01:2INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B15:NW01:3NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B15:NW01:3POWERSTATEIN")
}

record(stringin, "ACSW:B15:NW01:3POWERSTATEIN") {
  field(FLNK, "ACSW:B15:NW01:3POWERSTATESV")
}

record(scalcout, "ACSW:B15:NW01:3POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B15:NW01:3POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B15:NW01:3POWERSTATE")
}

record(mbbi, "ACSW:B15:NW01:3POWERSTATE") {
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B15:NW01:3POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B15:NW01:3POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(3) acsw-b15-nw01")
}

record(bo, "ACSW:B15:NW01:3POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(3) acsw-b15-nw01")
}

record(bo, "ACSW:B15:NW01:3HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(3) acsw-b15-nw01")
}

record(stringin, "ACSW:B15:NW01:3NAMESET") {
  field(FLNK, "ACSW:B15:NW01:3NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B15:NW01:3NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(3) acsw-b15-nw01")
  field(DOL, "ACSW:B15:NW01:3NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B15:NW01:3SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(3) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINIT")
}

record(bo, "ACSW:B15:NW01:3SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(3) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINIT")
}

record(stringin, "ACSW:B15:NW01:3INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B15:NW01:3INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B15:NW01:3INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B15:NW01:3INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B15:NW01:3INITSTATE")
}

record(mbbi, "ACSW:B15:NW01:3INITSTATE") {
#  field(SDIS, "ACSW:B15:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B15:NW01:3INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B15:NW01:4NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B15:NW01:4POWERSTATEIN")
}

record(stringin, "ACSW:B15:NW01:4POWERSTATEIN") {
  field(FLNK, "ACSW:B15:NW01:4POWERSTATESV")
}

record(scalcout, "ACSW:B15:NW01:4POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B15:NW01:4POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B15:NW01:4POWERSTATE")
}

record(mbbi, "ACSW:B15:NW01:4POWERSTATE") {
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B15:NW01:4POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B15:NW01:4POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(4) acsw-b15-nw01")
}

record(bo, "ACSW:B15:NW01:4POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(4) acsw-b15-nw01")
}

record(bo, "ACSW:B15:NW01:4HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(4) acsw-b15-nw01")
}

record(stringin, "ACSW:B15:NW01:4NAMESET") {
  field(FLNK, "ACSW:B15:NW01:4NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B15:NW01:4NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(4) acsw-b15-nw01")
  field(DOL, "ACSW:B15:NW01:4NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B15:NW01:4SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(4) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINIT")
}

record(bo, "ACSW:B15:NW01:4SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(4) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINIT")
}

record(stringin, "ACSW:B15:NW01:4INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B15:NW01:4INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B15:NW01:4INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B15:NW01:4INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B15:NW01:4INITSTATE")
}

record(mbbi, "ACSW:B15:NW01:4INITSTATE") {
#  field(SDIS, "ACSW:B15:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B15:NW01:4INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B15:NW01:5NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B15:NW01:5POWERSTATEIN")
}

record(stringin, "ACSW:B15:NW01:5POWERSTATEIN") {
  field(FLNK, "ACSW:B15:NW01:5POWERSTATESV")
}

record(scalcout, "ACSW:B15:NW01:5POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B15:NW01:5POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B15:NW01:5POWERSTATE")
}

record(mbbi, "ACSW:B15:NW01:5POWERSTATE") {
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B15:NW01:5POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B15:NW01:5POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(5) acsw-b15-nw01")
}

record(bo, "ACSW:B15:NW01:5POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(5) acsw-b15-nw01")
}

record(bo, "ACSW:B15:NW01:5HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(5) acsw-b15-nw01")
}

record(stringin, "ACSW:B15:NW01:5NAMESET") {
  field(FLNK, "ACSW:B15:NW01:5NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B15:NW01:5NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(5) acsw-b15-nw01")
  field(DOL, "ACSW:B15:NW01:5NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B15:NW01:5SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(5) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINIT")
}

record(bo, "ACSW:B15:NW01:5SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(5) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINIT")
}

record(stringin, "ACSW:B15:NW01:5INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B15:NW01:5INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B15:NW01:5INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B15:NW01:5INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B15:NW01:5INITSTATE")
}

record(mbbi, "ACSW:B15:NW01:5INITSTATE") {
#  field(SDIS, "ACSW:B15:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B15:NW01:5INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B15:NW01:6NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B15:NW01:6POWERSTATEIN")
}

record(stringin, "ACSW:B15:NW01:6POWERSTATEIN") {
  field(FLNK, "ACSW:B15:NW01:6POWERSTATESV")
}

record(scalcout, "ACSW:B15:NW01:6POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B15:NW01:6POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B15:NW01:6POWERSTATE")
}

record(mbbi, "ACSW:B15:NW01:6POWERSTATE") {
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B15:NW01:6POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B15:NW01:6POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(6) acsw-b15-nw01")
}

record(bo, "ACSW:B15:NW01:6POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(6) acsw-b15-nw01")
}

record(bo, "ACSW:B15:NW01:6HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(6) acsw-b15-nw01")
}

record(stringin, "ACSW:B15:NW01:6NAMESET") {
  field(FLNK, "ACSW:B15:NW01:6NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B15:NW01:6NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(6) acsw-b15-nw01")
  field(DOL, "ACSW:B15:NW01:6NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B15:NW01:6SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(6) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINIT")
}

record(bo, "ACSW:B15:NW01:6SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(6) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINIT")
}

record(stringin, "ACSW:B15:NW01:6INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B15:NW01:6INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B15:NW01:6INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B15:NW01:6INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B15:NW01:6INITSTATE")
}

record(mbbi, "ACSW:B15:NW01:6INITSTATE") {
#  field(SDIS, "ACSW:B15:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B15:NW01:6INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B15:NW01:7NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B15:NW01:7POWERSTATEIN")
}

record(stringin, "ACSW:B15:NW01:7POWERSTATEIN") {
  field(FLNK, "ACSW:B15:NW01:7POWERSTATESV")
}

record(scalcout, "ACSW:B15:NW01:7POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B15:NW01:7POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B15:NW01:7POWERSTATE")
}

record(mbbi, "ACSW:B15:NW01:7POWERSTATE") {
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B15:NW01:7POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B15:NW01:7POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(7) acsw-b15-nw01")
}

record(bo, "ACSW:B15:NW01:7POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(7) acsw-b15-nw01")
}

record(bo, "ACSW:B15:NW01:7HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(7) acsw-b15-nw01")
}

record(stringin, "ACSW:B15:NW01:7NAMESET") {
  field(FLNK, "ACSW:B15:NW01:7NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B15:NW01:7NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(7) acsw-b15-nw01")
  field(DOL, "ACSW:B15:NW01:7NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B15:NW01:7SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(7) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINIT")
}

record(bo, "ACSW:B15:NW01:7SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(7) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINIT")
}

record(stringin, "ACSW:B15:NW01:7INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B15:NW01:7INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B15:NW01:7INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B15:NW01:7INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B15:NW01:7INITSTATE")
}

record(mbbi, "ACSW:B15:NW01:7INITSTATE") {
#  field(SDIS, "ACSW:B15:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B15:NW01:7INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B15:NW01:8NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B15:NW01:8POWERSTATEIN")
}

record(stringin, "ACSW:B15:NW01:8POWERSTATEIN") {
  field(FLNK, "ACSW:B15:NW01:8POWERSTATESV")
}

record(scalcout, "ACSW:B15:NW01:8POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B15:NW01:8POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B15:NW01:8POWERSTATE")
}

record(mbbi, "ACSW:B15:NW01:8POWERSTATE") {
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B15:NW01:8POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B15:NW01:8POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(8) acsw-b15-nw01")
}

record(bo, "ACSW:B15:NW01:8POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(8) acsw-b15-nw01")
}

record(bo, "ACSW:B15:NW01:8HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(8) acsw-b15-nw01")
}

record(stringin, "ACSW:B15:NW01:8NAMESET") {
  field(FLNK, "ACSW:B15:NW01:8NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B15:NW01:8NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(8) acsw-b15-nw01")
  field(DOL, "ACSW:B15:NW01:8NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B15:NW01:8SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(8) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINIT")
}

record(bo, "ACSW:B15:NW01:8SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(8) acsw-b15-nw01")
  field(FLNK, "ACSW:B15:NW01:GETINIT")
}

record(stringin, "ACSW:B15:NW01:8INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B15:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B15:NW01:8INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B15:NW01:8INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B15:NW01:8INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B15:NW01:8INITSTATE")
}

record(mbbi, "ACSW:B15:NW01:8INITSTATE") {
#  field(SDIS, "ACSW:B15:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B15:NW01:8INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B25:NW01:LOGIN") {
  field(PINI, "YES")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db setLogin(ACSW:B25:NW01) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINFO")
}

record(stringin, "ACSW:B25:NW01:GETINFO") {
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getInfo(ACSW:B25:NW01) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINIT")
}

record(stringin, "ACSW:B25:NW01:FWVERSION") {
  field(SCAN, "10 second")
  field(FLNK, "ACSW:B25:NW01:NETFWVERSION")
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B25:NW01:NETFWVERSION") {
  field(DESC, "Network adapter fw vers")
  field(FLNK, "ACSW:B25:NW01:SITEID")
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B25:NW01:SITEID") {
  field(DESC, "ACSW node name")
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")

}

record(bo, "ACSW:B25:NW01:GETINIT") {
  field(DESC, "Get outlet init states")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db getOutletInitState8(ACSW:B25:NW01) acsw-b25-nw01")
}

record(stringin, "ACSW:B25:NW01:GETSTATUS") {
  field(SCAN, "2 second")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getOutletState8(ACSW:B25:NW01) acsw-b25-nw01")
}

record(ai, "ACSW:B25:NW01:TYPE") {
  field(DESC, "APC 8 Port AC Power Switch")
  field(PINI, "YES")
  field(VAL, "10")
}

record(stringin, "ACSW:B25:NW01:LOC") {
  field(PINI, "YES")
  field(VAL, "B25-LAB")
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
  info(autosaveFields,"VAL")
}

record(bo, "ACSW:B25:NW01:DISCONN") {
  field(DESC, "Disconn to allow access")
  field(DISA, "1")
  field(DISS, "NO_ALARM")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setDisconnect acsw-b25-nw01")
}

record(calcout, "ACSW:B25:NW01:CONNCALC") {
  field(CALC, "A=B && C#D")
  field(SCAN, "2 second")
  field(INPA, "ACSW:B25:NW01:DISCONN.DISA")
  field(INPB, "ACSW:B25:NW01:DISCONN.DISV")
  field(INPC, "ACSW:B25:NW01:GETSTATUS.DISA")
  field(INPD, "ACSW:B25:NW01:GETSTATUS.DISV")
  field(OOPT, "On Change")
  field(OUT, "ACSW:B25:NW01:CONNSTA PP")
}

record(bi, "ACSW:B25:NW01:CONNSTA") {
  field(ZNAM, "Not connected")
  field(ONAM, "Connected")
  field(ZSV, "MINOR")
  field(OSV, "NO_ALARM")
}

# Disconnect from ACSW to allow
# other clients access to ACSW
record(seq, "ACSW:B25:NW01:ACCSTART") {
  field(SELM, "All")
  field(DOL1, "1")
  field(LNK1, "ACSW:B25:NW01:GETSTATUS.DISA")
  field(DOL2, "0")
  field(LNK2, "ACSW:B25:NW01:DISCONN.DISA PP")
}

# Reconnect to ACSW
record(seq, "ACSW:B25:NW01:ACCSTOP") {
  field(SELM, "All")
  field(DOL1, "0")
  field(LNK1, "ACSW:B25:NW01:GETSTATUS.DISA")
  field(DOL2, "1")
  field(LNK2, "ACSW:B25:NW01:DISCONN.DISA")
}

#Not in use since using CLI
record(ai, "ACSW:B25:NW01:UPTIMEHOUR") {
  field(FLNK, "ACSW:B25:NW01:UPTIMEMINUTE")
  field(EGU, "Hours")
}
record(ai, "ACSW:B25:NW01:UPTIMEDAY") {
  field(FLNK, "ACSW:B25:NW01:UPTIMEHOUR")
  field(EGU, "Days")
}
record(ai, "ACSW:B25:NW01:UPTIMEMINUTE") {
  field(FLNK, "ACSW:B25:NW01:1NAME")
  field(EGU, "Minutes")
}

record(stringin, "ACSW:B25:NW01:1NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B25:NW01:1POWERSTATEIN")
}

record(stringin, "ACSW:B25:NW01:1POWERSTATEIN") {
  field(FLNK, "ACSW:B25:NW01:1POWERSTATESV")
}

record(scalcout, "ACSW:B25:NW01:1POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B25:NW01:1POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B25:NW01:1POWERSTATE")
}

record(mbbi, "ACSW:B25:NW01:1POWERSTATE") {
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B25:NW01:1POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B25:NW01:1POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(1) acsw-b25-nw01")
}

record(bo, "ACSW:B25:NW01:1POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(1) acsw-b25-nw01")
}

record(bo, "ACSW:B25:NW01:1HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(1) acsw-b25-nw01")
}

record(stringin, "ACSW:B25:NW01:1NAMESET") {
  field(FLNK, "ACSW:B25:NW01:1NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B25:NW01:1NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(1) acsw-b25-nw01")
  field(DOL, "ACSW:B25:NW01:1NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B25:NW01:1SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(1) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINIT")
}

record(bo, "ACSW:B25:NW01:1SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(1) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINIT")
}

record(stringin, "ACSW:B25:NW01:1INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B25:NW01:1INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B25:NW01:1INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B25:NW01:1INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B25:NW01:1INITSTATE")
}

record(mbbi, "ACSW:B25:NW01:1INITSTATE") {
#  field(SDIS, "ACSW:B25:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B25:NW01:1INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B25:NW01:2NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B25:NW01:2POWERSTATEIN")
}

record(stringin, "ACSW:B25:NW01:2POWERSTATEIN") {
  field(FLNK, "ACSW:B25:NW01:2POWERSTATESV")
}

record(scalcout, "ACSW:B25:NW01:2POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B25:NW01:2POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B25:NW01:2POWERSTATE")
}

record(mbbi, "ACSW:B25:NW01:2POWERSTATE") {
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B25:NW01:2POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B25:NW01:2POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(2) acsw-b25-nw01")
}

record(bo, "ACSW:B25:NW01:2POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(2) acsw-b25-nw01")
}

record(bo, "ACSW:B25:NW01:2HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(2) acsw-b25-nw01")
}

record(stringin, "ACSW:B25:NW01:2NAMESET") {
  field(FLNK, "ACSW:B25:NW01:2NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B25:NW01:2NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(2) acsw-b25-nw01")
  field(DOL, "ACSW:B25:NW01:2NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B25:NW01:2SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(2) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINIT")
}

record(bo, "ACSW:B25:NW01:2SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(2) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINIT")
}

record(stringin, "ACSW:B25:NW01:2INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B25:NW01:2INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B25:NW01:2INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B25:NW01:2INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B25:NW01:2INITSTATE")
}

record(mbbi, "ACSW:B25:NW01:2INITSTATE") {
#  field(SDIS, "ACSW:B25:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B25:NW01:2INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B25:NW01:3NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B25:NW01:3POWERSTATEIN")
}

record(stringin, "ACSW:B25:NW01:3POWERSTATEIN") {
  field(FLNK, "ACSW:B25:NW01:3POWERSTATESV")
}

record(scalcout, "ACSW:B25:NW01:3POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B25:NW01:3POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B25:NW01:3POWERSTATE")
}

record(mbbi, "ACSW:B25:NW01:3POWERSTATE") {
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B25:NW01:3POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B25:NW01:3POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(3) acsw-b25-nw01")
}

record(bo, "ACSW:B25:NW01:3POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(3) acsw-b25-nw01")
}

record(bo, "ACSW:B25:NW01:3HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(3) acsw-b25-nw01")
}

record(stringin, "ACSW:B25:NW01:3NAMESET") {
  field(FLNK, "ACSW:B25:NW01:3NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B25:NW01:3NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(3) acsw-b25-nw01")
  field(DOL, "ACSW:B25:NW01:3NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B25:NW01:3SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(3) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINIT")
}

record(bo, "ACSW:B25:NW01:3SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(3) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINIT")
}

record(stringin, "ACSW:B25:NW01:3INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B25:NW01:3INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B25:NW01:3INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B25:NW01:3INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B25:NW01:3INITSTATE")
}

record(mbbi, "ACSW:B25:NW01:3INITSTATE") {
#  field(SDIS, "ACSW:B25:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B25:NW01:3INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B25:NW01:4NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B25:NW01:4POWERSTATEIN")
}

record(stringin, "ACSW:B25:NW01:4POWERSTATEIN") {
  field(FLNK, "ACSW:B25:NW01:4POWERSTATESV")
}

record(scalcout, "ACSW:B25:NW01:4POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B25:NW01:4POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B25:NW01:4POWERSTATE")
}

record(mbbi, "ACSW:B25:NW01:4POWERSTATE") {
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B25:NW01:4POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B25:NW01:4POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(4) acsw-b25-nw01")
}

record(bo, "ACSW:B25:NW01:4POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(4) acsw-b25-nw01")
}

record(bo, "ACSW:B25:NW01:4HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(4) acsw-b25-nw01")
}

record(stringin, "ACSW:B25:NW01:4NAMESET") {
  field(FLNK, "ACSW:B25:NW01:4NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B25:NW01:4NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(4) acsw-b25-nw01")
  field(DOL, "ACSW:B25:NW01:4NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B25:NW01:4SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(4) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINIT")
}

record(bo, "ACSW:B25:NW01:4SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(4) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINIT")
}

record(stringin, "ACSW:B25:NW01:4INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B25:NW01:4INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B25:NW01:4INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B25:NW01:4INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B25:NW01:4INITSTATE")
}

record(mbbi, "ACSW:B25:NW01:4INITSTATE") {
#  field(SDIS, "ACSW:B25:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B25:NW01:4INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B25:NW01:5NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B25:NW01:5POWERSTATEIN")
}

record(stringin, "ACSW:B25:NW01:5POWERSTATEIN") {
  field(FLNK, "ACSW:B25:NW01:5POWERSTATESV")
}

record(scalcout, "ACSW:B25:NW01:5POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B25:NW01:5POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B25:NW01:5POWERSTATE")
}

record(mbbi, "ACSW:B25:NW01:5POWERSTATE") {
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B25:NW01:5POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B25:NW01:5POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(5) acsw-b25-nw01")
}

record(bo, "ACSW:B25:NW01:5POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(5) acsw-b25-nw01")
}

record(bo, "ACSW:B25:NW01:5HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(5) acsw-b25-nw01")
}

record(stringin, "ACSW:B25:NW01:5NAMESET") {
  field(FLNK, "ACSW:B25:NW01:5NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B25:NW01:5NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(5) acsw-b25-nw01")
  field(DOL, "ACSW:B25:NW01:5NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B25:NW01:5SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(5) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINIT")
}

record(bo, "ACSW:B25:NW01:5SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(5) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINIT")
}

record(stringin, "ACSW:B25:NW01:5INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B25:NW01:5INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B25:NW01:5INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B25:NW01:5INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B25:NW01:5INITSTATE")
}

record(mbbi, "ACSW:B25:NW01:5INITSTATE") {
#  field(SDIS, "ACSW:B25:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B25:NW01:5INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B25:NW01:6NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B25:NW01:6POWERSTATEIN")
}

record(stringin, "ACSW:B25:NW01:6POWERSTATEIN") {
  field(FLNK, "ACSW:B25:NW01:6POWERSTATESV")
}

record(scalcout, "ACSW:B25:NW01:6POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B25:NW01:6POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B25:NW01:6POWERSTATE")
}

record(mbbi, "ACSW:B25:NW01:6POWERSTATE") {
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B25:NW01:6POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B25:NW01:6POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(6) acsw-b25-nw01")
}

record(bo, "ACSW:B25:NW01:6POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(6) acsw-b25-nw01")
}

record(bo, "ACSW:B25:NW01:6HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(6) acsw-b25-nw01")
}

record(stringin, "ACSW:B25:NW01:6NAMESET") {
  field(FLNK, "ACSW:B25:NW01:6NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B25:NW01:6NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(6) acsw-b25-nw01")
  field(DOL, "ACSW:B25:NW01:6NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B25:NW01:6SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(6) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINIT")
}

record(bo, "ACSW:B25:NW01:6SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(6) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINIT")
}

record(stringin, "ACSW:B25:NW01:6INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B25:NW01:6INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B25:NW01:6INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B25:NW01:6INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B25:NW01:6INITSTATE")
}

record(mbbi, "ACSW:B25:NW01:6INITSTATE") {
#  field(SDIS, "ACSW:B25:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B25:NW01:6INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B25:NW01:7NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B25:NW01:7POWERSTATEIN")
}

record(stringin, "ACSW:B25:NW01:7POWERSTATEIN") {
  field(FLNK, "ACSW:B25:NW01:7POWERSTATESV")
}

record(scalcout, "ACSW:B25:NW01:7POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B25:NW01:7POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B25:NW01:7POWERSTATE")
}

record(mbbi, "ACSW:B25:NW01:7POWERSTATE") {
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B25:NW01:7POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B25:NW01:7POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(7) acsw-b25-nw01")
}

record(bo, "ACSW:B25:NW01:7POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(7) acsw-b25-nw01")
}

record(bo, "ACSW:B25:NW01:7HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(7) acsw-b25-nw01")
}

record(stringin, "ACSW:B25:NW01:7NAMESET") {
  field(FLNK, "ACSW:B25:NW01:7NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B25:NW01:7NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(7) acsw-b25-nw01")
  field(DOL, "ACSW:B25:NW01:7NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B25:NW01:7SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(7) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINIT")
}

record(bo, "ACSW:B25:NW01:7SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(7) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINIT")
}

record(stringin, "ACSW:B25:NW01:7INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B25:NW01:7INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B25:NW01:7INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B25:NW01:7INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B25:NW01:7INITSTATE")
}

record(mbbi, "ACSW:B25:NW01:7INITSTATE") {
#  field(SDIS, "ACSW:B25:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B25:NW01:7INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B25:NW01:8NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B25:NW01:8POWERSTATEIN")
}

record(stringin, "ACSW:B25:NW01:8POWERSTATEIN") {
  field(FLNK, "ACSW:B25:NW01:8POWERSTATESV")
}

record(scalcout, "ACSW:B25:NW01:8POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B25:NW01:8POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B25:NW01:8POWERSTATE")
}

record(mbbi, "ACSW:B25:NW01:8POWERSTATE") {
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B25:NW01:8POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B25:NW01:8POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(8) acsw-b25-nw01")
}

record(bo, "ACSW:B25:NW01:8POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(8) acsw-b25-nw01")
}

record(bo, "ACSW:B25:NW01:8HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(8) acsw-b25-nw01")
}

record(stringin, "ACSW:B25:NW01:8NAMESET") {
  field(FLNK, "ACSW:B25:NW01:8NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B25:NW01:8NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(8) acsw-b25-nw01")
  field(DOL, "ACSW:B25:NW01:8NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B25:NW01:8SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(8) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINIT")
}

record(bo, "ACSW:B25:NW01:8SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(8) acsw-b25-nw01")
  field(FLNK, "ACSW:B25:NW01:GETINIT")
}

record(stringin, "ACSW:B25:NW01:8INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B25:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B25:NW01:8INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B25:NW01:8INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B25:NW01:8INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B25:NW01:8INITSTATE")
}

record(mbbi, "ACSW:B25:NW01:8INITSTATE") {
#  field(SDIS, "ACSW:B25:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B25:NW01:8INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW01:LOGIN") {
  field(PINI, "YES")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db setLogin(ACSW:B34:NW01) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINFO")
}

record(stringin, "ACSW:B34:NW01:GETINFO") {
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getInfo(ACSW:B34:NW01) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINIT")
}

record(stringin, "ACSW:B34:NW01:FWVERSION") {
  field(SCAN, "10 second")
  field(FLNK, "ACSW:B34:NW01:NETFWVERSION")
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B34:NW01:NETFWVERSION") {
  field(DESC, "Network adapter fw vers")
  field(FLNK, "ACSW:B34:NW01:SITEID")
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B34:NW01:SITEID") {
  field(DESC, "ACSW node name")
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")

}

record(bo, "ACSW:B34:NW01:GETINIT") {
  field(DESC, "Get outlet init states")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db getOutletInitState8(ACSW:B34:NW01) acsw-b34-nw01")
}

record(stringin, "ACSW:B34:NW01:GETSTATUS") {
  field(SCAN, "2 second")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getOutletState8(ACSW:B34:NW01) acsw-b34-nw01")
}

record(ai, "ACSW:B34:NW01:TYPE") {
  field(DESC, "APC 8 Port AC Power Switch")
  field(PINI, "YES")
  field(VAL, "10")
}

record(stringin, "ACSW:B34:NW01:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM203-08")
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
  info(autosaveFields,"VAL")
}

record(bo, "ACSW:B34:NW01:DISCONN") {
  field(DESC, "Disconn to allow access")
  field(DISA, "1")
  field(DISS, "NO_ALARM")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setDisconnect acsw-b34-nw01")
}

record(calcout, "ACSW:B34:NW01:CONNCALC") {
  field(CALC, "A=B && C#D")
  field(SCAN, "2 second")
  field(INPA, "ACSW:B34:NW01:DISCONN.DISA")
  field(INPB, "ACSW:B34:NW01:DISCONN.DISV")
  field(INPC, "ACSW:B34:NW01:GETSTATUS.DISA")
  field(INPD, "ACSW:B34:NW01:GETSTATUS.DISV")
  field(OOPT, "On Change")
  field(OUT, "ACSW:B34:NW01:CONNSTA PP")
}

record(bi, "ACSW:B34:NW01:CONNSTA") {
  field(ZNAM, "Not connected")
  field(ONAM, "Connected")
  field(ZSV, "MINOR")
  field(OSV, "NO_ALARM")
}

# Disconnect from ACSW to allow
# other clients access to ACSW
record(seq, "ACSW:B34:NW01:ACCSTART") {
  field(SELM, "All")
  field(DOL1, "1")
  field(LNK1, "ACSW:B34:NW01:GETSTATUS.DISA")
  field(DOL2, "0")
  field(LNK2, "ACSW:B34:NW01:DISCONN.DISA PP")
}

# Reconnect to ACSW
record(seq, "ACSW:B34:NW01:ACCSTOP") {
  field(SELM, "All")
  field(DOL1, "0")
  field(LNK1, "ACSW:B34:NW01:GETSTATUS.DISA")
  field(DOL2, "1")
  field(LNK2, "ACSW:B34:NW01:DISCONN.DISA")
}

#Not in use since using CLI
record(ai, "ACSW:B34:NW01:UPTIMEHOUR") {
  field(FLNK, "ACSW:B34:NW01:UPTIMEMINUTE")
  field(EGU, "Hours")
}
record(ai, "ACSW:B34:NW01:UPTIMEDAY") {
  field(FLNK, "ACSW:B34:NW01:UPTIMEHOUR")
  field(EGU, "Days")
}
record(ai, "ACSW:B34:NW01:UPTIMEMINUTE") {
  field(FLNK, "ACSW:B34:NW01:1NAME")
  field(EGU, "Minutes")
}

record(stringin, "ACSW:B34:NW01:1NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW01:1POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW01:1POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW01:1POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW01:1POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW01:1POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW01:1POWERSTATE")
}

record(mbbi, "ACSW:B34:NW01:1POWERSTATE") {
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW01:1POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW01:1POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(1) acsw-b34-nw01")
}

record(bo, "ACSW:B34:NW01:1POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(1) acsw-b34-nw01")
}

record(bo, "ACSW:B34:NW01:1HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(1) acsw-b34-nw01")
}

record(stringin, "ACSW:B34:NW01:1NAMESET") {
  field(FLNK, "ACSW:B34:NW01:1NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW01:1NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(1) acsw-b34-nw01")
  field(DOL, "ACSW:B34:NW01:1NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW01:1SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(1) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINIT")
}

record(bo, "ACSW:B34:NW01:1SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(1) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINIT")
}

record(stringin, "ACSW:B34:NW01:1INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW01:1INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW01:1INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW01:1INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW01:1INITSTATE")
}

record(mbbi, "ACSW:B34:NW01:1INITSTATE") {
#  field(SDIS, "ACSW:B34:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW01:1INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW01:2NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW01:2POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW01:2POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW01:2POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW01:2POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW01:2POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW01:2POWERSTATE")
}

record(mbbi, "ACSW:B34:NW01:2POWERSTATE") {
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW01:2POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW01:2POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(2) acsw-b34-nw01")
}

record(bo, "ACSW:B34:NW01:2POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(2) acsw-b34-nw01")
}

record(bo, "ACSW:B34:NW01:2HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(2) acsw-b34-nw01")
}

record(stringin, "ACSW:B34:NW01:2NAMESET") {
  field(FLNK, "ACSW:B34:NW01:2NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW01:2NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(2) acsw-b34-nw01")
  field(DOL, "ACSW:B34:NW01:2NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW01:2SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(2) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINIT")
}

record(bo, "ACSW:B34:NW01:2SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(2) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINIT")
}

record(stringin, "ACSW:B34:NW01:2INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW01:2INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW01:2INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW01:2INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW01:2INITSTATE")
}

record(mbbi, "ACSW:B34:NW01:2INITSTATE") {
#  field(SDIS, "ACSW:B34:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW01:2INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW01:3NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW01:3POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW01:3POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW01:3POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW01:3POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW01:3POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW01:3POWERSTATE")
}

record(mbbi, "ACSW:B34:NW01:3POWERSTATE") {
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW01:3POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW01:3POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(3) acsw-b34-nw01")
}

record(bo, "ACSW:B34:NW01:3POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(3) acsw-b34-nw01")
}

record(bo, "ACSW:B34:NW01:3HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(3) acsw-b34-nw01")
}

record(stringin, "ACSW:B34:NW01:3NAMESET") {
  field(FLNK, "ACSW:B34:NW01:3NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW01:3NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(3) acsw-b34-nw01")
  field(DOL, "ACSW:B34:NW01:3NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW01:3SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(3) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINIT")
}

record(bo, "ACSW:B34:NW01:3SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(3) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINIT")
}

record(stringin, "ACSW:B34:NW01:3INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW01:3INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW01:3INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW01:3INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW01:3INITSTATE")
}

record(mbbi, "ACSW:B34:NW01:3INITSTATE") {
#  field(SDIS, "ACSW:B34:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW01:3INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW01:4NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW01:4POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW01:4POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW01:4POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW01:4POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW01:4POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW01:4POWERSTATE")
}

record(mbbi, "ACSW:B34:NW01:4POWERSTATE") {
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW01:4POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW01:4POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(4) acsw-b34-nw01")
}

record(bo, "ACSW:B34:NW01:4POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(4) acsw-b34-nw01")
}

record(bo, "ACSW:B34:NW01:4HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(4) acsw-b34-nw01")
}

record(stringin, "ACSW:B34:NW01:4NAMESET") {
  field(FLNK, "ACSW:B34:NW01:4NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW01:4NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(4) acsw-b34-nw01")
  field(DOL, "ACSW:B34:NW01:4NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW01:4SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(4) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINIT")
}

record(bo, "ACSW:B34:NW01:4SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(4) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINIT")
}

record(stringin, "ACSW:B34:NW01:4INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW01:4INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW01:4INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW01:4INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW01:4INITSTATE")
}

record(mbbi, "ACSW:B34:NW01:4INITSTATE") {
#  field(SDIS, "ACSW:B34:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW01:4INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW01:5NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW01:5POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW01:5POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW01:5POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW01:5POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW01:5POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW01:5POWERSTATE")
}

record(mbbi, "ACSW:B34:NW01:5POWERSTATE") {
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW01:5POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW01:5POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(5) acsw-b34-nw01")
}

record(bo, "ACSW:B34:NW01:5POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(5) acsw-b34-nw01")
}

record(bo, "ACSW:B34:NW01:5HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(5) acsw-b34-nw01")
}

record(stringin, "ACSW:B34:NW01:5NAMESET") {
  field(FLNK, "ACSW:B34:NW01:5NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW01:5NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(5) acsw-b34-nw01")
  field(DOL, "ACSW:B34:NW01:5NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW01:5SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(5) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINIT")
}

record(bo, "ACSW:B34:NW01:5SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(5) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINIT")
}

record(stringin, "ACSW:B34:NW01:5INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW01:5INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW01:5INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW01:5INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW01:5INITSTATE")
}

record(mbbi, "ACSW:B34:NW01:5INITSTATE") {
#  field(SDIS, "ACSW:B34:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW01:5INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW01:6NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW01:6POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW01:6POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW01:6POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW01:6POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW01:6POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW01:6POWERSTATE")
}

record(mbbi, "ACSW:B34:NW01:6POWERSTATE") {
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW01:6POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW01:6POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(6) acsw-b34-nw01")
}

record(bo, "ACSW:B34:NW01:6POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(6) acsw-b34-nw01")
}

record(bo, "ACSW:B34:NW01:6HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(6) acsw-b34-nw01")
}

record(stringin, "ACSW:B34:NW01:6NAMESET") {
  field(FLNK, "ACSW:B34:NW01:6NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW01:6NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(6) acsw-b34-nw01")
  field(DOL, "ACSW:B34:NW01:6NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW01:6SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(6) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINIT")
}

record(bo, "ACSW:B34:NW01:6SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(6) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINIT")
}

record(stringin, "ACSW:B34:NW01:6INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW01:6INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW01:6INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW01:6INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW01:6INITSTATE")
}

record(mbbi, "ACSW:B34:NW01:6INITSTATE") {
#  field(SDIS, "ACSW:B34:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW01:6INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW01:7NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW01:7POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW01:7POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW01:7POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW01:7POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW01:7POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW01:7POWERSTATE")
}

record(mbbi, "ACSW:B34:NW01:7POWERSTATE") {
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW01:7POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW01:7POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(7) acsw-b34-nw01")
}

record(bo, "ACSW:B34:NW01:7POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(7) acsw-b34-nw01")
}

record(bo, "ACSW:B34:NW01:7HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(7) acsw-b34-nw01")
}

record(stringin, "ACSW:B34:NW01:7NAMESET") {
  field(FLNK, "ACSW:B34:NW01:7NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW01:7NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(7) acsw-b34-nw01")
  field(DOL, "ACSW:B34:NW01:7NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW01:7SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(7) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINIT")
}

record(bo, "ACSW:B34:NW01:7SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(7) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINIT")
}

record(stringin, "ACSW:B34:NW01:7INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW01:7INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW01:7INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW01:7INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW01:7INITSTATE")
}

record(mbbi, "ACSW:B34:NW01:7INITSTATE") {
#  field(SDIS, "ACSW:B34:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW01:7INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW01:8NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW01:8POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW01:8POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW01:8POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW01:8POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW01:8POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW01:8POWERSTATE")
}

record(mbbi, "ACSW:B34:NW01:8POWERSTATE") {
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW01:8POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW01:8POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(8) acsw-b34-nw01")
}

record(bo, "ACSW:B34:NW01:8POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(8) acsw-b34-nw01")
}

record(bo, "ACSW:B34:NW01:8HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(8) acsw-b34-nw01")
}

record(stringin, "ACSW:B34:NW01:8NAMESET") {
  field(FLNK, "ACSW:B34:NW01:8NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW01:8NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(8) acsw-b34-nw01")
  field(DOL, "ACSW:B34:NW01:8NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW01:8SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(8) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINIT")
}

record(bo, "ACSW:B34:NW01:8SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(8) acsw-b34-nw01")
  field(FLNK, "ACSW:B34:NW01:GETINIT")
}

record(stringin, "ACSW:B34:NW01:8INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW01:8INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW01:8INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW01:8INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW01:8INITSTATE")
}

record(mbbi, "ACSW:B34:NW01:8INITSTATE") {
#  field(SDIS, "ACSW:B34:NW01:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW01:8INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW02:LOGIN") {
  field(PINI, "YES")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db setLogin(ACSW:B34:NW02) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINFO")
}

record(stringin, "ACSW:B34:NW02:GETINFO") {
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getInfo(ACSW:B34:NW02) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINIT")
}

record(stringin, "ACSW:B34:NW02:FWVERSION") {
  field(SCAN, "10 second")
  field(FLNK, "ACSW:B34:NW02:NETFWVERSION")
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B34:NW02:NETFWVERSION") {
  field(DESC, "Network adapter fw vers")
  field(FLNK, "ACSW:B34:NW02:SITEID")
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B34:NW02:SITEID") {
  field(DESC, "ACSW node name")
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")

}

record(bo, "ACSW:B34:NW02:GETINIT") {
  field(DESC, "Get outlet init states")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db getOutletInitState8(ACSW:B34:NW02) acsw-b34-nw02")
}

record(stringin, "ACSW:B34:NW02:GETSTATUS") {
  field(SCAN, "2 second")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getOutletState8(ACSW:B34:NW02) acsw-b34-nw02")
}

record(ai, "ACSW:B34:NW02:TYPE") {
  field(DESC, "APC 8 Port AC Power Switch")
  field(PINI, "YES")
  field(VAL, "10")
}

record(stringin, "ACSW:B34:NW02:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM253-202-26")
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
  info(autosaveFields,"VAL")
}

record(bo, "ACSW:B34:NW02:DISCONN") {
  field(DESC, "Disconn to allow access")
  field(DISA, "1")
  field(DISS, "NO_ALARM")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setDisconnect acsw-b34-nw02")
}

record(calcout, "ACSW:B34:NW02:CONNCALC") {
  field(CALC, "A=B && C#D")
  field(SCAN, "2 second")
  field(INPA, "ACSW:B34:NW02:DISCONN.DISA")
  field(INPB, "ACSW:B34:NW02:DISCONN.DISV")
  field(INPC, "ACSW:B34:NW02:GETSTATUS.DISA")
  field(INPD, "ACSW:B34:NW02:GETSTATUS.DISV")
  field(OOPT, "On Change")
  field(OUT, "ACSW:B34:NW02:CONNSTA PP")
}

record(bi, "ACSW:B34:NW02:CONNSTA") {
  field(ZNAM, "Not connected")
  field(ONAM, "Connected")
  field(ZSV, "MINOR")
  field(OSV, "NO_ALARM")
}

# Disconnect from ACSW to allow
# other clients access to ACSW
record(seq, "ACSW:B34:NW02:ACCSTART") {
  field(SELM, "All")
  field(DOL1, "1")
  field(LNK1, "ACSW:B34:NW02:GETSTATUS.DISA")
  field(DOL2, "0")
  field(LNK2, "ACSW:B34:NW02:DISCONN.DISA PP")
}

# Reconnect to ACSW
record(seq, "ACSW:B34:NW02:ACCSTOP") {
  field(SELM, "All")
  field(DOL1, "0")
  field(LNK1, "ACSW:B34:NW02:GETSTATUS.DISA")
  field(DOL2, "1")
  field(LNK2, "ACSW:B34:NW02:DISCONN.DISA")
}

#Not in use since using CLI
record(ai, "ACSW:B34:NW02:UPTIMEHOUR") {
  field(FLNK, "ACSW:B34:NW02:UPTIMEMINUTE")
  field(EGU, "Hours")
}
record(ai, "ACSW:B34:NW02:UPTIMEDAY") {
  field(FLNK, "ACSW:B34:NW02:UPTIMEHOUR")
  field(EGU, "Days")
}
record(ai, "ACSW:B34:NW02:UPTIMEMINUTE") {
  field(FLNK, "ACSW:B34:NW02:1NAME")
  field(EGU, "Minutes")
}

record(stringin, "ACSW:B34:NW02:1NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW02:1POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW02:1POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW02:1POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW02:1POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW02:1POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW02:1POWERSTATE")
}

record(mbbi, "ACSW:B34:NW02:1POWERSTATE") {
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW02:1POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW02:1POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(1) acsw-b34-nw02")
}

record(bo, "ACSW:B34:NW02:1POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(1) acsw-b34-nw02")
}

record(bo, "ACSW:B34:NW02:1HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(1) acsw-b34-nw02")
}

record(stringin, "ACSW:B34:NW02:1NAMESET") {
  field(FLNK, "ACSW:B34:NW02:1NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW02:1NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(1) acsw-b34-nw02")
  field(DOL, "ACSW:B34:NW02:1NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW02:1SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(1) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINIT")
}

record(bo, "ACSW:B34:NW02:1SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(1) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINIT")
}

record(stringin, "ACSW:B34:NW02:1INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW02:1INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW02:1INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW02:1INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW02:1INITSTATE")
}

record(mbbi, "ACSW:B34:NW02:1INITSTATE") {
#  field(SDIS, "ACSW:B34:NW02:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW02:1INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW02:2NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW02:2POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW02:2POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW02:2POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW02:2POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW02:2POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW02:2POWERSTATE")
}

record(mbbi, "ACSW:B34:NW02:2POWERSTATE") {
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW02:2POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW02:2POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(2) acsw-b34-nw02")
}

record(bo, "ACSW:B34:NW02:2POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(2) acsw-b34-nw02")
}

record(bo, "ACSW:B34:NW02:2HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(2) acsw-b34-nw02")
}

record(stringin, "ACSW:B34:NW02:2NAMESET") {
  field(FLNK, "ACSW:B34:NW02:2NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW02:2NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(2) acsw-b34-nw02")
  field(DOL, "ACSW:B34:NW02:2NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW02:2SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(2) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINIT")
}

record(bo, "ACSW:B34:NW02:2SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(2) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINIT")
}

record(stringin, "ACSW:B34:NW02:2INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW02:2INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW02:2INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW02:2INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW02:2INITSTATE")
}

record(mbbi, "ACSW:B34:NW02:2INITSTATE") {
#  field(SDIS, "ACSW:B34:NW02:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW02:2INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW02:3NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW02:3POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW02:3POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW02:3POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW02:3POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW02:3POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW02:3POWERSTATE")
}

record(mbbi, "ACSW:B34:NW02:3POWERSTATE") {
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW02:3POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW02:3POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(3) acsw-b34-nw02")
}

record(bo, "ACSW:B34:NW02:3POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(3) acsw-b34-nw02")
}

record(bo, "ACSW:B34:NW02:3HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(3) acsw-b34-nw02")
}

record(stringin, "ACSW:B34:NW02:3NAMESET") {
  field(FLNK, "ACSW:B34:NW02:3NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW02:3NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(3) acsw-b34-nw02")
  field(DOL, "ACSW:B34:NW02:3NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW02:3SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(3) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINIT")
}

record(bo, "ACSW:B34:NW02:3SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(3) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINIT")
}

record(stringin, "ACSW:B34:NW02:3INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW02:3INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW02:3INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW02:3INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW02:3INITSTATE")
}

record(mbbi, "ACSW:B34:NW02:3INITSTATE") {
#  field(SDIS, "ACSW:B34:NW02:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW02:3INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW02:4NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW02:4POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW02:4POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW02:4POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW02:4POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW02:4POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW02:4POWERSTATE")
}

record(mbbi, "ACSW:B34:NW02:4POWERSTATE") {
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW02:4POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW02:4POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(4) acsw-b34-nw02")
}

record(bo, "ACSW:B34:NW02:4POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(4) acsw-b34-nw02")
}

record(bo, "ACSW:B34:NW02:4HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(4) acsw-b34-nw02")
}

record(stringin, "ACSW:B34:NW02:4NAMESET") {
  field(FLNK, "ACSW:B34:NW02:4NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW02:4NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(4) acsw-b34-nw02")
  field(DOL, "ACSW:B34:NW02:4NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW02:4SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(4) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINIT")
}

record(bo, "ACSW:B34:NW02:4SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(4) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINIT")
}

record(stringin, "ACSW:B34:NW02:4INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW02:4INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW02:4INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW02:4INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW02:4INITSTATE")
}

record(mbbi, "ACSW:B34:NW02:4INITSTATE") {
#  field(SDIS, "ACSW:B34:NW02:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW02:4INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW02:5NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW02:5POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW02:5POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW02:5POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW02:5POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW02:5POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW02:5POWERSTATE")
}

record(mbbi, "ACSW:B34:NW02:5POWERSTATE") {
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW02:5POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW02:5POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(5) acsw-b34-nw02")
}

record(bo, "ACSW:B34:NW02:5POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(5) acsw-b34-nw02")
}

record(bo, "ACSW:B34:NW02:5HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(5) acsw-b34-nw02")
}

record(stringin, "ACSW:B34:NW02:5NAMESET") {
  field(FLNK, "ACSW:B34:NW02:5NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW02:5NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(5) acsw-b34-nw02")
  field(DOL, "ACSW:B34:NW02:5NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW02:5SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(5) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINIT")
}

record(bo, "ACSW:B34:NW02:5SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(5) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINIT")
}

record(stringin, "ACSW:B34:NW02:5INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW02:5INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW02:5INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW02:5INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW02:5INITSTATE")
}

record(mbbi, "ACSW:B34:NW02:5INITSTATE") {
#  field(SDIS, "ACSW:B34:NW02:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW02:5INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW02:6NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW02:6POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW02:6POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW02:6POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW02:6POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW02:6POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW02:6POWERSTATE")
}

record(mbbi, "ACSW:B34:NW02:6POWERSTATE") {
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW02:6POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW02:6POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(6) acsw-b34-nw02")
}

record(bo, "ACSW:B34:NW02:6POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(6) acsw-b34-nw02")
}

record(bo, "ACSW:B34:NW02:6HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(6) acsw-b34-nw02")
}

record(stringin, "ACSW:B34:NW02:6NAMESET") {
  field(FLNK, "ACSW:B34:NW02:6NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW02:6NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(6) acsw-b34-nw02")
  field(DOL, "ACSW:B34:NW02:6NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW02:6SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(6) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINIT")
}

record(bo, "ACSW:B34:NW02:6SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(6) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINIT")
}

record(stringin, "ACSW:B34:NW02:6INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW02:6INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW02:6INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW02:6INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW02:6INITSTATE")
}

record(mbbi, "ACSW:B34:NW02:6INITSTATE") {
#  field(SDIS, "ACSW:B34:NW02:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW02:6INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW02:7NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW02:7POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW02:7POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW02:7POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW02:7POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW02:7POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW02:7POWERSTATE")
}

record(mbbi, "ACSW:B34:NW02:7POWERSTATE") {
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW02:7POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW02:7POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(7) acsw-b34-nw02")
}

record(bo, "ACSW:B34:NW02:7POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(7) acsw-b34-nw02")
}

record(bo, "ACSW:B34:NW02:7HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(7) acsw-b34-nw02")
}

record(stringin, "ACSW:B34:NW02:7NAMESET") {
  field(FLNK, "ACSW:B34:NW02:7NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW02:7NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(7) acsw-b34-nw02")
  field(DOL, "ACSW:B34:NW02:7NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW02:7SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(7) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINIT")
}

record(bo, "ACSW:B34:NW02:7SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(7) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINIT")
}

record(stringin, "ACSW:B34:NW02:7INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW02:7INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW02:7INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW02:7INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW02:7INITSTATE")
}

record(mbbi, "ACSW:B34:NW02:7INITSTATE") {
#  field(SDIS, "ACSW:B34:NW02:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW02:7INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW02:8NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW02:8POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW02:8POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW02:8POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW02:8POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW02:8POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW02:8POWERSTATE")
}

record(mbbi, "ACSW:B34:NW02:8POWERSTATE") {
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW02:8POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW02:8POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(8) acsw-b34-nw02")
}

record(bo, "ACSW:B34:NW02:8POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(8) acsw-b34-nw02")
}

record(bo, "ACSW:B34:NW02:8HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(8) acsw-b34-nw02")
}

record(stringin, "ACSW:B34:NW02:8NAMESET") {
  field(FLNK, "ACSW:B34:NW02:8NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW02:8NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(8) acsw-b34-nw02")
  field(DOL, "ACSW:B34:NW02:8NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW02:8SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(8) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINIT")
}

record(bo, "ACSW:B34:NW02:8SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(8) acsw-b34-nw02")
  field(FLNK, "ACSW:B34:NW02:GETINIT")
}

record(stringin, "ACSW:B34:NW02:8INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW02:8INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW02:8INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW02:8INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW02:8INITSTATE")
}

record(mbbi, "ACSW:B34:NW02:8INITSTATE") {
#  field(SDIS, "ACSW:B34:NW02:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW02:8INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW03:LOGIN") {
  field(PINI, "YES")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db setLogin(ACSW:B34:NW03) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINFO")
}

record(stringin, "ACSW:B34:NW03:GETINFO") {
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getInfo(ACSW:B34:NW03) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINIT")
}

record(stringin, "ACSW:B34:NW03:FWVERSION") {
  field(SCAN, "10 second")
  field(FLNK, "ACSW:B34:NW03:NETFWVERSION")
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B34:NW03:NETFWVERSION") {
  field(DESC, "Network adapter fw vers")
  field(FLNK, "ACSW:B34:NW03:SITEID")
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B34:NW03:SITEID") {
  field(DESC, "ACSW node name")
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")

}

record(bo, "ACSW:B34:NW03:GETINIT") {
  field(DESC, "Get outlet init states")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db getOutletInitState8(ACSW:B34:NW03) acsw-b34-nw03")
}

record(stringin, "ACSW:B34:NW03:GETSTATUS") {
  field(SCAN, "2 second")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getOutletState8(ACSW:B34:NW03) acsw-b34-nw03")
}

record(ai, "ACSW:B34:NW03:TYPE") {
  field(DESC, "APC 8 Port AC Power Switch")
  field(PINI, "YES")
  field(VAL, "10")
}

record(stringin, "ACSW:B34:NW03:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-201-04")
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
  info(autosaveFields,"VAL")
}

record(bo, "ACSW:B34:NW03:DISCONN") {
  field(DESC, "Disconn to allow access")
  field(DISA, "1")
  field(DISS, "NO_ALARM")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setDisconnect acsw-b34-nw03")
}

record(calcout, "ACSW:B34:NW03:CONNCALC") {
  field(CALC, "A=B && C#D")
  field(SCAN, "2 second")
  field(INPA, "ACSW:B34:NW03:DISCONN.DISA")
  field(INPB, "ACSW:B34:NW03:DISCONN.DISV")
  field(INPC, "ACSW:B34:NW03:GETSTATUS.DISA")
  field(INPD, "ACSW:B34:NW03:GETSTATUS.DISV")
  field(OOPT, "On Change")
  field(OUT, "ACSW:B34:NW03:CONNSTA PP")
}

record(bi, "ACSW:B34:NW03:CONNSTA") {
  field(ZNAM, "Not connected")
  field(ONAM, "Connected")
  field(ZSV, "MINOR")
  field(OSV, "NO_ALARM")
}

# Disconnect from ACSW to allow
# other clients access to ACSW
record(seq, "ACSW:B34:NW03:ACCSTART") {
  field(SELM, "All")
  field(DOL1, "1")
  field(LNK1, "ACSW:B34:NW03:GETSTATUS.DISA")
  field(DOL2, "0")
  field(LNK2, "ACSW:B34:NW03:DISCONN.DISA PP")
}

# Reconnect to ACSW
record(seq, "ACSW:B34:NW03:ACCSTOP") {
  field(SELM, "All")
  field(DOL1, "0")
  field(LNK1, "ACSW:B34:NW03:GETSTATUS.DISA")
  field(DOL2, "1")
  field(LNK2, "ACSW:B34:NW03:DISCONN.DISA")
}

#Not in use since using CLI
record(ai, "ACSW:B34:NW03:UPTIMEHOUR") {
  field(FLNK, "ACSW:B34:NW03:UPTIMEMINUTE")
  field(EGU, "Hours")
}
record(ai, "ACSW:B34:NW03:UPTIMEDAY") {
  field(FLNK, "ACSW:B34:NW03:UPTIMEHOUR")
  field(EGU, "Days")
}
record(ai, "ACSW:B34:NW03:UPTIMEMINUTE") {
  field(FLNK, "ACSW:B34:NW03:1NAME")
  field(EGU, "Minutes")
}

record(stringin, "ACSW:B34:NW03:1NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW03:1POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW03:1POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW03:1POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW03:1POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW03:1POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW03:1POWERSTATE")
}

record(mbbi, "ACSW:B34:NW03:1POWERSTATE") {
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW03:1POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW03:1POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(1) acsw-b34-nw03")
}

record(bo, "ACSW:B34:NW03:1POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(1) acsw-b34-nw03")
}

record(bo, "ACSW:B34:NW03:1HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(1) acsw-b34-nw03")
}

record(stringin, "ACSW:B34:NW03:1NAMESET") {
  field(FLNK, "ACSW:B34:NW03:1NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW03:1NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(1) acsw-b34-nw03")
  field(DOL, "ACSW:B34:NW03:1NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW03:1SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(1) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINIT")
}

record(bo, "ACSW:B34:NW03:1SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(1) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINIT")
}

record(stringin, "ACSW:B34:NW03:1INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW03:1INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW03:1INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW03:1INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW03:1INITSTATE")
}

record(mbbi, "ACSW:B34:NW03:1INITSTATE") {
#  field(SDIS, "ACSW:B34:NW03:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW03:1INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW03:2NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW03:2POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW03:2POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW03:2POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW03:2POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW03:2POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW03:2POWERSTATE")
}

record(mbbi, "ACSW:B34:NW03:2POWERSTATE") {
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW03:2POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW03:2POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(2) acsw-b34-nw03")
}

record(bo, "ACSW:B34:NW03:2POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(2) acsw-b34-nw03")
}

record(bo, "ACSW:B34:NW03:2HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(2) acsw-b34-nw03")
}

record(stringin, "ACSW:B34:NW03:2NAMESET") {
  field(FLNK, "ACSW:B34:NW03:2NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW03:2NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(2) acsw-b34-nw03")
  field(DOL, "ACSW:B34:NW03:2NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW03:2SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(2) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINIT")
}

record(bo, "ACSW:B34:NW03:2SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(2) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINIT")
}

record(stringin, "ACSW:B34:NW03:2INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW03:2INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW03:2INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW03:2INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW03:2INITSTATE")
}

record(mbbi, "ACSW:B34:NW03:2INITSTATE") {
#  field(SDIS, "ACSW:B34:NW03:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW03:2INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW03:3NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW03:3POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW03:3POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW03:3POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW03:3POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW03:3POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW03:3POWERSTATE")
}

record(mbbi, "ACSW:B34:NW03:3POWERSTATE") {
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW03:3POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW03:3POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(3) acsw-b34-nw03")
}

record(bo, "ACSW:B34:NW03:3POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(3) acsw-b34-nw03")
}

record(bo, "ACSW:B34:NW03:3HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(3) acsw-b34-nw03")
}

record(stringin, "ACSW:B34:NW03:3NAMESET") {
  field(FLNK, "ACSW:B34:NW03:3NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW03:3NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(3) acsw-b34-nw03")
  field(DOL, "ACSW:B34:NW03:3NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW03:3SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(3) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINIT")
}

record(bo, "ACSW:B34:NW03:3SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(3) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINIT")
}

record(stringin, "ACSW:B34:NW03:3INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW03:3INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW03:3INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW03:3INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW03:3INITSTATE")
}

record(mbbi, "ACSW:B34:NW03:3INITSTATE") {
#  field(SDIS, "ACSW:B34:NW03:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW03:3INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW03:4NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW03:4POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW03:4POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW03:4POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW03:4POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW03:4POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW03:4POWERSTATE")
}

record(mbbi, "ACSW:B34:NW03:4POWERSTATE") {
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW03:4POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW03:4POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(4) acsw-b34-nw03")
}

record(bo, "ACSW:B34:NW03:4POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(4) acsw-b34-nw03")
}

record(bo, "ACSW:B34:NW03:4HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(4) acsw-b34-nw03")
}

record(stringin, "ACSW:B34:NW03:4NAMESET") {
  field(FLNK, "ACSW:B34:NW03:4NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW03:4NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(4) acsw-b34-nw03")
  field(DOL, "ACSW:B34:NW03:4NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW03:4SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(4) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINIT")
}

record(bo, "ACSW:B34:NW03:4SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(4) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINIT")
}

record(stringin, "ACSW:B34:NW03:4INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW03:4INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW03:4INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW03:4INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW03:4INITSTATE")
}

record(mbbi, "ACSW:B34:NW03:4INITSTATE") {
#  field(SDIS, "ACSW:B34:NW03:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW03:4INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW03:5NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW03:5POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW03:5POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW03:5POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW03:5POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW03:5POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW03:5POWERSTATE")
}

record(mbbi, "ACSW:B34:NW03:5POWERSTATE") {
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW03:5POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW03:5POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(5) acsw-b34-nw03")
}

record(bo, "ACSW:B34:NW03:5POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(5) acsw-b34-nw03")
}

record(bo, "ACSW:B34:NW03:5HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(5) acsw-b34-nw03")
}

record(stringin, "ACSW:B34:NW03:5NAMESET") {
  field(FLNK, "ACSW:B34:NW03:5NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW03:5NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(5) acsw-b34-nw03")
  field(DOL, "ACSW:B34:NW03:5NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW03:5SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(5) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINIT")
}

record(bo, "ACSW:B34:NW03:5SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(5) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINIT")
}

record(stringin, "ACSW:B34:NW03:5INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW03:5INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW03:5INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW03:5INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW03:5INITSTATE")
}

record(mbbi, "ACSW:B34:NW03:5INITSTATE") {
#  field(SDIS, "ACSW:B34:NW03:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW03:5INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW03:6NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW03:6POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW03:6POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW03:6POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW03:6POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW03:6POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW03:6POWERSTATE")
}

record(mbbi, "ACSW:B34:NW03:6POWERSTATE") {
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW03:6POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW03:6POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(6) acsw-b34-nw03")
}

record(bo, "ACSW:B34:NW03:6POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(6) acsw-b34-nw03")
}

record(bo, "ACSW:B34:NW03:6HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(6) acsw-b34-nw03")
}

record(stringin, "ACSW:B34:NW03:6NAMESET") {
  field(FLNK, "ACSW:B34:NW03:6NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW03:6NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(6) acsw-b34-nw03")
  field(DOL, "ACSW:B34:NW03:6NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW03:6SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(6) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINIT")
}

record(bo, "ACSW:B34:NW03:6SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(6) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINIT")
}

record(stringin, "ACSW:B34:NW03:6INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW03:6INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW03:6INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW03:6INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW03:6INITSTATE")
}

record(mbbi, "ACSW:B34:NW03:6INITSTATE") {
#  field(SDIS, "ACSW:B34:NW03:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW03:6INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW03:7NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW03:7POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW03:7POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW03:7POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW03:7POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW03:7POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW03:7POWERSTATE")
}

record(mbbi, "ACSW:B34:NW03:7POWERSTATE") {
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW03:7POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW03:7POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(7) acsw-b34-nw03")
}

record(bo, "ACSW:B34:NW03:7POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(7) acsw-b34-nw03")
}

record(bo, "ACSW:B34:NW03:7HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(7) acsw-b34-nw03")
}

record(stringin, "ACSW:B34:NW03:7NAMESET") {
  field(FLNK, "ACSW:B34:NW03:7NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW03:7NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(7) acsw-b34-nw03")
  field(DOL, "ACSW:B34:NW03:7NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW03:7SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(7) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINIT")
}

record(bo, "ACSW:B34:NW03:7SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(7) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINIT")
}

record(stringin, "ACSW:B34:NW03:7INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW03:7INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW03:7INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW03:7INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW03:7INITSTATE")
}

record(mbbi, "ACSW:B34:NW03:7INITSTATE") {
#  field(SDIS, "ACSW:B34:NW03:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW03:7INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW03:8NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW03:8POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW03:8POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW03:8POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW03:8POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW03:8POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW03:8POWERSTATE")
}

record(mbbi, "ACSW:B34:NW03:8POWERSTATE") {
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW03:8POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW03:8POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(8) acsw-b34-nw03")
}

record(bo, "ACSW:B34:NW03:8POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(8) acsw-b34-nw03")
}

record(bo, "ACSW:B34:NW03:8HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(8) acsw-b34-nw03")
}

record(stringin, "ACSW:B34:NW03:8NAMESET") {
  field(FLNK, "ACSW:B34:NW03:8NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW03:8NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(8) acsw-b34-nw03")
  field(DOL, "ACSW:B34:NW03:8NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW03:8SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(8) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINIT")
}

record(bo, "ACSW:B34:NW03:8SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(8) acsw-b34-nw03")
  field(FLNK, "ACSW:B34:NW03:GETINIT")
}

record(stringin, "ACSW:B34:NW03:8INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW03:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW03:8INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW03:8INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW03:8INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW03:8INITSTATE")
}

record(mbbi, "ACSW:B34:NW03:8INITSTATE") {
#  field(SDIS, "ACSW:B34:NW03:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW03:8INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW04:LOGIN") {
  field(PINI, "YES")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db setLogin(ACSW:B34:NW04) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINFO")
}

record(stringin, "ACSW:B34:NW04:GETINFO") {
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getInfo(ACSW:B34:NW04) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINIT")
}

record(stringin, "ACSW:B34:NW04:FWVERSION") {
  field(SCAN, "10 second")
  field(FLNK, "ACSW:B34:NW04:NETFWVERSION")
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B34:NW04:NETFWVERSION") {
  field(DESC, "Network adapter fw vers")
  field(FLNK, "ACSW:B34:NW04:SITEID")
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B34:NW04:SITEID") {
  field(DESC, "ACSW node name")
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")

}

record(bo, "ACSW:B34:NW04:GETINIT") {
  field(DESC, "Get outlet init states")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db getOutletInitState8(ACSW:B34:NW04) acsw-b34-nw04")
}

record(stringin, "ACSW:B34:NW04:GETSTATUS") {
  field(SCAN, "2 second")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getOutletState8(ACSW:B34:NW04) acsw-b34-nw04")
}

record(ai, "ACSW:B34:NW04:TYPE") {
  field(DESC, "APC 8 Port AC Power Switch")
  field(PINI, "YES")
  field(VAL, "10")
}

record(stringin, "ACSW:B34:NW04:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM206")
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
  info(autosaveFields,"VAL")
}

record(bo, "ACSW:B34:NW04:DISCONN") {
  field(DESC, "Disconn to allow access")
  field(DISA, "1")
  field(DISS, "NO_ALARM")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setDisconnect acsw-b34-nw04")
}

record(calcout, "ACSW:B34:NW04:CONNCALC") {
  field(CALC, "A=B && C#D")
  field(SCAN, "2 second")
  field(INPA, "ACSW:B34:NW04:DISCONN.DISA")
  field(INPB, "ACSW:B34:NW04:DISCONN.DISV")
  field(INPC, "ACSW:B34:NW04:GETSTATUS.DISA")
  field(INPD, "ACSW:B34:NW04:GETSTATUS.DISV")
  field(OOPT, "On Change")
  field(OUT, "ACSW:B34:NW04:CONNSTA PP")
}

record(bi, "ACSW:B34:NW04:CONNSTA") {
  field(ZNAM, "Not connected")
  field(ONAM, "Connected")
  field(ZSV, "MINOR")
  field(OSV, "NO_ALARM")
}

# Disconnect from ACSW to allow
# other clients access to ACSW
record(seq, "ACSW:B34:NW04:ACCSTART") {
  field(SELM, "All")
  field(DOL1, "1")
  field(LNK1, "ACSW:B34:NW04:GETSTATUS.DISA")
  field(DOL2, "0")
  field(LNK2, "ACSW:B34:NW04:DISCONN.DISA PP")
}

# Reconnect to ACSW
record(seq, "ACSW:B34:NW04:ACCSTOP") {
  field(SELM, "All")
  field(DOL1, "0")
  field(LNK1, "ACSW:B34:NW04:GETSTATUS.DISA")
  field(DOL2, "1")
  field(LNK2, "ACSW:B34:NW04:DISCONN.DISA")
}

#Not in use since using CLI
record(ai, "ACSW:B34:NW04:UPTIMEHOUR") {
  field(FLNK, "ACSW:B34:NW04:UPTIMEMINUTE")
  field(EGU, "Hours")
}
record(ai, "ACSW:B34:NW04:UPTIMEDAY") {
  field(FLNK, "ACSW:B34:NW04:UPTIMEHOUR")
  field(EGU, "Days")
}
record(ai, "ACSW:B34:NW04:UPTIMEMINUTE") {
  field(FLNK, "ACSW:B34:NW04:1NAME")
  field(EGU, "Minutes")
}

record(stringin, "ACSW:B34:NW04:1NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW04:1POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW04:1POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW04:1POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW04:1POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW04:1POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW04:1POWERSTATE")
}

record(mbbi, "ACSW:B34:NW04:1POWERSTATE") {
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW04:1POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW04:1POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(1) acsw-b34-nw04")
}

record(bo, "ACSW:B34:NW04:1POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(1) acsw-b34-nw04")
}

record(bo, "ACSW:B34:NW04:1HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(1) acsw-b34-nw04")
}

record(stringin, "ACSW:B34:NW04:1NAMESET") {
  field(FLNK, "ACSW:B34:NW04:1NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW04:1NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(1) acsw-b34-nw04")
  field(DOL, "ACSW:B34:NW04:1NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW04:1SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(1) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINIT")
}

record(bo, "ACSW:B34:NW04:1SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(1) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINIT")
}

record(stringin, "ACSW:B34:NW04:1INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW04:1INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW04:1INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW04:1INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW04:1INITSTATE")
}

record(mbbi, "ACSW:B34:NW04:1INITSTATE") {
#  field(SDIS, "ACSW:B34:NW04:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW04:1INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW04:2NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW04:2POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW04:2POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW04:2POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW04:2POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW04:2POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW04:2POWERSTATE")
}

record(mbbi, "ACSW:B34:NW04:2POWERSTATE") {
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW04:2POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW04:2POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(2) acsw-b34-nw04")
}

record(bo, "ACSW:B34:NW04:2POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(2) acsw-b34-nw04")
}

record(bo, "ACSW:B34:NW04:2HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(2) acsw-b34-nw04")
}

record(stringin, "ACSW:B34:NW04:2NAMESET") {
  field(FLNK, "ACSW:B34:NW04:2NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW04:2NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(2) acsw-b34-nw04")
  field(DOL, "ACSW:B34:NW04:2NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW04:2SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(2) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINIT")
}

record(bo, "ACSW:B34:NW04:2SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(2) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINIT")
}

record(stringin, "ACSW:B34:NW04:2INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW04:2INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW04:2INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW04:2INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW04:2INITSTATE")
}

record(mbbi, "ACSW:B34:NW04:2INITSTATE") {
#  field(SDIS, "ACSW:B34:NW04:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW04:2INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW04:3NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW04:3POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW04:3POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW04:3POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW04:3POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW04:3POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW04:3POWERSTATE")
}

record(mbbi, "ACSW:B34:NW04:3POWERSTATE") {
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW04:3POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW04:3POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(3) acsw-b34-nw04")
}

record(bo, "ACSW:B34:NW04:3POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(3) acsw-b34-nw04")
}

record(bo, "ACSW:B34:NW04:3HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(3) acsw-b34-nw04")
}

record(stringin, "ACSW:B34:NW04:3NAMESET") {
  field(FLNK, "ACSW:B34:NW04:3NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW04:3NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(3) acsw-b34-nw04")
  field(DOL, "ACSW:B34:NW04:3NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW04:3SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(3) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINIT")
}

record(bo, "ACSW:B34:NW04:3SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(3) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINIT")
}

record(stringin, "ACSW:B34:NW04:3INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW04:3INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW04:3INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW04:3INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW04:3INITSTATE")
}

record(mbbi, "ACSW:B34:NW04:3INITSTATE") {
#  field(SDIS, "ACSW:B34:NW04:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW04:3INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW04:4NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW04:4POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW04:4POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW04:4POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW04:4POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW04:4POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW04:4POWERSTATE")
}

record(mbbi, "ACSW:B34:NW04:4POWERSTATE") {
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW04:4POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW04:4POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(4) acsw-b34-nw04")
}

record(bo, "ACSW:B34:NW04:4POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(4) acsw-b34-nw04")
}

record(bo, "ACSW:B34:NW04:4HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(4) acsw-b34-nw04")
}

record(stringin, "ACSW:B34:NW04:4NAMESET") {
  field(FLNK, "ACSW:B34:NW04:4NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW04:4NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(4) acsw-b34-nw04")
  field(DOL, "ACSW:B34:NW04:4NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW04:4SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(4) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINIT")
}

record(bo, "ACSW:B34:NW04:4SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(4) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINIT")
}

record(stringin, "ACSW:B34:NW04:4INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW04:4INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW04:4INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW04:4INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW04:4INITSTATE")
}

record(mbbi, "ACSW:B34:NW04:4INITSTATE") {
#  field(SDIS, "ACSW:B34:NW04:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW04:4INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW04:5NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW04:5POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW04:5POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW04:5POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW04:5POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW04:5POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW04:5POWERSTATE")
}

record(mbbi, "ACSW:B34:NW04:5POWERSTATE") {
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW04:5POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW04:5POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(5) acsw-b34-nw04")
}

record(bo, "ACSW:B34:NW04:5POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(5) acsw-b34-nw04")
}

record(bo, "ACSW:B34:NW04:5HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(5) acsw-b34-nw04")
}

record(stringin, "ACSW:B34:NW04:5NAMESET") {
  field(FLNK, "ACSW:B34:NW04:5NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW04:5NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(5) acsw-b34-nw04")
  field(DOL, "ACSW:B34:NW04:5NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW04:5SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(5) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINIT")
}

record(bo, "ACSW:B34:NW04:5SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(5) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINIT")
}

record(stringin, "ACSW:B34:NW04:5INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW04:5INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW04:5INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW04:5INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW04:5INITSTATE")
}

record(mbbi, "ACSW:B34:NW04:5INITSTATE") {
#  field(SDIS, "ACSW:B34:NW04:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW04:5INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW04:6NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW04:6POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW04:6POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW04:6POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW04:6POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW04:6POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW04:6POWERSTATE")
}

record(mbbi, "ACSW:B34:NW04:6POWERSTATE") {
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW04:6POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW04:6POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(6) acsw-b34-nw04")
}

record(bo, "ACSW:B34:NW04:6POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(6) acsw-b34-nw04")
}

record(bo, "ACSW:B34:NW04:6HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(6) acsw-b34-nw04")
}

record(stringin, "ACSW:B34:NW04:6NAMESET") {
  field(FLNK, "ACSW:B34:NW04:6NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW04:6NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(6) acsw-b34-nw04")
  field(DOL, "ACSW:B34:NW04:6NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW04:6SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(6) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINIT")
}

record(bo, "ACSW:B34:NW04:6SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(6) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINIT")
}

record(stringin, "ACSW:B34:NW04:6INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW04:6INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW04:6INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW04:6INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW04:6INITSTATE")
}

record(mbbi, "ACSW:B34:NW04:6INITSTATE") {
#  field(SDIS, "ACSW:B34:NW04:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW04:6INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW04:7NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW04:7POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW04:7POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW04:7POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW04:7POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW04:7POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW04:7POWERSTATE")
}

record(mbbi, "ACSW:B34:NW04:7POWERSTATE") {
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW04:7POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW04:7POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(7) acsw-b34-nw04")
}

record(bo, "ACSW:B34:NW04:7POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(7) acsw-b34-nw04")
}

record(bo, "ACSW:B34:NW04:7HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(7) acsw-b34-nw04")
}

record(stringin, "ACSW:B34:NW04:7NAMESET") {
  field(FLNK, "ACSW:B34:NW04:7NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW04:7NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(7) acsw-b34-nw04")
  field(DOL, "ACSW:B34:NW04:7NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW04:7SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(7) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINIT")
}

record(bo, "ACSW:B34:NW04:7SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(7) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINIT")
}

record(stringin, "ACSW:B34:NW04:7INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW04:7INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW04:7INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW04:7INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW04:7INITSTATE")
}

record(mbbi, "ACSW:B34:NW04:7INITSTATE") {
#  field(SDIS, "ACSW:B34:NW04:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW04:7INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW04:8NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW04:8POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW04:8POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW04:8POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW04:8POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW04:8POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW04:8POWERSTATE")
}

record(mbbi, "ACSW:B34:NW04:8POWERSTATE") {
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW04:8POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW04:8POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(8) acsw-b34-nw04")
}

record(bo, "ACSW:B34:NW04:8POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(8) acsw-b34-nw04")
}

record(bo, "ACSW:B34:NW04:8HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(8) acsw-b34-nw04")
}

record(stringin, "ACSW:B34:NW04:8NAMESET") {
  field(FLNK, "ACSW:B34:NW04:8NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW04:8NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(8) acsw-b34-nw04")
  field(DOL, "ACSW:B34:NW04:8NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW04:8SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(8) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINIT")
}

record(bo, "ACSW:B34:NW04:8SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(8) acsw-b34-nw04")
  field(FLNK, "ACSW:B34:NW04:GETINIT")
}

record(stringin, "ACSW:B34:NW04:8INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW04:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW04:8INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW04:8INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW04:8INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW04:8INITSTATE")
}

record(mbbi, "ACSW:B34:NW04:8INITSTATE") {
#  field(SDIS, "ACSW:B34:NW04:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW04:8INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW06:LOGIN") {
  field(PINI, "YES")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db setLogin(ACSW:B34:NW06) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINFO")
}

record(stringin, "ACSW:B34:NW06:GETINFO") {
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getInfo(ACSW:B34:NW06) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINIT")
}

record(stringin, "ACSW:B34:NW06:FWVERSION") {
  field(SCAN, "10 second")
  field(FLNK, "ACSW:B34:NW06:NETFWVERSION")
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B34:NW06:NETFWVERSION") {
  field(DESC, "Network adapter fw vers")
  field(FLNK, "ACSW:B34:NW06:SITEID")
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B34:NW06:SITEID") {
  field(DESC, "ACSW node name")
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")

}

record(bo, "ACSW:B34:NW06:GETINIT") {
  field(DESC, "Get outlet init states")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db getOutletInitState8(ACSW:B34:NW06) acsw-b34-nw06")
}

record(stringin, "ACSW:B34:NW06:GETSTATUS") {
  field(SCAN, "2 second")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getOutletState8(ACSW:B34:NW06) acsw-b34-nw06")
}

record(ai, "ACSW:B34:NW06:TYPE") {
  field(DESC, "APC 8 Port AC Power Switch")
  field(PINI, "YES")
  field(VAL, "10")
}

record(stringin, "ACSW:B34:NW06:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM197")
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
  info(autosaveFields,"VAL")
}

record(bo, "ACSW:B34:NW06:DISCONN") {
  field(DESC, "Disconn to allow access")
  field(DISA, "1")
  field(DISS, "NO_ALARM")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setDisconnect acsw-b34-nw06")
}

record(calcout, "ACSW:B34:NW06:CONNCALC") {
  field(CALC, "A=B && C#D")
  field(SCAN, "2 second")
  field(INPA, "ACSW:B34:NW06:DISCONN.DISA")
  field(INPB, "ACSW:B34:NW06:DISCONN.DISV")
  field(INPC, "ACSW:B34:NW06:GETSTATUS.DISA")
  field(INPD, "ACSW:B34:NW06:GETSTATUS.DISV")
  field(OOPT, "On Change")
  field(OUT, "ACSW:B34:NW06:CONNSTA PP")
}

record(bi, "ACSW:B34:NW06:CONNSTA") {
  field(ZNAM, "Not connected")
  field(ONAM, "Connected")
  field(ZSV, "MINOR")
  field(OSV, "NO_ALARM")
}

# Disconnect from ACSW to allow
# other clients access to ACSW
record(seq, "ACSW:B34:NW06:ACCSTART") {
  field(SELM, "All")
  field(DOL1, "1")
  field(LNK1, "ACSW:B34:NW06:GETSTATUS.DISA")
  field(DOL2, "0")
  field(LNK2, "ACSW:B34:NW06:DISCONN.DISA PP")
}

# Reconnect to ACSW
record(seq, "ACSW:B34:NW06:ACCSTOP") {
  field(SELM, "All")
  field(DOL1, "0")
  field(LNK1, "ACSW:B34:NW06:GETSTATUS.DISA")
  field(DOL2, "1")
  field(LNK2, "ACSW:B34:NW06:DISCONN.DISA")
}

#Not in use since using CLI
record(ai, "ACSW:B34:NW06:UPTIMEHOUR") {
  field(FLNK, "ACSW:B34:NW06:UPTIMEMINUTE")
  field(EGU, "Hours")
}
record(ai, "ACSW:B34:NW06:UPTIMEDAY") {
  field(FLNK, "ACSW:B34:NW06:UPTIMEHOUR")
  field(EGU, "Days")
}
record(ai, "ACSW:B34:NW06:UPTIMEMINUTE") {
  field(FLNK, "ACSW:B34:NW06:1NAME")
  field(EGU, "Minutes")
}

record(stringin, "ACSW:B34:NW06:1NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW06:1POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW06:1POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW06:1POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW06:1POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW06:1POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW06:1POWERSTATE")
}

record(mbbi, "ACSW:B34:NW06:1POWERSTATE") {
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW06:1POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW06:1POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(1) acsw-b34-nw06")
}

record(bo, "ACSW:B34:NW06:1POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(1) acsw-b34-nw06")
}

record(bo, "ACSW:B34:NW06:1HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(1) acsw-b34-nw06")
}

record(stringin, "ACSW:B34:NW06:1NAMESET") {
  field(FLNK, "ACSW:B34:NW06:1NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW06:1NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(1) acsw-b34-nw06")
  field(DOL, "ACSW:B34:NW06:1NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW06:1SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(1) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINIT")
}

record(bo, "ACSW:B34:NW06:1SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(1) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINIT")
}

record(stringin, "ACSW:B34:NW06:1INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW06:1INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW06:1INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW06:1INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW06:1INITSTATE")
}

record(mbbi, "ACSW:B34:NW06:1INITSTATE") {
#  field(SDIS, "ACSW:B34:NW06:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW06:1INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW06:2NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW06:2POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW06:2POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW06:2POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW06:2POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW06:2POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW06:2POWERSTATE")
}

record(mbbi, "ACSW:B34:NW06:2POWERSTATE") {
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW06:2POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW06:2POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(2) acsw-b34-nw06")
}

record(bo, "ACSW:B34:NW06:2POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(2) acsw-b34-nw06")
}

record(bo, "ACSW:B34:NW06:2HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(2) acsw-b34-nw06")
}

record(stringin, "ACSW:B34:NW06:2NAMESET") {
  field(FLNK, "ACSW:B34:NW06:2NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW06:2NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(2) acsw-b34-nw06")
  field(DOL, "ACSW:B34:NW06:2NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW06:2SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(2) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINIT")
}

record(bo, "ACSW:B34:NW06:2SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(2) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINIT")
}

record(stringin, "ACSW:B34:NW06:2INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW06:2INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW06:2INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW06:2INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW06:2INITSTATE")
}

record(mbbi, "ACSW:B34:NW06:2INITSTATE") {
#  field(SDIS, "ACSW:B34:NW06:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW06:2INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW06:3NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW06:3POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW06:3POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW06:3POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW06:3POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW06:3POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW06:3POWERSTATE")
}

record(mbbi, "ACSW:B34:NW06:3POWERSTATE") {
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW06:3POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW06:3POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(3) acsw-b34-nw06")
}

record(bo, "ACSW:B34:NW06:3POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(3) acsw-b34-nw06")
}

record(bo, "ACSW:B34:NW06:3HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(3) acsw-b34-nw06")
}

record(stringin, "ACSW:B34:NW06:3NAMESET") {
  field(FLNK, "ACSW:B34:NW06:3NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW06:3NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(3) acsw-b34-nw06")
  field(DOL, "ACSW:B34:NW06:3NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW06:3SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(3) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINIT")
}

record(bo, "ACSW:B34:NW06:3SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(3) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINIT")
}

record(stringin, "ACSW:B34:NW06:3INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW06:3INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW06:3INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW06:3INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW06:3INITSTATE")
}

record(mbbi, "ACSW:B34:NW06:3INITSTATE") {
#  field(SDIS, "ACSW:B34:NW06:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW06:3INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW06:4NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW06:4POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW06:4POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW06:4POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW06:4POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW06:4POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW06:4POWERSTATE")
}

record(mbbi, "ACSW:B34:NW06:4POWERSTATE") {
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW06:4POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW06:4POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(4) acsw-b34-nw06")
}

record(bo, "ACSW:B34:NW06:4POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(4) acsw-b34-nw06")
}

record(bo, "ACSW:B34:NW06:4HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(4) acsw-b34-nw06")
}

record(stringin, "ACSW:B34:NW06:4NAMESET") {
  field(FLNK, "ACSW:B34:NW06:4NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW06:4NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(4) acsw-b34-nw06")
  field(DOL, "ACSW:B34:NW06:4NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW06:4SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(4) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINIT")
}

record(bo, "ACSW:B34:NW06:4SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(4) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINIT")
}

record(stringin, "ACSW:B34:NW06:4INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW06:4INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW06:4INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW06:4INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW06:4INITSTATE")
}

record(mbbi, "ACSW:B34:NW06:4INITSTATE") {
#  field(SDIS, "ACSW:B34:NW06:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW06:4INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW06:5NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW06:5POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW06:5POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW06:5POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW06:5POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW06:5POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW06:5POWERSTATE")
}

record(mbbi, "ACSW:B34:NW06:5POWERSTATE") {
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW06:5POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW06:5POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(5) acsw-b34-nw06")
}

record(bo, "ACSW:B34:NW06:5POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(5) acsw-b34-nw06")
}

record(bo, "ACSW:B34:NW06:5HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(5) acsw-b34-nw06")
}

record(stringin, "ACSW:B34:NW06:5NAMESET") {
  field(FLNK, "ACSW:B34:NW06:5NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW06:5NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(5) acsw-b34-nw06")
  field(DOL, "ACSW:B34:NW06:5NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW06:5SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(5) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINIT")
}

record(bo, "ACSW:B34:NW06:5SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(5) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINIT")
}

record(stringin, "ACSW:B34:NW06:5INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW06:5INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW06:5INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW06:5INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW06:5INITSTATE")
}

record(mbbi, "ACSW:B34:NW06:5INITSTATE") {
#  field(SDIS, "ACSW:B34:NW06:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW06:5INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW06:6NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW06:6POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW06:6POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW06:6POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW06:6POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW06:6POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW06:6POWERSTATE")
}

record(mbbi, "ACSW:B34:NW06:6POWERSTATE") {
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW06:6POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW06:6POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(6) acsw-b34-nw06")
}

record(bo, "ACSW:B34:NW06:6POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(6) acsw-b34-nw06")
}

record(bo, "ACSW:B34:NW06:6HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(6) acsw-b34-nw06")
}

record(stringin, "ACSW:B34:NW06:6NAMESET") {
  field(FLNK, "ACSW:B34:NW06:6NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW06:6NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(6) acsw-b34-nw06")
  field(DOL, "ACSW:B34:NW06:6NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW06:6SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(6) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINIT")
}

record(bo, "ACSW:B34:NW06:6SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(6) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINIT")
}

record(stringin, "ACSW:B34:NW06:6INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW06:6INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW06:6INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW06:6INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW06:6INITSTATE")
}

record(mbbi, "ACSW:B34:NW06:6INITSTATE") {
#  field(SDIS, "ACSW:B34:NW06:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW06:6INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW06:7NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW06:7POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW06:7POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW06:7POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW06:7POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW06:7POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW06:7POWERSTATE")
}

record(mbbi, "ACSW:B34:NW06:7POWERSTATE") {
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW06:7POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW06:7POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(7) acsw-b34-nw06")
}

record(bo, "ACSW:B34:NW06:7POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(7) acsw-b34-nw06")
}

record(bo, "ACSW:B34:NW06:7HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(7) acsw-b34-nw06")
}

record(stringin, "ACSW:B34:NW06:7NAMESET") {
  field(FLNK, "ACSW:B34:NW06:7NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW06:7NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(7) acsw-b34-nw06")
  field(DOL, "ACSW:B34:NW06:7NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW06:7SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(7) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINIT")
}

record(bo, "ACSW:B34:NW06:7SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(7) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINIT")
}

record(stringin, "ACSW:B34:NW06:7INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW06:7INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW06:7INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW06:7INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW06:7INITSTATE")
}

record(mbbi, "ACSW:B34:NW06:7INITSTATE") {
#  field(SDIS, "ACSW:B34:NW06:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW06:7INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW06:8NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW06:8POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW06:8POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW06:8POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW06:8POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW06:8POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW06:8POWERSTATE")
}

record(mbbi, "ACSW:B34:NW06:8POWERSTATE") {
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW06:8POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW06:8POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(8) acsw-b34-nw06")
}

record(bo, "ACSW:B34:NW06:8POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(8) acsw-b34-nw06")
}

record(bo, "ACSW:B34:NW06:8HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(8) acsw-b34-nw06")
}

record(stringin, "ACSW:B34:NW06:8NAMESET") {
  field(FLNK, "ACSW:B34:NW06:8NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW06:8NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(8) acsw-b34-nw06")
  field(DOL, "ACSW:B34:NW06:8NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW06:8SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(8) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINIT")
}

record(bo, "ACSW:B34:NW06:8SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(8) acsw-b34-nw06")
  field(FLNK, "ACSW:B34:NW06:GETINIT")
}

record(stringin, "ACSW:B34:NW06:8INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW06:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW06:8INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW06:8INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW06:8INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW06:8INITSTATE")
}

record(mbbi, "ACSW:B34:NW06:8INITSTATE") {
#  field(SDIS, "ACSW:B34:NW06:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW06:8INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW07:LOGIN") {
  field(PINI, "YES")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db setLogin(ACSW:B34:NW07) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINFO")
}

record(stringin, "ACSW:B34:NW07:GETINFO") {
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getInfo(ACSW:B34:NW07) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINIT")
}

record(stringin, "ACSW:B34:NW07:FWVERSION") {
  field(SCAN, "10 second")
  field(FLNK, "ACSW:B34:NW07:NETFWVERSION")
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B34:NW07:NETFWVERSION") {
  field(DESC, "Network adapter fw vers")
  field(FLNK, "ACSW:B34:NW07:SITEID")
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B34:NW07:SITEID") {
  field(DESC, "ACSW node name")
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")

}

record(bo, "ACSW:B34:NW07:GETINIT") {
  field(DESC, "Get outlet init states")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db getOutletInitState8(ACSW:B34:NW07) acsw-b34-nw07")
}

record(stringin, "ACSW:B34:NW07:GETSTATUS") {
  field(SCAN, "2 second")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getOutletState8(ACSW:B34:NW07) acsw-b34-nw07")
}

record(ai, "ACSW:B34:NW07:TYPE") {
  field(DESC, "APC 8 Port AC Power Switch")
  field(PINI, "YES")
  field(VAL, "10")
}

record(stringin, "ACSW:B34:NW07:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-RM137-LAB")
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
  info(autosaveFields,"VAL")
}

record(bo, "ACSW:B34:NW07:DISCONN") {
  field(DESC, "Disconn to allow access")
  field(DISA, "1")
  field(DISS, "NO_ALARM")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setDisconnect acsw-b34-nw07")
}

record(calcout, "ACSW:B34:NW07:CONNCALC") {
  field(CALC, "A=B && C#D")
  field(SCAN, "2 second")
  field(INPA, "ACSW:B34:NW07:DISCONN.DISA")
  field(INPB, "ACSW:B34:NW07:DISCONN.DISV")
  field(INPC, "ACSW:B34:NW07:GETSTATUS.DISA")
  field(INPD, "ACSW:B34:NW07:GETSTATUS.DISV")
  field(OOPT, "On Change")
  field(OUT, "ACSW:B34:NW07:CONNSTA PP")
}

record(bi, "ACSW:B34:NW07:CONNSTA") {
  field(ZNAM, "Not connected")
  field(ONAM, "Connected")
  field(ZSV, "MINOR")
  field(OSV, "NO_ALARM")
}

# Disconnect from ACSW to allow
# other clients access to ACSW
record(seq, "ACSW:B34:NW07:ACCSTART") {
  field(SELM, "All")
  field(DOL1, "1")
  field(LNK1, "ACSW:B34:NW07:GETSTATUS.DISA")
  field(DOL2, "0")
  field(LNK2, "ACSW:B34:NW07:DISCONN.DISA PP")
}

# Reconnect to ACSW
record(seq, "ACSW:B34:NW07:ACCSTOP") {
  field(SELM, "All")
  field(DOL1, "0")
  field(LNK1, "ACSW:B34:NW07:GETSTATUS.DISA")
  field(DOL2, "1")
  field(LNK2, "ACSW:B34:NW07:DISCONN.DISA")
}

#Not in use since using CLI
record(ai, "ACSW:B34:NW07:UPTIMEHOUR") {
  field(FLNK, "ACSW:B34:NW07:UPTIMEMINUTE")
  field(EGU, "Hours")
}
record(ai, "ACSW:B34:NW07:UPTIMEDAY") {
  field(FLNK, "ACSW:B34:NW07:UPTIMEHOUR")
  field(EGU, "Days")
}
record(ai, "ACSW:B34:NW07:UPTIMEMINUTE") {
  field(FLNK, "ACSW:B34:NW07:1NAME")
  field(EGU, "Minutes")
}

record(stringin, "ACSW:B34:NW07:1NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW07:1POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW07:1POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW07:1POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW07:1POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW07:1POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW07:1POWERSTATE")
}

record(mbbi, "ACSW:B34:NW07:1POWERSTATE") {
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW07:1POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW07:1POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(1) acsw-b34-nw07")
}

record(bo, "ACSW:B34:NW07:1POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(1) acsw-b34-nw07")
}

record(bo, "ACSW:B34:NW07:1HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(1) acsw-b34-nw07")
}

record(stringin, "ACSW:B34:NW07:1NAMESET") {
  field(FLNK, "ACSW:B34:NW07:1NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW07:1NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(1) acsw-b34-nw07")
  field(DOL, "ACSW:B34:NW07:1NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW07:1SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(1) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINIT")
}

record(bo, "ACSW:B34:NW07:1SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(1) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINIT")
}

record(stringin, "ACSW:B34:NW07:1INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW07:1INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW07:1INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW07:1INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW07:1INITSTATE")
}

record(mbbi, "ACSW:B34:NW07:1INITSTATE") {
#  field(SDIS, "ACSW:B34:NW07:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW07:1INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW07:2NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW07:2POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW07:2POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW07:2POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW07:2POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW07:2POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW07:2POWERSTATE")
}

record(mbbi, "ACSW:B34:NW07:2POWERSTATE") {
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW07:2POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW07:2POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(2) acsw-b34-nw07")
}

record(bo, "ACSW:B34:NW07:2POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(2) acsw-b34-nw07")
}

record(bo, "ACSW:B34:NW07:2HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(2) acsw-b34-nw07")
}

record(stringin, "ACSW:B34:NW07:2NAMESET") {
  field(FLNK, "ACSW:B34:NW07:2NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW07:2NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(2) acsw-b34-nw07")
  field(DOL, "ACSW:B34:NW07:2NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW07:2SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(2) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINIT")
}

record(bo, "ACSW:B34:NW07:2SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(2) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINIT")
}

record(stringin, "ACSW:B34:NW07:2INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW07:2INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW07:2INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW07:2INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW07:2INITSTATE")
}

record(mbbi, "ACSW:B34:NW07:2INITSTATE") {
#  field(SDIS, "ACSW:B34:NW07:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW07:2INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW07:3NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW07:3POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW07:3POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW07:3POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW07:3POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW07:3POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW07:3POWERSTATE")
}

record(mbbi, "ACSW:B34:NW07:3POWERSTATE") {
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW07:3POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW07:3POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(3) acsw-b34-nw07")
}

record(bo, "ACSW:B34:NW07:3POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(3) acsw-b34-nw07")
}

record(bo, "ACSW:B34:NW07:3HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(3) acsw-b34-nw07")
}

record(stringin, "ACSW:B34:NW07:3NAMESET") {
  field(FLNK, "ACSW:B34:NW07:3NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW07:3NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(3) acsw-b34-nw07")
  field(DOL, "ACSW:B34:NW07:3NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW07:3SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(3) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINIT")
}

record(bo, "ACSW:B34:NW07:3SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(3) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINIT")
}

record(stringin, "ACSW:B34:NW07:3INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW07:3INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW07:3INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW07:3INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW07:3INITSTATE")
}

record(mbbi, "ACSW:B34:NW07:3INITSTATE") {
#  field(SDIS, "ACSW:B34:NW07:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW07:3INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW07:4NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW07:4POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW07:4POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW07:4POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW07:4POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW07:4POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW07:4POWERSTATE")
}

record(mbbi, "ACSW:B34:NW07:4POWERSTATE") {
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW07:4POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW07:4POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(4) acsw-b34-nw07")
}

record(bo, "ACSW:B34:NW07:4POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(4) acsw-b34-nw07")
}

record(bo, "ACSW:B34:NW07:4HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(4) acsw-b34-nw07")
}

record(stringin, "ACSW:B34:NW07:4NAMESET") {
  field(FLNK, "ACSW:B34:NW07:4NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW07:4NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(4) acsw-b34-nw07")
  field(DOL, "ACSW:B34:NW07:4NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW07:4SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(4) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINIT")
}

record(bo, "ACSW:B34:NW07:4SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(4) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINIT")
}

record(stringin, "ACSW:B34:NW07:4INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW07:4INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW07:4INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW07:4INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW07:4INITSTATE")
}

record(mbbi, "ACSW:B34:NW07:4INITSTATE") {
#  field(SDIS, "ACSW:B34:NW07:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW07:4INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW07:5NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW07:5POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW07:5POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW07:5POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW07:5POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW07:5POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW07:5POWERSTATE")
}

record(mbbi, "ACSW:B34:NW07:5POWERSTATE") {
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW07:5POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW07:5POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(5) acsw-b34-nw07")
}

record(bo, "ACSW:B34:NW07:5POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(5) acsw-b34-nw07")
}

record(bo, "ACSW:B34:NW07:5HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(5) acsw-b34-nw07")
}

record(stringin, "ACSW:B34:NW07:5NAMESET") {
  field(FLNK, "ACSW:B34:NW07:5NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW07:5NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(5) acsw-b34-nw07")
  field(DOL, "ACSW:B34:NW07:5NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW07:5SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(5) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINIT")
}

record(bo, "ACSW:B34:NW07:5SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(5) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINIT")
}

record(stringin, "ACSW:B34:NW07:5INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW07:5INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW07:5INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW07:5INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW07:5INITSTATE")
}

record(mbbi, "ACSW:B34:NW07:5INITSTATE") {
#  field(SDIS, "ACSW:B34:NW07:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW07:5INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW07:6NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW07:6POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW07:6POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW07:6POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW07:6POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW07:6POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW07:6POWERSTATE")
}

record(mbbi, "ACSW:B34:NW07:6POWERSTATE") {
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW07:6POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW07:6POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(6) acsw-b34-nw07")
}

record(bo, "ACSW:B34:NW07:6POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(6) acsw-b34-nw07")
}

record(bo, "ACSW:B34:NW07:6HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(6) acsw-b34-nw07")
}

record(stringin, "ACSW:B34:NW07:6NAMESET") {
  field(FLNK, "ACSW:B34:NW07:6NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW07:6NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(6) acsw-b34-nw07")
  field(DOL, "ACSW:B34:NW07:6NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW07:6SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(6) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINIT")
}

record(bo, "ACSW:B34:NW07:6SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(6) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINIT")
}

record(stringin, "ACSW:B34:NW07:6INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW07:6INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW07:6INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW07:6INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW07:6INITSTATE")
}

record(mbbi, "ACSW:B34:NW07:6INITSTATE") {
#  field(SDIS, "ACSW:B34:NW07:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW07:6INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW07:7NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW07:7POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW07:7POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW07:7POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW07:7POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW07:7POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW07:7POWERSTATE")
}

record(mbbi, "ACSW:B34:NW07:7POWERSTATE") {
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW07:7POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW07:7POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(7) acsw-b34-nw07")
}

record(bo, "ACSW:B34:NW07:7POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(7) acsw-b34-nw07")
}

record(bo, "ACSW:B34:NW07:7HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(7) acsw-b34-nw07")
}

record(stringin, "ACSW:B34:NW07:7NAMESET") {
  field(FLNK, "ACSW:B34:NW07:7NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW07:7NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(7) acsw-b34-nw07")
  field(DOL, "ACSW:B34:NW07:7NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW07:7SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(7) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINIT")
}

record(bo, "ACSW:B34:NW07:7SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(7) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINIT")
}

record(stringin, "ACSW:B34:NW07:7INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW07:7INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW07:7INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW07:7INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW07:7INITSTATE")
}

record(mbbi, "ACSW:B34:NW07:7INITSTATE") {
#  field(SDIS, "ACSW:B34:NW07:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW07:7INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW07:8NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW07:8POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW07:8POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW07:8POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW07:8POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW07:8POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW07:8POWERSTATE")
}

record(mbbi, "ACSW:B34:NW07:8POWERSTATE") {
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW07:8POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW07:8POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(8) acsw-b34-nw07")
}

record(bo, "ACSW:B34:NW07:8POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(8) acsw-b34-nw07")
}

record(bo, "ACSW:B34:NW07:8HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(8) acsw-b34-nw07")
}

record(stringin, "ACSW:B34:NW07:8NAMESET") {
  field(FLNK, "ACSW:B34:NW07:8NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW07:8NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(8) acsw-b34-nw07")
  field(DOL, "ACSW:B34:NW07:8NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW07:8SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(8) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINIT")
}

record(bo, "ACSW:B34:NW07:8SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(8) acsw-b34-nw07")
  field(FLNK, "ACSW:B34:NW07:GETINIT")
}

record(stringin, "ACSW:B34:NW07:8INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW07:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW07:8INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW07:8INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW07:8INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW07:8INITSTATE")
}

record(mbbi, "ACSW:B34:NW07:8INITSTATE") {
#  field(SDIS, "ACSW:B34:NW07:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW07:8INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW09:LOGIN") {
  field(PINI, "YES")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db setLogin(ACSW:B34:NW09) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINFO")
}

record(stringin, "ACSW:B34:NW09:GETINFO") {
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getInfo(ACSW:B34:NW09) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINIT")
}

record(stringin, "ACSW:B34:NW09:FWVERSION") {
  field(SCAN, "10 second")
  field(FLNK, "ACSW:B34:NW09:NETFWVERSION")
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B34:NW09:NETFWVERSION") {
  field(DESC, "Network adapter fw vers")
  field(FLNK, "ACSW:B34:NW09:SITEID")
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B34:NW09:SITEID") {
  field(DESC, "ACSW node name")
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")

}

record(bo, "ACSW:B34:NW09:GETINIT") {
  field(DESC, "Get outlet init states")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db getOutletInitState8(ACSW:B34:NW09) acsw-b34-nw09")
}

record(stringin, "ACSW:B34:NW09:GETSTATUS") {
  field(SCAN, "2 second")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getOutletState8(ACSW:B34:NW09) acsw-b34-nw09")
}

record(ai, "ACSW:B34:NW09:TYPE") {
  field(DESC, "APC 8 Port AC Power Switch")
  field(PINI, "YES")
  field(VAL, "10")
}

record(stringin, "ACSW:B34:NW09:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-LAB196-MCR03-38")
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
  info(autosaveFields,"VAL")
}

record(bo, "ACSW:B34:NW09:DISCONN") {
  field(DESC, "Disconn to allow access")
  field(DISA, "1")
  field(DISS, "NO_ALARM")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setDisconnect acsw-b34-nw09")
}

record(calcout, "ACSW:B34:NW09:CONNCALC") {
  field(CALC, "A=B && C#D")
  field(SCAN, "2 second")
  field(INPA, "ACSW:B34:NW09:DISCONN.DISA")
  field(INPB, "ACSW:B34:NW09:DISCONN.DISV")
  field(INPC, "ACSW:B34:NW09:GETSTATUS.DISA")
  field(INPD, "ACSW:B34:NW09:GETSTATUS.DISV")
  field(OOPT, "On Change")
  field(OUT, "ACSW:B34:NW09:CONNSTA PP")
}

record(bi, "ACSW:B34:NW09:CONNSTA") {
  field(ZNAM, "Not connected")
  field(ONAM, "Connected")
  field(ZSV, "MINOR")
  field(OSV, "NO_ALARM")
}

# Disconnect from ACSW to allow
# other clients access to ACSW
record(seq, "ACSW:B34:NW09:ACCSTART") {
  field(SELM, "All")
  field(DOL1, "1")
  field(LNK1, "ACSW:B34:NW09:GETSTATUS.DISA")
  field(DOL2, "0")
  field(LNK2, "ACSW:B34:NW09:DISCONN.DISA PP")
}

# Reconnect to ACSW
record(seq, "ACSW:B34:NW09:ACCSTOP") {
  field(SELM, "All")
  field(DOL1, "0")
  field(LNK1, "ACSW:B34:NW09:GETSTATUS.DISA")
  field(DOL2, "1")
  field(LNK2, "ACSW:B34:NW09:DISCONN.DISA")
}

#Not in use since using CLI
record(ai, "ACSW:B34:NW09:UPTIMEHOUR") {
  field(FLNK, "ACSW:B34:NW09:UPTIMEMINUTE")
  field(EGU, "Hours")
}
record(ai, "ACSW:B34:NW09:UPTIMEDAY") {
  field(FLNK, "ACSW:B34:NW09:UPTIMEHOUR")
  field(EGU, "Days")
}
record(ai, "ACSW:B34:NW09:UPTIMEMINUTE") {
  field(FLNK, "ACSW:B34:NW09:1NAME")
  field(EGU, "Minutes")
}

record(stringin, "ACSW:B34:NW09:1NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW09:1POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW09:1POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW09:1POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW09:1POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW09:1POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW09:1POWERSTATE")
}

record(mbbi, "ACSW:B34:NW09:1POWERSTATE") {
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW09:1POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW09:1POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(1) acsw-b34-nw09")
}

record(bo, "ACSW:B34:NW09:1POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(1) acsw-b34-nw09")
}

record(bo, "ACSW:B34:NW09:1HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(1) acsw-b34-nw09")
}

record(stringin, "ACSW:B34:NW09:1NAMESET") {
  field(FLNK, "ACSW:B34:NW09:1NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW09:1NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(1) acsw-b34-nw09")
  field(DOL, "ACSW:B34:NW09:1NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW09:1SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(1) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINIT")
}

record(bo, "ACSW:B34:NW09:1SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(1) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINIT")
}

record(stringin, "ACSW:B34:NW09:1INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW09:1INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW09:1INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW09:1INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW09:1INITSTATE")
}

record(mbbi, "ACSW:B34:NW09:1INITSTATE") {
#  field(SDIS, "ACSW:B34:NW09:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW09:1INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW09:2NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW09:2POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW09:2POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW09:2POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW09:2POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW09:2POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW09:2POWERSTATE")
}

record(mbbi, "ACSW:B34:NW09:2POWERSTATE") {
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW09:2POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW09:2POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(2) acsw-b34-nw09")
}

record(bo, "ACSW:B34:NW09:2POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(2) acsw-b34-nw09")
}

record(bo, "ACSW:B34:NW09:2HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(2) acsw-b34-nw09")
}

record(stringin, "ACSW:B34:NW09:2NAMESET") {
  field(FLNK, "ACSW:B34:NW09:2NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW09:2NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(2) acsw-b34-nw09")
  field(DOL, "ACSW:B34:NW09:2NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW09:2SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(2) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINIT")
}

record(bo, "ACSW:B34:NW09:2SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(2) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINIT")
}

record(stringin, "ACSW:B34:NW09:2INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW09:2INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW09:2INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW09:2INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW09:2INITSTATE")
}

record(mbbi, "ACSW:B34:NW09:2INITSTATE") {
#  field(SDIS, "ACSW:B34:NW09:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW09:2INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW09:3NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW09:3POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW09:3POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW09:3POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW09:3POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW09:3POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW09:3POWERSTATE")
}

record(mbbi, "ACSW:B34:NW09:3POWERSTATE") {
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW09:3POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW09:3POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(3) acsw-b34-nw09")
}

record(bo, "ACSW:B34:NW09:3POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(3) acsw-b34-nw09")
}

record(bo, "ACSW:B34:NW09:3HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(3) acsw-b34-nw09")
}

record(stringin, "ACSW:B34:NW09:3NAMESET") {
  field(FLNK, "ACSW:B34:NW09:3NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW09:3NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(3) acsw-b34-nw09")
  field(DOL, "ACSW:B34:NW09:3NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW09:3SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(3) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINIT")
}

record(bo, "ACSW:B34:NW09:3SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(3) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINIT")
}

record(stringin, "ACSW:B34:NW09:3INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW09:3INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW09:3INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW09:3INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW09:3INITSTATE")
}

record(mbbi, "ACSW:B34:NW09:3INITSTATE") {
#  field(SDIS, "ACSW:B34:NW09:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW09:3INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW09:4NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW09:4POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW09:4POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW09:4POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW09:4POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW09:4POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW09:4POWERSTATE")
}

record(mbbi, "ACSW:B34:NW09:4POWERSTATE") {
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW09:4POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW09:4POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(4) acsw-b34-nw09")
}

record(bo, "ACSW:B34:NW09:4POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(4) acsw-b34-nw09")
}

record(bo, "ACSW:B34:NW09:4HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(4) acsw-b34-nw09")
}

record(stringin, "ACSW:B34:NW09:4NAMESET") {
  field(FLNK, "ACSW:B34:NW09:4NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW09:4NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(4) acsw-b34-nw09")
  field(DOL, "ACSW:B34:NW09:4NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW09:4SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(4) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINIT")
}

record(bo, "ACSW:B34:NW09:4SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(4) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINIT")
}

record(stringin, "ACSW:B34:NW09:4INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW09:4INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW09:4INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW09:4INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW09:4INITSTATE")
}

record(mbbi, "ACSW:B34:NW09:4INITSTATE") {
#  field(SDIS, "ACSW:B34:NW09:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW09:4INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW09:5NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW09:5POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW09:5POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW09:5POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW09:5POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW09:5POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW09:5POWERSTATE")
}

record(mbbi, "ACSW:B34:NW09:5POWERSTATE") {
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW09:5POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW09:5POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(5) acsw-b34-nw09")
}

record(bo, "ACSW:B34:NW09:5POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(5) acsw-b34-nw09")
}

record(bo, "ACSW:B34:NW09:5HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(5) acsw-b34-nw09")
}

record(stringin, "ACSW:B34:NW09:5NAMESET") {
  field(FLNK, "ACSW:B34:NW09:5NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW09:5NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(5) acsw-b34-nw09")
  field(DOL, "ACSW:B34:NW09:5NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW09:5SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(5) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINIT")
}

record(bo, "ACSW:B34:NW09:5SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(5) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINIT")
}

record(stringin, "ACSW:B34:NW09:5INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW09:5INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW09:5INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW09:5INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW09:5INITSTATE")
}

record(mbbi, "ACSW:B34:NW09:5INITSTATE") {
#  field(SDIS, "ACSW:B34:NW09:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW09:5INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW09:6NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW09:6POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW09:6POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW09:6POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW09:6POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW09:6POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW09:6POWERSTATE")
}

record(mbbi, "ACSW:B34:NW09:6POWERSTATE") {
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW09:6POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW09:6POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(6) acsw-b34-nw09")
}

record(bo, "ACSW:B34:NW09:6POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(6) acsw-b34-nw09")
}

record(bo, "ACSW:B34:NW09:6HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(6) acsw-b34-nw09")
}

record(stringin, "ACSW:B34:NW09:6NAMESET") {
  field(FLNK, "ACSW:B34:NW09:6NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW09:6NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(6) acsw-b34-nw09")
  field(DOL, "ACSW:B34:NW09:6NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW09:6SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(6) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINIT")
}

record(bo, "ACSW:B34:NW09:6SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(6) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINIT")
}

record(stringin, "ACSW:B34:NW09:6INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW09:6INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW09:6INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW09:6INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW09:6INITSTATE")
}

record(mbbi, "ACSW:B34:NW09:6INITSTATE") {
#  field(SDIS, "ACSW:B34:NW09:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW09:6INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW09:7NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW09:7POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW09:7POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW09:7POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW09:7POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW09:7POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW09:7POWERSTATE")
}

record(mbbi, "ACSW:B34:NW09:7POWERSTATE") {
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW09:7POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW09:7POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(7) acsw-b34-nw09")
}

record(bo, "ACSW:B34:NW09:7POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(7) acsw-b34-nw09")
}

record(bo, "ACSW:B34:NW09:7HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(7) acsw-b34-nw09")
}

record(stringin, "ACSW:B34:NW09:7NAMESET") {
  field(FLNK, "ACSW:B34:NW09:7NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW09:7NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(7) acsw-b34-nw09")
  field(DOL, "ACSW:B34:NW09:7NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW09:7SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(7) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINIT")
}

record(bo, "ACSW:B34:NW09:7SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(7) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINIT")
}

record(stringin, "ACSW:B34:NW09:7INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW09:7INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW09:7INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW09:7INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW09:7INITSTATE")
}

record(mbbi, "ACSW:B34:NW09:7INITSTATE") {
#  field(SDIS, "ACSW:B34:NW09:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW09:7INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW09:8NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW09:8POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW09:8POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW09:8POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW09:8POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW09:8POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW09:8POWERSTATE")
}

record(mbbi, "ACSW:B34:NW09:8POWERSTATE") {
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW09:8POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW09:8POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(8) acsw-b34-nw09")
}

record(bo, "ACSW:B34:NW09:8POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(8) acsw-b34-nw09")
}

record(bo, "ACSW:B34:NW09:8HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(8) acsw-b34-nw09")
}

record(stringin, "ACSW:B34:NW09:8NAMESET") {
  field(FLNK, "ACSW:B34:NW09:8NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW09:8NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(8) acsw-b34-nw09")
  field(DOL, "ACSW:B34:NW09:8NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW09:8SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(8) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINIT")
}

record(bo, "ACSW:B34:NW09:8SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(8) acsw-b34-nw09")
  field(FLNK, "ACSW:B34:NW09:GETINIT")
}

record(stringin, "ACSW:B34:NW09:8INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW09:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW09:8INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW09:8INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW09:8INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW09:8INITSTATE")
}

record(mbbi, "ACSW:B34:NW09:8INITSTATE") {
#  field(SDIS, "ACSW:B34:NW09:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW09:8INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW12:LOGIN") {
  field(PINI, "YES")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db setLogin(ACSW:B34:NW12) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINFO")
}

record(stringin, "ACSW:B34:NW12:GETINFO") {
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getInfo(ACSW:B34:NW12) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINIT")
}

record(stringin, "ACSW:B34:NW12:FWVERSION") {
  field(SCAN, "10 second")
  field(FLNK, "ACSW:B34:NW12:NETFWVERSION")
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B34:NW12:NETFWVERSION") {
  field(DESC, "Network adapter fw vers")
  field(FLNK, "ACSW:B34:NW12:SITEID")
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B34:NW12:SITEID") {
  field(DESC, "ACSW node name")
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")

}

record(bo, "ACSW:B34:NW12:GETINIT") {
  field(DESC, "Get outlet init states")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db getOutletInitState8(ACSW:B34:NW12) acsw-b34-nw12")
}

record(stringin, "ACSW:B34:NW12:GETSTATUS") {
  field(SCAN, "2 second")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getOutletState8(ACSW:B34:NW12) acsw-b34-nw12")
}

record(ai, "ACSW:B34:NW12:TYPE") {
  field(DESC, "APC 8 Port AC Power Switch")
  field(PINI, "YES")
  field(VAL, "10")
}

record(stringin, "ACSW:B34:NW12:LOC") {
  field(PINI, "YES")
  field(VAL, "B34-137")
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
  info(autosaveFields,"VAL")
}

record(bo, "ACSW:B34:NW12:DISCONN") {
  field(DESC, "Disconn to allow access")
  field(DISA, "1")
  field(DISS, "NO_ALARM")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setDisconnect acsw-b34-nw12")
}

record(calcout, "ACSW:B34:NW12:CONNCALC") {
  field(CALC, "A=B && C#D")
  field(SCAN, "2 second")
  field(INPA, "ACSW:B34:NW12:DISCONN.DISA")
  field(INPB, "ACSW:B34:NW12:DISCONN.DISV")
  field(INPC, "ACSW:B34:NW12:GETSTATUS.DISA")
  field(INPD, "ACSW:B34:NW12:GETSTATUS.DISV")
  field(OOPT, "On Change")
  field(OUT, "ACSW:B34:NW12:CONNSTA PP")
}

record(bi, "ACSW:B34:NW12:CONNSTA") {
  field(ZNAM, "Not connected")
  field(ONAM, "Connected")
  field(ZSV, "MINOR")
  field(OSV, "NO_ALARM")
}

# Disconnect from ACSW to allow
# other clients access to ACSW
record(seq, "ACSW:B34:NW12:ACCSTART") {
  field(SELM, "All")
  field(DOL1, "1")
  field(LNK1, "ACSW:B34:NW12:GETSTATUS.DISA")
  field(DOL2, "0")
  field(LNK2, "ACSW:B34:NW12:DISCONN.DISA PP")
}

# Reconnect to ACSW
record(seq, "ACSW:B34:NW12:ACCSTOP") {
  field(SELM, "All")
  field(DOL1, "0")
  field(LNK1, "ACSW:B34:NW12:GETSTATUS.DISA")
  field(DOL2, "1")
  field(LNK2, "ACSW:B34:NW12:DISCONN.DISA")
}

#Not in use since using CLI
record(ai, "ACSW:B34:NW12:UPTIMEHOUR") {
  field(FLNK, "ACSW:B34:NW12:UPTIMEMINUTE")
  field(EGU, "Hours")
}
record(ai, "ACSW:B34:NW12:UPTIMEDAY") {
  field(FLNK, "ACSW:B34:NW12:UPTIMEHOUR")
  field(EGU, "Days")
}
record(ai, "ACSW:B34:NW12:UPTIMEMINUTE") {
  field(FLNK, "ACSW:B34:NW12:1NAME")
  field(EGU, "Minutes")
}

record(stringin, "ACSW:B34:NW12:1NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW12:1POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW12:1POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW12:1POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW12:1POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW12:1POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW12:1POWERSTATE")
}

record(mbbi, "ACSW:B34:NW12:1POWERSTATE") {
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW12:1POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW12:1POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(1) acsw-b34-nw12")
}

record(bo, "ACSW:B34:NW12:1POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(1) acsw-b34-nw12")
}

record(bo, "ACSW:B34:NW12:1HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(1) acsw-b34-nw12")
}

record(stringin, "ACSW:B34:NW12:1NAMESET") {
  field(FLNK, "ACSW:B34:NW12:1NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW12:1NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(1) acsw-b34-nw12")
  field(DOL, "ACSW:B34:NW12:1NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW12:1SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(1) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINIT")
}

record(bo, "ACSW:B34:NW12:1SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(1) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINIT")
}

record(stringin, "ACSW:B34:NW12:1INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW12:1INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW12:1INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW12:1INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW12:1INITSTATE")
}

record(mbbi, "ACSW:B34:NW12:1INITSTATE") {
#  field(SDIS, "ACSW:B34:NW12:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW12:1INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW12:2NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW12:2POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW12:2POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW12:2POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW12:2POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW12:2POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW12:2POWERSTATE")
}

record(mbbi, "ACSW:B34:NW12:2POWERSTATE") {
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW12:2POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW12:2POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(2) acsw-b34-nw12")
}

record(bo, "ACSW:B34:NW12:2POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(2) acsw-b34-nw12")
}

record(bo, "ACSW:B34:NW12:2HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(2) acsw-b34-nw12")
}

record(stringin, "ACSW:B34:NW12:2NAMESET") {
  field(FLNK, "ACSW:B34:NW12:2NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW12:2NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(2) acsw-b34-nw12")
  field(DOL, "ACSW:B34:NW12:2NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW12:2SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(2) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINIT")
}

record(bo, "ACSW:B34:NW12:2SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(2) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINIT")
}

record(stringin, "ACSW:B34:NW12:2INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW12:2INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW12:2INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW12:2INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW12:2INITSTATE")
}

record(mbbi, "ACSW:B34:NW12:2INITSTATE") {
#  field(SDIS, "ACSW:B34:NW12:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW12:2INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW12:3NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW12:3POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW12:3POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW12:3POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW12:3POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW12:3POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW12:3POWERSTATE")
}

record(mbbi, "ACSW:B34:NW12:3POWERSTATE") {
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW12:3POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW12:3POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(3) acsw-b34-nw12")
}

record(bo, "ACSW:B34:NW12:3POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(3) acsw-b34-nw12")
}

record(bo, "ACSW:B34:NW12:3HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(3) acsw-b34-nw12")
}

record(stringin, "ACSW:B34:NW12:3NAMESET") {
  field(FLNK, "ACSW:B34:NW12:3NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW12:3NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(3) acsw-b34-nw12")
  field(DOL, "ACSW:B34:NW12:3NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW12:3SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(3) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINIT")
}

record(bo, "ACSW:B34:NW12:3SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(3) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINIT")
}

record(stringin, "ACSW:B34:NW12:3INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW12:3INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW12:3INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW12:3INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW12:3INITSTATE")
}

record(mbbi, "ACSW:B34:NW12:3INITSTATE") {
#  field(SDIS, "ACSW:B34:NW12:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW12:3INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW12:4NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW12:4POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW12:4POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW12:4POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW12:4POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW12:4POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW12:4POWERSTATE")
}

record(mbbi, "ACSW:B34:NW12:4POWERSTATE") {
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW12:4POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW12:4POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(4) acsw-b34-nw12")
}

record(bo, "ACSW:B34:NW12:4POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(4) acsw-b34-nw12")
}

record(bo, "ACSW:B34:NW12:4HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(4) acsw-b34-nw12")
}

record(stringin, "ACSW:B34:NW12:4NAMESET") {
  field(FLNK, "ACSW:B34:NW12:4NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW12:4NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(4) acsw-b34-nw12")
  field(DOL, "ACSW:B34:NW12:4NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW12:4SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(4) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINIT")
}

record(bo, "ACSW:B34:NW12:4SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(4) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINIT")
}

record(stringin, "ACSW:B34:NW12:4INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW12:4INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW12:4INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW12:4INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW12:4INITSTATE")
}

record(mbbi, "ACSW:B34:NW12:4INITSTATE") {
#  field(SDIS, "ACSW:B34:NW12:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW12:4INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW12:5NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW12:5POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW12:5POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW12:5POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW12:5POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW12:5POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW12:5POWERSTATE")
}

record(mbbi, "ACSW:B34:NW12:5POWERSTATE") {
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW12:5POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW12:5POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(5) acsw-b34-nw12")
}

record(bo, "ACSW:B34:NW12:5POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(5) acsw-b34-nw12")
}

record(bo, "ACSW:B34:NW12:5HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(5) acsw-b34-nw12")
}

record(stringin, "ACSW:B34:NW12:5NAMESET") {
  field(FLNK, "ACSW:B34:NW12:5NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW12:5NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(5) acsw-b34-nw12")
  field(DOL, "ACSW:B34:NW12:5NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW12:5SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(5) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINIT")
}

record(bo, "ACSW:B34:NW12:5SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(5) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINIT")
}

record(stringin, "ACSW:B34:NW12:5INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW12:5INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW12:5INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW12:5INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW12:5INITSTATE")
}

record(mbbi, "ACSW:B34:NW12:5INITSTATE") {
#  field(SDIS, "ACSW:B34:NW12:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW12:5INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW12:6NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW12:6POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW12:6POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW12:6POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW12:6POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW12:6POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW12:6POWERSTATE")
}

record(mbbi, "ACSW:B34:NW12:6POWERSTATE") {
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW12:6POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW12:6POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(6) acsw-b34-nw12")
}

record(bo, "ACSW:B34:NW12:6POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(6) acsw-b34-nw12")
}

record(bo, "ACSW:B34:NW12:6HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(6) acsw-b34-nw12")
}

record(stringin, "ACSW:B34:NW12:6NAMESET") {
  field(FLNK, "ACSW:B34:NW12:6NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW12:6NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(6) acsw-b34-nw12")
  field(DOL, "ACSW:B34:NW12:6NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW12:6SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(6) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINIT")
}

record(bo, "ACSW:B34:NW12:6SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(6) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINIT")
}

record(stringin, "ACSW:B34:NW12:6INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW12:6INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW12:6INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW12:6INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW12:6INITSTATE")
}

record(mbbi, "ACSW:B34:NW12:6INITSTATE") {
#  field(SDIS, "ACSW:B34:NW12:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW12:6INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW12:7NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW12:7POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW12:7POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW12:7POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW12:7POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW12:7POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW12:7POWERSTATE")
}

record(mbbi, "ACSW:B34:NW12:7POWERSTATE") {
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW12:7POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW12:7POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(7) acsw-b34-nw12")
}

record(bo, "ACSW:B34:NW12:7POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(7) acsw-b34-nw12")
}

record(bo, "ACSW:B34:NW12:7HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(7) acsw-b34-nw12")
}

record(stringin, "ACSW:B34:NW12:7NAMESET") {
  field(FLNK, "ACSW:B34:NW12:7NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW12:7NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(7) acsw-b34-nw12")
  field(DOL, "ACSW:B34:NW12:7NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW12:7SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(7) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINIT")
}

record(bo, "ACSW:B34:NW12:7SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(7) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINIT")
}

record(stringin, "ACSW:B34:NW12:7INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW12:7INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW12:7INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW12:7INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW12:7INITSTATE")
}

record(mbbi, "ACSW:B34:NW12:7INITSTATE") {
#  field(SDIS, "ACSW:B34:NW12:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW12:7INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B34:NW12:8NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW12:8POWERSTATEIN")
}

record(stringin, "ACSW:B34:NW12:8POWERSTATEIN") {
  field(FLNK, "ACSW:B34:NW12:8POWERSTATESV")
}

record(scalcout, "ACSW:B34:NW12:8POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B34:NW12:8POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B34:NW12:8POWERSTATE")
}

record(mbbi, "ACSW:B34:NW12:8POWERSTATE") {
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW12:8POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B34:NW12:8POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(8) acsw-b34-nw12")
}

record(bo, "ACSW:B34:NW12:8POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(8) acsw-b34-nw12")
}

record(bo, "ACSW:B34:NW12:8HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(8) acsw-b34-nw12")
}

record(stringin, "ACSW:B34:NW12:8NAMESET") {
  field(FLNK, "ACSW:B34:NW12:8NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B34:NW12:8NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(8) acsw-b34-nw12")
  field(DOL, "ACSW:B34:NW12:8NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B34:NW12:8SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(8) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINIT")
}

record(bo, "ACSW:B34:NW12:8SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(8) acsw-b34-nw12")
  field(FLNK, "ACSW:B34:NW12:GETINIT")
}

record(stringin, "ACSW:B34:NW12:8INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B34:NW12:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B34:NW12:8INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B34:NW12:8INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B34:NW12:8INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B34:NW12:8INITSTATE")
}

record(mbbi, "ACSW:B34:NW12:8INITSTATE") {
#  field(SDIS, "ACSW:B34:NW12:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B34:NW12:8INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B44:NW05:LOGIN") {
  field(PINI, "YES")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db setLogin(ACSW:B44:NW05) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINFO")
}

record(stringin, "ACSW:B44:NW05:GETINFO") {
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getInfo(ACSW:B44:NW05) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINIT")
}

record(stringin, "ACSW:B44:NW05:FWVERSION") {
  field(SCAN, "10 second")
  field(FLNK, "ACSW:B44:NW05:NETFWVERSION")
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B44:NW05:NETFWVERSION") {
  field(DESC, "Network adapter fw vers")
  field(FLNK, "ACSW:B44:NW05:SITEID")
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B44:NW05:SITEID") {
  field(DESC, "ACSW node name")
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")

}

record(bo, "ACSW:B44:NW05:GETINIT") {
  field(DESC, "Get outlet init states")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db getOutletInitState8(ACSW:B44:NW05) acsw-b44-nw05")
}

record(stringin, "ACSW:B44:NW05:GETSTATUS") {
  field(SCAN, "2 second")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getOutletState8(ACSW:B44:NW05) acsw-b44-nw05")
}

record(ai, "ACSW:B44:NW05:TYPE") {
  field(DESC, "APC 8 Port AC Power Switch")
  field(PINI, "YES")
  field(VAL, "10")
}

record(stringin, "ACSW:B44:NW05:LOC") {
  field(PINI, "YES")
  field(VAL, "B44-KLYSLAB_UPSTRS")
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
  info(autosaveFields,"VAL")
}

record(bo, "ACSW:B44:NW05:DISCONN") {
  field(DESC, "Disconn to allow access")
  field(DISA, "1")
  field(DISS, "NO_ALARM")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setDisconnect acsw-b44-nw05")
}

record(calcout, "ACSW:B44:NW05:CONNCALC") {
  field(CALC, "A=B && C#D")
  field(SCAN, "2 second")
  field(INPA, "ACSW:B44:NW05:DISCONN.DISA")
  field(INPB, "ACSW:B44:NW05:DISCONN.DISV")
  field(INPC, "ACSW:B44:NW05:GETSTATUS.DISA")
  field(INPD, "ACSW:B44:NW05:GETSTATUS.DISV")
  field(OOPT, "On Change")
  field(OUT, "ACSW:B44:NW05:CONNSTA PP")
}

record(bi, "ACSW:B44:NW05:CONNSTA") {
  field(ZNAM, "Not connected")
  field(ONAM, "Connected")
  field(ZSV, "MINOR")
  field(OSV, "NO_ALARM")
}

# Disconnect from ACSW to allow
# other clients access to ACSW
record(seq, "ACSW:B44:NW05:ACCSTART") {
  field(SELM, "All")
  field(DOL1, "1")
  field(LNK1, "ACSW:B44:NW05:GETSTATUS.DISA")
  field(DOL2, "0")
  field(LNK2, "ACSW:B44:NW05:DISCONN.DISA PP")
}

# Reconnect to ACSW
record(seq, "ACSW:B44:NW05:ACCSTOP") {
  field(SELM, "All")
  field(DOL1, "0")
  field(LNK1, "ACSW:B44:NW05:GETSTATUS.DISA")
  field(DOL2, "1")
  field(LNK2, "ACSW:B44:NW05:DISCONN.DISA")
}

#Not in use since using CLI
record(ai, "ACSW:B44:NW05:UPTIMEHOUR") {
  field(FLNK, "ACSW:B44:NW05:UPTIMEMINUTE")
  field(EGU, "Hours")
}
record(ai, "ACSW:B44:NW05:UPTIMEDAY") {
  field(FLNK, "ACSW:B44:NW05:UPTIMEHOUR")
  field(EGU, "Days")
}
record(ai, "ACSW:B44:NW05:UPTIMEMINUTE") {
  field(FLNK, "ACSW:B44:NW05:1NAME")
  field(EGU, "Minutes")
}

record(stringin, "ACSW:B44:NW05:1NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW05:1POWERSTATEIN")
}

record(stringin, "ACSW:B44:NW05:1POWERSTATEIN") {
  field(FLNK, "ACSW:B44:NW05:1POWERSTATESV")
}

record(scalcout, "ACSW:B44:NW05:1POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B44:NW05:1POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B44:NW05:1POWERSTATE")
}

record(mbbi, "ACSW:B44:NW05:1POWERSTATE") {
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW05:1POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B44:NW05:1POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(1) acsw-b44-nw05")
}

record(bo, "ACSW:B44:NW05:1POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(1) acsw-b44-nw05")
}

record(bo, "ACSW:B44:NW05:1HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(1) acsw-b44-nw05")
}

record(stringin, "ACSW:B44:NW05:1NAMESET") {
  field(FLNK, "ACSW:B44:NW05:1NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B44:NW05:1NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(1) acsw-b44-nw05")
  field(DOL, "ACSW:B44:NW05:1NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B44:NW05:1SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(1) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINIT")
}

record(bo, "ACSW:B44:NW05:1SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(1) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINIT")
}

record(stringin, "ACSW:B44:NW05:1INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW05:1INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B44:NW05:1INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B44:NW05:1INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B44:NW05:1INITSTATE")
}

record(mbbi, "ACSW:B44:NW05:1INITSTATE") {
#  field(SDIS, "ACSW:B44:NW05:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW05:1INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B44:NW05:2NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW05:2POWERSTATEIN")
}

record(stringin, "ACSW:B44:NW05:2POWERSTATEIN") {
  field(FLNK, "ACSW:B44:NW05:2POWERSTATESV")
}

record(scalcout, "ACSW:B44:NW05:2POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B44:NW05:2POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B44:NW05:2POWERSTATE")
}

record(mbbi, "ACSW:B44:NW05:2POWERSTATE") {
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW05:2POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B44:NW05:2POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(2) acsw-b44-nw05")
}

record(bo, "ACSW:B44:NW05:2POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(2) acsw-b44-nw05")
}

record(bo, "ACSW:B44:NW05:2HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(2) acsw-b44-nw05")
}

record(stringin, "ACSW:B44:NW05:2NAMESET") {
  field(FLNK, "ACSW:B44:NW05:2NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B44:NW05:2NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(2) acsw-b44-nw05")
  field(DOL, "ACSW:B44:NW05:2NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B44:NW05:2SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(2) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINIT")
}

record(bo, "ACSW:B44:NW05:2SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(2) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINIT")
}

record(stringin, "ACSW:B44:NW05:2INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW05:2INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B44:NW05:2INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B44:NW05:2INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B44:NW05:2INITSTATE")
}

record(mbbi, "ACSW:B44:NW05:2INITSTATE") {
#  field(SDIS, "ACSW:B44:NW05:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW05:2INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B44:NW05:3NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW05:3POWERSTATEIN")
}

record(stringin, "ACSW:B44:NW05:3POWERSTATEIN") {
  field(FLNK, "ACSW:B44:NW05:3POWERSTATESV")
}

record(scalcout, "ACSW:B44:NW05:3POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B44:NW05:3POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B44:NW05:3POWERSTATE")
}

record(mbbi, "ACSW:B44:NW05:3POWERSTATE") {
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW05:3POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B44:NW05:3POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(3) acsw-b44-nw05")
}

record(bo, "ACSW:B44:NW05:3POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(3) acsw-b44-nw05")
}

record(bo, "ACSW:B44:NW05:3HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(3) acsw-b44-nw05")
}

record(stringin, "ACSW:B44:NW05:3NAMESET") {
  field(FLNK, "ACSW:B44:NW05:3NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B44:NW05:3NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(3) acsw-b44-nw05")
  field(DOL, "ACSW:B44:NW05:3NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B44:NW05:3SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(3) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINIT")
}

record(bo, "ACSW:B44:NW05:3SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(3) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINIT")
}

record(stringin, "ACSW:B44:NW05:3INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW05:3INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B44:NW05:3INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B44:NW05:3INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B44:NW05:3INITSTATE")
}

record(mbbi, "ACSW:B44:NW05:3INITSTATE") {
#  field(SDIS, "ACSW:B44:NW05:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW05:3INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B44:NW05:4NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW05:4POWERSTATEIN")
}

record(stringin, "ACSW:B44:NW05:4POWERSTATEIN") {
  field(FLNK, "ACSW:B44:NW05:4POWERSTATESV")
}

record(scalcout, "ACSW:B44:NW05:4POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B44:NW05:4POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B44:NW05:4POWERSTATE")
}

record(mbbi, "ACSW:B44:NW05:4POWERSTATE") {
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW05:4POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B44:NW05:4POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(4) acsw-b44-nw05")
}

record(bo, "ACSW:B44:NW05:4POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(4) acsw-b44-nw05")
}

record(bo, "ACSW:B44:NW05:4HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(4) acsw-b44-nw05")
}

record(stringin, "ACSW:B44:NW05:4NAMESET") {
  field(FLNK, "ACSW:B44:NW05:4NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B44:NW05:4NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(4) acsw-b44-nw05")
  field(DOL, "ACSW:B44:NW05:4NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B44:NW05:4SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(4) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINIT")
}

record(bo, "ACSW:B44:NW05:4SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(4) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINIT")
}

record(stringin, "ACSW:B44:NW05:4INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW05:4INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B44:NW05:4INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B44:NW05:4INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B44:NW05:4INITSTATE")
}

record(mbbi, "ACSW:B44:NW05:4INITSTATE") {
#  field(SDIS, "ACSW:B44:NW05:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW05:4INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B44:NW05:5NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW05:5POWERSTATEIN")
}

record(stringin, "ACSW:B44:NW05:5POWERSTATEIN") {
  field(FLNK, "ACSW:B44:NW05:5POWERSTATESV")
}

record(scalcout, "ACSW:B44:NW05:5POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B44:NW05:5POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B44:NW05:5POWERSTATE")
}

record(mbbi, "ACSW:B44:NW05:5POWERSTATE") {
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW05:5POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B44:NW05:5POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(5) acsw-b44-nw05")
}

record(bo, "ACSW:B44:NW05:5POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(5) acsw-b44-nw05")
}

record(bo, "ACSW:B44:NW05:5HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(5) acsw-b44-nw05")
}

record(stringin, "ACSW:B44:NW05:5NAMESET") {
  field(FLNK, "ACSW:B44:NW05:5NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B44:NW05:5NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(5) acsw-b44-nw05")
  field(DOL, "ACSW:B44:NW05:5NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B44:NW05:5SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(5) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINIT")
}

record(bo, "ACSW:B44:NW05:5SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(5) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINIT")
}

record(stringin, "ACSW:B44:NW05:5INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW05:5INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B44:NW05:5INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B44:NW05:5INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B44:NW05:5INITSTATE")
}

record(mbbi, "ACSW:B44:NW05:5INITSTATE") {
#  field(SDIS, "ACSW:B44:NW05:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW05:5INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B44:NW05:6NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW05:6POWERSTATEIN")
}

record(stringin, "ACSW:B44:NW05:6POWERSTATEIN") {
  field(FLNK, "ACSW:B44:NW05:6POWERSTATESV")
}

record(scalcout, "ACSW:B44:NW05:6POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B44:NW05:6POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B44:NW05:6POWERSTATE")
}

record(mbbi, "ACSW:B44:NW05:6POWERSTATE") {
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW05:6POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B44:NW05:6POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(6) acsw-b44-nw05")
}

record(bo, "ACSW:B44:NW05:6POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(6) acsw-b44-nw05")
}

record(bo, "ACSW:B44:NW05:6HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(6) acsw-b44-nw05")
}

record(stringin, "ACSW:B44:NW05:6NAMESET") {
  field(FLNK, "ACSW:B44:NW05:6NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B44:NW05:6NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(6) acsw-b44-nw05")
  field(DOL, "ACSW:B44:NW05:6NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B44:NW05:6SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(6) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINIT")
}

record(bo, "ACSW:B44:NW05:6SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(6) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINIT")
}

record(stringin, "ACSW:B44:NW05:6INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW05:6INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B44:NW05:6INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B44:NW05:6INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B44:NW05:6INITSTATE")
}

record(mbbi, "ACSW:B44:NW05:6INITSTATE") {
#  field(SDIS, "ACSW:B44:NW05:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW05:6INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B44:NW05:7NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW05:7POWERSTATEIN")
}

record(stringin, "ACSW:B44:NW05:7POWERSTATEIN") {
  field(FLNK, "ACSW:B44:NW05:7POWERSTATESV")
}

record(scalcout, "ACSW:B44:NW05:7POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B44:NW05:7POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B44:NW05:7POWERSTATE")
}

record(mbbi, "ACSW:B44:NW05:7POWERSTATE") {
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW05:7POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B44:NW05:7POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(7) acsw-b44-nw05")
}

record(bo, "ACSW:B44:NW05:7POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(7) acsw-b44-nw05")
}

record(bo, "ACSW:B44:NW05:7HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(7) acsw-b44-nw05")
}

record(stringin, "ACSW:B44:NW05:7NAMESET") {
  field(FLNK, "ACSW:B44:NW05:7NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B44:NW05:7NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(7) acsw-b44-nw05")
  field(DOL, "ACSW:B44:NW05:7NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B44:NW05:7SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(7) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINIT")
}

record(bo, "ACSW:B44:NW05:7SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(7) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINIT")
}

record(stringin, "ACSW:B44:NW05:7INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW05:7INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B44:NW05:7INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B44:NW05:7INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B44:NW05:7INITSTATE")
}

record(mbbi, "ACSW:B44:NW05:7INITSTATE") {
#  field(SDIS, "ACSW:B44:NW05:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW05:7INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B44:NW05:8NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW05:8POWERSTATEIN")
}

record(stringin, "ACSW:B44:NW05:8POWERSTATEIN") {
  field(FLNK, "ACSW:B44:NW05:8POWERSTATESV")
}

record(scalcout, "ACSW:B44:NW05:8POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B44:NW05:8POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B44:NW05:8POWERSTATE")
}

record(mbbi, "ACSW:B44:NW05:8POWERSTATE") {
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW05:8POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B44:NW05:8POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(8) acsw-b44-nw05")
}

record(bo, "ACSW:B44:NW05:8POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(8) acsw-b44-nw05")
}

record(bo, "ACSW:B44:NW05:8HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(8) acsw-b44-nw05")
}

record(stringin, "ACSW:B44:NW05:8NAMESET") {
  field(FLNK, "ACSW:B44:NW05:8NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B44:NW05:8NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(8) acsw-b44-nw05")
  field(DOL, "ACSW:B44:NW05:8NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B44:NW05:8SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(8) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINIT")
}

record(bo, "ACSW:B44:NW05:8SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(8) acsw-b44-nw05")
  field(FLNK, "ACSW:B44:NW05:GETINIT")
}

record(stringin, "ACSW:B44:NW05:8INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW05:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW05:8INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B44:NW05:8INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B44:NW05:8INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B44:NW05:8INITSTATE")
}

record(mbbi, "ACSW:B44:NW05:8INITSTATE") {
#  field(SDIS, "ACSW:B44:NW05:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW05:8INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B44:NW06:LOGIN") {
  field(PINI, "YES")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db setLogin(ACSW:B44:NW06) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINFO")
}

record(stringin, "ACSW:B44:NW06:GETINFO") {
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getInfo(ACSW:B44:NW06) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINIT")
}

record(stringin, "ACSW:B44:NW06:FWVERSION") {
  field(SCAN, "10 second")
  field(FLNK, "ACSW:B44:NW06:NETFWVERSION")
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B44:NW06:NETFWVERSION") {
  field(DESC, "Network adapter fw vers")
  field(FLNK, "ACSW:B44:NW06:SITEID")
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B44:NW06:SITEID") {
  field(DESC, "ACSW node name")
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")

}

record(bo, "ACSW:B44:NW06:GETINIT") {
  field(DESC, "Get outlet init states")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db getOutletInitState8(ACSW:B44:NW06) acsw-b44-nw06")
}

record(stringin, "ACSW:B44:NW06:GETSTATUS") {
  field(SCAN, "2 second")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getOutletState8(ACSW:B44:NW06) acsw-b44-nw06")
}

record(ai, "ACSW:B44:NW06:TYPE") {
  field(DESC, "APC 8 Port AC Power Switch")
  field(PINI, "YES")
  field(VAL, "10")
}

record(stringin, "ACSW:B44:NW06:LOC") {
  field(PINI, "YES")
  field(VAL, "B44-205")
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
  info(autosaveFields,"VAL")
}

record(bo, "ACSW:B44:NW06:DISCONN") {
  field(DESC, "Disconn to allow access")
  field(DISA, "1")
  field(DISS, "NO_ALARM")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setDisconnect acsw-b44-nw06")
}

record(calcout, "ACSW:B44:NW06:CONNCALC") {
  field(CALC, "A=B && C#D")
  field(SCAN, "2 second")
  field(INPA, "ACSW:B44:NW06:DISCONN.DISA")
  field(INPB, "ACSW:B44:NW06:DISCONN.DISV")
  field(INPC, "ACSW:B44:NW06:GETSTATUS.DISA")
  field(INPD, "ACSW:B44:NW06:GETSTATUS.DISV")
  field(OOPT, "On Change")
  field(OUT, "ACSW:B44:NW06:CONNSTA PP")
}

record(bi, "ACSW:B44:NW06:CONNSTA") {
  field(ZNAM, "Not connected")
  field(ONAM, "Connected")
  field(ZSV, "MINOR")
  field(OSV, "NO_ALARM")
}

# Disconnect from ACSW to allow
# other clients access to ACSW
record(seq, "ACSW:B44:NW06:ACCSTART") {
  field(SELM, "All")
  field(DOL1, "1")
  field(LNK1, "ACSW:B44:NW06:GETSTATUS.DISA")
  field(DOL2, "0")
  field(LNK2, "ACSW:B44:NW06:DISCONN.DISA PP")
}

# Reconnect to ACSW
record(seq, "ACSW:B44:NW06:ACCSTOP") {
  field(SELM, "All")
  field(DOL1, "0")
  field(LNK1, "ACSW:B44:NW06:GETSTATUS.DISA")
  field(DOL2, "1")
  field(LNK2, "ACSW:B44:NW06:DISCONN.DISA")
}

#Not in use since using CLI
record(ai, "ACSW:B44:NW06:UPTIMEHOUR") {
  field(FLNK, "ACSW:B44:NW06:UPTIMEMINUTE")
  field(EGU, "Hours")
}
record(ai, "ACSW:B44:NW06:UPTIMEDAY") {
  field(FLNK, "ACSW:B44:NW06:UPTIMEHOUR")
  field(EGU, "Days")
}
record(ai, "ACSW:B44:NW06:UPTIMEMINUTE") {
  field(FLNK, "ACSW:B44:NW06:1NAME")
  field(EGU, "Minutes")
}

record(stringin, "ACSW:B44:NW06:1NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW06:1POWERSTATEIN")
}

record(stringin, "ACSW:B44:NW06:1POWERSTATEIN") {
  field(FLNK, "ACSW:B44:NW06:1POWERSTATESV")
}

record(scalcout, "ACSW:B44:NW06:1POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B44:NW06:1POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B44:NW06:1POWERSTATE")
}

record(mbbi, "ACSW:B44:NW06:1POWERSTATE") {
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW06:1POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B44:NW06:1POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(1) acsw-b44-nw06")
}

record(bo, "ACSW:B44:NW06:1POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(1) acsw-b44-nw06")
}

record(bo, "ACSW:B44:NW06:1HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(1) acsw-b44-nw06")
}

record(stringin, "ACSW:B44:NW06:1NAMESET") {
  field(FLNK, "ACSW:B44:NW06:1NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B44:NW06:1NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(1) acsw-b44-nw06")
  field(DOL, "ACSW:B44:NW06:1NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B44:NW06:1SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(1) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINIT")
}

record(bo, "ACSW:B44:NW06:1SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(1) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINIT")
}

record(stringin, "ACSW:B44:NW06:1INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW06:1INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B44:NW06:1INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B44:NW06:1INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B44:NW06:1INITSTATE")
}

record(mbbi, "ACSW:B44:NW06:1INITSTATE") {
#  field(SDIS, "ACSW:B44:NW06:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW06:1INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B44:NW06:2NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW06:2POWERSTATEIN")
}

record(stringin, "ACSW:B44:NW06:2POWERSTATEIN") {
  field(FLNK, "ACSW:B44:NW06:2POWERSTATESV")
}

record(scalcout, "ACSW:B44:NW06:2POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B44:NW06:2POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B44:NW06:2POWERSTATE")
}

record(mbbi, "ACSW:B44:NW06:2POWERSTATE") {
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW06:2POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B44:NW06:2POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(2) acsw-b44-nw06")
}

record(bo, "ACSW:B44:NW06:2POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(2) acsw-b44-nw06")
}

record(bo, "ACSW:B44:NW06:2HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(2) acsw-b44-nw06")
}

record(stringin, "ACSW:B44:NW06:2NAMESET") {
  field(FLNK, "ACSW:B44:NW06:2NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B44:NW06:2NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(2) acsw-b44-nw06")
  field(DOL, "ACSW:B44:NW06:2NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B44:NW06:2SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(2) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINIT")
}

record(bo, "ACSW:B44:NW06:2SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(2) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINIT")
}

record(stringin, "ACSW:B44:NW06:2INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW06:2INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B44:NW06:2INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B44:NW06:2INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B44:NW06:2INITSTATE")
}

record(mbbi, "ACSW:B44:NW06:2INITSTATE") {
#  field(SDIS, "ACSW:B44:NW06:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW06:2INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B44:NW06:3NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW06:3POWERSTATEIN")
}

record(stringin, "ACSW:B44:NW06:3POWERSTATEIN") {
  field(FLNK, "ACSW:B44:NW06:3POWERSTATESV")
}

record(scalcout, "ACSW:B44:NW06:3POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B44:NW06:3POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B44:NW06:3POWERSTATE")
}

record(mbbi, "ACSW:B44:NW06:3POWERSTATE") {
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW06:3POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B44:NW06:3POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(3) acsw-b44-nw06")
}

record(bo, "ACSW:B44:NW06:3POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(3) acsw-b44-nw06")
}

record(bo, "ACSW:B44:NW06:3HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(3) acsw-b44-nw06")
}

record(stringin, "ACSW:B44:NW06:3NAMESET") {
  field(FLNK, "ACSW:B44:NW06:3NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B44:NW06:3NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(3) acsw-b44-nw06")
  field(DOL, "ACSW:B44:NW06:3NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B44:NW06:3SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(3) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINIT")
}

record(bo, "ACSW:B44:NW06:3SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(3) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINIT")
}

record(stringin, "ACSW:B44:NW06:3INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW06:3INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B44:NW06:3INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B44:NW06:3INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B44:NW06:3INITSTATE")
}

record(mbbi, "ACSW:B44:NW06:3INITSTATE") {
#  field(SDIS, "ACSW:B44:NW06:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW06:3INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B44:NW06:4NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW06:4POWERSTATEIN")
}

record(stringin, "ACSW:B44:NW06:4POWERSTATEIN") {
  field(FLNK, "ACSW:B44:NW06:4POWERSTATESV")
}

record(scalcout, "ACSW:B44:NW06:4POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B44:NW06:4POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B44:NW06:4POWERSTATE")
}

record(mbbi, "ACSW:B44:NW06:4POWERSTATE") {
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW06:4POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B44:NW06:4POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(4) acsw-b44-nw06")
}

record(bo, "ACSW:B44:NW06:4POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(4) acsw-b44-nw06")
}

record(bo, "ACSW:B44:NW06:4HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(4) acsw-b44-nw06")
}

record(stringin, "ACSW:B44:NW06:4NAMESET") {
  field(FLNK, "ACSW:B44:NW06:4NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B44:NW06:4NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(4) acsw-b44-nw06")
  field(DOL, "ACSW:B44:NW06:4NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B44:NW06:4SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(4) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINIT")
}

record(bo, "ACSW:B44:NW06:4SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(4) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINIT")
}

record(stringin, "ACSW:B44:NW06:4INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW06:4INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B44:NW06:4INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B44:NW06:4INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B44:NW06:4INITSTATE")
}

record(mbbi, "ACSW:B44:NW06:4INITSTATE") {
#  field(SDIS, "ACSW:B44:NW06:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW06:4INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B44:NW06:5NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW06:5POWERSTATEIN")
}

record(stringin, "ACSW:B44:NW06:5POWERSTATEIN") {
  field(FLNK, "ACSW:B44:NW06:5POWERSTATESV")
}

record(scalcout, "ACSW:B44:NW06:5POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B44:NW06:5POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B44:NW06:5POWERSTATE")
}

record(mbbi, "ACSW:B44:NW06:5POWERSTATE") {
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW06:5POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B44:NW06:5POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(5) acsw-b44-nw06")
}

record(bo, "ACSW:B44:NW06:5POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(5) acsw-b44-nw06")
}

record(bo, "ACSW:B44:NW06:5HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(5) acsw-b44-nw06")
}

record(stringin, "ACSW:B44:NW06:5NAMESET") {
  field(FLNK, "ACSW:B44:NW06:5NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B44:NW06:5NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(5) acsw-b44-nw06")
  field(DOL, "ACSW:B44:NW06:5NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B44:NW06:5SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(5) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINIT")
}

record(bo, "ACSW:B44:NW06:5SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(5) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINIT")
}

record(stringin, "ACSW:B44:NW06:5INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW06:5INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B44:NW06:5INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B44:NW06:5INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B44:NW06:5INITSTATE")
}

record(mbbi, "ACSW:B44:NW06:5INITSTATE") {
#  field(SDIS, "ACSW:B44:NW06:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW06:5INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B44:NW06:6NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW06:6POWERSTATEIN")
}

record(stringin, "ACSW:B44:NW06:6POWERSTATEIN") {
  field(FLNK, "ACSW:B44:NW06:6POWERSTATESV")
}

record(scalcout, "ACSW:B44:NW06:6POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B44:NW06:6POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B44:NW06:6POWERSTATE")
}

record(mbbi, "ACSW:B44:NW06:6POWERSTATE") {
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW06:6POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B44:NW06:6POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(6) acsw-b44-nw06")
}

record(bo, "ACSW:B44:NW06:6POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(6) acsw-b44-nw06")
}

record(bo, "ACSW:B44:NW06:6HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(6) acsw-b44-nw06")
}

record(stringin, "ACSW:B44:NW06:6NAMESET") {
  field(FLNK, "ACSW:B44:NW06:6NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B44:NW06:6NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(6) acsw-b44-nw06")
  field(DOL, "ACSW:B44:NW06:6NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B44:NW06:6SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(6) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINIT")
}

record(bo, "ACSW:B44:NW06:6SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(6) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINIT")
}

record(stringin, "ACSW:B44:NW06:6INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW06:6INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B44:NW06:6INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B44:NW06:6INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B44:NW06:6INITSTATE")
}

record(mbbi, "ACSW:B44:NW06:6INITSTATE") {
#  field(SDIS, "ACSW:B44:NW06:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW06:6INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B44:NW06:7NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW06:7POWERSTATEIN")
}

record(stringin, "ACSW:B44:NW06:7POWERSTATEIN") {
  field(FLNK, "ACSW:B44:NW06:7POWERSTATESV")
}

record(scalcout, "ACSW:B44:NW06:7POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B44:NW06:7POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B44:NW06:7POWERSTATE")
}

record(mbbi, "ACSW:B44:NW06:7POWERSTATE") {
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW06:7POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B44:NW06:7POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(7) acsw-b44-nw06")
}

record(bo, "ACSW:B44:NW06:7POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(7) acsw-b44-nw06")
}

record(bo, "ACSW:B44:NW06:7HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(7) acsw-b44-nw06")
}

record(stringin, "ACSW:B44:NW06:7NAMESET") {
  field(FLNK, "ACSW:B44:NW06:7NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B44:NW06:7NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(7) acsw-b44-nw06")
  field(DOL, "ACSW:B44:NW06:7NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B44:NW06:7SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(7) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINIT")
}

record(bo, "ACSW:B44:NW06:7SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(7) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINIT")
}

record(stringin, "ACSW:B44:NW06:7INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW06:7INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B44:NW06:7INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B44:NW06:7INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B44:NW06:7INITSTATE")
}

record(mbbi, "ACSW:B44:NW06:7INITSTATE") {
#  field(SDIS, "ACSW:B44:NW06:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW06:7INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B44:NW06:8NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW06:8POWERSTATEIN")
}

record(stringin, "ACSW:B44:NW06:8POWERSTATEIN") {
  field(FLNK, "ACSW:B44:NW06:8POWERSTATESV")
}

record(scalcout, "ACSW:B44:NW06:8POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B44:NW06:8POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B44:NW06:8POWERSTATE")
}

record(mbbi, "ACSW:B44:NW06:8POWERSTATE") {
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW06:8POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B44:NW06:8POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(8) acsw-b44-nw06")
}

record(bo, "ACSW:B44:NW06:8POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(8) acsw-b44-nw06")
}

record(bo, "ACSW:B44:NW06:8HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(8) acsw-b44-nw06")
}

record(stringin, "ACSW:B44:NW06:8NAMESET") {
  field(FLNK, "ACSW:B44:NW06:8NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B44:NW06:8NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(8) acsw-b44-nw06")
  field(DOL, "ACSW:B44:NW06:8NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B44:NW06:8SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(8) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINIT")
}

record(bo, "ACSW:B44:NW06:8SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(8) acsw-b44-nw06")
  field(FLNK, "ACSW:B44:NW06:GETINIT")
}

record(stringin, "ACSW:B44:NW06:8INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B44:NW06:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B44:NW06:8INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B44:NW06:8INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B44:NW06:8INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B44:NW06:8INITSTATE")
}

record(mbbi, "ACSW:B44:NW06:8INITSTATE") {
#  field(SDIS, "ACSW:B44:NW06:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B44:NW06:8INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B084:NW02:LOGIN") {
  field(PINI, "YES")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db setLogin(ACSW:B084:NW02) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINFO")
}

record(stringin, "ACSW:B084:NW02:GETINFO") {
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getInfo(ACSW:B084:NW02) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINIT")
}

record(stringin, "ACSW:B084:NW02:FWVERSION") {
  field(SCAN, "10 second")
  field(FLNK, "ACSW:B084:NW02:NETFWVERSION")
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B084:NW02:NETFWVERSION") {
  field(DESC, "Network adapter fw vers")
  field(FLNK, "ACSW:B084:NW02:SITEID")
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B084:NW02:SITEID") {
  field(DESC, "ACSW node name")
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")

}

record(bo, "ACSW:B084:NW02:GETINIT") {
  field(DESC, "Get outlet init states")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db getOutletInitState8(ACSW:B084:NW02) acsw-b084-nw02")
}

record(stringin, "ACSW:B084:NW02:GETSTATUS") {
  field(SCAN, "2 second")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getOutletState8(ACSW:B084:NW02) acsw-b084-nw02")
}

record(ai, "ACSW:B084:NW02:TYPE") {
  field(DESC, "APC 8 Port AC Power Switch")
  field(PINI, "YES")
  field(VAL, "10")
}

record(stringin, "ACSW:B084:NW02:LOC") {
  field(PINI, "YES")
  field(VAL, "B84-RM156")
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
  info(autosaveFields,"VAL")
}

record(bo, "ACSW:B084:NW02:DISCONN") {
  field(DESC, "Disconn to allow access")
  field(DISA, "1")
  field(DISS, "NO_ALARM")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setDisconnect acsw-b084-nw02")
}

record(calcout, "ACSW:B084:NW02:CONNCALC") {
  field(CALC, "A=B && C#D")
  field(SCAN, "2 second")
  field(INPA, "ACSW:B084:NW02:DISCONN.DISA")
  field(INPB, "ACSW:B084:NW02:DISCONN.DISV")
  field(INPC, "ACSW:B084:NW02:GETSTATUS.DISA")
  field(INPD, "ACSW:B084:NW02:GETSTATUS.DISV")
  field(OOPT, "On Change")
  field(OUT, "ACSW:B084:NW02:CONNSTA PP")
}

record(bi, "ACSW:B084:NW02:CONNSTA") {
  field(ZNAM, "Not connected")
  field(ONAM, "Connected")
  field(ZSV, "MINOR")
  field(OSV, "NO_ALARM")
}

# Disconnect from ACSW to allow
# other clients access to ACSW
record(seq, "ACSW:B084:NW02:ACCSTART") {
  field(SELM, "All")
  field(DOL1, "1")
  field(LNK1, "ACSW:B084:NW02:GETSTATUS.DISA")
  field(DOL2, "0")
  field(LNK2, "ACSW:B084:NW02:DISCONN.DISA PP")
}

# Reconnect to ACSW
record(seq, "ACSW:B084:NW02:ACCSTOP") {
  field(SELM, "All")
  field(DOL1, "0")
  field(LNK1, "ACSW:B084:NW02:GETSTATUS.DISA")
  field(DOL2, "1")
  field(LNK2, "ACSW:B084:NW02:DISCONN.DISA")
}

#Not in use since using CLI
record(ai, "ACSW:B084:NW02:UPTIMEHOUR") {
  field(FLNK, "ACSW:B084:NW02:UPTIMEMINUTE")
  field(EGU, "Hours")
}
record(ai, "ACSW:B084:NW02:UPTIMEDAY") {
  field(FLNK, "ACSW:B084:NW02:UPTIMEHOUR")
  field(EGU, "Days")
}
record(ai, "ACSW:B084:NW02:UPTIMEMINUTE") {
  field(FLNK, "ACSW:B084:NW02:1NAME")
  field(EGU, "Minutes")
}

record(stringin, "ACSW:B084:NW02:1NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW02:1POWERSTATEIN")
}

record(stringin, "ACSW:B084:NW02:1POWERSTATEIN") {
  field(FLNK, "ACSW:B084:NW02:1POWERSTATESV")
}

record(scalcout, "ACSW:B084:NW02:1POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B084:NW02:1POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B084:NW02:1POWERSTATE")
}

record(mbbi, "ACSW:B084:NW02:1POWERSTATE") {
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW02:1POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B084:NW02:1POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(1) acsw-b084-nw02")
}

record(bo, "ACSW:B084:NW02:1POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(1) acsw-b084-nw02")
}

record(bo, "ACSW:B084:NW02:1HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(1) acsw-b084-nw02")
}

record(stringin, "ACSW:B084:NW02:1NAMESET") {
  field(FLNK, "ACSW:B084:NW02:1NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B084:NW02:1NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(1) acsw-b084-nw02")
  field(DOL, "ACSW:B084:NW02:1NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B084:NW02:1SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(1) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINIT")
}

record(bo, "ACSW:B084:NW02:1SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(1) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINIT")
}

record(stringin, "ACSW:B084:NW02:1INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW02:1INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B084:NW02:1INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B084:NW02:1INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B084:NW02:1INITSTATE")
}

record(mbbi, "ACSW:B084:NW02:1INITSTATE") {
#  field(SDIS, "ACSW:B084:NW02:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW02:1INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B084:NW02:2NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW02:2POWERSTATEIN")
}

record(stringin, "ACSW:B084:NW02:2POWERSTATEIN") {
  field(FLNK, "ACSW:B084:NW02:2POWERSTATESV")
}

record(scalcout, "ACSW:B084:NW02:2POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B084:NW02:2POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B084:NW02:2POWERSTATE")
}

record(mbbi, "ACSW:B084:NW02:2POWERSTATE") {
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW02:2POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B084:NW02:2POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(2) acsw-b084-nw02")
}

record(bo, "ACSW:B084:NW02:2POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(2) acsw-b084-nw02")
}

record(bo, "ACSW:B084:NW02:2HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(2) acsw-b084-nw02")
}

record(stringin, "ACSW:B084:NW02:2NAMESET") {
  field(FLNK, "ACSW:B084:NW02:2NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B084:NW02:2NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(2) acsw-b084-nw02")
  field(DOL, "ACSW:B084:NW02:2NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B084:NW02:2SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(2) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINIT")
}

record(bo, "ACSW:B084:NW02:2SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(2) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINIT")
}

record(stringin, "ACSW:B084:NW02:2INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW02:2INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B084:NW02:2INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B084:NW02:2INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B084:NW02:2INITSTATE")
}

record(mbbi, "ACSW:B084:NW02:2INITSTATE") {
#  field(SDIS, "ACSW:B084:NW02:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW02:2INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B084:NW02:3NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW02:3POWERSTATEIN")
}

record(stringin, "ACSW:B084:NW02:3POWERSTATEIN") {
  field(FLNK, "ACSW:B084:NW02:3POWERSTATESV")
}

record(scalcout, "ACSW:B084:NW02:3POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B084:NW02:3POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B084:NW02:3POWERSTATE")
}

record(mbbi, "ACSW:B084:NW02:3POWERSTATE") {
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW02:3POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B084:NW02:3POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(3) acsw-b084-nw02")
}

record(bo, "ACSW:B084:NW02:3POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(3) acsw-b084-nw02")
}

record(bo, "ACSW:B084:NW02:3HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(3) acsw-b084-nw02")
}

record(stringin, "ACSW:B084:NW02:3NAMESET") {
  field(FLNK, "ACSW:B084:NW02:3NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B084:NW02:3NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(3) acsw-b084-nw02")
  field(DOL, "ACSW:B084:NW02:3NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B084:NW02:3SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(3) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINIT")
}

record(bo, "ACSW:B084:NW02:3SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(3) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINIT")
}

record(stringin, "ACSW:B084:NW02:3INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW02:3INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B084:NW02:3INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B084:NW02:3INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B084:NW02:3INITSTATE")
}

record(mbbi, "ACSW:B084:NW02:3INITSTATE") {
#  field(SDIS, "ACSW:B084:NW02:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW02:3INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B084:NW02:4NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW02:4POWERSTATEIN")
}

record(stringin, "ACSW:B084:NW02:4POWERSTATEIN") {
  field(FLNK, "ACSW:B084:NW02:4POWERSTATESV")
}

record(scalcout, "ACSW:B084:NW02:4POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B084:NW02:4POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B084:NW02:4POWERSTATE")
}

record(mbbi, "ACSW:B084:NW02:4POWERSTATE") {
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW02:4POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B084:NW02:4POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(4) acsw-b084-nw02")
}

record(bo, "ACSW:B084:NW02:4POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(4) acsw-b084-nw02")
}

record(bo, "ACSW:B084:NW02:4HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(4) acsw-b084-nw02")
}

record(stringin, "ACSW:B084:NW02:4NAMESET") {
  field(FLNK, "ACSW:B084:NW02:4NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B084:NW02:4NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(4) acsw-b084-nw02")
  field(DOL, "ACSW:B084:NW02:4NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B084:NW02:4SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(4) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINIT")
}

record(bo, "ACSW:B084:NW02:4SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(4) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINIT")
}

record(stringin, "ACSW:B084:NW02:4INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW02:4INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B084:NW02:4INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B084:NW02:4INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B084:NW02:4INITSTATE")
}

record(mbbi, "ACSW:B084:NW02:4INITSTATE") {
#  field(SDIS, "ACSW:B084:NW02:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW02:4INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B084:NW02:5NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW02:5POWERSTATEIN")
}

record(stringin, "ACSW:B084:NW02:5POWERSTATEIN") {
  field(FLNK, "ACSW:B084:NW02:5POWERSTATESV")
}

record(scalcout, "ACSW:B084:NW02:5POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B084:NW02:5POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B084:NW02:5POWERSTATE")
}

record(mbbi, "ACSW:B084:NW02:5POWERSTATE") {
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW02:5POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B084:NW02:5POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(5) acsw-b084-nw02")
}

record(bo, "ACSW:B084:NW02:5POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(5) acsw-b084-nw02")
}

record(bo, "ACSW:B084:NW02:5HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(5) acsw-b084-nw02")
}

record(stringin, "ACSW:B084:NW02:5NAMESET") {
  field(FLNK, "ACSW:B084:NW02:5NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B084:NW02:5NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(5) acsw-b084-nw02")
  field(DOL, "ACSW:B084:NW02:5NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B084:NW02:5SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(5) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINIT")
}

record(bo, "ACSW:B084:NW02:5SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(5) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINIT")
}

record(stringin, "ACSW:B084:NW02:5INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW02:5INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B084:NW02:5INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B084:NW02:5INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B084:NW02:5INITSTATE")
}

record(mbbi, "ACSW:B084:NW02:5INITSTATE") {
#  field(SDIS, "ACSW:B084:NW02:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW02:5INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B084:NW02:6NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW02:6POWERSTATEIN")
}

record(stringin, "ACSW:B084:NW02:6POWERSTATEIN") {
  field(FLNK, "ACSW:B084:NW02:6POWERSTATESV")
}

record(scalcout, "ACSW:B084:NW02:6POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B084:NW02:6POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B084:NW02:6POWERSTATE")
}

record(mbbi, "ACSW:B084:NW02:6POWERSTATE") {
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW02:6POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B084:NW02:6POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(6) acsw-b084-nw02")
}

record(bo, "ACSW:B084:NW02:6POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(6) acsw-b084-nw02")
}

record(bo, "ACSW:B084:NW02:6HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(6) acsw-b084-nw02")
}

record(stringin, "ACSW:B084:NW02:6NAMESET") {
  field(FLNK, "ACSW:B084:NW02:6NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B084:NW02:6NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(6) acsw-b084-nw02")
  field(DOL, "ACSW:B084:NW02:6NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B084:NW02:6SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(6) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINIT")
}

record(bo, "ACSW:B084:NW02:6SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(6) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINIT")
}

record(stringin, "ACSW:B084:NW02:6INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW02:6INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B084:NW02:6INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B084:NW02:6INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B084:NW02:6INITSTATE")
}

record(mbbi, "ACSW:B084:NW02:6INITSTATE") {
#  field(SDIS, "ACSW:B084:NW02:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW02:6INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B084:NW02:7NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW02:7POWERSTATEIN")
}

record(stringin, "ACSW:B084:NW02:7POWERSTATEIN") {
  field(FLNK, "ACSW:B084:NW02:7POWERSTATESV")
}

record(scalcout, "ACSW:B084:NW02:7POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B084:NW02:7POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B084:NW02:7POWERSTATE")
}

record(mbbi, "ACSW:B084:NW02:7POWERSTATE") {
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW02:7POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B084:NW02:7POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(7) acsw-b084-nw02")
}

record(bo, "ACSW:B084:NW02:7POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(7) acsw-b084-nw02")
}

record(bo, "ACSW:B084:NW02:7HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(7) acsw-b084-nw02")
}

record(stringin, "ACSW:B084:NW02:7NAMESET") {
  field(FLNK, "ACSW:B084:NW02:7NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B084:NW02:7NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(7) acsw-b084-nw02")
  field(DOL, "ACSW:B084:NW02:7NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B084:NW02:7SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(7) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINIT")
}

record(bo, "ACSW:B084:NW02:7SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(7) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINIT")
}

record(stringin, "ACSW:B084:NW02:7INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW02:7INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B084:NW02:7INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B084:NW02:7INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B084:NW02:7INITSTATE")
}

record(mbbi, "ACSW:B084:NW02:7INITSTATE") {
#  field(SDIS, "ACSW:B084:NW02:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW02:7INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B084:NW02:8NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW02:8POWERSTATEIN")
}

record(stringin, "ACSW:B084:NW02:8POWERSTATEIN") {
  field(FLNK, "ACSW:B084:NW02:8POWERSTATESV")
}

record(scalcout, "ACSW:B084:NW02:8POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B084:NW02:8POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B084:NW02:8POWERSTATE")
}

record(mbbi, "ACSW:B084:NW02:8POWERSTATE") {
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW02:8POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B084:NW02:8POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(8) acsw-b084-nw02")
}

record(bo, "ACSW:B084:NW02:8POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(8) acsw-b084-nw02")
}

record(bo, "ACSW:B084:NW02:8HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(8) acsw-b084-nw02")
}

record(stringin, "ACSW:B084:NW02:8NAMESET") {
  field(FLNK, "ACSW:B084:NW02:8NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B084:NW02:8NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(8) acsw-b084-nw02")
  field(DOL, "ACSW:B084:NW02:8NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B084:NW02:8SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(8) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINIT")
}

record(bo, "ACSW:B084:NW02:8SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(8) acsw-b084-nw02")
  field(FLNK, "ACSW:B084:NW02:GETINIT")
}

record(stringin, "ACSW:B084:NW02:8INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW02:8INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B084:NW02:8INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B084:NW02:8INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B084:NW02:8INITSTATE")
}

record(mbbi, "ACSW:B084:NW02:8INITSTATE") {
#  field(SDIS, "ACSW:B084:NW02:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW02:8INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B084:NW04:LOGIN") {
  field(PINI, "YES")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db setLogin(ACSW:B084:NW04) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINFO")
}

record(stringin, "ACSW:B084:NW04:GETINFO") {
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getInfo(ACSW:B084:NW04) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINIT")
}

record(stringin, "ACSW:B084:NW04:FWVERSION") {
  field(SCAN, "10 second")
  field(FLNK, "ACSW:B084:NW04:NETFWVERSION")
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B084:NW04:NETFWVERSION") {
  field(DESC, "Network adapter fw vers")
  field(FLNK, "ACSW:B084:NW04:SITEID")
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(stringin, "ACSW:B084:NW04:SITEID") {
  field(DESC, "ACSW node name")
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")

}

record(bo, "ACSW:B084:NW04:GETINIT") {
  field(DESC, "Get outlet init states")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db getOutletInitState8(ACSW:B084:NW04) acsw-b084-nw04")
}

record(stringin, "ACSW:B084:NW04:GETSTATUS") {
  field(SCAN, "2 second")
  field(DTYP, "stream")
  field(INP, "@acsw_apc.proto.db getOutletState8(ACSW:B084:NW04) acsw-b084-nw04")
}

record(ai, "ACSW:B084:NW04:TYPE") {
  field(DESC, "APC 8 Port AC Power Switch")
  field(PINI, "YES")
  field(VAL, "10")
}

record(stringin, "ACSW:B084:NW04:LOC") {
  field(PINI, "YES")
  field(VAL, "B84-RM136")
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
  info(autosaveFields,"VAL")
}

record(bo, "ACSW:B084:NW04:DISCONN") {
  field(DESC, "Disconn to allow access")
  field(DISA, "1")
  field(DISS, "NO_ALARM")
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setDisconnect acsw-b084-nw04")
}

record(calcout, "ACSW:B084:NW04:CONNCALC") {
  field(CALC, "A=B && C#D")
  field(SCAN, "2 second")
  field(INPA, "ACSW:B084:NW04:DISCONN.DISA")
  field(INPB, "ACSW:B084:NW04:DISCONN.DISV")
  field(INPC, "ACSW:B084:NW04:GETSTATUS.DISA")
  field(INPD, "ACSW:B084:NW04:GETSTATUS.DISV")
  field(OOPT, "On Change")
  field(OUT, "ACSW:B084:NW04:CONNSTA PP")
}

record(bi, "ACSW:B084:NW04:CONNSTA") {
  field(ZNAM, "Not connected")
  field(ONAM, "Connected")
  field(ZSV, "MINOR")
  field(OSV, "NO_ALARM")
}

# Disconnect from ACSW to allow
# other clients access to ACSW
record(seq, "ACSW:B084:NW04:ACCSTART") {
  field(SELM, "All")
  field(DOL1, "1")
  field(LNK1, "ACSW:B084:NW04:GETSTATUS.DISA")
  field(DOL2, "0")
  field(LNK2, "ACSW:B084:NW04:DISCONN.DISA PP")
}

# Reconnect to ACSW
record(seq, "ACSW:B084:NW04:ACCSTOP") {
  field(SELM, "All")
  field(DOL1, "0")
  field(LNK1, "ACSW:B084:NW04:GETSTATUS.DISA")
  field(DOL2, "1")
  field(LNK2, "ACSW:B084:NW04:DISCONN.DISA")
}

#Not in use since using CLI
record(ai, "ACSW:B084:NW04:UPTIMEHOUR") {
  field(FLNK, "ACSW:B084:NW04:UPTIMEMINUTE")
  field(EGU, "Hours")
}
record(ai, "ACSW:B084:NW04:UPTIMEDAY") {
  field(FLNK, "ACSW:B084:NW04:UPTIMEHOUR")
  field(EGU, "Days")
}
record(ai, "ACSW:B084:NW04:UPTIMEMINUTE") {
  field(FLNK, "ACSW:B084:NW04:1NAME")
  field(EGU, "Minutes")
}

record(stringin, "ACSW:B084:NW04:1NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW04:1POWERSTATEIN")
}

record(stringin, "ACSW:B084:NW04:1POWERSTATEIN") {
  field(FLNK, "ACSW:B084:NW04:1POWERSTATESV")
}

record(scalcout, "ACSW:B084:NW04:1POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B084:NW04:1POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B084:NW04:1POWERSTATE")
}

record(mbbi, "ACSW:B084:NW04:1POWERSTATE") {
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW04:1POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B084:NW04:1POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(1) acsw-b084-nw04")
}

record(bo, "ACSW:B084:NW04:1POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(1) acsw-b084-nw04")
}

record(bo, "ACSW:B084:NW04:1HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(1) acsw-b084-nw04")
}

record(stringin, "ACSW:B084:NW04:1NAMESET") {
  field(FLNK, "ACSW:B084:NW04:1NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B084:NW04:1NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(1) acsw-b084-nw04")
  field(DOL, "ACSW:B084:NW04:1NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B084:NW04:1SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(1) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINIT")
}

record(bo, "ACSW:B084:NW04:1SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(1) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINIT")
}

record(stringin, "ACSW:B084:NW04:1INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW04:1INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B084:NW04:1INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B084:NW04:1INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B084:NW04:1INITSTATE")
}

record(mbbi, "ACSW:B084:NW04:1INITSTATE") {
#  field(SDIS, "ACSW:B084:NW04:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW04:1INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B084:NW04:2NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW04:2POWERSTATEIN")
}

record(stringin, "ACSW:B084:NW04:2POWERSTATEIN") {
  field(FLNK, "ACSW:B084:NW04:2POWERSTATESV")
}

record(scalcout, "ACSW:B084:NW04:2POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B084:NW04:2POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B084:NW04:2POWERSTATE")
}

record(mbbi, "ACSW:B084:NW04:2POWERSTATE") {
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW04:2POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B084:NW04:2POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(2) acsw-b084-nw04")
}

record(bo, "ACSW:B084:NW04:2POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(2) acsw-b084-nw04")
}

record(bo, "ACSW:B084:NW04:2HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(2) acsw-b084-nw04")
}

record(stringin, "ACSW:B084:NW04:2NAMESET") {
  field(FLNK, "ACSW:B084:NW04:2NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B084:NW04:2NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(2) acsw-b084-nw04")
  field(DOL, "ACSW:B084:NW04:2NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B084:NW04:2SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(2) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINIT")
}

record(bo, "ACSW:B084:NW04:2SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(2) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINIT")
}

record(stringin, "ACSW:B084:NW04:2INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW04:2INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B084:NW04:2INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B084:NW04:2INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B084:NW04:2INITSTATE")
}

record(mbbi, "ACSW:B084:NW04:2INITSTATE") {
#  field(SDIS, "ACSW:B084:NW04:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW04:2INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B084:NW04:3NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW04:3POWERSTATEIN")
}

record(stringin, "ACSW:B084:NW04:3POWERSTATEIN") {
  field(FLNK, "ACSW:B084:NW04:3POWERSTATESV")
}

record(scalcout, "ACSW:B084:NW04:3POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B084:NW04:3POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B084:NW04:3POWERSTATE")
}

record(mbbi, "ACSW:B084:NW04:3POWERSTATE") {
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW04:3POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B084:NW04:3POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(3) acsw-b084-nw04")
}

record(bo, "ACSW:B084:NW04:3POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(3) acsw-b084-nw04")
}

record(bo, "ACSW:B084:NW04:3HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(3) acsw-b084-nw04")
}

record(stringin, "ACSW:B084:NW04:3NAMESET") {
  field(FLNK, "ACSW:B084:NW04:3NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B084:NW04:3NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(3) acsw-b084-nw04")
  field(DOL, "ACSW:B084:NW04:3NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B084:NW04:3SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(3) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINIT")
}

record(bo, "ACSW:B084:NW04:3SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(3) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINIT")
}

record(stringin, "ACSW:B084:NW04:3INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW04:3INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B084:NW04:3INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B084:NW04:3INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B084:NW04:3INITSTATE")
}

record(mbbi, "ACSW:B084:NW04:3INITSTATE") {
#  field(SDIS, "ACSW:B084:NW04:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW04:3INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B084:NW04:4NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW04:4POWERSTATEIN")
}

record(stringin, "ACSW:B084:NW04:4POWERSTATEIN") {
  field(FLNK, "ACSW:B084:NW04:4POWERSTATESV")
}

record(scalcout, "ACSW:B084:NW04:4POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B084:NW04:4POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B084:NW04:4POWERSTATE")
}

record(mbbi, "ACSW:B084:NW04:4POWERSTATE") {
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW04:4POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B084:NW04:4POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(4) acsw-b084-nw04")
}

record(bo, "ACSW:B084:NW04:4POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(4) acsw-b084-nw04")
}

record(bo, "ACSW:B084:NW04:4HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(4) acsw-b084-nw04")
}

record(stringin, "ACSW:B084:NW04:4NAMESET") {
  field(FLNK, "ACSW:B084:NW04:4NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B084:NW04:4NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(4) acsw-b084-nw04")
  field(DOL, "ACSW:B084:NW04:4NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B084:NW04:4SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(4) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINIT")
}

record(bo, "ACSW:B084:NW04:4SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(4) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINIT")
}

record(stringin, "ACSW:B084:NW04:4INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW04:4INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B084:NW04:4INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B084:NW04:4INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B084:NW04:4INITSTATE")
}

record(mbbi, "ACSW:B084:NW04:4INITSTATE") {
#  field(SDIS, "ACSW:B084:NW04:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW04:4INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B084:NW04:5NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW04:5POWERSTATEIN")
}

record(stringin, "ACSW:B084:NW04:5POWERSTATEIN") {
  field(FLNK, "ACSW:B084:NW04:5POWERSTATESV")
}

record(scalcout, "ACSW:B084:NW04:5POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B084:NW04:5POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B084:NW04:5POWERSTATE")
}

record(mbbi, "ACSW:B084:NW04:5POWERSTATE") {
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW04:5POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B084:NW04:5POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(5) acsw-b084-nw04")
}

record(bo, "ACSW:B084:NW04:5POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(5) acsw-b084-nw04")
}

record(bo, "ACSW:B084:NW04:5HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(5) acsw-b084-nw04")
}

record(stringin, "ACSW:B084:NW04:5NAMESET") {
  field(FLNK, "ACSW:B084:NW04:5NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B084:NW04:5NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(5) acsw-b084-nw04")
  field(DOL, "ACSW:B084:NW04:5NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B084:NW04:5SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(5) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINIT")
}

record(bo, "ACSW:B084:NW04:5SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(5) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINIT")
}

record(stringin, "ACSW:B084:NW04:5INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW04:5INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B084:NW04:5INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B084:NW04:5INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B084:NW04:5INITSTATE")
}

record(mbbi, "ACSW:B084:NW04:5INITSTATE") {
#  field(SDIS, "ACSW:B084:NW04:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW04:5INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B084:NW04:6NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW04:6POWERSTATEIN")
}

record(stringin, "ACSW:B084:NW04:6POWERSTATEIN") {
  field(FLNK, "ACSW:B084:NW04:6POWERSTATESV")
}

record(scalcout, "ACSW:B084:NW04:6POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B084:NW04:6POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B084:NW04:6POWERSTATE")
}

record(mbbi, "ACSW:B084:NW04:6POWERSTATE") {
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW04:6POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B084:NW04:6POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(6) acsw-b084-nw04")
}

record(bo, "ACSW:B084:NW04:6POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(6) acsw-b084-nw04")
}

record(bo, "ACSW:B084:NW04:6HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(6) acsw-b084-nw04")
}

record(stringin, "ACSW:B084:NW04:6NAMESET") {
  field(FLNK, "ACSW:B084:NW04:6NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B084:NW04:6NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(6) acsw-b084-nw04")
  field(DOL, "ACSW:B084:NW04:6NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B084:NW04:6SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(6) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINIT")
}

record(bo, "ACSW:B084:NW04:6SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(6) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINIT")
}

record(stringin, "ACSW:B084:NW04:6INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW04:6INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B084:NW04:6INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B084:NW04:6INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B084:NW04:6INITSTATE")
}

record(mbbi, "ACSW:B084:NW04:6INITSTATE") {
#  field(SDIS, "ACSW:B084:NW04:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW04:6INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B084:NW04:7NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW04:7POWERSTATEIN")
}

record(stringin, "ACSW:B084:NW04:7POWERSTATEIN") {
  field(FLNK, "ACSW:B084:NW04:7POWERSTATESV")
}

record(scalcout, "ACSW:B084:NW04:7POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B084:NW04:7POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B084:NW04:7POWERSTATE")
}

record(mbbi, "ACSW:B084:NW04:7POWERSTATE") {
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW04:7POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B084:NW04:7POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(7) acsw-b084-nw04")
}

record(bo, "ACSW:B084:NW04:7POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(7) acsw-b084-nw04")
}

record(bo, "ACSW:B084:NW04:7HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(7) acsw-b084-nw04")
}

record(stringin, "ACSW:B084:NW04:7NAMESET") {
  field(FLNK, "ACSW:B084:NW04:7NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B084:NW04:7NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(7) acsw-b084-nw04")
  field(DOL, "ACSW:B084:NW04:7NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B084:NW04:7SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(7) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINIT")
}

record(bo, "ACSW:B084:NW04:7SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(7) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINIT")
}

record(stringin, "ACSW:B084:NW04:7INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW04:7INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B084:NW04:7INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B084:NW04:7INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B084:NW04:7INITSTATE")
}

record(mbbi, "ACSW:B084:NW04:7INITSTATE") {
#  field(SDIS, "ACSW:B084:NW04:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW04:7INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
record(stringin, "ACSW:B084:NW04:8NAME") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW04:8POWERSTATEIN")
}

record(stringin, "ACSW:B084:NW04:8POWERSTATEIN") {
  field(FLNK, "ACSW:B084:NW04:8POWERSTATESV")
}

record(scalcout, "ACSW:B084:NW04:8POWERSTATESV") {
  field(CALC,  "AA==BB?0:(AA==CC?1):(AA==DD?2):3")
  field(INAA, "ACSW:B084:NW04:8POWERSTATEIN")
  field(BB, "ON")
  field(CC, "OFF*")
  field(DD, "OFF")
  field(FLNK, "ACSW:B084:NW04:8POWERSTATE")
}

record(mbbi, "ACSW:B084:NW04:8POWERSTATE") {
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW04:8POWERSTATESV")
  field(FLNK, "")
  field(ZRST, "ON")
  field(ONST, "OFF*")
  field(TWST, "OFF")
  field(THST, "UNKNOWN")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
  field(TWSV, "MAJOR")
  field(THSV, "INVALID")
  field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

record(bo, "ACSW:B084:NW04:8POWEROFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOff(8) acsw-b084-nw04")
}

record(bo, "ACSW:B084:NW04:8POWERON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletOn(8) acsw-b084-nw04")
}

record(bo, "ACSW:B084:NW04:8HARDRESET") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletHardReset(8) acsw-b084-nw04")
}

record(stringin, "ACSW:B084:NW04:8NAMESET") {
  field(FLNK, "ACSW:B084:NW04:8NAMESETGO")
  field(VAL, "")
}

record(stringout, "ACSW:B084:NW04:8NAMESETGO") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletName(8) acsw-b084-nw04")
  field(DOL, "ACSW:B084:NW04:8NAMESET")
  field(OMSL, "closed_loop")
}

record(bo, "ACSW:B084:NW04:8SETINITOFF") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOff(8) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINIT")
}

record(bo, "ACSW:B084:NW04:8SETINITON") {
  field(DTYP, "stream")
  field(OUT, "@acsw_apc.proto.db setOutletInitOn(8) acsw-b084-nw04")
  field(FLNK, "ACSW:B084:NW04:GETINIT")
}

record(stringin, "ACSW:B084:NW04:8INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:B084:NW04:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:B084:NW04:8INITSTATESV")
}

# Currently, power on delay is always 0 or never, 
# so our 2 initial states are 'on' or 'off'.
# If we start using delays, we should modify this
# logic to display the delay. 
record(scalcout, "ACSW:B084:NW04:8INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:B084:NW04:8INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:B084:NW04:8INITSTATE")
}

record(mbbi, "ACSW:B084:NW04:8INITSTATE") {
#  field(SDIS, "ACSW:B084:NW04:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:B084:NW04:8INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
