Merge branch 'pocket-alpha-dev' of https://github.com/MikaylaFischler/cc-mek-scada into pocket-alpha-dev

coordinator/coordinator.lua

@@ -89,7 +89,7 @@ function coordinator.load_config()
 
     if type(config.AuthKey) == "string" then
         local len = string.len(config.AuthKey)
-        cfv.assert_eq(len == 0 or len >= 8, true)
+        cfv.assert(len == 0 or len >= 8)
     end
 
     cfv.assert_type_int(config.LogMode)
@@ -192,7 +192,7 @@ end
 ---@return function? update, function? done
 local function log_dmesg(message, dmesg_tag, working)
     local colors = {
-        GRAPHICS = colors.green,
+        RENDER = colors.green,
         SYSTEM = colors.cyan,
         BOOT = colors.blue,
         COMMS = colors.purple,
@@ -206,7 +206,7 @@ local function log_dmesg(message, dmesg_tag, working)
     end
 end
 
-function coordinator.log_graphics(message) log_dmesg(message, "GRAPHICS") end
+function coordinator.log_render(message) log_dmesg(message, "RENDER") end
 function coordinator.log_sys(message) log_dmesg(message, "SYSTEM") end
 function coordinator.log_boot(message) log_dmesg(message, "BOOT") end
 function coordinator.log_comms(message) log_dmesg(message, "COMMS") end

coordinator/iocontrol.lua

@@ -363,6 +363,13 @@ function iocontrol.fp_monitor_state(id, connected)
     end
 end
 
+-- report thread (routine) statuses
+---@param thread string thread name
+---@param ok boolean thread state
+function iocontrol.fp_rt_status(thread, ok)
+    io.fp.ps.publish(util.c("routine__", thread), ok)
+end
+
 -- report PKT firmware version and PKT session connection state
 ---@param session_id integer PKT session
 ---@param fw string firmware version

coordinator/renderer.lua

@@ -2,22 +2,26 @@
 -- Graphics Rendering Control
 --
 
-local log        = require("scada-common.log")
+local log         = require("scada-common.log")
+local util        = require("scada-common.util")
 
-local iocontrol  = require("coordinator.iocontrol")
+local coordinator = require("coordinator.coordinator")
+local iocontrol   = require("coordinator.iocontrol")
 
-local style      = require("coordinator.ui.style")
+local style       = require("coordinator.ui.style")
-local pgi        = require("coordinator.ui.pgi")
+local pgi         = require("coordinator.ui.pgi")
 
-local flow_view  = require("coordinator.ui.layout.flow_view")
+local flow_view   = require("coordinator.ui.layout.flow_view")
-local panel_view = require("coordinator.ui.layout.front_panel")
+local panel_view  = require("coordinator.ui.layout.front_panel")
-local main_view  = require("coordinator.ui.layout.main_view")
+local main_view   = require("coordinator.ui.layout.main_view")
-local unit_view  = require("coordinator.ui.layout.unit_view")
+local unit_view   = require("coordinator.ui.layout.unit_view")
 
-local core       = require("graphics.core")
+local core        = require("graphics.core")
-local flasher    = require("graphics.flasher")
+local flasher     = require("graphics.flasher")
 
-local DisplayBox = require("graphics.elements.displaybox")
+local DisplayBox  = require("graphics.elements.displaybox")
+
+local log_render = coordinator.log_render
 
 ---@class coord_renderer
 local renderer = {}
@@ -195,18 +199,21 @@ function renderer.try_start_ui()
             if engine.monitors.main ~= nil then
                 engine.ui.main_display = DisplayBox{window=engine.monitors.main,fg_bg=style.root}
                 main_view(engine.ui.main_display)
+                util.nop()
             end
 
             -- show flow view on flow monitor
             if engine.monitors.flow ~= nil then
                 engine.ui.flow_display = DisplayBox{window=engine.monitors.flow,fg_bg=style.root}
                 flow_view(engine.ui.flow_display)
+                util.nop()
             end
 
             -- show unit views on unit displays
             for idx, display in pairs(engine.monitors.unit_displays) do
                 engine.ui.unit_displays[idx] = DisplayBox{window=display,fg_bg=style.root}
                 unit_view(engine.ui.unit_displays[idx], idx)
+                util.nop()
             end
         end)
 
@@ -247,6 +254,11 @@ function renderer.close_ui()
     -- clear unit monitors
     for _, monitor in ipairs(engine.monitors.unit_displays) do monitor.clear() end
 
+    if not engine.disable_flow_view then
+        -- clear flow monitor
+        engine.monitors.flow.clear()
+    end
+
     -- re-draw dmesg
     engine.dmesg_window.setVisible(true)
     engine.dmesg_window.redraw()
@@ -383,12 +395,15 @@ function renderer.handle_resize(name)
         engine.dmesg_window.setVisible(not engine.ui_ready)
 
         if engine.ui_ready then
+            local draw_start = util.time_ms()
             local ok = pcall(function ()
                 ui.main_display = DisplayBox{window=device,fg_bg=style.root}
                 main_view(ui.main_display)
             end)
 
-            if not ok then
+            if ok then
+                log_render("main view re-draw completed in " .. (util.time_ms() - draw_start) .. "ms")
+            else
                 if ui.main_display then
                     ui.main_display.delete()
                     ui.main_display = nil
@@ -416,14 +431,15 @@ function renderer.handle_resize(name)
         iocontrol.fp_monitor_state("flow", true)
 
         if engine.ui_ready then
-            engine.dmesg_window.setVisible(false)
+            local draw_start = util.time_ms()
-
             local ok = pcall(function ()
                 ui.flow_display = DisplayBox{window=device,fg_bg=style.root}
                 flow_view(ui.flow_display)
             end)
 
-            if not ok then
+            if ok then
+                log_render("flow view re-draw completed in " .. (util.time_ms() - draw_start) .. "ms")
+            else
                 if ui.flow_display then
                     ui.flow_display.delete()
                     ui.flow_display = nil
@@ -453,14 +469,15 @@ function renderer.handle_resize(name)
                 iocontrol.fp_monitor_state(idx, true)
 
                 if engine.ui_ready then
-                    engine.dmesg_window.setVisible(false)
+                    local draw_start = util.time_ms()
-
                     local ok = pcall(function ()
                         ui.unit_displays[idx] = DisplayBox{window=device,fg_bg=style.root}
                         unit_view(ui.unit_displays[idx], idx)
                     end)
 
-                    if not ok then
+                    if ok then
+                        log_render("unit " .. idx .. " view re-draw completed in " .. (util.time_ms() - draw_start) .. "ms")
+                    else
                         if ui.unit_displays[idx] then
                             ui.unit_displays[idx].delete()
                             ui.unit_displays[idx] = nil

coordinator/startup.lua

@@ -7,32 +7,29 @@ require("/initenv").init_env()
 local comms       = require("scada-common.comms")
 local crash       = require("scada-common.crash")
 local log         = require("scada-common.log")
+local mqueue      = require("scada-common.mqueue")
 local network     = require("scada-common.network")
 local ppm         = require("scada-common.ppm")
-local tcd         = require("scada-common.tcd")
 local util        = require("scada-common.util")
 
-local core        = require("graphics.core")
-
 local configure   = require("coordinator.configure")
 local coordinator = require("coordinator.coordinator")
 local iocontrol   = require("coordinator.iocontrol")
 local renderer    = require("coordinator.renderer")
 local sounder     = require("coordinator.sounder")
+local threads     = require("coordinator.threads")
 
-local apisessions = require("coordinator.session.apisessions")
+local COORDINATOR_VERSION = "v1.4.2"
-
-local COORDINATOR_VERSION = "v1.3.5"
 
 local CHUNK_LOAD_DELAY_S = 30.0
 
-local println = util.println
+local println    = util.println
 local println_ts = util.println_ts
 
-local log_graphics = coordinator.log_graphics
+local log_render = coordinator.log_render
-local log_sys = coordinator.log_sys
+local log_sys    = coordinator.log_sys
-local log_boot = coordinator.log_boot
+local log_boot   = coordinator.log_boot
-local log_comms = coordinator.log_comms
+local log_comms  = coordinator.log_comms
 local log_crypto = coordinator.log_crypto
 
 ----------------------------------------
@@ -129,16 +126,58 @@ local function main()
     -- lets get started!
     log.info("monitors ready, dmesg output incoming...")
 
-    log_graphics("displays connected and reset")
+    log_render("displays connected and reset")
     log_sys("system start on " .. os.date("%c"))
     log_boot("starting " .. COORDINATOR_VERSION)
 
+    ----------------------------------------
+    -- memory allocation
+    ----------------------------------------
+
+    -- shared memory across threads
+    ---@class crd_shared_memory
+    local __shared_memory = {
+        -- time and date format for display
+        date_format = util.trinary(config.Time24Hour, "%X \x04 %A, %B %d %Y", "%r \x04 %A, %B %d %Y"),
+
+        -- coordinator system state flags
+        ---@class crd_state
+        crd_state = {
+            fp_ok = false,
+            ui_ok = true,       -- default true, used to abort on fail
+            link_fail = false,
+            shutdown = false
+        },
+
+        -- core coordinator devices
+        crd_dev = {
+            speaker = ppm.get_device("speaker"),
+            modem = ppm.get_wireless_modem()
+        },
+
+        -- system objects
+        crd_sys = {
+            nic = nil,          ---@type nic
+            coord_comms = nil,  ---@type coord_comms
+            conn_watchdog = nil ---@type watchdog
+        },
+
+        -- message queues
+        q = {
+            mq_render = mqueue.new()
+        }
+    }
+
+    local smem_dev = __shared_memory.crd_dev
+    local smem_sys = __shared_memory.crd_sys
+
+    local crd_state = __shared_memory.crd_state
+
     ----------------------------------------
     -- setup alarm sounder subsystem
     ----------------------------------------
 
-    local speaker = ppm.get_device("speaker")
+    if smem_dev.speaker == nil then
-    if speaker == nil then
         log_boot("annunciator alarm speaker not found")
         println("startup> speaker not found")
         log.fatal("no annunciator alarm speaker found")
@@ -146,7 +185,7 @@ local function main()
     else
         local sounder_start = util.time_ms()
         log_boot("annunciator alarm speaker connected")
-        sounder.init(speaker, config.SpeakerVolume)
+        sounder.init(smem_dev.speaker, config.SpeakerVolume)
         log_boot("tone generation took " .. (util.time_ms() - sounder_start) .. "ms")
         log_sys("annunciator alarm configured")
         iocontrol.fp_has_speaker(true)
@@ -163,8 +202,7 @@ local function main()
     end
 
     -- get the communications modem
-    local modem = ppm.get_wireless_modem()
+    if smem_dev.modem == nil then
-    if modem == nil then
         log_comms("wireless modem not found")
         println("startup> wireless modem not found")
         log.fatal("no wireless modem on startup")
@@ -175,243 +213,54 @@ local function main()
     end
 
     -- create connection watchdog
-    local conn_watchdog = util.new_watchdog(config.SVR_Timeout)
+    smem_sys.conn_watchdog = util.new_watchdog(config.SVR_Timeout)
-    conn_watchdog.cancel()
+    smem_sys.conn_watchdog.cancel()
     log.debug("startup> conn watchdog created")
 
     -- create network interface then setup comms
-    local nic = network.nic(modem)
+    smem_sys.nic = network.nic(smem_dev.modem)
-    local coord_comms = coordinator.comms(COORDINATOR_VERSION, nic, conn_watchdog)
+    smem_sys.coord_comms = coordinator.comms(COORDINATOR_VERSION, smem_sys.nic, smem_sys.conn_watchdog)
     log.debug("startup> comms init")
     log_comms("comms initialized")
 
-    -- base loop clock (2Hz, 10 ticks)
-    local MAIN_CLOCK = 0.5
-    local loop_clock = util.new_clock(MAIN_CLOCK)
-
     ----------------------------------------
-    -- start front panel & UI start function
+    -- start front panel
     ----------------------------------------
 
-    log_graphics("starting front panel UI...")
+    log_render("starting front panel UI...")
 
-    local fp_ok, fp_message = renderer.try_start_fp()
+    local fp_message
-    if not fp_ok then
+    crd_state.fp_ok, fp_message = renderer.try_start_fp()
-        log_graphics(util.c("front panel UI error: ", fp_message))
+    if not crd_state.fp_ok then
+        log_render(util.c("front panel UI error: ", fp_message))
         println_ts("front panel UI creation failed")
         log.fatal(util.c("front panel GUI render failed with error ", fp_message))
         return
-    else log_graphics("front panel ready") end
+    else log_render("front panel ready") end
-
-    -- start up the main UI
-    ---@return boolean ui_ok started ok
-    local function start_main_ui()
-        log_graphics("starting main UI...")
-
-        local draw_start = util.time_ms()
-
-        local ui_ok, ui_message = renderer.try_start_ui()
-        if not ui_ok then
-            log_graphics(util.c("main UI error: ", ui_message))
-            log.fatal(util.c("main GUI render failed with error ", ui_message))
-        else
-            log_graphics("main UI draw took " .. (util.time_ms() - draw_start) .. "ms")
-        end
-
-        return ui_ok
-    end
 
     ----------------------------------------
-    -- main event loop
+    -- start system
     ----------------------------------------
 
-    local link_failed = false
+    -- init threads
-    local ui_ok = true
+    local main_thread   = threads.thread__main(__shared_memory)
-    local date_format = util.trinary(config.Time24Hour, "%X \x04 %A, %B %d %Y", "%r \x04 %A, %B %d %Y")
+    local render_thread = threads.thread__render(__shared_memory)
 
-    -- start clock
+    log.info("startup> completed")
-    loop_clock.start()
 
-    log_sys("system started successfully")
+    -- run threads
-
+    parallel.waitForAll(main_thread.p_exec, render_thread.p_exec)
-    -- main event loop
-    while true do
-        local event, param1, param2, param3, param4, param5 = util.pull_event()
-
-        -- handle event
-        if event == "peripheral_detach" then
-            local type, device = ppm.handle_unmount(param1)
-
-            if type ~= nil and device ~= nil then
-                if type == "modem" then
-                    -- we only really care if this is our wireless modem
-                    -- if it is another modem, handle other peripheral losses separately
-                    if nic.is_modem(device) then
-                        nic.disconnect()
-                        log_sys("comms modem disconnected")
-
-                        local other_modem = ppm.get_wireless_modem()
-                        if other_modem then
-                            log_sys("found another wireless modem, using it for comms")
-                            nic.connect(other_modem)
-                        else
-                            -- close out main UI
-                            renderer.close_ui()
-
-                            -- alert user to status
-                            log_sys("awaiting comms modem reconnect...")
-
-                            iocontrol.fp_has_modem(false)
-                        end
-                    else
-                        log_sys("non-comms modem disconnected")
-                    end
-                elseif type == "monitor" then
-                    if renderer.handle_disconnect(device) then
-                        log_sys("lost a configured monitor")
-                    else
-                        log_sys("lost an unused monitor")
-                    end
-                elseif type == "speaker" then
-                    log_sys("lost alarm sounder speaker")
-                    iocontrol.fp_has_speaker(false)
-                end
-            end
-        elseif event == "peripheral" then
-            local type, device = ppm.mount(param1)
-
-            if type ~= nil and device ~= nil then
-                if type == "modem" then
-                    if device.isWireless() and not nic.is_connected() then
-                        -- reconnected modem
-                        log_sys("comms modem reconnected")
-                        nic.connect(device)
-                        iocontrol.fp_has_modem(true)
-                    elseif device.isWireless() then
-                        log.info("unused wireless modem reconnected")
-                    else
-                        log_sys("wired modem reconnected")
-                    end
-                elseif type == "monitor" then
-                    if renderer.handle_reconnect(param1, device) then
-                        log_sys(util.c("configured monitor ", param1, " reconnected"))
-                    else
-                        log_sys(util.c("unused monitor ", param1, " connected"))
-                    end
-                elseif type == "speaker" then
-                    log_sys("alarm sounder speaker reconnected")
-                    sounder.reconnect(device)
-                    iocontrol.fp_has_speaker(true)
-                end
-            end
-        elseif event == "monitor_resize" then
-            local is_used, is_ok = renderer.handle_resize(param1)
-            if is_used then
-                log_sys(util.c("configured monitor ", param1, " resized, ", util.trinary(is_ok, "display still fits", "display no longer fits")))
-            end
-        elseif event == "timer" then
-            if loop_clock.is_clock(param1) then
-                -- main loop tick
-
-                -- toggle heartbeat
-                iocontrol.heartbeat()
-
-                -- maintain connection
-                if nic.is_connected() then
-                    local ok, start_ui = coord_comms.try_connect()
-                    if not ok then
-                        link_failed = true
-                        log_sys("supervisor connection failed, shutting down...")
-                        log.fatal("failed to connect to supervisor")
-                        break
-                    elseif start_ui then
-                        log_sys("supervisor connected, proceeding to main UI start")
-                        ui_ok = start_main_ui()
-                        if not ui_ok then break end
-                    end
-                end
-
-                -- iterate sessions
-                apisessions.iterate_all()
-
-                -- free any closed sessions
-                apisessions.free_all_closed()
-
-                -- update date and time string for main display
-                if coord_comms.is_linked() then
-                    iocontrol.get_db().facility.ps.publish("date_time", os.date(date_format))
-                end
-
-                loop_clock.start()
-            elseif conn_watchdog.is_timer(param1) then
-                -- supervisor watchdog timeout
-                log_comms("supervisor server timeout")
-
-                -- close connection, main UI, and stop sounder
-                coord_comms.close()
-                renderer.close_ui()
-                sounder.stop()
-            else
-                -- a non-clock/main watchdog timer event
-
-                -- check API watchdogs
-                apisessions.check_all_watchdogs(param1)
-
-                -- notify timer callback dispatcher
-                tcd.handle(param1)
-            end
-        elseif event == "modem_message" then
-            -- got a packet
-            local packet = coord_comms.parse_packet(param1, param2, param3, param4, param5)
-
-            -- handle then check if it was a disconnect
-            if coord_comms.handle_packet(packet) then
-                log_comms("supervisor closed connection")
-
-                -- close connection, main UI, and stop sounder
-                coord_comms.close()
-                renderer.close_ui()
-                sounder.stop()
-            end
-        elseif event == "monitor_touch" or event == "mouse_click" or event == "mouse_up" or
-               event == "mouse_drag" or event == "mouse_scroll" or event == "double_click" then
-            -- handle a mouse event
-            renderer.handle_mouse(core.events.new_mouse_event(event, param1, param2, param3))
-        elseif event == "speaker_audio_empty" then
-            -- handle speaker buffer emptied
-            sounder.continue()
-        end
-
-        -- check for termination request
-        if event == "terminate" or ppm.should_terminate() then
-            -- handle supervisor connection
-            coord_comms.try_connect(true)
-
-            if coord_comms.is_linked() then
-                log_comms("terminate requested, closing supervisor connection...")
-            else link_failed = true end
-
-            coord_comms.close()
-            log_comms("supervisor connection closed")
-
-            -- handle API sessions
-            log_comms("closing api sessions...")
-            apisessions.close_all()
-            log_comms("api sessions closed")
-            break
-        end
-    end
 
     renderer.close_ui()
     renderer.close_fp()
     sounder.stop()
     log_sys("system shutdown")
 
-    if link_failed then println_ts("failed to connect to supervisor") end
+    if crd_state.link_fail then println_ts("failed to connect to supervisor") end
-    if not ui_ok then println_ts("main UI creation failed") end
+    if not crd_state.ui_ok then println_ts("main UI creation failed") end
 
     -- close on error exit (such as UI error)
-    if coord_comms.is_linked() then coord_comms.close() end
+    if smem_sys.coord_comms.is_linked() then smem_sys.coord_comms.close() end
 
     println_ts("exited")
     log.info("exited")

coordinator/threads.lua

@@ -0,0 +1,363 @@
+local log         = require("scada-common.log")
+local mqueue      = require("scada-common.mqueue")
+local ppm         = require("scada-common.ppm")
+local tcd         = require("scada-common.tcd")
+local util        = require("scada-common.util")
+
+local coordinator = require("coordinator.coordinator")
+local iocontrol   = require("coordinator.iocontrol")
+local renderer    = require("coordinator.renderer")
+local sounder     = require("coordinator.sounder")
+
+local apisessions = require("coordinator.session.apisessions")
+
+local core        = require("graphics.core")
+
+local log_render = coordinator.log_render
+local log_sys    = coordinator.log_sys
+local log_comms  = coordinator.log_comms
+
+local threads = {}
+
+local MAIN_CLOCK   = 0.5 -- (2Hz,   10 ticks)
+local RENDER_SLEEP = 100 -- (100ms, 2 ticks)
+
+local MQ__RENDER_CMD = {
+    START_MAIN_UI = 1
+}
+
+local MQ__RENDER_DATA = {
+    MON_CONNECT = 1,
+    MON_DISCONNECT = 2,
+    MON_RESIZE = 3
+}
+
+-- main thread
+---@nodiscard
+---@param smem crd_shared_memory
+function threads.thread__main(smem)
+    ---@class parallel_thread
+    local public = {}
+
+    -- execute thread
+    function public.exec()
+        iocontrol.fp_rt_status("main", true)
+        log.debug("main thread start")
+
+        local loop_clock = util.new_clock(MAIN_CLOCK)
+
+        -- start clock
+        loop_clock.start()
+
+        log_sys("system started successfully")
+
+        -- load in from shared memory
+        local crd_state     = smem.crd_state
+        local nic           = smem.crd_sys.nic
+        local coord_comms   = smem.crd_sys.coord_comms
+        local conn_watchdog = smem.crd_sys.conn_watchdog
+
+        -- event loop
+        while true do
+            local event, param1, param2, param3, param4, param5 = util.pull_event()
+
+            -- handle event
+            if event == "peripheral_detach" then
+                local type, device = ppm.handle_unmount(param1)
+
+                if type ~= nil and device ~= nil then
+                    if type == "modem" then
+                        -- we only really care if this is our wireless modem
+                        -- if it is another modem, handle other peripheral losses separately
+                        if nic.is_modem(device) then
+                            nic.disconnect()
+                            log_sys("comms modem disconnected")
+
+                            local other_modem = ppm.get_wireless_modem()
+                            if other_modem then
+                                log_sys("found another wireless modem, using it for comms")
+                                nic.connect(other_modem)
+                            else
+                                -- close out main UI
+                                renderer.close_ui()
+
+                                -- alert user to status
+                                log_sys("awaiting comms modem reconnect...")
+
+                                iocontrol.fp_has_modem(false)
+                            end
+                        else
+                            log_sys("non-comms modem disconnected")
+                        end
+                    elseif type == "monitor" then
+                        smem.q.mq_render.push_data(MQ__RENDER_DATA.MON_DISCONNECT, device)
+                    elseif type == "speaker" then
+                        log_sys("lost alarm sounder speaker")
+                        iocontrol.fp_has_speaker(false)
+                    end
+                end
+            elseif event == "peripheral" then
+                local type, device = ppm.mount(param1)
+
+                if type ~= nil and device ~= nil then
+                    if type == "modem" then
+                        if device.isWireless() and not nic.is_connected() then
+                            -- reconnected modem
+                            log_sys("comms modem reconnected")
+                            nic.connect(device)
+                            iocontrol.fp_has_modem(true)
+                        elseif device.isWireless() then
+                            log.info("unused wireless modem reconnected")
+                        else
+                            log_sys("wired modem reconnected")
+                        end
+                    elseif type == "monitor" then
+                        smem.q.mq_render.push_data(MQ__RENDER_DATA.MON_CONNECT, { name = param1, device = device })
+                    elseif type == "speaker" then
+                        log_sys("alarm sounder speaker reconnected")
+                        sounder.reconnect(device)
+                        iocontrol.fp_has_speaker(true)
+                    end
+                end
+            elseif event == "monitor_resize" then
+                smem.q.mq_render.push_data(MQ__RENDER_DATA.MON_RESIZE, param1)
+            elseif event == "timer" then
+                if loop_clock.is_clock(param1) then
+                    -- main loop tick
+
+                    -- toggle heartbeat
+                    iocontrol.heartbeat()
+
+                    -- maintain connection
+                    if nic.is_connected() then
+                        local ok, start_ui = coord_comms.try_connect()
+                        if not ok then
+                            crd_state.link_fail = true
+                            crd_state.shutdown = true
+                            log_sys("supervisor connection failed, shutting down...")
+                            log.fatal("failed to connect to supervisor")
+                            break
+                        elseif start_ui then
+                            log_sys("supervisor connected, dispatching main UI start")
+                            smem.q.mq_render.push_command(MQ__RENDER_CMD.START_MAIN_UI)
+                        end
+                    end
+
+                    -- iterate sessions and free any closed ones
+                    apisessions.iterate_all()
+                    apisessions.free_all_closed()
+
+                    if renderer.ui_ready() then
+                        -- update clock used on main and flow monitors
+                        iocontrol.get_db().facility.ps.publish("date_time", os.date(smem.date_format))
+                    end
+
+                    loop_clock.start()
+                elseif conn_watchdog.is_timer(param1) then
+                    -- supervisor watchdog timeout
+                    log_comms("supervisor server timeout")
+
+                    -- close connection, main UI, and stop sounder
+                    coord_comms.close()
+                    renderer.close_ui()
+                    sounder.stop()
+                else
+                    -- a non-clock/main watchdog timer event
+
+                    -- check API watchdogs
+                    apisessions.check_all_watchdogs(param1)
+
+                    -- notify timer callback dispatcher
+                    tcd.handle(param1)
+                end
+            elseif event == "modem_message" then
+                -- got a packet
+                local packet = coord_comms.parse_packet(param1, param2, param3, param4, param5)
+
+                -- handle then check if it was a disconnect
+                if coord_comms.handle_packet(packet) then
+                    log_comms("supervisor closed connection")
+
+                    -- close connection, main UI, and stop sounder
+                    coord_comms.close()
+                    renderer.close_ui()
+                    sounder.stop()
+                end
+            elseif event == "monitor_touch" or event == "mouse_click" or event == "mouse_up" or
+                   event == "mouse_drag" or event == "mouse_scroll" or event == "double_click" then
+                -- handle a mouse event
+                renderer.handle_mouse(core.events.new_mouse_event(event, param1, param2, param3))
+            elseif event == "speaker_audio_empty" then
+                -- handle speaker buffer emptied
+                sounder.continue()
+            end
+
+            -- check for termination request or UI crash
+            if event == "terminate" or ppm.should_terminate() then
+                crd_state.shutdown = true
+                log.info("terminate requested, main thread exiting")
+            elseif not crd_state.ui_ok then
+                crd_state.shutdown = true
+                log.info("terminating due to fatal UI error")
+            end
+
+            if crd_state.shutdown then
+                -- handle closing supervisor connection
+                coord_comms.try_connect(true)
+
+                if coord_comms.is_linked() then
+                    log_comms("closing supervisor connection...")
+                else crd_state.link_fail = true end
+
+                coord_comms.close()
+                log_comms("supervisor connection closed")
+
+                -- handle API sessions
+                log_comms("closing api sessions...")
+                apisessions.close_all()
+                log_comms("api sessions closed")
+                break
+            end
+        end
+    end
+
+    -- execute the thread in a protected mode, retrying it on return if not shutting down
+    function public.p_exec()
+        local crd_state = smem.crd_state
+
+        while not crd_state.shutdown do
+            local status, result = pcall(public.exec)
+            if status == false then
+                log.fatal(util.strval(result))
+            end
+
+            iocontrol.fp_rt_status("main", false)
+
+            -- if status is true, then we are probably exiting, so this won't matter
+            -- this thread cannot be slept because it will miss events (namely "terminate")
+            if not crd_state.shutdown then
+                log.info("main thread restarting now...")
+            end
+        end
+    end
+
+    return public
+end
+
+-- coordinator renderer thread, tasked with long duration re-draws
+---@nodiscard
+---@param smem crd_shared_memory
+function threads.thread__render(smem)
+    ---@class parallel_thread
+    local public = {}
+
+    -- execute thread
+    function public.exec()
+        iocontrol.fp_rt_status("render", true)
+        log.debug("render thread start")
+
+        -- load in from shared memory
+        local crd_state    = smem.crd_state
+        local render_queue = smem.q.mq_render
+
+        local last_update = util.time()
+
+        -- thread loop
+        while true do
+            -- check for messages in the message queue
+            while render_queue.ready() and not crd_state.shutdown do
+                local msg = render_queue.pop()
+
+                if msg ~= nil then
+                    if msg.qtype == mqueue.TYPE.COMMAND then
+                        -- received a command
+                        if msg.message == MQ__RENDER_CMD.START_MAIN_UI then
+                            -- stop the UI if it was already started
+                            -- this may occur on a quick supervisor disconnect -> connect
+                            if renderer.ui_ready() then
+                                log_render("closing main UI before executing new request to start")
+                                renderer.close_ui()
+                            end
+
+                            -- start up the main UI
+                            log_render("starting main UI...")
+
+                            local draw_start = util.time_ms()
+
+                            local ui_message
+                            crd_state.ui_ok, ui_message = renderer.try_start_ui()
+                            if not crd_state.ui_ok then
+                                log_render(util.c("main UI error: ", ui_message))
+                                log.fatal(util.c("main GUI render failed with error ", ui_message))
+                            else
+                                log_render("main UI draw took " .. (util.time_ms() - draw_start) .. "ms")
+                            end
+                        end
+                    elseif msg.qtype == mqueue.TYPE.DATA then
+                        -- received data
+                        local cmd = msg.message ---@type queue_data
+
+                        if cmd.key == MQ__RENDER_DATA.MON_CONNECT then
+                            -- monitor connected
+                            if renderer.handle_reconnect(cmd.val.name, cmd.val.device) then
+                                log_sys(util.c("configured monitor ", cmd.val.name, " reconnected"))
+                            else
+                                log_sys(util.c("unused monitor ", cmd.val.name, " connected"))
+                            end
+                        elseif cmd.key == MQ__RENDER_DATA.MON_DISCONNECT then
+                            -- monitor disconnected
+                            if renderer.handle_disconnect(cmd.val) then
+                                log_sys("lost a configured monitor")
+                            else
+                                log_sys("lost an unused monitor")
+                            end
+                        elseif cmd.key == MQ__RENDER_DATA.MON_RESIZE then
+                            -- monitor resized
+                            local is_used, is_ok = renderer.handle_resize(cmd.val)
+                            if is_used then
+                                log_sys(util.c("configured monitor ", cmd.val, " resized, ", util.trinary(is_ok, "display fits", "display does not fit")))
+                            end
+                        end
+                    elseif msg.qtype == mqueue.TYPE.PACKET then
+                        -- received a packet
+                    end
+                end
+
+                -- quick yield
+                util.nop()
+            end
+
+            -- check for termination request
+            if crd_state.shutdown then
+                log.info("render thread exiting")
+                break
+            end
+
+            -- delay before next check
+            last_update = util.adaptive_delay(RENDER_SLEEP, last_update)
+        end
+    end
+
+    -- execute the thread in a protected mode, retrying it on return if not shutting down
+    function public.p_exec()
+        local crd_state = smem.crd_state
+
+        while not crd_state.shutdown do
+            local status, result = pcall(public.exec)
+            if status == false then
+                log.fatal(util.strval(result))
+            end
+
+            iocontrol.fp_rt_status("render", false)
+
+            if not crd_state.shutdown then
+                log.info("render thread restarting in 5 seconds...")
+                util.psleep(5)
+            end
+        end
+    end
+
+    return public
+end
+
+return threads

coordinator/ui/components/process_ctl.lua

@@ -145,7 +145,7 @@ local function new_view(root, x, y)
     local cur_charge = DataIndicator{parent=targets,x=9,y=9,label="",format="%19d",value=0,unit="MFE",commas=true,lu_colors=black,width=23,fg_bg=blk_brn}
 
     c_target.register(facility.ps, "process_charge_target", c_target.set_value)
-    cur_charge.register(facility.induction_ps_tbl[1], "energy", function (j) cur_charge.update(util.joules_to_fe(j) / 1000000) end)
+    cur_charge.register(facility.induction_ps_tbl[1], "avg_charge", function (fe) cur_charge.update(fe / 1000000) end)
 
     local gen_tag = Div{parent=targets,x=1,y=11,width=8,height=4,fg_bg=blk_pur}
     TextBox{parent=gen_tag,x=2,y=2,text="Gen. Target",width=7,height=2}

coordinator/ui/components/unit_detail.lua

@@ -352,6 +352,8 @@ local function init(parent, id)
         t3_trp.register(t_ps[3], "TurbineTrip", t3_trp.update)
     end
 
+    util.nop()
+
     ----------------------
     -- reactor controls --
     ----------------------

coordinator/ui/layout/flow_view.lua

@@ -250,6 +250,7 @@ local function init(main)
         local y_offset = y_ofs(i)
         unit_flow(main, flow_x, 5 + y_offset, #water_pipes == 0, units[i])
         table.insert(po_pipes, pipe(0, 3 + y_offset, 4, 0, colors.cyan, true, true))
+        util.nop()
     end
 
     PipeNetwork{parent=main,x=139,y=15,pipes=po_pipes,bg=style.theme.bg}
@@ -335,6 +336,8 @@ local function init(main)
         end
     end
 
+    util.nop()
+
     ---------
     -- SPS --
     ---------

coordinator/ui/layout/front_panel.lua

@@ -100,6 +100,14 @@ local function init(panel, num_units)
     local speaker = LED{parent=system,label="SPEAKER",colors=led_grn}
     speaker.register(ps, "has_speaker", speaker.update)
 
+    system.line_break()
+
+    local rt_main = LED{parent=system,label="RT MAIN",colors=led_grn}
+    local rt_render = LED{parent=system,label="RT RENDER",colors=led_grn}
+
+    rt_main.register(ps, "routine__main", rt_main.update)
+    rt_render.register(ps, "routine__render", rt_render.update)
+
 ---@diagnostic disable-next-line: undefined-field
     local comp_id = util.sprintf("(%d)", os.getComputerID())
     TextBox{parent=system,x=9,y=4,width=6,height=1,text=comp_id,fg_bg=style.fp.disabled_fg}

coordinator/ui/layout/main_view.lua

@@ -2,6 +2,8 @@
 -- Main SCADA Coordinator GUI
 --
 
+local util          = require("scada-common.util")
+
 local iocontrol     = require("coordinator.iocontrol")
 
 local style         = require("coordinator.ui.style")
@@ -53,6 +55,8 @@ local function init(main)
 
     cnc_y_start = cnc_y_start + row_1_height + 1
 
+    util.nop()
+
     if facility.num_units >= 3 then
         -- base offset 3, spacing 1, max height of units 1 and 2
         local row_2_offset = cnc_y_start
@@ -64,6 +68,8 @@ local function init(main)
             uo_4 = unit_overview(main, 84, row_2_offset, units[4])
             cnc_y_start = math.max(cnc_y_start, row_2_offset + uo_4.get_height() + 1)
         end
+
+        util.nop()
     end
 
     -- command & control
@@ -79,6 +85,8 @@ local function init(main)
 
     process_ctl(main, 2, cnc_bottom_align_start)
 
+    util.nop()
+
     imatrix(main, 131, cnc_bottom_align_start, facility.induction_data_tbl[1], facility.induction_ps_tbl[1])
 end
 

reactor-plc/plc.lua

@@ -74,7 +74,7 @@ function plc.load_config()
 
         if type(config.AuthKey) == "string" then
             local len = string.len(config.AuthKey)
-            cfv.assert_eq(len == 0 or len >= 8, true)
+            cfv.assert(len == 0 or len >= 8)
         end
     end
 

reactor-plc/startup.lua

@@ -18,7 +18,7 @@ local plc       = require("reactor-plc.plc")
 local renderer  = require("reactor-plc.renderer")
 local threads   = require("reactor-plc.threads")
 
-local R_PLC_VERSION = "v1.7.4"
+local R_PLC_VERSION = "v1.7.7"
 
 local println = util.println
 local println_ts = util.println_ts

reactor-plc/threads.lua

@@ -368,9 +368,9 @@ function threads.thread__rps(smem)
                     end
                 end
 
-                -- if we are in standalone mode, continuously reset RPS
+                -- if we are in standalone mode and the front panel isn't working, continuously reset RPS
                 -- RPS will trip again if there are faults, but if it isn't cleared, the user can't re-enable
-                if not networked then rps.reset(true) end
+                if not (networked or smem.plc_state.fp_ok) then rps.reset(true) end
 
                 -- check safety (SCRAM occurs if tripped)
                 if not plc_state.no_reactor then
@@ -662,8 +662,9 @@ function threads.thread__setpoint_control(smem)
                     if (type(cur_burn_rate) == "number") and (setpoints.burn_rate ~= cur_burn_rate) and rps.is_active() then
                         last_burn_sp = setpoints.burn_rate
 
-                        -- update without ramp if <= 2.5 mB/t change
+                        -- update without ramp if <= 2.5 mB/t increase
-                        running = math.abs(setpoints.burn_rate - cur_burn_rate) > 2.5
+                        -- no need to ramp down, as the ramp up poses the safety risks
+                        running = (setpoints.burn_rate - cur_burn_rate) > 2.5
 
                         if running then
                             log.debug(util.c("SPCTL: starting burn rate ramp from ", cur_burn_rate, " mB/t to ", setpoints.burn_rate, " mB/t"))

rtu/rtu.lua

@@ -60,7 +60,7 @@ function rtu.load_config()
 
     if type(config.AuthKey) == "string" then
         local len = string.len(config.AuthKey)
-        cfv.assert_eq(len == 0 or len >= 8, true)
+        cfv.assert(len == 0 or len >= 8)
     end
 
     cfv.assert_type_int(config.LogMode)

rtu/startup.lua

@@ -31,7 +31,7 @@ local sna_rtu      = require("rtu.dev.sna_rtu")
 local sps_rtu      = require("rtu.dev.sps_rtu")
 local turbinev_rtu = require("rtu.dev.turbinev_rtu")
 
-local RTU_VERSION = "v1.9.3"
+local RTU_VERSION = "v1.9.4"
 
 local RTU_UNIT_TYPE = types.RTU_UNIT_TYPE
 local RTU_UNIT_HW_STATE = databus.RTU_UNIT_HW_STATE

scada-common/constants.lua

@@ -68,19 +68,32 @@ constants.ALARM_LIMITS = alarms
 
 --#region Supervisor Constants
 
--- milliseconds until turbine flow is assumed to be stable enough to enable coolant checks
+-- milliseconds until coolant flow is assumed to be stable enough to enable certain coolant checks
-constants.FLOW_STABILITY_DELAY_MS = 15000
+constants.FLOW_STABILITY_DELAY_MS = 10000
 
 -- Notes on Radiation
 -- - background radiation 0.0000001 Sv/h (99.99 nSv/h)
 -- - "green tint" radiation 0.00001 Sv/h (10 uSv/h)
 -- - damaging radiation 0.00006 Sv/h (60 uSv/h)
-constants.LOW_RADIATION = 0.00001
+constants.LOW_RADIATION       = 0.00001
-constants.HAZARD_RADIATION = 0.00006
+constants.HAZARD_RADIATION    = 0.00006
-constants.HIGH_RADIATION = 0.001
+constants.HIGH_RADIATION      = 0.001
 constants.VERY_HIGH_RADIATION = 0.1
-constants.SEVERE_RADIATION = 8.0
+constants.SEVERE_RADIATION    = 8.0
-constants.EXTREME_RADIATION = 100.0
+constants.EXTREME_RADIATION   = 100.0
+
+--#endregion
+
+--#region Mekanism Configuration Constants
+
+---@class _mek_constants
+local mek = {}
+
+mek.TURBINE_GAS_PER_TANK   = 64000  -- mekanism: turbineGasPerTank
+mek.TURBINE_DISPERSER_FLOW = 1280   -- mekanism: turbineDisperserGasFlow
+mek.TURBINE_VENT_FLOW      = 32000  -- mekanism: turbineVentGasFlow
+
+constants.mek = mek
 
 --#endregion
 

supervisor/configure.lua

@@ -91,6 +91,7 @@ local tmp_cfg = {
     CoolingConfig = {},
     FacilityTankMode = 0,
     FacilityTankDefs = {},
+    ExtChargeIdling = false,
     SVR_Channel = nil,  ---@type integer
     PLC_Channel = nil,  ---@type integer
     RTU_Channel = nil,  ---@type integer
@@ -120,6 +121,7 @@ local fields = {
     { "CoolingConfig", "Cooling Configuration", {} },
     { "FacilityTankMode", "Facility Tank Mode", 0 },
     { "FacilityTankDefs", "Facility Tank Definitions", {} },
+    { "ExtChargeIdling", "Extended Charge Idling", false },
     { "SVR_Channel", "SVR Channel", 16240 },
     { "PLC_Channel", "PLC Channel", 16241 },
     { "RTU_Channel", "RTU Channel", 16242 },
@@ -222,8 +224,9 @@ local function config_view(display)
     local svr_c_4 = Div{parent=svr_cfg,x=2,y=4,width=49}
     local svr_c_5 = Div{parent=svr_cfg,x=2,y=4,width=49}
     local svr_c_6 = Div{parent=svr_cfg,x=2,y=4,width=49}
+    local svr_c_7 = Div{parent=svr_cfg,x=2,y=4,width=49}
 
-    local svr_pane = MultiPane{parent=svr_cfg,x=1,y=4,panes={svr_c_1,svr_c_2,svr_c_3,svr_c_4,svr_c_5,svr_c_6}}
+    local svr_pane = MultiPane{parent=svr_cfg,x=1,y=4,panes={svr_c_1,svr_c_2,svr_c_3,svr_c_4,svr_c_5,svr_c_6,svr_c_7}}
 
     TextBox{parent=svr_cfg,x=1,y=2,height=1,text=" Facility Configuration",fg_bg=cpair(colors.black,colors.yellow)}
 
@@ -329,7 +332,7 @@ local function config_view(display)
         else
             tmp_cfg.FacilityTankMode = 0
             tmp_cfg.FacilityTankDefs = {}
-            main_pane.set_value(3)
+            svr_pane.set_value(7)
         end
     end
 
@@ -563,7 +566,7 @@ local function config_view(display)
 
     local function submit_mode()
         tmp_cfg.FacilityTankMode = tank_mode.get_value()
-        main_pane.set_value(3)
+        svr_pane.set_value(7)
     end
 
     PushButton{parent=svr_c_5,x=1,y=14,text="\x1b Back",callback=function()svr_pane.set_value(4)end,fg_bg=nav_fg_bg,active_fg_bg=btn_act_fg_bg}
@@ -577,6 +580,23 @@ local function config_view(display)
 
     PushButton{parent=svr_c_6,x=1,y=14,text="\x1b Back",callback=function()svr_pane.set_value(5)end,fg_bg=nav_fg_bg,active_fg_bg=btn_act_fg_bg}
 
+    TextBox{parent=svr_c_7,height=6,text="Charge control provides automatic control to maintain an induction matrix charge level. In order to have smoother control, reactors that were activated will be held on at 0.01 mB/t for a short period before allowing them to turn off. This minimizes overshooting the charge target."}
+    TextBox{parent=svr_c_7,y=8,height=3,text="You can extend this to a full minute to minimize reactors flickering on/off, but there may be more overshoot of the target."}
+
+    local ext_idling = CheckBox{parent=svr_c_7,x=1,y=12,label="Enable Extended Idling",default=ini_cfg.ExtChargeIdling,box_fg_bg=cpair(colors.yellow,colors.black)}
+
+    local function back_from_idling()
+        svr_pane.set_value(util.trinary(tmp_cfg.FacilityTankMode == 0, 3, 5))
+    end
+
+    local function submit_idling()
+        tmp_cfg.ExtChargeIdling = ext_idling.get_value()
+        main_pane.set_value(3)
+    end
+
+    PushButton{parent=svr_c_7,x=1,y=14,text="\x1b Back",callback=back_from_idling,fg_bg=nav_fg_bg,active_fg_bg=btn_act_fg_bg}
+    PushButton{parent=svr_c_7,x=44,y=14,text="Next \x1a",callback=submit_idling,fg_bg=nav_fg_bg,active_fg_bg=btn_act_fg_bg}
+
     --#endregion
 
     --#region Network

supervisor/facility.lua

@@ -23,7 +23,7 @@ local RTU_UNIT_TYPE  = types.RTU_UNIT_TYPE
 local WASTE_MODE     = types.WASTE_MODE
 local WASTE          = types.WASTE_PRODUCT
 
-local IO = rsio.IO
+local IO             = rsio.IO
 
 local DTV_RTU_S_DATA = qtypes.DTV_RTU_S_DATA
 
@@ -50,9 +50,9 @@ local START_STATUS = {
     BLADE_MISMATCH = 2
 }
 
-local charge_Kp = 0.275
+local charge_Kp = 0.15
 local charge_Ki = 0.0
-local charge_Kd = 4.5
+local charge_Kd = 0.6
 
 local rate_Kp = 2.45
 local rate_Ki = 0.4825
@@ -63,9 +63,9 @@ local facility = {}
 
 -- create a new facility management object
 ---@nodiscard
----@param num_reactors integer number of reactor units
+---@param config svr_config supervisor configuration
 ---@param cooling_conf sv_cooling_conf cooling configurations of reactor units
-function facility.new(num_reactors, cooling_conf)
+function facility.new(config, cooling_conf)
     local self = {
         units = {},
         status_text = { "START UP", "initializing..." },
@@ -134,8 +134,8 @@ function facility.new(num_reactors, cooling_conf)
     }
 
     -- create units
-    for i = 1, num_reactors do
+    for i = 1, config.UnitCount do
-        table.insert(self.units, unit.new(i, cooling_conf.r_cool[i].BoilerCount, cooling_conf.r_cool[i].TurbineCount))
+        table.insert(self.units, unit.new(i, cooling_conf.r_cool[i].BoilerCount, cooling_conf.r_cool[i].TurbineCount, config.ExtChargeIdling))
         table.insert(self.group_map, 0)
     end
 
@@ -225,6 +225,14 @@ function facility.new(num_reactors, cooling_conf)
         return unallocated, false
     end
 
+    -- set idle state of all assigned reactors
+    ---@param idle boolean idle state
+    local function _set_idling(idle)
+        for i = 1, #self.prio_defs do
+            for _, u in pairs(self.prio_defs[i]) do u.auto_set_idle(idle) end
+        end
+    end
+
     -- PUBLIC FUNCTIONS --
 
     ---@class facility
@@ -325,10 +333,11 @@ function facility.new(num_reactors, cooling_conf)
 
         --#region
 
-        local avg_charge = self.avg_charge.compute()
+        local avg_charge  = self.avg_charge.compute()
-        local avg_inflow = self.avg_inflow.compute()
+        local avg_inflow  = self.avg_inflow.compute()
+        local avg_outflow = self.avg_outflow.compute()
 
-        local now = util.time_s()
+        local now = os.clock()
 
         local state_changed = self.mode ~= self.last_mode
         local next_mode = self.mode
@@ -390,6 +399,7 @@ function facility.new(num_reactors, cooling_conf)
                     -- disable reactors and disengage auto control
                     for _, u in pairs(self.prio_defs[i]) do
                         u.disable()
+                        u.auto_set_idle(false)
                         u.auto_disengage()
                     end
                 end
@@ -460,6 +470,9 @@ function facility.new(num_reactors, cooling_conf)
                 self.last_error = 0
                 self.accumulator = 0
 
+                -- enabling idling on all assigned units
+                _set_idling(true)
+
                 self.status_text = { "CHARGE MODE", "running control loop" }
                 log.info("FAC: CHARGE mode starting PID control")
             elseif self.last_update ~= charge_update then
@@ -475,9 +488,9 @@ function facility.new(num_reactors, cooling_conf)
                 local integral = self.accumulator
                 local derivative = (error - self.last_error) / (now - self.last_time)
 
-                local P = (charge_Kp * error)
+                local P = charge_Kp * error
-                local I = (charge_Ki * integral)
+                local I = charge_Ki * integral
-                local D = (charge_Kd * derivative)
+                local D = charge_Kd * derivative
 
                 local output = P + I + D
 
@@ -486,7 +499,12 @@ function facility.new(num_reactors, cooling_conf)
 
                 self.saturated = output ~= out_c
 
-                -- log.debug(util.sprintf("CHARGE[%f] { CHRG[%f] ERR[%f] INT[%f] => OUT[%f] OUT_C[%f] <= P[%f] I[%f] D[%d] }",
+                if not config.ExtChargeIdling then
+                    -- stop idling early if the output is zero, we are at or above the setpoint, and are not losing charge
+                    _set_idling(not ((out_c == 0) and (error <= 0) and (avg_outflow <= 0)))
+                end
+
+                -- log.debug(util.sprintf("CHARGE[%f] { CHRG[%f] ERR[%f] INT[%f] => OUT[%f] OUT_C[%f] <= P[%f] I[%f] D[%f] }",
                 --     runtime, avg_charge, error, integral, output, out_c, P, I, D))
 
                 _allocate_burn_rate(out_c, true)
@@ -544,9 +562,9 @@ function facility.new(num_reactors, cooling_conf)
                 local integral = self.accumulator
                 local derivative = (error - self.last_error) / (now - self.last_time)
 
-                local P = (rate_Kp * error)
+                local P = rate_Kp * error
-                local I = (rate_Ki * integral)
+                local I = rate_Ki * integral
-                local D = (rate_Kd * derivative)
+                local D = rate_Kd * derivative
 
                 -- velocity (rate) (derivative of charge level => rate) feed forward
                 local FF = self.gen_rate_setpoint / self.charge_conversion
@@ -936,41 +954,41 @@ function facility.new(num_reactors, cooling_conf)
     function public.auto_stop() self.mode = PROCESS.INACTIVE end
 
     -- set automatic control configuration and start the process
-    ---@param config coord_auto_config configuration
+    ---@param auto_cfg coord_auto_config configuration
     ---@return table response ready state (successfully started) and current configuration (after updating)
-    function public.auto_start(config)
+    function public.auto_start(auto_cfg)
         local charge_scaler = 1000000   -- convert MFE to FE
         local gen_scaler    = 1000      -- convert kFE to FE
         local ready         = false
 
         -- load up current limits
         local limits = {}
-        for i = 1, num_reactors do
+        for i = 1, config.UnitCount do
             local u = self.units[i] ---@type reactor_unit
             limits[i] = u.get_control_inf().lim_br100 * 100
         end
 
         -- only allow changes if not running
         if self.mode == PROCESS.INACTIVE then
-            if (type(config.mode) == "number") and (config.mode > PROCESS.INACTIVE) and (config.mode <= PROCESS.GEN_RATE) then
+            if (type(auto_cfg.mode) == "number") and (auto_cfg.mode > PROCESS.INACTIVE) and (auto_cfg.mode <= PROCESS.GEN_RATE) then
-                self.mode_set = config.mode
+                self.mode_set = auto_cfg.mode
             end
 
-            if (type(config.burn_target) == "number") and config.burn_target >= 0.1 then
+            if (type(auto_cfg.burn_target) == "number") and auto_cfg.burn_target >= 0.1 then
-                self.burn_target = config.burn_target
+                self.burn_target = auto_cfg.burn_target
             end
 
-            if (type(config.charge_target) == "number") and config.charge_target >= 0 then
+            if (type(auto_cfg.charge_target) == "number") and auto_cfg.charge_target >= 0 then
-                self.charge_setpoint = config.charge_target * charge_scaler
+                self.charge_setpoint = auto_cfg.charge_target * charge_scaler
             end
 
-            if (type(config.gen_target) == "number") and config.gen_target >= 0 then
+            if (type(auto_cfg.gen_target) == "number") and auto_cfg.gen_target >= 0 then
-                self.gen_rate_setpoint = config.gen_target * gen_scaler
+                self.gen_rate_setpoint = auto_cfg.gen_target * gen_scaler
             end
 
-            if (type(config.limits) == "table") and (#config.limits == num_reactors) then
+            if (type(auto_cfg.limits) == "table") and (#auto_cfg.limits == config.UnitCount) then
-                for i = 1, num_reactors do
+                for i = 1, config.UnitCount do
-                    local limit = config.limits[i]
+                    local limit = auto_cfg.limits[i]
 
                     if (type(limit) == "number") and (limit >= 0.1) then
                         limits[i] = limit
@@ -1010,7 +1028,7 @@ function facility.new(num_reactors, cooling_conf)
     ---@param unit_id integer unit ID
     ---@param group integer group ID or 0 for independent
     function public.set_group(unit_id, group)
-        if (group >= 0 and group <= 4) and (unit_id > 0 and unit_id <= num_reactors) and self.mode == PROCESS.INACTIVE then
+        if (group >= 0 and group <= 4) and (unit_id > 0 and unit_id <= config.UnitCount) and self.mode == PROCESS.INACTIVE then
             -- remove from old group if previously assigned
             local old_group = self.group_map[unit_id]
             if old_group ~= 0 then

supervisor/session/coordinator.lua

@@ -17,9 +17,6 @@ local FAC_COMMAND = comms.FAC_COMMAND
 
 local SV_Q_DATA = svqtypes.SV_Q_DATA
 
--- grace period in seconds for coordinator to finish UI draw to prevent timeout
-local WATCHDOG_GRACE = 20.0
-
 -- retry time constants in ms
 -- local INITIAL_WAIT = 1500
 local RETRY_PERIOD = 1000
@@ -360,15 +357,7 @@ function coordinator.new_session(id, s_addr, in_queue, out_queue, timeout, facil
     -- check if a timer matches this session's watchdog
     ---@nodiscard
     function public.check_wd(timer)
-        local is_wd = self.conn_watchdog.is_timer(timer) and self.connected
+        return self.conn_watchdog.is_timer(timer) and self.connected
-
-        -- if we are waiting for initial coordinator UI draw, don't close yet
-        if is_wd and (util.time_s() - self.establish_time) <= WATCHDOG_GRACE then
-            self.conn_watchdog.feed()
-            is_wd = false
-        end
-
-        return is_wd
     end
 
     -- close the connection

supervisor/session/svsessions.lua

@@ -201,7 +201,7 @@ function svsessions.init(nic, fp_ok, config, cooling_conf)
     self.nic = nic
     self.fp_ok = fp_ok
     self.config = config
-    self.facility = facility.new(config.UnitCount, cooling_conf)
+    self.facility = facility.new(config, cooling_conf)
 end
 
 -- find an RTU session by the computer ID

supervisor/startup.lua

@@ -21,7 +21,7 @@ local supervisor = require("supervisor.supervisor")
 
 local svsessions = require("supervisor.session.svsessions")
 
-local SUPERVISOR_VERSION = "v1.3.4"
+local SUPERVISOR_VERSION = "v1.3.6"
 
 local println = util.println
 local println_ts = util.println_ts

supervisor/supervisor.lua

@@ -26,6 +26,7 @@ function supervisor.load_config()
     config.CoolingConfig = settings.get("CoolingConfig")
     config.FacilityTankMode = settings.get("FacilityTankMode")
     config.FacilityTankDefs = settings.get("FacilityTankDefs")
+    config.ExtChargeIdling = settings.get("ExtChargeIdling")
 
     config.SVR_Channel = settings.get("SVR_Channel")
     config.PLC_Channel = settings.get("PLC_Channel")
@@ -58,6 +59,8 @@ function supervisor.load_config()
     cfv.assert_type_int(config.FacilityTankMode)
     cfv.assert_range(config.FacilityTankMode, 0, 8)
 
+    cfv.assert_type_bool(config.ExtChargeIdling)
+
     cfv.assert_channel(config.SVR_Channel)
     cfv.assert_channel(config.PLC_Channel)
     cfv.assert_channel(config.RTU_Channel)
@@ -78,7 +81,7 @@ function supervisor.load_config()
 
     if type(config.AuthKey) == "string" then
         local len = string.len(config.AuthKey)
-        cfv.assert_eq(len == 0 or len >= 8, true)
+        cfv.assert(len == 0 or len >= 8)
     end
 
     cfv.assert_type_int(config.LogMode)

supervisor/unit.lua

@@ -8,9 +8,6 @@ local logic = require("supervisor.unitlogic")
 local plc   = require("supervisor.session.plc")
 local rsctl = require("supervisor.session.rsctl")
 
----@class reactor_control_unit
-local unit = {}
-
 local WASTE_MODE    = types.WASTE_MODE
 local WASTE         = types.WASTE_PRODUCT
 local ALARM         = types.ALARM
@@ -55,12 +52,22 @@ local AISTATE = {
 ---@field id ALARM alarm ID
 ---@field tier integer alarm urgency tier (0 = highest)
 
+-- burn rate to idle at
+local IDLE_RATE = 0.01
+
+---@class reactor_control_unit
+local unit = {}
+
 -- create a new reactor unit
 ---@nodiscard
 ---@param reactor_id integer reactor unit number
 ---@param num_boilers integer number of boilers expected
 ---@param num_turbines integer number of turbines expected
-function unit.new(reactor_id, num_boilers, num_turbines)
+---@param ext_idle boolean extended idling mode
+function unit.new(reactor_id, num_boilers, num_turbines, ext_idle)
+    -- time (ms) to idle for auto idling
+    local IDLE_TIME = util.trinary(ext_idle, 60000, 10000)
+
     ---@class _unit_self
     local self = {
         r_id = reactor_id,
@@ -83,6 +90,9 @@ function unit.new(reactor_id, num_boilers, num_turbines)
         emcool_opened = false,
         -- auto control
         auto_engaged = false,
+        auto_idle = false,
+        auto_idling = false,
+        auto_idle_start = 0,
         auto_was_alarmed = false,
         ramp_target_br100 = 0,
         -- state tracking
@@ -98,6 +108,8 @@ function unit.new(reactor_id, num_boilers, num_turbines)
         status_text = { "UNKNOWN", "awaiting connection..." },
         -- logic for alarms
         had_reactor = false,
+        turbine_flow_stable = false,
+        turbine_stability_data = {},
         last_rate_change_ms = 0,
         ---@type rps_status
         last_rps_trips = {
@@ -251,6 +263,7 @@ function unit.new(reactor_id, num_boilers, num_turbines)
         table.insert(self.db.annunciator.TurbineOverSpeed, false)
         table.insert(self.db.annunciator.GeneratorTrip, false)
         table.insert(self.db.annunciator.TurbineTrip, false)
+        table.insert(self.turbine_stability_data, { time_state = 0, time_tanks = 0, rotation = 1 })
     end
 
     -- PRIVATE FUNCTIONS --
@@ -530,6 +543,13 @@ function unit.new(reactor_id, num_boilers, num_turbines)
 
             -- re-engage auto lock if it reconnected without it
             if self.auto_engaged and not self.plc_i.is_auto_locked() then self.plc_i.auto_lock(true) end
+
+            -- stop idling when completed
+            if self.auto_idling and (((util.time_ms() - self.auto_idle_start) > IDLE_TIME) or not self.auto_idle) then
+                log.info(util.c("UNIT ", self.r_id, ": completed idling period"))
+                self.auto_idling = false
+                self.plc_i.auto_set_burn(0, false)
+            end
         end
 
         -- update deltas
@@ -578,6 +598,23 @@ function unit.new(reactor_id, num_boilers, num_turbines)
         end
     end
 
+    -- set automatic control idling mode to change behavior when given a burn rate command of zero<br>
+    -- - enabling it will hold the reactor at 0.01 mB/t for a period when commanded zero before disabling
+    -- - disabling it will stop the reactor when commanded zero
+    ---@param idle boolean true to enable, false to disable (and stop)
+    function public.auto_set_idle(idle)
+        if idle and not self.auto_idle then
+            self.auto_idling = false
+            self.auto_idle_start = 0
+        end
+
+        if idle ~= self.auto_idle then
+            log.debug(util.c("UNIT ", self.r_id, ": idling mode changed to ", idle))
+        end
+
+        self.auto_idle = idle
+    end
+
     -- get the actual limit of this unit<br>
     -- if it is degraded or not ready, the limit will be 0
     ---@nodiscard
@@ -597,7 +634,35 @@ function unit.new(reactor_id, num_boilers, num_turbines)
         if self.auto_engaged then
             if self.plc_i ~= nil then
                 log.debug(util.c("UNIT ", self.r_id, ": commit br100 of ", self.db.control.br100, " with ramp set to ", ramp))
-                self.plc_i.auto_set_burn(self.db.control.br100 / 100, ramp)
+
+                local rate = self.db.control.br100 / 100
+
+                if self.auto_idle then
+                    if rate <= IDLE_RATE then
+                        if self.auto_idle_start == 0 then
+                            self.auto_idling = true
+                            self.auto_idle_start = util.time_ms()
+                            log.info(util.c("UNIT ", self.r_id, ": started idling at ", IDLE_RATE, " mB/t"))
+
+                            rate = IDLE_RATE
+                        elseif (util.time_ms() - self.auto_idle_start) > IDLE_TIME then
+                            if self.auto_idling then
+                                self.auto_idling = false
+                                log.info(util.c("UNIT ", self.r_id, ": completed idling period"))
+                            end
+                        else
+                            log.debug(util.c("UNIT ", self.r_id, ": continuing idle at ", IDLE_RATE, " mB/t"))
+
+                            rate = IDLE_RATE
+                        end
+                    else
+                        self.auto_idling = false
+                        self.auto_idle_start = 0
+                    end
+                end
+
+                self.plc_i.auto_set_burn(rate, ramp)
+
                 if ramp then self.ramp_target_br100 = self.db.control.br100 end
             end
         end

supervisor/unitlogic.lua

@@ -39,6 +39,21 @@ local ALARM_LIMS = const.ALARM_LIMITS
 ---@class unit_logic_extension
 local logic = {}
 
+-- compute Mekanism's rotation rate for a turbine
+---@param turbine turbinev_session_db
+local function turbine_rotation(turbine)
+    local build = turbine.build
+
+    local inner_vol = build.steam_cap / const.mek.TURBINE_GAS_PER_TANK
+    local disp_rate = (build.dispersers * const.mek.TURBINE_DISPERSER_FLOW) * inner_vol
+    local vent_rate = build.vents * const.mek.TURBINE_VENT_FLOW
+
+    local max_rate = math.min(disp_rate, vent_rate)
+    local flow = math.min(max_rate, turbine.tanks.steam.amount)
+
+    return (flow * (turbine.tanks.steam.amount / build.steam_cap)) / max_rate
+end
+
 -- update the annunciator
 ---@param self _unit_self
 function logic.update_annunciator(self)
@@ -81,6 +96,11 @@ function logic.update_annunciator(self)
         -- some alarms wait until the burn rate has stabilized, so keep track of that
         if math.abs(_get_dt(DT_KEYS.ReactorBurnR)) > 0 then
             self.last_rate_change_ms = util.time_ms()
+            self.turbine_flow_stable = false
+
+            for t = 1, self.num_turbines do
+                self.turbine_stability_data[t] = { time_state = 0, time_tanks = 0, rotation = 1 }
+            end
         end
 
         -- record reactor stats
@@ -274,6 +294,7 @@ function logic.update_annunciator(self)
     local total_flow_rate = 0
     local total_input_rate = 0
     local max_water_return_rate = 0
+    local turbines_stable = true
 
     -- recompute blade count on the chance that it may have changed
     self.db.control.blade_count = 0
@@ -282,12 +303,14 @@ function logic.update_annunciator(self)
     for i = 1, #self.turbines do
         local session = self.turbines[i] ---@type unit_session
         local turbine = session.get_db() ---@type turbinev_session_db
+        local idx = session.get_device_idx()
 
         annunc.RCSFault = annunc.RCSFault or (not turbine.formed) or session.is_faulted()
+        annunc.TurbineOnline[idx] = true
 
         -- update ready state
-        --  - must be formed
+        -- - must be formed
-        --  - must have received build, state, and tanks at least once
+        -- - must have received build, state, and tanks at least once
         turbines_ready = turbines_ready and turbine.formed and
                         (turbine.build.last_update > 0) and
                         (turbine.state.last_update > 0) and
@@ -296,11 +319,56 @@ function logic.update_annunciator(self)
         total_flow_rate = total_flow_rate + turbine.state.flow_rate
         total_input_rate = total_input_rate + turbine.state.steam_input_rate
         max_water_return_rate = max_water_return_rate + turbine.build.max_water_output
+
         self.db.control.blade_count = self.db.control.blade_count + turbine.build.blades
 
-        annunc.TurbineOnline[session.get_device_idx()] = true
+        local last = self.turbine_stability_data[i]
+
+        if (not self.turbine_flow_stable) and (turbine.state.steam_input_rate > 0) then
+            local rotation = turbine_rotation(turbine)
+            local rotation_stable = false
+
+            -- see if data updated, and if so, check rotation speed change
+            -- minimal change indicates the turbine is converging on a flow rate
+            if last.time_tanks < turbine.tanks.last_update then
+                if last.time_tanks > 0 then
+                    rotation_stable = math.abs(rotation - last.rotation) < 0.00000003
+                end
+
+                last.time_tanks = turbine.tanks.last_update
+                last.rotation = rotation
+            end
+
+            -- flow is stable if the flow rate is at the input rate or at the max (±1 mB/t)
+            local flow_stable = false
+            if last.time_state < turbine.state.last_update then
+                if (last.time_state > 0) and (turbine.state.flow_rate > 0) then
+                    flow_stable = math.abs(turbine.state.flow_rate - math.min(turbine.state.steam_input_rate, turbine.build.max_flow_rate)) < 2
+                end
+
+                last.time_state = turbine.state.last_update
+            end
+
+            if rotation_stable then
+                log.debug(util.c("UNIT ", self.r_id, ": turbine ", idx, " reached rotational stability (", rotation, ")"))
+            end
+
+            if flow_stable then
+                log.debug(util.c("UNIT ", self.r_id, ": turbine ", idx, " reached flow stability (", turbine.state.flow_rate, " mB/t)"))
+            end
+
+            turbines_stable = turbines_stable and (rotation_stable or flow_stable)
+        else
+            last.time_state = 0
+            last.time_tanks = 0
+            last.rotation = 1
+
+            turbines_stable = false
+        end
     end
 
+    self.turbine_flow_stable = self.turbine_flow_stable or turbines_stable
+
     -- check for boil rate mismatch (> 4% error) either between reactor and turbine or boiler and turbine
     annunc.BoilRateMismatch = math.abs(total_boil_rate - total_input_rate) > (0.04 * total_boil_rate)
 
@@ -508,11 +576,25 @@ function logic.update_alarms(self)
 
     local rcs_trans = any_low or any_over or gen_trip or annunc.RCPTrip or annunc.MaxWaterReturnFeed
 
-    -- annunciator indicators for these states may not indicate a real issue when:
+    if plc_cache.active then
-    --  > flow is ramping up right after reactor start
+        -- these conditions may not indicate an issue when flow is changing after a burn rate change
-    --  > flow is ramping down after reactor shutdown
+        if self.num_boilers == 0 then
-    if ((util.time_ms() - self.last_rate_change_ms) > FLOW_STABILITY_DELAY_MS) and plc_cache.active then
+            if (util.time_ms() - self.last_rate_change_ms) > FLOW_STABILITY_DELAY_MS then
-        rcs_trans = rcs_trans or annunc.RCSFlowLow or annunc.BoilRateMismatch or annunc.CoolantFeedMismatch or annunc.SteamFeedMismatch
+                rcs_trans = rcs_trans or annunc.BoilRateMismatch
+            end
+
+            if self.turbine_flow_stable then
+                rcs_trans = rcs_trans or annunc.RCSFlowLow or annunc.CoolantFeedMismatch or annunc.SteamFeedMismatch
+            end
+        else
+            if (util.time_ms() - self.last_rate_change_ms) > FLOW_STABILITY_DELAY_MS then
+                rcs_trans = rcs_trans or annunc.RCSFlowLow or annunc.BoilRateMismatch or annunc.CoolantFeedMismatch
+            end
+
+            if self.turbine_flow_stable then
+                rcs_trans = rcs_trans or annunc.SteamFeedMismatch
+            end
+        end
     end
 
     if _update_alarm_state(self, rcs_trans, self.alarms.RCSTransient) then
@@ -666,7 +748,9 @@ function logic.update_status_text(self)
             elseif annunc.WasteLineOcclusion then
                 self.status_text[2] = "insufficient waste output rate"
             elseif (util.time_ms() - self.last_rate_change_ms) <= FLOW_STABILITY_DELAY_MS then
-                self.status_text[2] = "awaiting flow stability"
+                self.status_text[2] = "awaiting coolant flow stability"
+            elseif not self.turbine_flow_stable then
+                self.status_text[2] = "awaiting turbine flow stability"
             else
                 self.status_text[2] = "system nominal"
             end