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

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

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

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

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

}

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

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

record(ai, "ACSW:XT01:NW01:TYPE") {
  field(DESC, "APC 24 Port AC Power Switch")
  field(PINI, "YES")
  field(VAL, "17")
}

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

record(bo, "ACSW:XT01: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-xt01-nw01")
}

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

record(bi, "ACSW:XT01: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:XT01:NW01:ACCSTART") {
  field(SELM, "All")
  field(DOL1, "1")
  field(LNK1, "ACSW:XT01:NW01:GETSTATUS.DISA")
  field(DOL2, "0")
  field(LNK2, "ACSW:XT01:NW01:DISCONN.DISA PP")
}

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

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

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

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

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

record(mbbi, "ACSW:XT01:NW01:1POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01: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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

record(stringin, "ACSW:XT01:NW01:1INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:XT01:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:XT01: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:XT01:NW01:1INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:1INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:1INITSTATE")
}

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

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

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

record(mbbi, "ACSW:XT01:NW01:2POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01: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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

record(stringin, "ACSW:XT01:NW01:2INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:XT01:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:XT01: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:XT01:NW01:2INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:2INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:2INITSTATE")
}

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

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

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

record(mbbi, "ACSW:XT01:NW01:3POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01: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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

record(stringin, "ACSW:XT01:NW01:3INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:XT01:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:XT01: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:XT01:NW01:3INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:3INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:3INITSTATE")
}

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

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

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

record(mbbi, "ACSW:XT01:NW01:4POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01: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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

record(stringin, "ACSW:XT01:NW01:4INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:XT01:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:XT01: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:XT01:NW01:4INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:4INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:4INITSTATE")
}

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

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

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

record(mbbi, "ACSW:XT01:NW01:5POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01: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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

record(stringin, "ACSW:XT01:NW01:5INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:XT01:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:XT01: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:XT01:NW01:5INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:5INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:5INITSTATE")
}

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

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

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

record(mbbi, "ACSW:XT01:NW01:6POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01: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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

record(stringin, "ACSW:XT01:NW01:6INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:XT01:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:XT01: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:XT01:NW01:6INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:6INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:6INITSTATE")
}

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

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

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

record(mbbi, "ACSW:XT01:NW01:7POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01: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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

record(stringin, "ACSW:XT01:NW01:7INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:XT01:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:XT01: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:XT01:NW01:7INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:7INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:7INITSTATE")
}

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

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

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

record(mbbi, "ACSW:XT01:NW01:8POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01: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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

record(stringin, "ACSW:XT01:NW01:8INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:XT01:NW01:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:XT01: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:XT01:NW01:8INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:8INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:8INITSTATE")
}

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

record(stringin, "ACSW:XT01:NW01:9POWERSTATEIN") {
  field(FLNK, "ACSW:XT01:NW01:9POWERSTATESV")
}

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

record(mbbi, "ACSW:XT01:NW01:9POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01:NW01:9POWERSTATESV")
  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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

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

# 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:XT01:NW01:9INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:9INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:9INITSTATE")
}

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

record(stringin, "ACSW:XT01:NW01:10POWERSTATEIN") {
  field(FLNK, "ACSW:XT01:NW01:10POWERSTATESV")
}

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

record(mbbi, "ACSW:XT01:NW01:10POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01:NW01:10POWERSTATESV")
  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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

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

# 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:XT01:NW01:10INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:10INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:10INITSTATE")
}

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

record(stringin, "ACSW:XT01:NW01:11POWERSTATEIN") {
  field(FLNK, "ACSW:XT01:NW01:11POWERSTATESV")
}

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

record(mbbi, "ACSW:XT01:NW01:11POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01:NW01:11POWERSTATESV")
  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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

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

# 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:XT01:NW01:11INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:11INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:11INITSTATE")
}

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

record(stringin, "ACSW:XT01:NW01:12POWERSTATEIN") {
  field(FLNK, "ACSW:XT01:NW01:12POWERSTATESV")
}

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

record(mbbi, "ACSW:XT01:NW01:12POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01:NW01:12POWERSTATESV")
  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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

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

# 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:XT01:NW01:12INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:12INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:12INITSTATE")
}

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

record(stringin, "ACSW:XT01:NW01:13POWERSTATEIN") {
  field(FLNK, "ACSW:XT01:NW01:13POWERSTATESV")
}

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

record(mbbi, "ACSW:XT01:NW01:13POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01:NW01:13POWERSTATESV")
  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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

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

# 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:XT01:NW01:13INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:13INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:13INITSTATE")
}

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

record(stringin, "ACSW:XT01:NW01:14POWERSTATEIN") {
  field(FLNK, "ACSW:XT01:NW01:14POWERSTATESV")
}

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

record(mbbi, "ACSW:XT01:NW01:14POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01:NW01:14POWERSTATESV")
  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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

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

# 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:XT01:NW01:14INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:14INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:14INITSTATE")
}

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

record(stringin, "ACSW:XT01:NW01:15POWERSTATEIN") {
  field(FLNK, "ACSW:XT01:NW01:15POWERSTATESV")
}

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

record(mbbi, "ACSW:XT01:NW01:15POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01:NW01:15POWERSTATESV")
  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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

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

# 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:XT01:NW01:15INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:15INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:15INITSTATE")
}

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

record(stringin, "ACSW:XT01:NW01:16POWERSTATEIN") {
  field(FLNK, "ACSW:XT01:NW01:16POWERSTATESV")
}

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

record(mbbi, "ACSW:XT01:NW01:16POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01:NW01:16POWERSTATESV")
  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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

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

# 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:XT01:NW01:16INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:16INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:16INITSTATE")
}

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

record(stringin, "ACSW:XT01:NW01:17POWERSTATEIN") {
  field(FLNK, "ACSW:XT01:NW01:17POWERSTATESV")
}

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

record(mbbi, "ACSW:XT01:NW01:17POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01:NW01:17POWERSTATESV")
  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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

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

# 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:XT01:NW01:17INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:17INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:17INITSTATE")
}

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

record(stringin, "ACSW:XT01:NW01:18POWERSTATEIN") {
  field(FLNK, "ACSW:XT01:NW01:18POWERSTATESV")
}

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

record(mbbi, "ACSW:XT01:NW01:18POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01:NW01:18POWERSTATESV")
  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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

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

# 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:XT01:NW01:18INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:18INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:18INITSTATE")
}

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

record(stringin, "ACSW:XT01:NW01:19POWERSTATEIN") {
  field(FLNK, "ACSW:XT01:NW01:19POWERSTATESV")
}

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

record(mbbi, "ACSW:XT01:NW01:19POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01:NW01:19POWERSTATESV")
  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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

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

# 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:XT01:NW01:19INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:19INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:19INITSTATE")
}

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

record(stringin, "ACSW:XT01:NW01:20POWERSTATEIN") {
  field(FLNK, "ACSW:XT01:NW01:20POWERSTATESV")
}

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

record(mbbi, "ACSW:XT01:NW01:20POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01:NW01:20POWERSTATESV")
  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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

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

# 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:XT01:NW01:20INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:20INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:20INITSTATE")
}

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

record(stringin, "ACSW:XT01:NW01:21POWERSTATEIN") {
  field(FLNK, "ACSW:XT01:NW01:21POWERSTATESV")
}

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

record(mbbi, "ACSW:XT01:NW01:21POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01:NW01:21POWERSTATESV")
  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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

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

# 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:XT01:NW01:21INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:21INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:21INITSTATE")
}

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

record(stringin, "ACSW:XT01:NW01:22POWERSTATEIN") {
  field(FLNK, "ACSW:XT01:NW01:22POWERSTATESV")
}

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

record(mbbi, "ACSW:XT01:NW01:22POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01:NW01:22POWERSTATESV")
  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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

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

# 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:XT01:NW01:22INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:22INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:22INITSTATE")
}

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

record(stringin, "ACSW:XT01:NW01:23POWERSTATEIN") {
  field(FLNK, "ACSW:XT01:NW01:23POWERSTATESV")
}

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

record(mbbi, "ACSW:XT01:NW01:23POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01:NW01:23POWERSTATESV")
  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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

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

# 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:XT01:NW01:23INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:23INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:23INITSTATE")
}

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

record(stringin, "ACSW:XT01:NW01:24POWERSTATEIN") {
  field(FLNK, "ACSW:XT01:NW01:24POWERSTATESV")
}

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

record(mbbi, "ACSW:XT01:NW01:24POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW01:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01:NW01:24POWERSTATESV")
  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:XT01:NW01:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

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

# 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:XT01:NW01:24INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW01:24INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW01:24INITSTATE")
}

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

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

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

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

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

}

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

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

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

record(stringin, "ACSW:XT01:NW02:LOC") {
  field(PINI, "YES")
  field(VAL, "B062")
  field(SDIS, "ACSW:XT01:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
  info(autosaveFields,"VAL")
}

record(bo, "ACSW:XT01: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-xt01-nw02")
}

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

record(bi, "ACSW:XT01: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:XT01:NW02:ACCSTART") {
  field(SELM, "All")
  field(DOL1, "1")
  field(LNK1, "ACSW:XT01:NW02:GETSTATUS.DISA")
  field(DOL2, "0")
  field(LNK2, "ACSW:XT01:NW02:DISCONN.DISA PP")
}

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

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

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

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

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

record(mbbi, "ACSW:XT01:NW02:1POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01: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:XT01:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

record(stringin, "ACSW:XT01:NW02:1INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:XT01:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:XT01: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:XT01:NW02:1INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW02:1INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW02:1INITSTATE")
}

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

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

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

record(mbbi, "ACSW:XT01:NW02:2POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01: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:XT01:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

record(stringin, "ACSW:XT01:NW02:2INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:XT01:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:XT01: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:XT01:NW02:2INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW02:2INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW02:2INITSTATE")
}

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

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

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

record(mbbi, "ACSW:XT01:NW02:3POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01: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:XT01:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

record(stringin, "ACSW:XT01:NW02:3INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:XT01:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:XT01: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:XT01:NW02:3INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW02:3INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW02:3INITSTATE")
}

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

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

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

record(mbbi, "ACSW:XT01:NW02:4POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01: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:XT01:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

record(stringin, "ACSW:XT01:NW02:4INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:XT01:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:XT01: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:XT01:NW02:4INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW02:4INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW02:4INITSTATE")
}

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

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

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

record(mbbi, "ACSW:XT01:NW02:5POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01: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:XT01:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

record(stringin, "ACSW:XT01:NW02:5INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:XT01:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:XT01: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:XT01:NW02:5INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW02:5INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW02:5INITSTATE")
}

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

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

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

record(mbbi, "ACSW:XT01:NW02:6POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01: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:XT01:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

record(stringin, "ACSW:XT01:NW02:6INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:XT01:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:XT01: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:XT01:NW02:6INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW02:6INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW02:6INITSTATE")
}

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

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

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

record(mbbi, "ACSW:XT01:NW02:7POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01: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:XT01:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

record(stringin, "ACSW:XT01:NW02:7INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:XT01:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:XT01: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:XT01:NW02:7INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW02:7INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW02:7INITSTATE")
}

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

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

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

record(mbbi, "ACSW:XT01:NW02:8POWERSTATE") {
  field(SDIS, "ACSW:XT01:NW02:GETSTATUS.DISA NPP MS")
  field(DISS, "INVALID")
  field(INP, "ACSW:XT01: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:XT01:NW02:GETSTATUS.SEVR CPP MS")
  field(DISV, "20")
}

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

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

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

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

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

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

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

record(stringin, "ACSW:XT01:NW02:8INITSTATEIN") {
   field(DESC, "Plug device name")
   field(SDIS, "ACSW:XT01:NW02:GETSTATUS.SEVR")
   field(DISV, "3")
   field(DISS, "INVALID")
   field(PINI, "YES")
   field(FLNK, "ACSW:XT01: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:XT01:NW02:8INITSTATESV") {
  field(CALC, "AA==BB?1:0")
  field(INAA, "ACSW:XT01:NW02:8INITSTATEIN NPP MS")
  field(BB, "never")
  field(FLNK, "ACSW:XT01:NW02:8INITSTATE")
}

record(mbbi, "ACSW:XT01:NW02:8INITSTATE") {
#  field(SDIS, "ACSW:XT01:NW02:GETSTATUS.DISA NPP MS")
#  field(DISS, "INVALID")
  field(INP, "ACSW:XT01:NW02:8INITSTATESV NPP MS")
  field(ZRST, "ON")
  field(ONST, "OFF")
  field(ZRSV, "NO_ALARM")
  field(ONSV, "MINOR")
}
