662 lines
23 KiB
Lua
662 lines
23 KiB
Lua
--
|
|
-- I/O Control's Data Receive (Rx) Handlers
|
|
--
|
|
|
|
local const = require("scada-common.constants")
|
|
local types = require("scada-common.types")
|
|
local util = require("scada-common.util")
|
|
|
|
local ALARM = types.ALARM
|
|
local ALARM_STATE = types.ALARM_STATE
|
|
|
|
local BLR_STATE = types.BOILER_STATE
|
|
local TRB_STATE = types.TURBINE_STATE
|
|
local TNK_STATE = types.TANK_STATE
|
|
|
|
local io ---@type pocket_ioctl
|
|
local iorx = {} ---@class iorx
|
|
|
|
-- populate facility data from API_GET_FAC
|
|
---@param data table
|
|
---@return boolean valid
|
|
function iorx.record_facility_data(data)
|
|
local valid = true
|
|
|
|
local fac = io.facility
|
|
|
|
fac.all_sys_ok = data[1]
|
|
fac.rtu_count = data[2]
|
|
fac.radiation = data[3]
|
|
|
|
-- auto control
|
|
if type(data[4]) == "table" and #data[4] == 4 then
|
|
fac.auto_ready = data[4][1]
|
|
fac.auto_active = data[4][2]
|
|
fac.auto_ramping = data[4][3]
|
|
fac.auto_saturated = data[4][4]
|
|
end
|
|
|
|
-- waste
|
|
if type(data[5]) == "table" and #data[5] == 2 then
|
|
fac.auto_current_waste_product = data[5][1]
|
|
fac.auto_pu_fallback_active = data[5][2]
|
|
end
|
|
|
|
fac.num_tanks = data[6]
|
|
fac.has_imatrix = data[7]
|
|
fac.has_sps = data[8]
|
|
|
|
return valid
|
|
end
|
|
|
|
local function tripped(state) return state == ALARM_STATE.TRIPPED or state == ALARM_STATE.ACKED end
|
|
|
|
local function _record_multiblock_status(faulted, data, ps)
|
|
ps.publish("formed", data.formed)
|
|
ps.publish("faulted", faulted)
|
|
|
|
for key, val in pairs(data.state) do ps.publish(key, val) end
|
|
for key, val in pairs(data.tanks) do ps.publish(key, val) end
|
|
end
|
|
|
|
-- update unit status data from API_GET_UNIT
|
|
---@param data table
|
|
function iorx.record_unit_data(data)
|
|
local unit = io.units[data[1]]
|
|
|
|
unit.connected = data[2]
|
|
local comp_statuses = data[3]
|
|
unit.a_group = data[4]
|
|
unit.alarms = data[5]
|
|
|
|
local next_c_stat = 1
|
|
|
|
unit.unit_ps.publish("auto_group_id", unit.a_group)
|
|
unit.unit_ps.publish("auto_group", types.AUTO_GROUP_NAMES[unit.a_group + 1])
|
|
|
|
--#region Annunciator
|
|
|
|
unit.annunciator = data[6]
|
|
|
|
local rcs_disconn, rcs_warn, rcs_hazard = false, false, false
|
|
|
|
for key, val in pairs(unit.annunciator) do
|
|
if key == "BoilerOnline" or key == "TurbineOnline" then
|
|
local every = true
|
|
|
|
-- split up online arrays
|
|
for id = 1, #val do
|
|
every = every and val[id]
|
|
|
|
if key == "BoilerOnline" then
|
|
unit.boiler_ps_tbl[id].publish(key, val[id])
|
|
else
|
|
unit.turbine_ps_tbl[id].publish(key, val[id])
|
|
end
|
|
end
|
|
|
|
if not every then rcs_disconn = true end
|
|
|
|
unit.unit_ps.publish("U_" .. key, every)
|
|
elseif key == "HeatingRateLow" or key == "WaterLevelLow" then
|
|
-- split up array for all boilers
|
|
local any = false
|
|
for id = 1, #val do
|
|
any = any or val[id]
|
|
unit.boiler_ps_tbl[id].publish(key, val[id])
|
|
end
|
|
|
|
if key == "HeatingRateLow" and any then
|
|
rcs_warn = true
|
|
elseif key == "WaterLevelLow" and any then
|
|
rcs_hazard = true
|
|
end
|
|
|
|
unit.unit_ps.publish("U_" .. key, any)
|
|
elseif key == "SteamDumpOpen" or key == "TurbineOverSpeed" or key == "GeneratorTrip" or key == "TurbineTrip" then
|
|
-- split up array for all turbines
|
|
local any = false
|
|
for id = 1, #val do
|
|
any = any or val[id]
|
|
unit.turbine_ps_tbl[id].publish(key, val[id])
|
|
end
|
|
|
|
if key == "GeneratorTrip" and any then
|
|
rcs_warn = true
|
|
elseif (key == "TurbineOverSpeed" or key == "TurbineTrip") and any then
|
|
rcs_hazard = true
|
|
end
|
|
|
|
unit.unit_ps.publish("U_" .. key, any)
|
|
else
|
|
-- non-table fields
|
|
unit.unit_ps.publish(key, val)
|
|
end
|
|
end
|
|
|
|
local anc = unit.annunciator
|
|
rcs_hazard = rcs_hazard or anc.RCPTrip
|
|
rcs_warn = rcs_warn or anc.RCSFlowLow or anc.CoolantLevelLow or anc.RCSFault or anc.MaxWaterReturnFeed or
|
|
anc.CoolantFeedMismatch or anc.BoilRateMismatch or anc.SteamFeedMismatch
|
|
|
|
local rcs_status = 4
|
|
if rcs_hazard then
|
|
rcs_status = 2
|
|
elseif rcs_warn then
|
|
rcs_status = 3
|
|
elseif rcs_disconn then
|
|
rcs_status = 1
|
|
end
|
|
|
|
unit.unit_ps.publish("U_RCS", rcs_status)
|
|
|
|
--#endregion
|
|
|
|
--#region Reactor Data
|
|
|
|
unit.reactor_data = data[7]
|
|
|
|
local control_status = 1
|
|
local reactor_status = 1
|
|
local rps_status = 1
|
|
|
|
if unit.connected then
|
|
-- update RPS status
|
|
if unit.reactor_data.rps_tripped then
|
|
control_status = 2
|
|
rps_status = util.trinary(unit.reactor_data.rps_trip_cause == "manual", 3, 2)
|
|
else
|
|
rps_status = 4
|
|
end
|
|
|
|
reactor_status = 4 -- ok, until proven otherwise
|
|
|
|
-- update reactor/control status
|
|
if unit.reactor_data.mek_status.status then
|
|
control_status = util.trinary(unit.annunciator.AutoControl, 4, 3)
|
|
else
|
|
if unit.reactor_data.no_reactor then
|
|
reactor_status = 2
|
|
elseif (not unit.reactor_data.formed) or unit.reactor_data.rps_status.force_dis then
|
|
reactor_status = 3
|
|
end
|
|
end
|
|
|
|
for key, val in pairs(unit.reactor_data) do
|
|
if key ~= "rps_status" and key ~= "mek_struct" and key ~= "mek_status" then
|
|
unit.unit_ps.publish(key, val)
|
|
end
|
|
end
|
|
|
|
for key, val in pairs(unit.reactor_data.rps_status) do
|
|
unit.unit_ps.publish(key, val)
|
|
end
|
|
|
|
for key, val in pairs(unit.reactor_data.mek_struct) do
|
|
unit.unit_ps.publish(key, val)
|
|
end
|
|
|
|
for key, val in pairs(unit.reactor_data.mek_status) do
|
|
unit.unit_ps.publish(key, val)
|
|
end
|
|
end
|
|
|
|
unit.unit_ps.publish("U_ControlStatus", control_status)
|
|
unit.unit_ps.publish("U_ReactorStatus", reactor_status)
|
|
unit.unit_ps.publish("U_ReactorStateStatus", comp_statuses[next_c_stat])
|
|
unit.unit_ps.publish("U_RPS", rps_status)
|
|
|
|
next_c_stat = next_c_stat + 1
|
|
|
|
--#endregion
|
|
|
|
--#region RTU Devices
|
|
|
|
unit.boiler_data_tbl = data[8]
|
|
|
|
for id = 1, #unit.boiler_data_tbl do
|
|
local boiler = unit.boiler_data_tbl[id]
|
|
local ps = unit.boiler_ps_tbl[id]
|
|
local c_stat = comp_statuses[next_c_stat]
|
|
|
|
local boiler_status = 1
|
|
|
|
if c_stat ~= BLR_STATE.OFFLINE then
|
|
if c_stat == BLR_STATE.FAULT then
|
|
boiler_status = 3
|
|
elseif c_stat ~= BLR_STATE.UNFORMED then
|
|
boiler_status = 4
|
|
else
|
|
boiler_status = 2
|
|
end
|
|
|
|
_record_multiblock_status(c_stat == BLR_STATE.FAULT, boiler, ps)
|
|
end
|
|
|
|
ps.publish("BoilerStatus", boiler_status)
|
|
ps.publish("BoilerStateStatus", c_stat)
|
|
|
|
next_c_stat = next_c_stat + 1
|
|
end
|
|
|
|
unit.turbine_data_tbl = data[9]
|
|
|
|
for id = 1, #unit.turbine_data_tbl do
|
|
local turbine = unit.turbine_data_tbl[id]
|
|
local ps = unit.turbine_ps_tbl[id]
|
|
local c_stat = comp_statuses[next_c_stat]
|
|
|
|
local turbine_status = 1
|
|
|
|
if c_stat ~= TRB_STATE.OFFLINE then
|
|
if c_stat == TRB_STATE.FAULT then
|
|
turbine_status = 3
|
|
elseif turbine.formed then
|
|
turbine_status = 4
|
|
else
|
|
turbine_status = 2
|
|
end
|
|
|
|
_record_multiblock_status(c_stat == TRB_STATE.FAULT, turbine, ps)
|
|
end
|
|
|
|
ps.publish("TurbineStatus", turbine_status)
|
|
ps.publish("TurbineStateStatus", c_stat)
|
|
|
|
next_c_stat = next_c_stat + 1
|
|
end
|
|
|
|
unit.tank_data_tbl = data[10]
|
|
|
|
for id = 1, #unit.tank_data_tbl do
|
|
local tank = unit.tank_data_tbl[id]
|
|
local ps = unit.tank_ps_tbl[id]
|
|
local c_stat = comp_statuses[next_c_stat]
|
|
|
|
local tank_status = 1
|
|
|
|
if c_stat ~= TNK_STATE.OFFLINE then
|
|
if c_stat == TNK_STATE.FAULT then
|
|
tank_status = 3
|
|
elseif tank.formed then
|
|
tank_status = 4
|
|
else
|
|
tank_status = 2
|
|
end
|
|
|
|
_record_multiblock_status(c_stat == TNK_STATE.FAULT, tank, ps)
|
|
end
|
|
|
|
ps.publish("DynamicTankStatus", tank_status)
|
|
ps.publish("DynamicTankStateStatus", c_stat)
|
|
|
|
next_c_stat = next_c_stat + 1
|
|
end
|
|
|
|
unit.last_rate_change_ms = data[11]
|
|
unit.turbine_flow_stable = data[12]
|
|
|
|
--#endregion
|
|
|
|
--#region Status Information Display
|
|
|
|
local ecam = {} -- aviation reference :)
|
|
|
|
-- local function red(text) return { text = text, color = colors.red } end
|
|
local function white(text) return { text = text, color = colors.white } end
|
|
local function blue(text) return { text = text, color = colors.blue } end
|
|
|
|
-- if unit.reactor_data.rps_status then
|
|
-- for k, v in pairs(unit.alarms) do
|
|
-- unit.alarms[k] = ALARM_STATE.TRIPPED
|
|
-- end
|
|
-- end
|
|
|
|
if tripped(unit.alarms[ALARM.ContainmentBreach]) then
|
|
local items = { white("REACTOR MELTDOWN"), blue("DON HAZMAT SUIT") }
|
|
table.insert(ecam, { color = colors.red, text = "CONTAINMENT BREACH", help = "ContainmentBreach", items = items })
|
|
end
|
|
|
|
if tripped(unit.alarms[ALARM.ContainmentRadiation]) then
|
|
local items = {
|
|
white("RADIATION DETECTED"),
|
|
blue("DON HAZMAT SUIT"),
|
|
blue("RESOLVE LEAK"),
|
|
blue("AWAIT SAFE LEVELS")
|
|
}
|
|
|
|
table.insert(ecam, { color = colors.red, text = "RADIATION LEAK", help = "ContainmentRadiation", items = items })
|
|
end
|
|
|
|
if tripped(unit.alarms[ALARM.CriticalDamage]) then
|
|
local items = { white("MELTDOWN IMMINENT"), blue("EVACUATE") }
|
|
table.insert(ecam, { color = colors.red, text = "RCT DAMAGE CRITICAL", help = "CriticalDamage", items = items })
|
|
end
|
|
|
|
if tripped(unit.alarms[ALARM.ReactorLost]) then
|
|
local items = { white("REACTOR OFF-LINE"), blue("CHECK PLC") }
|
|
table.insert(ecam, { color = colors.red, text = "REACTOR CONN LOST", help = "ReactorLost", items = items })
|
|
end
|
|
|
|
if tripped(unit.alarms[ALARM.ReactorDamage]) then
|
|
local items = { white("REACTOR DAMAGED"), blue("CHECK RCS"), blue("AWAIT DMG REDUCED") }
|
|
table.insert(ecam, { color = colors.red, text = "REACTOR DAMAGE", help = "ReactorDamage", items = items })
|
|
end
|
|
|
|
if tripped(unit.alarms[ALARM.ReactorOverTemp]) then
|
|
local items = { white("DAMAGING TEMP"), blue("CHECK RCS"), blue("AWAIT COOLDOWN") }
|
|
table.insert(ecam, { color = colors.red, text = "REACTOR OVER TEMP", help = "ReactorOverTemp", items = items })
|
|
end
|
|
|
|
if tripped(unit.alarms[ALARM.ReactorHighTemp]) then
|
|
local items = { white("OVER EXPECTED TEMP"), blue("CHECK RCS") }
|
|
table.insert(ecam, { color = colors.yellow, text = "REACTOR HIGH TEMP", help = "ReactorHighTemp", items = items})
|
|
end
|
|
|
|
if tripped(unit.alarms[ALARM.ReactorWasteLeak]) then
|
|
local items = { white("AT WASTE CAPACITY"), blue("CHECK WASTE OUTPUT"), blue("KEEP RCT DISABLED") }
|
|
table.insert(ecam, { color = colors.red, text = "REACTOR WASTE LEAK", help = "ReactorWasteLeak", items = items})
|
|
end
|
|
|
|
if tripped(unit.alarms[ALARM.ReactorHighWaste]) then
|
|
local items = { blue("CHECK WASTE OUTPUT") }
|
|
table.insert(ecam, { color = colors.yellow, text = "REACTOR WASTE HIGH", help = "ReactorHighWaste", items = items})
|
|
end
|
|
|
|
if tripped(unit.alarms[ALARM.RPSTransient]) then
|
|
local items = {}
|
|
local stat = unit.reactor_data.rps_status
|
|
|
|
-- for k, _ in pairs(stat) do stat[k] = true end
|
|
|
|
local function insert(cond, key, text, color) if cond[key] then table.insert(items, { text = text, help = key, color = color }) end end
|
|
|
|
table.insert(items, white("REACTOR SCRAMMED"))
|
|
insert(stat, "high_dmg", "HIGH DAMAGE", colors.red)
|
|
insert(stat, "high_temp", "HIGH TEMPERATURE", colors.red)
|
|
insert(stat, "low_cool", "CRIT LOW COOLANT")
|
|
insert(stat, "ex_waste", "EXCESS WASTE")
|
|
insert(stat, "ex_hcool", "EXCESS HEATED COOL")
|
|
insert(stat, "no_fuel", "NO FUEL")
|
|
insert(stat, "fault", "HARDWARE FAULT")
|
|
insert(stat, "timeout", "SUPERVISOR DISCONN")
|
|
insert(stat, "manual", "MANUAL SCRAM", colors.white)
|
|
insert(stat, "automatic", "AUTOMATIC SCRAM")
|
|
insert(stat, "sys_fail", "NOT FORMED", colors.red)
|
|
insert(stat, "force_dis", "FORCE DISABLED", colors.red)
|
|
table.insert(items, blue("RESOLVE PROBLEM"))
|
|
table.insert(items, blue("RESET RPS"))
|
|
|
|
table.insert(ecam, { color = colors.yellow, text = "RPS TRANSIENT", help = "RPSTransient", items = items})
|
|
end
|
|
|
|
if tripped(unit.alarms[ALARM.RCSTransient]) then
|
|
local items = {}
|
|
local annunc = unit.annunciator
|
|
|
|
-- for k, v in pairs(annunc) do
|
|
-- if type(v) == "boolean" then annunc[k] = true end
|
|
-- if type(v) == "table" then
|
|
-- for a, _ in pairs(v) do
|
|
-- v[a] = true
|
|
-- end
|
|
-- end
|
|
-- end
|
|
|
|
local function insert(cond, key, text, color)
|
|
if cond == true or (type(cond) == "table" and cond[key]) then table.insert(items, { text = text, help = key, color = color }) end
|
|
end
|
|
|
|
table.insert(items, white("COOLANT PROBLEM"))
|
|
|
|
insert(annunc, "RCPTrip", "RCP TRIP", colors.red)
|
|
insert(annunc, "CoolantLevelLow", "LOW COOLANT")
|
|
|
|
if unit.num_boilers == 0 then
|
|
if (util.time_ms() - unit.last_rate_change_ms) > const.FLOW_STABILITY_DELAY_MS then
|
|
insert(annunc, "BoilRateMismatch", "BOIL RATE MISMATCH")
|
|
end
|
|
|
|
if unit.turbine_flow_stable then
|
|
insert(annunc, "RCSFlowLow", "RCS FLOW LOW")
|
|
insert(annunc, "CoolantFeedMismatch", "COOL FEED MISMATCH")
|
|
insert(annunc, "SteamFeedMismatch", "STM FEED MISMATCH")
|
|
end
|
|
else
|
|
if (util.time_ms() - unit.last_rate_change_ms) > const.FLOW_STABILITY_DELAY_MS then
|
|
insert(annunc, "RCSFlowLow", "RCS FLOW LOW")
|
|
insert(annunc, "BoilRateMismatch", "BOIL RATE MISMATCH")
|
|
insert(annunc, "CoolantFeedMismatch", "COOL FEED MISMATCH")
|
|
end
|
|
|
|
if unit.turbine_flow_stable then
|
|
insert(annunc, "SteamFeedMismatch", "STM FEED MISMATCH")
|
|
end
|
|
end
|
|
|
|
insert(annunc, "MaxWaterReturnFeed", "MAX WTR RTRN FEED")
|
|
|
|
for k, v in ipairs(annunc.WaterLevelLow) do insert(v, "WaterLevelLow", "BOILER " .. k .. " WTR LOW", colors.red) end
|
|
for k, v in ipairs(annunc.HeatingRateLow) do insert(v, "HeatingRateLow", "BOILER " .. k .. " HEAT RATE") end
|
|
for k, v in ipairs(annunc.TurbineOverSpeed) do insert(v, "TurbineOverSpeed", "TURBINE " .. k .. " OVERSPD", colors.red) end
|
|
for k, v in ipairs(annunc.GeneratorTrip) do insert(v, "GeneratorTrip", "TURBINE " .. k .. " GEN TRIP") end
|
|
|
|
table.insert(items, blue("CHECK COOLING SYS"))
|
|
|
|
table.insert(ecam, { color = colors.yellow, text = "RCS TRANSIENT", help = "RCSTransient", items = items})
|
|
end
|
|
|
|
if tripped(unit.alarms[ALARM.TurbineTrip]) then
|
|
local items = {}
|
|
|
|
for k, v in ipairs(unit.annunciator.TurbineTrip) do
|
|
if v then table.insert(items, { text = "TURBINE " .. k .. " TRIP", help = "TurbineTrip" }) end
|
|
end
|
|
|
|
table.insert(items, blue("CHECK ENERGY OUT"))
|
|
table.insert(ecam, { color = colors.red, text = "TURBINE TRIP", help = "TurbineTripAlarm", items = items})
|
|
end
|
|
|
|
if not (tripped(unit.alarms[ALARM.ReactorLost]) or unit.connected) then
|
|
local items = { blue("CHECK PLC") }
|
|
table.insert(ecam, { color = colors.yellow, text = "REACTOR OFF-LINE", items = items })
|
|
end
|
|
|
|
for k, v in ipairs(unit.annunciator.BoilerOnline) do
|
|
if not v then
|
|
local items = { blue("CHECK RTU") }
|
|
table.insert(ecam, { color = colors.yellow, text = "BOILER " .. k .. " OFF-LINE", items = items})
|
|
end
|
|
end
|
|
|
|
for k, v in ipairs(unit.annunciator.TurbineOnline) do
|
|
if not v then
|
|
local items = { blue("CHECK RTU") }
|
|
table.insert(ecam, { color = colors.yellow, text = "TURBINE " .. k .. " OFF-LINE", items = items})
|
|
end
|
|
end
|
|
|
|
-- if no alarms, put some basic status messages in
|
|
if #ecam == 0 then
|
|
table.insert(ecam, { color = colors.green, text = "REACTOR " .. util.trinary(unit.reactor_data.mek_status.status, "NOMINAL", "IDLE"), items = {}})
|
|
|
|
local plural = util.trinary(unit.num_turbines > 1, "S", "")
|
|
table.insert(ecam, { color = colors.green, text = "TURBINE" .. plural .. util.trinary(unit.turbine_flow_stable, " STABLE", " STABILIZING"), items = {}})
|
|
end
|
|
|
|
unit.unit_ps.publish("U_ECAM", textutils.serialize(ecam))
|
|
|
|
--#endregion
|
|
end
|
|
|
|
-- update control app with unit data from API_GET_CTRL
|
|
---@param data table
|
|
function iorx.record_control_data(data)
|
|
for u_id = 1, #data do
|
|
local unit = io.units[u_id]
|
|
local u_data = data[u_id]
|
|
|
|
unit.connected = u_data[1]
|
|
|
|
unit.reactor_data.rps_tripped = u_data[2]
|
|
unit.unit_ps.publish("rps_tripped", u_data[2])
|
|
unit.reactor_data.mek_status.status = u_data[3]
|
|
unit.unit_ps.publish("status", u_data[3])
|
|
unit.reactor_data.mek_status.temp = u_data[4]
|
|
unit.unit_ps.publish("temp", u_data[4])
|
|
unit.reactor_data.mek_status.burn_rate = u_data[5]
|
|
unit.unit_ps.publish("burn_rate", u_data[5])
|
|
unit.reactor_data.mek_status.act_burn_rate = u_data[6]
|
|
unit.unit_ps.publish("act_burn_rate", u_data[6])
|
|
unit.reactor_data.mek_struct.max_burn = u_data[7]
|
|
unit.unit_ps.publish("max_burn", u_data[7])
|
|
|
|
unit.annunciator.AutoControl = u_data[8]
|
|
unit.unit_ps.publish("AutoControl", u_data[8])
|
|
|
|
unit.a_group = u_data[9]
|
|
unit.unit_ps.publish("auto_group_id", unit.a_group)
|
|
unit.unit_ps.publish("auto_group", types.AUTO_GROUP_NAMES[unit.a_group + 1])
|
|
|
|
local control_status = 1
|
|
|
|
if unit.connected then
|
|
if unit.reactor_data.rps_tripped then
|
|
control_status = 2
|
|
end
|
|
|
|
if unit.reactor_data.mek_status.status then
|
|
control_status = util.trinary(unit.annunciator.AutoControl, 4, 3)
|
|
end
|
|
end
|
|
|
|
unit.unit_ps.publish("U_ControlStatus", control_status)
|
|
end
|
|
end
|
|
|
|
-- update process app with unit data from API_GET_PROC
|
|
---@param data table
|
|
function iorx.record_process_data(data)
|
|
-- get unit data
|
|
for u_id = 1, #io.units do
|
|
local unit = io.units[u_id]
|
|
local u_data = data[u_id]
|
|
|
|
unit.reactor_data.mek_status.status = u_data[1]
|
|
unit.reactor_data.mek_struct.max_burn = u_data[2]
|
|
unit.annunciator.AutoControl = u_data[6]
|
|
unit.a_group = u_data[7]
|
|
|
|
unit.unit_ps.publish("status", u_data[1])
|
|
unit.unit_ps.publish("max_burn", u_data[2])
|
|
unit.unit_ps.publish("burn_limit", u_data[3])
|
|
unit.unit_ps.publish("U_AutoReady", u_data[4])
|
|
unit.unit_ps.publish("U_AutoDegraded", u_data[5])
|
|
unit.unit_ps.publish("AutoControl", u_data[6])
|
|
unit.unit_ps.publish("auto_group_id", unit.a_group)
|
|
unit.unit_ps.publish("auto_group", types.AUTO_GROUP_NAMES[unit.a_group + 1])
|
|
end
|
|
|
|
-- get facility data
|
|
local fac = io.facility
|
|
local f_data = data[#io.units + 1]
|
|
|
|
fac.status_lines = f_data[1]
|
|
|
|
fac.auto_ready = f_data[2][1]
|
|
fac.auto_active = f_data[2][2]
|
|
fac.auto_ramping = f_data[2][3]
|
|
fac.auto_saturated = f_data[2][4]
|
|
|
|
fac.auto_scram = f_data[3]
|
|
fac.ascram_status = f_data[4]
|
|
|
|
fac.ps.publish("status_line_1", fac.status_lines[1])
|
|
fac.ps.publish("status_line_2", fac.status_lines[2])
|
|
|
|
fac.ps.publish("auto_ready", fac.auto_ready)
|
|
fac.ps.publish("auto_active", fac.auto_active)
|
|
fac.ps.publish("auto_ramping", fac.auto_ramping)
|
|
fac.ps.publish("auto_saturated", fac.auto_saturated)
|
|
|
|
fac.ps.publish("auto_scram", fac.auto_scram)
|
|
fac.ps.publish("as_matrix_fault", fac.ascram_status.matrix_fault)
|
|
fac.ps.publish("as_matrix_fill", fac.ascram_status.matrix_fill)
|
|
fac.ps.publish("as_crit_alarm", fac.ascram_status.crit_alarm)
|
|
fac.ps.publish("as_radiation", fac.ascram_status.radiation)
|
|
fac.ps.publish("as_gen_fault", fac.ascram_status.gen_fault)
|
|
|
|
fac.ps.publish("process_mode", f_data[5][1])
|
|
fac.ps.publish("process_burn_target", f_data[5][2])
|
|
fac.ps.publish("process_charge_target", f_data[5][3])
|
|
fac.ps.publish("process_gen_target", f_data[5][4])
|
|
end
|
|
|
|
-- update waste app with unit data from API_GET_WASTE
|
|
---@param data table
|
|
function iorx.record_waste_data(data)
|
|
-- get unit data
|
|
for u_id = 1, #io.units do
|
|
local unit = io.units[u_id]
|
|
local u_data = data[u_id]
|
|
|
|
unit.waste_mode = u_data[1]
|
|
unit.waste_product = u_data[2]
|
|
unit.num_snas = u_data[3]
|
|
unit.sna_peak_rate = u_data[4]
|
|
unit.sna_max_rate = u_data[5]
|
|
unit.sna_out_rate = u_data[6]
|
|
unit.waste_stats = u_data[7]
|
|
|
|
unit.unit_ps.publish("U_AutoWaste", unit.waste_mode == types.WASTE_MODE.AUTO)
|
|
unit.unit_ps.publish("U_WasteMode", unit.waste_mode)
|
|
unit.unit_ps.publish("U_WasteProduct", unit.waste_product)
|
|
|
|
unit.unit_ps.publish("sna_count", unit.num_snas)
|
|
unit.unit_ps.publish("sna_peak_rate", unit.sna_peak_rate)
|
|
unit.unit_ps.publish("sna_max_rate", unit.sna_max_rate)
|
|
unit.unit_ps.publish("sna_out_rate", unit.sna_out_rate)
|
|
|
|
unit.unit_ps.publish("pu_rate", unit.waste_stats[1])
|
|
unit.unit_ps.publish("po_rate", unit.waste_stats[2])
|
|
unit.unit_ps.publish("po_pl_rate", unit.waste_stats[3])
|
|
end
|
|
|
|
-- get facility data
|
|
local fac = io.facility
|
|
local f_data = data[#io.units + 1]
|
|
|
|
fac.auto_current_waste_product = f_data[1]
|
|
fac.auto_pu_fallback_active = f_data[2]
|
|
fac.auto_sps_disabled = f_data[3]
|
|
|
|
fac.ps.publish("current_waste_product", fac.auto_current_waste_product)
|
|
fac.ps.publish("pu_fallback_active", fac.auto_pu_fallback_active)
|
|
fac.ps.publish("sps_disabled_low_power", fac.auto_sps_disabled)
|
|
|
|
fac.ps.publish("process_waste_product", f_data[4])
|
|
fac.ps.publish("process_pu_fallback", f_data[5])
|
|
fac.ps.publish("process_sps_low_power", f_data[6])
|
|
|
|
fac.waste_stats = f_data[7]
|
|
|
|
fac.ps.publish("burn_sum", fac.waste_stats[1])
|
|
fac.ps.publish("pu_rate", fac.waste_stats[2])
|
|
fac.ps.publish("po_rate", fac.waste_stats[3])
|
|
fac.ps.publish("po_pl_rate", fac.waste_stats[4])
|
|
fac.ps.publish("po_am_rate", fac.waste_stats[5])
|
|
fac.ps.publish("spent_waste_rate", fac.waste_stats[6])
|
|
|
|
fac.ps.publish("sps_computed_status", f_data[8])
|
|
fac.ps.publish("sps_process_rate", f_data[9])
|
|
end
|
|
|
|
function iorx.record_fac_detail_data(data)
|
|
|
|
end
|
|
|
|
return function (io_obj)
|
|
io = io_obj
|
|
return iorx
|
|
end
|