Update README.md

Beta Release

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,27 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots and Logs**
+If applicable, add screenshots to help explain your problem. Please include a text snippet from the log.txt files if possible, otherwise include a screenshot.
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,17 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.gitignore

@@ -0,0 +1,2 @@
+_notes/
+program.sh

.vscode/settings.json

@@ -8,6 +8,16 @@
         "parallel",
         "colors",
         "textutils",
-        "shell"
+        "shell",
+        "settings",
+        "window",
+        "read",
+        "periphemu",
+        "mekanismEnergyHelper",
+        "_HOST",
+        "http"
+    ],
+    "Lua.diagnostics.disable": [
+        "duplicate-set-field"
     ]
 }

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Mikayla Fischler
+Copyright © 2022 - 2023 Mikayla Fischler
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,13 +1,27 @@
 # cc-mek-scada
 Configurable ComputerCraft SCADA system for multi-reactor control of Mekanism fission reactors with a GUI, automatic safety features, waste processing control, and more! 
 
-This requires CC: Tweaked and Mekanism v10.0+ (10.1 recommended for full feature set).
+Mod Requirements:
+- CC: Tweaked
+- Mekanism v10.1+
 
+Mod Recommendations:
+- Advanced Peripherals (adds the capability to detect environmental radiation levels)
+
+v10.1+ is required due the complete support of CC:Tweaked added in Mekanism v10.1
+
+There was also an apparent bug with boilers disconnecting and reconnecting when active in my test world on 10.0.24, so it may not even have been an option to fully implement this with support for 10.0.
+
+## Installation
+
+You can install this on a ComputerCraft computer using either:
+* `wget https://raw.githubusercontent.com/MikaylaFischler/cc-mek-scada/main/ccmsi.lua`
+* `pastebin get iUMjgW0C ccmsi.lua`
 
 ## [SCADA](https://en.wikipedia.org/wiki/SCADA)
 > Supervisory control and data acquisition (SCADA) is a control system architecture comprising computers, networked data communications and graphical user interfaces for high-level supervision of machines and processes. It also covers sensors and other devices, such as programmable logic controllers, which interface with process plant or machinery.
 
-This project implements concepts of a SCADA system in ComputerCraft (because why not? ..okay don't answer that). I recommend reviewing that linked wikipedia page on SCADA if you want to understand the concepts used here.
+This project implements concepts of a SCADA system in ComputerCraft (because why not? ..okay don't answer that). I recommend reviewing that linked wikipedia page on SCADA if you *want* to understand the concepts used here.
 
 ![Architecture](https://upload.wikimedia.org/wikipedia/commons/thumb/1/10/Functional_levels_of_a_Distributed_Control_System.svg/1000px-Functional_levels_of_a_Distributed_Control_System.svg.png)
 
@@ -35,7 +49,7 @@ The RTU control code is relatively unique, as instead of having instructions be
 
 ### PLCs
 
-PLCs are advanced devices that allow for both reporting and control to/from the SCADA system in addition to programed behaviors independent of the SCADA system. Currently there is only one type of PLC, and that is the reactor PLC. This is responsible for reporting on and controlling the reactor as a part of the SCADA system, and independently regulating the safety of the reactor. It checks the status for multiple hazard scenarios and shuts down the reactor if any condition is satisfied.
+PLCs are advanced devices that allow for both reporting and control to/from the SCADA system in addition to programed behaviors independent of the SCADA system. Currently there is only one type of PLC, and that is the reactor PLC. This is responsible for reporting on and controlling the reactor as a part of the SCADA system, and independently regulating the safety of the reactor. It checks the status for multiple hazard scenarios and shuts down the reactor if any condition is met.
 
 There can and should only be one of these per reactor. A single Advanced Computer will act as the PLC, with either a direct connection (physical contact) or a wired modem connection to the reactor logic port.
 
@@ -53,9 +67,8 @@ TBD, I am planning on AES symmetric encryption for security + HMAC to prevent re
 
 This is somewhat important here as otherwise anyone can just control your setup, which is undeseriable. Unlike normal Minecraft PVP chaos, it would be very difficult to identify who is messing with your system, as with an Ender Modem they can do it from effectively anywhere and the server operators would have to check every computer's filesystem to find suspicious code. 
 
-The only other possible security mitigation for commanding (no effect on monitoring) is to enforce a maximum authorized transmission range (which I will probably also do, or maybe fall back to), as modem message events contain the transmission distance.
+The other security mitigation for commanding (no effect on monitoring) is to enforce a maximum authorized transmission range, which has been added as a configurable feature.
 
 ## Known Issues
 
-GitHub issue \#29:
-It appears that with Mekanism 10.0, a boiler peripheral may rapidly disconnect/reconnect constantly while running. This will prevent that RTU from operating correctly while also filling up the log file. This may be due to a very specific version interaction of CC: Tweaked and Mekansim, so you are welcome to try this on Mekanism 10.0 servers, but do be aware it may not work.
+None yet since the switch to requiring 10.1+!

ccmsi.lua

@@ -0,0 +1,670 @@
+--
+-- ComputerCraft Mekanism SCADA System Installer Utility
+--
+
+--[[
+Copyright © 2023 Mikayla Fischler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the “Software”), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+]]--
+
+local function println(message) print(tostring(message)) end
+local function print(message) term.write(tostring(message)) end
+
+local CCMSI_VERSION = "v1.0"
+
+local install_dir = "/.install-cache"
+local repo_path = "http://raw.githubusercontent.com/MikaylaFischler/cc-mek-scada/"
+
+local opts = { ... }
+local mode = nil
+local app = nil
+
+-- record the local installation manifest
+---@param manifest table
+---@param dependencies table
+local function write_install_manifest(manifest, dependencies)
+    local versions = {}
+    for key, value in pairs(manifest.versions) do
+        local is_dependency = false
+        for _, dependency in pairs(dependencies) do
+            if key == "bootloader" and dependency == "system" then
+                is_dependency = true
+                break
+            end
+        end
+
+        if key == app or key == "comms" or is_dependency then versions[key] = value end
+    end
+
+    manifest.versions = versions
+
+    local imfile = fs.open("install_manifest.json", "w")
+    imfile.write(textutils.serializeJSON(manifest))
+    imfile.close()
+end
+
+--
+-- get and validate command line options
+--
+
+println("-- CC Mekanism SCADA Installer " .. CCMSI_VERSION .. " --")
+
+if #opts == 0 or opts[1] == "help" then
+    println("usage: ccmsi <mode> <app> <tag/branch>")
+    println("<mode>")
+    term.setTextColor(colors.lightGray)
+    println(" check       - check latest versions avilable")
+    term.setTextColor(colors.yellow)
+    println("               ccmsi check <tag/branch> for target")
+    term.setTextColor(colors.lightGray)
+    println(" install     - fresh install, overwrites config")
+    println(" update      - update files EXCEPT for config/logs")
+    println(" remove      - delete files EXCEPT for config/logs")
+    println(" purge       - delete files INCLUDING config/logs")
+    term.setTextColor(colors.white)
+    println("<app>")
+    term.setTextColor(colors.lightGray)
+    println(" reactor-plc - reactor PLC firmware")
+    println(" rtu         - RTU firmware")
+    println(" supervisor  - supervisor server application")
+    println(" coordinator - coordinator application")
+    println(" pocket      - pocket application")
+    term.setTextColor(colors.white)
+    println("<tag/branch>")
+    term.setTextColor(colors.yellow)
+    println(" second parameter when used with check")
+    term.setTextColor(colors.lightGray)
+    println(" note: defaults to main")
+    println(" target GitHub tag or branch name")
+    return
+else
+    for _, v in pairs({ "check", "install", "update", "remove", "purge" }) do
+        if opts[1] == v then
+            mode = v
+            break
+        end
+    end
+
+    if mode == nil then
+        println("unrecognized mode")
+        return
+    end
+
+    for _, v in pairs({ "reactor-plc", "rtu", "supervisor", "coordinator", "pocket" }) do
+        if opts[2] == v then
+            app = v
+            break
+        end
+    end
+
+    if app == nil and mode ~= "check" then
+        println("unrecognized application")
+        return
+    end
+end
+
+--
+-- run selected mode
+--
+
+if mode == "check" then
+    -------------------------
+    -- GET REMOTE MANIFEST --
+    -------------------------
+
+    if opts[2] then repo_path = repo_path .. opts[2] .. "/" else repo_path = repo_path .. "main/" end
+    local install_manifest = repo_path .. "install_manifest.json"
+
+    local response, error = http.get(install_manifest)
+
+    if response == nil then
+        term.setTextColor(colors.orange)
+        println("failed to get installation manifest from GitHub, cannot update or install")
+        term.setTextColor(colors.red)
+        println("HTTP error: " .. error)
+        term.setTextColor(colors.white)
+        return
+    end
+
+    local ok, manifest = pcall(function () return textutils.unserializeJSON(response.readAll()) end)
+
+    if not ok then
+        term.setTextColor(colors.red)
+        println("error parsing remote installation manifest")
+        term.setTextColor(colors.white)
+        return
+    end
+
+    ------------------------
+    -- GET LOCAL MANIFEST --
+    ------------------------
+
+    local imfile = fs.open("install_manifest.json", "r")
+    local local_ok = false
+    local local_manifest = {}
+
+    if imfile ~= nil then
+        local_ok, local_manifest = pcall(function () return textutils.unserializeJSON(imfile.readAll()) end)
+        imfile.close()
+    end
+
+    if not local_ok then
+        term.setTextColor(colors.yellow)
+        println("failed to load local installation information")
+        term.setTextColor(colors.white)
+
+        local_manifest = { versions = { installer = CCMSI_VERSION } }
+    else
+        local_manifest.versions.installer = CCMSI_VERSION
+    end
+
+    -- list all versions
+    for key, value in pairs(manifest.versions) do
+        term.setTextColor(colors.purple)
+        print(string.format("%-14s", "[" .. key .. "]"))
+        if key == "installer" or (local_ok and (local_manifest.versions[key] ~= nil)) then
+            term.setTextColor(colors.blue)
+            print(local_manifest.versions[key])
+            if value ~= local_manifest.versions[key] then
+                term.setTextColor(colors.white)
+                print(" (")
+                term.setTextColor(colors.cyan)
+                print(value)
+                term.setTextColor(colors.white)
+                println(" available)")
+            else
+                term.setTextColor(colors.green)
+                println(" (up to date)")
+            end
+        else
+            term.setTextColor(colors.lightGray)
+            print("not installed")
+            term.setTextColor(colors.white)
+            print(" (latest ")
+            term.setTextColor(colors.cyan)
+            print(value)
+            term.setTextColor(colors.white)
+            println(")")
+        end
+    end
+elseif mode == "install" or mode == "update" then
+    -------------------------
+    -- GET REMOTE MANIFEST --
+    -------------------------
+
+    if opts[3] then repo_path = repo_path .. opts[3] .. "/" else repo_path = repo_path .. "main/" end
+    local install_manifest = repo_path .. "install_manifest.json"
+
+    local response, error = http.get(install_manifest)
+
+    if response == nil then
+        term.setTextColor(colors.orange)
+        println("failed to get installation manifest from GitHub, cannot update or install")
+        term.setTextColor(colors.red)
+        println("HTTP error: " .. error)
+        term.setTextColor(colors.white)
+        return
+    end
+
+    local ok, manifest = pcall(function () return textutils.unserializeJSON(response.readAll()) end)
+
+    if not ok then
+        term.setTextColor(colors.red)
+        println("error parsing remote installation manifest")
+        term.setTextColor(colors.white)
+    end
+
+    ------------------------
+    -- GET LOCAL MANIFEST --
+    ------------------------
+
+    local imfile = fs.open("install_manifest.json", "r")
+    local local_ok = false
+    local local_manifest = {}
+
+    if imfile ~= nil then
+        local_ok, local_manifest = pcall(function () return textutils.unserializeJSON(imfile.readAll()) end)
+        imfile.close()
+    end
+
+    local local_app_version = nil
+    local local_comms_version = nil
+    local local_boot_version = nil
+
+    -- try to find local versions
+    if not local_ok then
+        if mode == "update" then
+            term.setTextColor(colors.red)
+            println("failed to load local installation information, cannot update")
+            term.setTextColor(colors.white)
+            return
+        end
+    else
+        local_app_version = local_manifest.versions[app]
+        local_comms_version = local_manifest.versions.comms
+        local_boot_version = local_manifest.versions.bootloader
+
+        if local_manifest.versions[app] == nil then
+            term.setTextColor(colors.red)
+            println("another application is already installed, please purge it before installing a new application")
+            term.setTextColor(colors.white)
+            return
+        end
+
+        local_manifest.versions.installer = CCMSI_VERSION
+        if manifest.versions.installer ~= CCMSI_VERSION then
+            term.setTextColor(colors.yellow)
+            println("a newer version of the installer is available, consider downloading it")
+            term.setTextColor(colors.white)
+        end
+    end
+
+    local remote_app_version = manifest.versions[app]
+    local remote_comms_version = manifest.versions.comms
+    local remote_boot_version = manifest.versions.bootloader
+
+    term.setTextColor(colors.green)
+    if mode == "install" then
+        println("installing " .. app .. " files...")
+    elseif mode == "update" then
+        println("updating " .. app .. " files... (keeping old config.lua)")
+    end
+    term.setTextColor(colors.white)
+
+    -- display bootloader version change information
+    if local_boot_version ~= nil then
+        if local_boot_version ~= remote_boot_version then
+            print("[bootldr] updating ")
+            term.setTextColor(colors.blue)
+            print(local_boot_version)
+            term.setTextColor(colors.white)
+            print(" \xbb ")
+            term.setTextColor(colors.blue)
+            println(remote_boot_version)
+            term.setTextColor(colors.white)
+        elseif mode == "install" then
+            print("[bootldr] reinstalling ")
+            term.setTextColor(colors.blue)
+            println(local_boot_version)
+            term.setTextColor(colors.white)
+        end
+    else
+        print("[bootldr] new install of ")
+        term.setTextColor(colors.blue)
+        println(remote_boot_version)
+        term.setTextColor(colors.white)
+    end
+
+    -- display app version change information
+    if local_app_version ~= nil then
+        if local_app_version ~= remote_app_version then
+            print("[" .. app .. "] updating ")
+            term.setTextColor(colors.blue)
+            print(local_app_version)
+            term.setTextColor(colors.white)
+            print(" \xbb ")
+            term.setTextColor(colors.blue)
+            println(remote_app_version)
+            term.setTextColor(colors.white)
+        elseif mode == "install" then
+            print("[" .. app .. "] reinstalling ")
+            term.setTextColor(colors.blue)
+            println(local_app_version)
+            term.setTextColor(colors.white)
+        end
+    else
+        print("[" .. app .. "] new install of ")
+        term.setTextColor(colors.blue)
+        println(remote_app_version)
+        term.setTextColor(colors.white)
+    end
+
+    -- display comms version change information
+    if local_comms_version ~= nil then
+        if local_comms_version ~= remote_comms_version then
+            print("[comms] updating ")
+            term.setTextColor(colors.blue)
+            print(local_comms_version)
+            term.setTextColor(colors.white)
+            print(" \xbb ")
+            term.setTextColor(colors.blue)
+            println(remote_comms_version)
+            term.setTextColor(colors.white)
+            print("[comms] ")
+            term.setTextColor(colors.yellow)
+            println("other devices on the network will require an update")
+            term.setTextColor(colors.white)
+        elseif mode == "install" then
+            print("[comms] reinstalling ")
+            term.setTextColor(colors.blue)
+            println(local_comms_version)
+            term.setTextColor(colors.white)
+        end
+    else
+        print("[comms] new install of ")
+        term.setTextColor(colors.blue)
+        println(remote_comms_version)
+        term.setTextColor(colors.white)
+    end
+
+    --------------------------
+    -- START INSTALL/UPDATE --
+    --------------------------
+
+    local space_required = manifest.sizes.manifest
+    local space_available = fs.getFreeSpace("/")
+
+    local single_file_mode = false
+    local file_list = manifest.files
+    local size_list = manifest.sizes
+    local dependencies = manifest.depends[app]
+    local config_file = app .. "/config.lua"
+
+    table.insert(dependencies, app)
+
+    for _, dependency in pairs(dependencies) do
+        local size = size_list[dependency]
+        space_required = space_required + size
+    end
+
+    -- check space constraints
+    if space_available < space_required then
+        single_file_mode = true
+        term.setTextColor(colors.yellow)
+        println("WARNING: Insufficient space available for a full download!")
+        term.setTextColor(colors.white)
+        println("Files can be downloaded one by one, so if you are replacing a current install this will not be a problem unless installation fails.")
+        println("Do you wish to continue? (y/N)")
+
+        local confirm = read()
+        if confirm ~= "y" and confirm ~= "Y" then
+            println("installation cancelled")
+            return
+        end
+    end
+
+---@diagnostic disable-next-line: undefined-field
+    os.sleep(2)
+
+    local success = true
+
+    if not single_file_mode then
+        if fs.exists(install_dir) then
+            fs.delete(install_dir)
+            fs.makeDir(install_dir)
+        end
+
+        -- download all dependencies
+        for _, dependency in pairs(dependencies) do
+            if mode == "update" and ((dependency == "system" and local_boot_version == remote_boot_version) or (local_app_version == remote_app_version)) then
+                -- skip system package if unchanged, skip app package if not changed
+                -- skip packages that have no version if app version didn't change
+                term.setTextColor(colors.white)
+                print("skipping download of unchanged package ")
+                term.setTextColor(colors.blue)
+                println(dependency)
+            else
+                term.setTextColor(colors.white)
+                print("downloading package ")
+                term.setTextColor(colors.blue)
+                println(dependency)
+
+                term.setTextColor(colors.lightGray)
+                local files = file_list[dependency]
+                for _, file in pairs(files) do
+                    println("GET " .. file)
+                    local dl, err = http.get(repo_path .. file)
+
+                    if dl == nil then
+                        term.setTextColor(colors.red)
+                        println("GET HTTP Error " .. err)
+                        success = false
+                        break
+                    else
+                        local handle = fs.open(install_dir .. "/" .. file, "w")
+                        handle.write(dl.readAll())
+                        handle.close()
+                    end
+                end
+            end
+        end
+
+        -- copy in downloaded files (installation)
+        if success then
+            for _, dependency in pairs(dependencies) do
+                if mode == "update" and ((dependency == "system" and local_boot_version == remote_boot_version) or (local_app_version == remote_app_version)) then
+                    -- skip system package if unchanged, skip app package if not changed
+                    -- skip packages that have no version if app version didn't change
+                    term.setTextColor(colors.white)
+                    print("skipping install of unchanged package ")
+                    term.setTextColor(colors.blue)
+                    println(dependency)
+                else
+                    term.setTextColor(colors.white)
+                    print("installing package ")
+                    term.setTextColor(colors.blue)
+                    println(dependency)
+
+                    term.setTextColor(colors.lightGray)
+                    local files = file_list[dependency]
+                    for _, file in pairs(files) do
+                        if mode == "install" or file ~= config_file then
+                            local temp_file = install_dir .. "/" .. file
+                            if fs.exists(file) then fs.delete(file) end
+                            fs.move(temp_file, file)
+                        end
+                    end
+                end
+            end
+        end
+
+        fs.delete(install_dir)
+
+        if success then
+            -- if we made it here, then none of the file system functions threw exceptions
+            -- that means everything is OK
+            write_install_manifest(manifest, dependencies)
+            term.setTextColor(colors.green)
+            if mode == "install" then
+                println("installation completed successfully")
+            else
+                println("update completed successfully")
+            end
+        else
+            if mode == "install" then
+                term.setTextColor(colors.red)
+                println("installation failed")
+            else
+                term.setTextColor(colors.orange)
+                println("update failed, existing files unmodified")
+            end
+        end
+    else
+        -- go through all files and replace one by one
+        for _, dependency in pairs(dependencies) do
+            if mode == "update" and ((dependency == "system" and local_boot_version == remote_boot_version) or (local_app_version == remote_app_version)) then
+                -- skip system package if unchanged, skip app package if not changed
+                -- skip packages that have no version if app version didn't change
+                term.setTextColor(colors.white)
+                print("skipping install of unchanged package ")
+                term.setTextColor(colors.blue)
+                println(dependency)
+            else
+                term.setTextColor(colors.white)
+                print("installing package ")
+                term.setTextColor(colors.blue)
+                println(dependency)
+
+                term.setTextColor(colors.lightGray)
+                local files = file_list[dependency]
+                for _, file in pairs(files) do
+                    if mode == "install" or file ~= config_file then
+                        println("GET " .. file)
+                        local dl, err = http.get(repo_path .. file)
+
+                        if dl == nil then
+                            println("GET HTTP Error " .. err)
+                            success = false
+                            break
+                        else
+                            local handle = fs.open("/" .. file, "w")
+                            handle.write(dl.readAll())
+                            handle.close()
+                        end
+                    end
+                end
+            end
+        end
+
+        if success then
+            -- if we made it here, then none of the file system functions threw exceptions
+            -- that means everything is OK
+            write_install_manifest(manifest, dependencies)
+            term.setTextColor(colors.green)
+            if mode == "install" then
+                println("installation completed successfully")
+            else
+                println("update completed successfully")
+            end
+        else
+            term.setTextColor(colors.red)
+            if mode == "install" then
+                println("installation failed, files may have been skipped")
+            else
+                println("update failed, files may have been skipped")
+            end
+        end
+    end
+elseif mode == "remove" or mode == "purge" then
+    local imfile = fs.open("install_manifest.json", "r")
+    local ok = false
+    local manifest = {}
+
+    if imfile ~= nil then
+        ok, manifest = pcall(function () return textutils.unserializeJSON(imfile.readAll()) end)
+        imfile.close()
+    end
+
+    if not ok then
+        term.setTextColor(colors.red)
+        println("error parsing local installation manifest")
+        term.setTextColor(colors.white)
+        return
+    elseif mode == "remove" and manifest.versions[app] == nil then
+        term.setTextColor(colors.red)
+        println(app .. " is not installed")
+        term.setTextColor(colors.white)
+        return
+    end
+
+    term.setTextColor(colors.orange)
+    if mode == "remove" then
+        println("removing all " .. app .. " files except for config.lua and log.txt...")
+    elseif mode == "purge" then
+        println("purging all " .. app .. " files...")
+    end
+
+---@diagnostic disable-next-line: undefined-field
+    os.sleep(2)
+
+    local file_list = manifest.files
+    local dependencies = manifest.depends[app]
+    local config_file = app .. "/config.lua"
+
+    table.insert(dependencies, app)
+
+    term.setTextColor(colors.lightGray)
+
+    -- delete log file if purging
+    if mode == "purge" and fs.exists(config_file) then
+        local log_deleted = pcall(function ()
+            local config = require(app .. ".config")
+            if fs.exists(config.LOG_PATH) then
+                fs.delete(config.LOG_PATH)
+                println("deleted log file " .. config.LOG_PATH)
+            end
+        end)
+
+        if not log_deleted then
+            term.setTextColor(colors.red)
+            println("failed to delete log file")
+            term.setTextColor(colors.lightGray)
+---@diagnostic disable-next-line: undefined-field
+            os.sleep(1)
+        end
+    end
+
+    -- delete all files except config unless purging
+    for _, dependency in pairs(dependencies) do
+        local files = file_list[dependency]
+        for _, file in pairs(files) do
+            if mode == "purge" or file ~= config_file then
+                if fs.exists(file) then
+                    fs.delete(file)
+                    println("deleted " .. file)
+                end
+            end
+        end
+
+        -- delete folders that we should be deleteing
+        if mode == "purge" or dependency ~= app then
+            local folder = files[1]
+            while true do
+                local dir = fs.getDir(folder)
+                if dir == "" or dir == ".." then
+                    break
+                else
+                    folder = dir
+                end
+            end
+
+            if fs.isDir(folder) then
+                fs.delete(folder)
+                println("deleted directory " .. folder)
+            end
+        elseif dependency == app then
+            for _, folder in pairs(files) do
+                while true do
+                    local dir = fs.getDir(folder)
+                    if dir == "" or dir == ".." or dir == app then
+                        break
+                    else
+                        folder = dir
+                    end
+                end
+
+                if folder ~= app and fs.isDir(folder) then
+                    fs.delete(folder)
+                    println("deleted app subdirectory " .. folder)
+                end
+            end
+        end
+    end
+
+    -- only delete manifest if purging
+    if mode == "purge" then
+        fs.delete("install_manifest.json")
+        println("deleted install_manifest.json")
+    else
+        -- remove all data from versions list to show nothing is installed
+        manifest.versions = {}
+        imfile = fs.open("install_manifest.json", "w")
+        imfile.write(textutils.serializeJSON(manifest))
+        imfile.close()
+    end
+
+    term.setTextColor(colors.green)
+    println("done!")
+end
+
+term.setTextColor(colors.white)

coordinator/apisessions.lua

@@ -0,0 +1,20 @@
+local apisessions = {}
+
+---@param packet capi_frame
+function apisessions.handle_packet(packet)
+end
+
+-- attempt to identify which session's watchdog timer fired
+---@param timer_event number
+function apisessions.check_all_watchdogs(timer_event)
+end
+
+-- delete all closed sessions
+function apisessions.free_all_closed()
+end
+
+-- close all open connections
+function apisessions.close_all()
+end
+
+return apisessions

coordinator/config.lua

@@ -0,0 +1,31 @@
+local config = {}
+
+-- port of the SCADA supervisor
+config.SCADA_SV_PORT = 16100
+-- port to listen to incoming packets from supervisor
+config.SCADA_SV_LISTEN = 16101
+-- listen port for SCADA coordinator API access
+config.SCADA_API_LISTEN = 16200
+-- max trusted modem message distance (0 to disable check)
+config.TRUSTED_RANGE = 0
+-- time in seconds (>= 2) before assuming a remote device is no longer active
+config.COMMS_TIMEOUT = 5
+
+-- expected number of reactor units, used only to require that number of unit monitors
+config.NUM_UNITS = 4
+
+-- alarm sounder volume (0.0 to 3.0, 1.0 being standard max volume, this is the option given to to speaker.play())
+-- note: alarm sine waves are at half saturation, so that multiple will be required to reach full scale
+config.SOUNDER_VOLUME = 1.0
+
+-- true for 24 hour time on main view screen
+config.TIME_24_HOUR = true
+
+-- log path
+config.LOG_PATH = "/log.txt"
+-- log mode
+--  0 = APPEND (adds to existing file on start)
+--  1 = NEW (replaces existing file on start)
+config.LOG_MODE = 0
+
+return config

coordinator/coordinator.lua

@@ -1,12 +1,671 @@
-local comms = require("scada-common.comms")
+local comms       = require("scada-common.comms")
+local log         = require("scada-common.log")
+local ppm         = require("scada-common.ppm")
+local util        = require("scada-common.util")
+
+local apisessions = require("coordinator.apisessions")
+local iocontrol   = require("coordinator.iocontrol")
+local process     = require("coordinator.process")
+
+local dialog      = require("coordinator.ui.dialog")
+
+local print = util.print
+local println = util.println
+local print_ts = util.print_ts
+local println_ts = util.println_ts
+
+local PROTOCOL = comms.PROTOCOL
+local DEVICE_TYPE = comms.DEVICE_TYPE
+local ESTABLISH_ACK = comms.ESTABLISH_ACK
+local SCADA_MGMT_TYPE = comms.SCADA_MGMT_TYPE
+local SCADA_CRDN_TYPE = comms.SCADA_CRDN_TYPE
+local UNIT_COMMAND = comms.UNIT_COMMAND
+local FAC_COMMAND = comms.FAC_COMMAND
 
 local coordinator = {}
 
--- coordinator communications
-coordinator.coord_comms = function ()
-    local self = {
-        reactor_struct_cache = nil
+-- request the user to select a monitor
+---@nodiscard
+---@param names table available monitors
+---@return boolean|string|nil
+local function ask_monitor(names)
+    println("available monitors:")
+    for i = 1, #names do
+        print(" " .. names[i])
+    end
+    println("")
+    println("select a monitor or type c to cancel")
+
+    local iface = dialog.ask_options(names, "c")
+
+    if iface ~= false and iface ~= nil then
+        util.filter_table(names, function (x) return x ~= iface end)
+    end
+
+    return iface
+end
+
+-- configure monitor layout
+---@param num_units integer number of units expected
+---@return boolean success, monitors_struct? monitors
+function coordinator.configure_monitors(num_units)
+    ---@class monitors_struct
+    local monitors = {
+        primary = nil,
+        primary_name = "",
+        unit_displays = {},
+        unit_name_map = {}
     }
+
+    local monitors_avail = ppm.get_monitor_list()
+    local names = {}
+    local available = {}
+
+    -- get all interface names
+    for iface, _ in pairs(monitors_avail) do
+        table.insert(names, iface)
+        table.insert(available, iface)
+    end
+
+    -- we need a certain number of monitors (1 per unit + 1 primary display)
+    local num_displays_needed = num_units + 1
+    if #names < num_displays_needed then
+        local message = "not enough monitors connected (need " .. num_displays_needed .. ")"
+        println(message)
+        log.warning(message)
+        return false
+    end
+
+    -- attempt to load settings
+    if not settings.load("/coord.settings") then
+        log.warning("configure_monitors(): failed to load coordinator settings file (may not exist yet)")
+    else
+        local _primary = settings.get("PRIMARY_DISPLAY")
+        local _unitd = settings.get("UNIT_DISPLAYS")
+
+        -- filter out already assigned monitors
+        util.filter_table(available, function (x) return x ~= _primary end)
+        if type(_unitd) == "table" then
+            util.filter_table(available, function (x) return not util.table_contains(_unitd, x) end)
+        end
+    end
+
+    ---------------------
+    -- PRIMARY DISPLAY --
+    ---------------------
+
+    local iface_primary_display = settings.get("PRIMARY_DISPLAY")   ---@type boolean|string|nil
+
+    if not util.table_contains(names, iface_primary_display) then
+        println("primary display is not connected")
+        local response = dialog.ask_y_n("would you like to change it", true)
+        if response == false then return false end
+        iface_primary_display = nil
+    end
+
+    while iface_primary_display == nil and #available > 0 do
+        -- lets get a monitor
+        iface_primary_display = ask_monitor(available)
+    end
+
+    if type(iface_primary_display) ~= "string" then return false end
+
+    settings.set("PRIMARY_DISPLAY", iface_primary_display)
+    util.filter_table(available, function (x) return x ~= iface_primary_display end)
+
+    monitors.primary = ppm.get_periph(iface_primary_display)
+    monitors.primary_name = iface_primary_display
+
+    -------------------
+    -- UNIT DISPLAYS --
+    -------------------
+
+    local unit_displays = settings.get("UNIT_DISPLAYS")
+
+    if unit_displays == nil then
+        unit_displays = {}
+        for i = 1, num_units do
+            local display = nil
+
+            while display == nil and #available > 0 do
+                -- lets get a monitor
+                println("please select monitor for unit #" .. i)
+                display = ask_monitor(available)
+            end
+
+            if display == false then return false end
+
+            unit_displays[i] = display
+        end
+    else
+        -- make sure all displays are connected
+        for i = 1, num_units do
+            local display = unit_displays[i]
+
+            if not util.table_contains(names, display) then
+                println("unit #" .. i .. " display is not connected")
+                local response = dialog.ask_y_n("would you like to change it", true)
+                if response == false then return false end
+                display = nil
+            end
+
+            while display == nil and #available > 0 do
+                -- lets get a monitor
+                display = ask_monitor(available)
+            end
+
+            if display == false then return false end
+
+            unit_displays[i] = display
+        end
+    end
+
+    settings.set("UNIT_DISPLAYS", unit_displays)
+    if not settings.save("/coord.settings") then
+        log.warning("configure_monitors(): failed to save coordinator settings file")
+    end
+
+    for i = 1, #unit_displays do
+        monitors.unit_displays[i] = ppm.get_periph(unit_displays[i])
+        monitors.unit_name_map[i] = unit_displays[i]
+    end
+
+    return true, monitors
+end
+
+-- dmesg print wrapper
+---@param message string message
+---@param dmesg_tag string tag
+---@param working? boolean to use dmesg_working
+---@return function? update, function? done
+local function log_dmesg(message, dmesg_tag, working)
+    local colors = {
+        GRAPHICS = colors.green,
+        SYSTEM = colors.cyan,
+        BOOT = colors.blue,
+        COMMS = colors.purple
+    }
+
+    if working then
+        return log.dmesg_working(message, dmesg_tag, colors[dmesg_tag])
+    else
+        log.dmesg(message, dmesg_tag, colors[dmesg_tag])
+    end
+end
+
+function coordinator.log_graphics(message) log_dmesg(message, "GRAPHICS") 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
+
+-- log a message for communications connecting, providing access to progress indication control functions
+---@nodiscard
+---@param message string
+---@return function update, function done
+function coordinator.log_comms_connecting(message)
+    local update, done = log_dmesg(message, "COMMS", true)
+    ---@cast update function
+    ---@cast done function
+    return update, done
+end
+
+-- coordinator communications
+---@nodiscard
+---@param version string coordinator version
+---@param modem table modem device
+---@param sv_port integer port of configured supervisor
+---@param sv_listen integer listening port for supervisor replys
+---@param api_listen integer listening port for pocket API
+---@param range integer trusted device connection range
+---@param sv_watchdog watchdog
+function coordinator.comms(version, modem, sv_port, sv_listen, api_listen, range, sv_watchdog)
+    local self = {
+        sv_linked = false,
+        sv_seq_num = 0,
+        sv_r_seq_num = nil,
+        sv_config_err = false,
+        connected = false,
+        last_est_ack = ESTABLISH_ACK.ALLOW
+    }
+
+    comms.set_trusted_range(range)
+
+    -- PRIVATE FUNCTIONS --
+
+    -- configure modem channels
+    local function _conf_channels()
+        modem.closeAll()
+        modem.open(sv_listen)
+        modem.open(api_listen)
+    end
+
+    _conf_channels()
+
+    -- send a packet to the supervisor
+    ---@param msg_type SCADA_MGMT_TYPE|SCADA_CRDN_TYPE
+    ---@param msg table
+    local function _send_sv(protocol, msg_type, msg)
+        local s_pkt = comms.scada_packet()
+        local pkt = nil ---@type mgmt_packet|crdn_packet
+
+        if protocol == PROTOCOL.SCADA_MGMT then
+            pkt = comms.mgmt_packet()
+        elseif protocol == PROTOCOL.SCADA_CRDN then
+            pkt = comms.crdn_packet()
+        else
+            return
+        end
+
+        pkt.make(msg_type, msg)
+        s_pkt.make(self.sv_seq_num, protocol, pkt.raw_sendable())
+
+        modem.transmit(sv_port, sv_listen, s_pkt.raw_sendable())
+        self.sv_seq_num = self.sv_seq_num + 1
+    end
+
+    -- attempt connection establishment
+    local function _send_establish()
+        _send_sv(PROTOCOL.SCADA_MGMT, SCADA_MGMT_TYPE.ESTABLISH, { comms.version, version, DEVICE_TYPE.CRDN })
+    end
+
+    -- keep alive ack
+    ---@param srv_time integer
+    local function _send_keep_alive_ack(srv_time)
+        _send_sv(PROTOCOL.SCADA_MGMT, SCADA_MGMT_TYPE.KEEP_ALIVE, { srv_time, util.time() })
+    end
+
+    -- PUBLIC FUNCTIONS --
+
+    ---@class coord_comms
+    local public = {}
+
+    -- reconnect a newly connected modem
+    ---@param new_modem table
+    function public.reconnect_modem(new_modem)
+        modem = new_modem
+        _conf_channels()
+    end
+
+    -- close the connection to the server
+    function public.close()
+        sv_watchdog.cancel()
+        self.sv_linked = false
+        _send_sv(PROTOCOL.SCADA_MGMT, SCADA_MGMT_TYPE.CLOSE, {})
+    end
+
+    -- attempt to connect to the subervisor
+    ---@nodiscard
+    ---@param timeout_s number timeout in seconds
+    ---@param tick_dmesg_waiting function callback to tick dmesg waiting
+    ---@param task_done function callback to show done on dmesg
+    ---@return boolean sv_linked true if connected, false otherwise
+    --- EVENT_CONSUMER: this function consumes events
+    function public.sv_connect(timeout_s, tick_dmesg_waiting, task_done)
+        local clock = util.new_clock(1)
+        local start = util.time_s()
+        local terminated = false
+
+        _send_establish()
+
+        clock.start()
+
+        while (util.time_s() - start) < timeout_s and (not self.sv_linked) and (not self.sv_config_err) do
+            local event, p1, p2, p3, p4, p5 = util.pull_event()
+
+            if event == "timer" and clock.is_clock(p1) then
+                -- timed out attempt, try again
+                tick_dmesg_waiting(math.max(0, timeout_s - (util.time_s() - start)))
+                _send_establish()
+                clock.start()
+            elseif event == "modem_message" then
+                -- handle message
+                local packet = public.parse_packet(p1, p2, p3, p4, p5)
+                if packet ~= nil and packet.type == SCADA_MGMT_TYPE.ESTABLISH then
+                    public.handle_packet(packet)
+                end
+            elseif event == "terminate" then
+                terminated = true
+                break
+            end
+        end
+
+        task_done(self.sv_linked)
+
+        if terminated then
+            coordinator.log_comms("supervisor connection attempt cancelled by user")
+        elseif self.sv_config_err then
+            coordinator.log_comms("supervisor cooling configuration invalid, check supervisor config file")
+        elseif not self.sv_linked then
+            if self.last_est_ack == ESTABLISH_ACK.DENY then
+                coordinator.log_comms("supervisor connection attempt denied")
+            elseif self.last_est_ack == ESTABLISH_ACK.COLLISION then
+                coordinator.log_comms("supervisor connection failed due to collision")
+            elseif self.last_est_ack == ESTABLISH_ACK.BAD_VERSION then
+                coordinator.log_comms("supervisor connection failed due to version mismatch")
+            else
+                coordinator.log_comms("supervisor connection failed with no valid response")
+            end
+        end
+
+        return self.sv_linked
+    end
+
+    -- send a facility command
+    ---@param cmd FAC_COMMAND command
+    function public.send_fac_command(cmd)
+        _send_sv(PROTOCOL.SCADA_CRDN, SCADA_CRDN_TYPE.FAC_CMD, { cmd })
+    end
+
+    -- send the auto process control configuration with a start command
+    ---@param config coord_auto_config configuration
+    function public.send_auto_start(config)
+        _send_sv(PROTOCOL.SCADA_CRDN, SCADA_CRDN_TYPE.FAC_CMD, {
+            FAC_COMMAND.START, config.mode, config.burn_target, config.charge_target, config.gen_target, config.limits
+        })
+    end
+
+    -- send a unit command
+    ---@param cmd UNIT_COMMAND command
+    ---@param unit integer unit ID
+    ---@param option any? optional option options for the optional options (like burn rate) (does option still look like a word?)
+    function public.send_unit_command(cmd, unit, option)
+        _send_sv(PROTOCOL.SCADA_CRDN, SCADA_CRDN_TYPE.UNIT_CMD, { cmd, unit, option })
+    end
+
+    -- parse a packet
+    ---@param side string
+    ---@param sender integer
+    ---@param reply_to integer
+    ---@param message any
+    ---@param distance integer
+    ---@return mgmt_frame|crdn_frame|capi_frame|nil packet
+    function public.parse_packet(side, sender, reply_to, message, distance)
+        local pkt = nil
+        local s_pkt = comms.scada_packet()
+
+        -- parse packet as generic SCADA packet
+        s_pkt.receive(side, sender, reply_to, message, distance)
+
+        if s_pkt.is_valid() then
+            -- get as SCADA management packet
+            if s_pkt.protocol() == PROTOCOL.SCADA_MGMT then
+                local mgmt_pkt = comms.mgmt_packet()
+                if mgmt_pkt.decode(s_pkt) then
+                    pkt = mgmt_pkt.get()
+                end
+            -- get as coordinator packet
+            elseif s_pkt.protocol() == PROTOCOL.SCADA_CRDN then
+                local crdn_pkt = comms.crdn_packet()
+                if crdn_pkt.decode(s_pkt) then
+                    pkt = crdn_pkt.get()
+                end
+            -- get as coordinator API packet
+            elseif s_pkt.protocol() == PROTOCOL.COORD_API then
+                local capi_pkt = comms.capi_packet()
+                if capi_pkt.decode(s_pkt) then
+                    pkt = capi_pkt.get()
+                end
+            else
+                log.debug("attempted parse of illegal packet type " .. s_pkt.protocol(), true)
+            end
+        end
+
+        return pkt
+    end
+
+    -- handle a packet
+    ---@param packet mgmt_frame|crdn_frame|capi_frame|nil
+    function public.handle_packet(packet)
+        if packet ~= nil then
+            local protocol = packet.scada_frame.protocol()
+            local l_port = packet.scada_frame.local_port()
+
+            if l_port == api_listen then
+                if protocol == PROTOCOL.COORD_API then
+                    ---@cast packet capi_frame
+                    apisessions.handle_packet(packet)
+                else
+                    log.debug("illegal packet type " .. protocol .. " on api listening channel", true)
+                end
+            elseif l_port == sv_listen then
+                -- check sequence number
+                if self.sv_r_seq_num == nil then
+                    self.sv_r_seq_num = packet.scada_frame.seq_num()
+                elseif self.connected and self.sv_r_seq_num >= packet.scada_frame.seq_num() then
+                    log.warning("sequence out-of-order: last = " .. self.sv_r_seq_num .. ", new = " .. packet.scada_frame.seq_num())
+                    return
+                else
+                    self.sv_r_seq_num = packet.scada_frame.seq_num()
+                end
+
+                -- feed watchdog on valid sequence number
+                sv_watchdog.feed()
+
+                -- handle packet
+                if protocol == PROTOCOL.SCADA_CRDN then
+                    ---@cast packet crdn_frame
+                    if self.sv_linked then
+                        if packet.type == SCADA_CRDN_TYPE.INITIAL_BUILDS then
+                            if packet.length == 2 then
+                                -- record builds
+                                local fac_builds = iocontrol.record_facility_builds(packet.data[1])
+                                local unit_builds = iocontrol.record_unit_builds(packet.data[2])
+
+                                if fac_builds and unit_builds then
+                                    -- acknowledge receipt of builds
+                                    _send_sv(PROTOCOL.SCADA_CRDN, SCADA_CRDN_TYPE.INITIAL_BUILDS, {})
+                                else
+                                    log.debug("received invalid INITIAL_BUILDS packet")
+                                end
+                            else
+                                log.debug("INITIAL_BUILDS packet length mismatch")
+                            end
+                        elseif packet.type == SCADA_CRDN_TYPE.FAC_BUILDS then
+                            if packet.length == 1 then
+                                -- record facility builds
+                                if iocontrol.record_facility_builds(packet.data[1]) then
+                                    -- acknowledge receipt of builds
+                                    _send_sv(PROTOCOL.SCADA_CRDN, SCADA_CRDN_TYPE.FAC_BUILDS, {})
+                                else
+                                    log.debug("received invalid FAC_BUILDS packet")
+                                end
+                            else
+                                log.debug("FAC_BUILDS packet length mismatch")
+                            end
+                        elseif packet.type == SCADA_CRDN_TYPE.FAC_STATUS then
+                            -- update facility status
+                            if not iocontrol.update_facility_status(packet.data) then
+                                log.debug("received invalid FAC_STATUS packet")
+                            end
+                        elseif packet.type == SCADA_CRDN_TYPE.FAC_CMD then
+                            -- facility command acknowledgement
+                            if packet.length >= 2 then
+                                local cmd = packet.data[1]
+                                local ack = packet.data[2] == true
+
+                                if cmd == FAC_COMMAND.SCRAM_ALL then
+                                    iocontrol.get_db().facility.scram_ack(ack)
+                                elseif cmd == FAC_COMMAND.STOP then
+                                    iocontrol.get_db().facility.stop_ack(ack)
+                                elseif cmd == FAC_COMMAND.START then
+                                    if packet.length == 7 then
+                                        process.start_ack_handle({ table.unpack(packet.data, 2) })
+                                    else
+                                        log.debug("SCADA_CRDN process start (with configuration) ack echo packet length mismatch")
+                                    end
+                                elseif cmd == FAC_COMMAND.ACK_ALL_ALARMS then
+                                    iocontrol.get_db().facility.ack_alarms_ack(ack)
+                                else
+                                    log.debug(util.c("received facility command ack with unknown command ", cmd))
+                                end
+                            else
+                                log.debug("SCADA_CRDN facility command ack packet length mismatch")
+                            end
+                        elseif packet.type == SCADA_CRDN_TYPE.UNIT_BUILDS then
+                            -- record builds
+                            if packet.length == 1 then
+                                if iocontrol.record_unit_builds(packet.data[1]) then
+                                    -- acknowledge receipt of builds
+                                    _send_sv(PROTOCOL.SCADA_CRDN, SCADA_CRDN_TYPE.UNIT_BUILDS, {})
+                                else
+                                    log.debug("received invalid UNIT_BUILDS packet")
+                                end
+                            else
+                                log.debug("UNIT_BUILDS packet length mismatch")
+                            end
+                        elseif packet.type == SCADA_CRDN_TYPE.UNIT_STATUSES then
+                            -- update statuses
+                            if not iocontrol.update_unit_statuses(packet.data) then
+                                log.error("received invalid UNIT_STATUSES packet")
+                            end
+                        elseif packet.type == SCADA_CRDN_TYPE.UNIT_CMD then
+                            -- unit command acknowledgement
+                            if packet.length == 3 then
+                                local cmd = packet.data[1]
+                                local unit_id = packet.data[2]
+                                local ack = packet.data[3] == true
+
+                                local unit = iocontrol.get_db().units[unit_id]  ---@type ioctl_unit
+
+                                if unit ~= nil then
+                                    if cmd == UNIT_COMMAND.SCRAM then
+                                        unit.scram_ack(ack)
+                                    elseif cmd == UNIT_COMMAND.START then
+                                        unit.start_ack(ack)
+                                    elseif cmd == UNIT_COMMAND.RESET_RPS then
+                                        unit.reset_rps_ack(ack)
+                                    elseif cmd == UNIT_COMMAND.SET_BURN then
+                                        unit.set_burn_ack(ack)
+                                    elseif cmd == UNIT_COMMAND.SET_WASTE then
+                                        unit.set_waste_ack(ack)
+                                    elseif cmd == UNIT_COMMAND.ACK_ALL_ALARMS then
+                                        unit.ack_alarms_ack(ack)
+                                    elseif cmd == UNIT_COMMAND.SET_GROUP then
+                                        -- UI will be updated to display current group if changed successfully
+                                    else
+                                        log.debug(util.c("received unit command ack with unknown command ", cmd))
+                                    end
+                                else
+                                    log.debug(util.c("received unit command ack with unknown unit ", unit_id))
+                                end
+                            else
+                                log.debug("SCADA_CRDN unit command ack packet length mismatch")
+                            end
+                        else
+                            log.warning("received unknown SCADA_CRDN packet type " .. packet.type)
+                        end
+                    else
+                        log.debug("discarding SCADA_CRDN packet before linked")
+                    end
+                elseif protocol == PROTOCOL.SCADA_MGMT then
+                    ---@cast packet mgmt_frame
+                    if packet.type == SCADA_MGMT_TYPE.ESTABLISH then
+                        -- connection with supervisor established
+                        if packet.length == 2 then
+                            local est_ack = packet.data[1]
+                            local config = packet.data[2]
+
+                            if est_ack == ESTABLISH_ACK.ALLOW then
+                                if type(config) == "table" and #config > 1 then
+                                    -- get configuration
+
+                                    ---@class facility_conf
+                                    local conf = {
+                                        num_units = config[1],  ---@type integer
+                                        defs = {}               -- boilers and turbines
+                                    }
+
+                                    if (#config - 1) == (conf.num_units * 2) then
+                                        -- record sequence of pairs of [#boilers, #turbines] per unit
+                                        for i = 2, #config do
+                                            table.insert(conf.defs, config[i])
+                                        end
+
+                                        -- init io controller
+                                        iocontrol.init(conf, public)
+
+                                        self.sv_linked = true
+                                        self.sv_config_err = false
+                                    else
+                                        self.sv_config_err = true
+                                        log.warning("invalid supervisor configuration definitions received, establish failed")
+                                    end
+                                else
+                                    log.debug("invalid supervisor configuration table received, establish failed")
+                                end
+                            else
+                                log.debug("SCADA_MGMT establish packet reply (len = 2) unsupported")
+                            end
+
+                            self.last_est_ack = est_ack
+                        elseif packet.length == 1 then
+                            local est_ack = packet.data[1]
+
+                            if est_ack == ESTABLISH_ACK.DENY then
+                                if self.last_est_ack ~= est_ack then
+                                    log.info("supervisor connection denied")
+                                end
+                            elseif est_ack == ESTABLISH_ACK.COLLISION then
+                                if self.last_est_ack ~= est_ack then
+                                    log.info("supervisor connection denied due to collision")
+                                end
+                            elseif est_ack == ESTABLISH_ACK.BAD_VERSION then
+                                if self.last_est_ack ~= est_ack then
+                                    log.info("supervisor comms version mismatch")
+                                end
+                            else
+                                log.debug("SCADA_MGMT establish packet reply (len = 1) unsupported")
+                            end
+
+                            self.last_est_ack = est_ack
+                        else
+                            log.debug("SCADA_MGMT establish packet length mismatch")
+                        end
+                    elseif self.sv_linked then
+                        if packet.type == SCADA_MGMT_TYPE.KEEP_ALIVE then
+                            -- keep alive request received, echo back
+                            if packet.length == 1 then
+                                local timestamp = packet.data[1]
+                                local trip_time = util.time() - timestamp
+
+                                if trip_time > 750 then
+                                    log.warning("coord KEEP_ALIVE trip time > 750ms (" .. trip_time .. "ms)")
+                                end
+
+                                -- log.debug("coord RTT = " .. trip_time .. "ms")
+
+                                iocontrol.get_db().facility.ps.publish("sv_ping", trip_time)
+
+                                _send_keep_alive_ack(timestamp)
+                            else
+                                log.debug("SCADA keep alive packet length mismatch")
+                            end
+                        elseif packet.type == SCADA_MGMT_TYPE.CLOSE then
+                            -- handle session close
+                            sv_watchdog.cancel()
+                            self.sv_linked = false
+                            println_ts("server connection closed by remote host")
+                            log.info("server connection closed by remote host")
+                        else
+                            log.debug("received unknown SCADA_MGMT packet type " .. packet.type)
+                        end
+                    else
+                        log.debug("discarding non-link SCADA_MGMT packet before linked")
+                    end
+                else
+                    log.debug("illegal packet type " .. protocol .. " on supervisor listening channel", true)
+                end
+            else
+                log.debug("received packet on unconfigured channel " .. l_port, true)
+            end
+        end
+    end
+
+    -- check if the coordinator is still linked to the supervisor
+    ---@nodiscard
+    function public.is_linked() return self.sv_linked end
+
+    return public
 end
 
 return coordinator

coordinator/iocontrol.lua

@@ -0,0 +1,772 @@
+--
+-- I/O Control for Supervisor/Coordinator Integration
+--
+
+local log     = require("scada-common.log")
+local psil    = require("scada-common.psil")
+local types   = require("scada-common.types")
+local util    = require("scada-common.util")
+
+local process = require("coordinator.process")
+local sounder = require("coordinator.sounder")
+
+local ALARM_STATE = types.ALARM_STATE
+local PROCESS = types.PROCESS
+
+local iocontrol = {}
+
+---@class ioctl
+local io = {}
+
+-- initialize the coordinator IO controller
+---@param conf facility_conf configuration
+---@param comms coord_comms comms reference
+function iocontrol.init(conf, comms)
+    ---@class ioctl_facility
+    io.facility = {
+        num_units = conf.num_units, ---@type integer
+        all_sys_ok = false,
+        rtu_count = 0,
+
+        auto_ready = false,
+        auto_active = false,
+        auto_ramping = false,
+        auto_saturated = false,
+
+        auto_scram = false,
+        ---@type ascram_status
+        ascram_status = {
+            matrix_dc = false,
+            matrix_fill = false,
+            crit_alarm = false,
+            radiation = false,
+            gen_fault = false
+        },
+
+        radiation = types.new_zero_radiation_reading(),
+
+        save_cfg_ack = function (success) end,      ---@param success boolean
+        start_ack = function (success) end,         ---@param success boolean
+        stop_ack = function (success) end,          ---@param success boolean
+        scram_ack = function (success) end,         ---@param success boolean
+        ack_alarms_ack = function (success) end,    ---@param success boolean
+
+        ps = psil.create(),
+
+        induction_ps_tbl = {},
+        induction_data_tbl = {},
+
+        env_d_ps = psil.create(),
+        env_d_data = {}
+    }
+
+    -- create induction tables (currently only 1 is supported)
+    for _ = 1, conf.num_units do
+        local data = {} ---@type imatrix_session_db
+        table.insert(io.facility.induction_ps_tbl, psil.create())
+        table.insert(io.facility.induction_data_tbl, data)
+    end
+
+    io.units = {}
+    for i = 1, conf.num_units do
+        local function ack(alarm) process.ack_alarm(i, alarm) end
+        local function reset(alarm) process.reset_alarm(i, alarm) end
+
+        ---@class ioctl_unit
+        local entry = {
+            ---@type integer
+            unit_id = i,
+
+            num_boilers = 0,
+            num_turbines = 0,
+
+            control_state = false,
+            burn_rate_cmd = 0.0,
+            waste_control = 0,
+            radiation = types.new_zero_radiation_reading(),
+
+            a_group = 0,                                                -- auto control group
+
+            start = function () process.start(i) end,
+            scram = function () process.scram(i) end,
+            reset_rps = function () process.reset_rps(i) end,
+            ack_alarms = function () process.ack_all_alarms(i) end,
+            set_burn = function (rate) process.set_rate(i, rate) end,   ---@param rate number burn rate
+            set_waste = function (mode) process.set_waste(i, mode) end, ---@param mode integer waste processing mode
+
+            set_group = function (grp) process.set_group(i, grp) end,   ---@param grp integer|0 group ID or 0
+
+            start_ack = function (success) end,                         ---@param success boolean
+            scram_ack = function (success) end,                         ---@param success boolean
+            reset_rps_ack = function (success) end,                     ---@param success boolean
+            ack_alarms_ack = function (success) end,                    ---@param success boolean
+            set_burn_ack = function (success) end,                      ---@param success boolean
+            set_waste_ack = function (success) end,                     ---@param success boolean
+
+            alarm_callbacks = {
+                c_breach   = { ack = function () ack(1)  end, reset = function () reset(1)  end },
+                radiation  = { ack = function () ack(2)  end, reset = function () reset(2)  end },
+                r_lost     = { ack = function () ack(3)  end, reset = function () reset(3)  end },
+                dmg_crit   = { ack = function () ack(4)  end, reset = function () reset(4)  end },
+                damage     = { ack = function () ack(5)  end, reset = function () reset(5)  end },
+                over_temp  = { ack = function () ack(6)  end, reset = function () reset(6)  end },
+                high_temp  = { ack = function () ack(7)  end, reset = function () reset(7)  end },
+                waste_leak = { ack = function () ack(8)  end, reset = function () reset(8)  end },
+                waste_high = { ack = function () ack(9)  end, reset = function () reset(9)  end },
+                rps_trans  = { ack = function () ack(10) end, reset = function () reset(10) end },
+                rcs_trans  = { ack = function () ack(11) end, reset = function () reset(11) end },
+                t_trip     = { ack = function () ack(12) end, reset = function () reset(12) end }
+            },
+
+            ---@type alarms
+            alarms = {
+                ALARM_STATE.INACTIVE,   -- containment breach
+                ALARM_STATE.INACTIVE,   -- containment radiation
+                ALARM_STATE.INACTIVE,   -- reactor lost
+                ALARM_STATE.INACTIVE,   -- damage critical
+                ALARM_STATE.INACTIVE,   -- reactor taking damage
+                ALARM_STATE.INACTIVE,   -- reactor over temperature
+                ALARM_STATE.INACTIVE,   -- reactor high temperature
+                ALARM_STATE.INACTIVE,   -- waste leak
+                ALARM_STATE.INACTIVE,   -- waste level high
+                ALARM_STATE.INACTIVE,   -- RPS transient
+                ALARM_STATE.INACTIVE,   -- RCS transient
+                ALARM_STATE.INACTIVE    -- turbine trip
+            },
+
+            annunciator = {},           ---@type annunciator
+
+            unit_ps = psil.create(),
+            reactor_data = {},          ---@type reactor_db
+
+            boiler_ps_tbl = {},
+            boiler_data_tbl = {},
+
+            turbine_ps_tbl = {},
+            turbine_data_tbl = {}
+        }
+
+        -- create boiler tables
+        for _ = 1, conf.defs[(i * 2) - 1] do
+            local data = {} ---@type boilerv_session_db
+            table.insert(entry.boiler_ps_tbl, psil.create())
+            table.insert(entry.boiler_data_tbl, data)
+        end
+
+        -- create turbine tables
+        for _ = 1, conf.defs[i * 2] do
+            local data = {} ---@type turbinev_session_db
+            table.insert(entry.turbine_ps_tbl, psil.create())
+            table.insert(entry.turbine_data_tbl, data)
+        end
+
+        entry.num_boilers = #entry.boiler_data_tbl
+        entry.num_turbines = #entry.turbine_data_tbl
+
+        table.insert(io.units, entry)
+    end
+
+    -- pass IO control here since it can't be require'd due to a require loop
+    process.init(io, comms)
+end
+
+-- populate facility structure builds
+---@param build table
+---@return boolean valid
+function iocontrol.record_facility_builds(build)
+    local valid = true
+
+    if type(build) == "table" then
+        local fac = io.facility
+
+        -- induction matricies
+        if type(build.induction) == "table" then
+            for id, matrix in pairs(build.induction) do
+                if type(fac.induction_data_tbl[id]) == "table" then
+                    fac.induction_data_tbl[id].formed = matrix[1]  ---@type boolean
+                    fac.induction_data_tbl[id].build  = matrix[2]  ---@type table
+
+                    fac.induction_ps_tbl[id].publish("formed", matrix[1])
+
+                    for key, val in pairs(fac.induction_data_tbl[id].build) do
+                        fac.induction_ps_tbl[id].publish(key, val)
+                    end
+                else
+                    log.debug(util.c("iocontrol.record_facility_builds: invalid induction matrix id ", id))
+                    valid = false
+                end
+            end
+        end
+    else
+        log.debug("facility builds not a table")
+        valid = false
+    end
+
+    return valid
+end
+
+-- populate unit structure builds
+---@param builds table
+---@return boolean valid
+function iocontrol.record_unit_builds(builds)
+    local valid = true
+
+    -- note: if not all units and RTUs are connected, some will be nil
+    for id, build in pairs(builds) do
+        local unit = io.units[id]    ---@type ioctl_unit
+
+        local log_header = util.c("iocontrol.record_unit_builds[UNIT ", id, "]: ")
+
+        if type(build) ~= "table" then
+            log.debug(log_header .. "build not a table")
+            valid = false
+        elseif type(unit) ~= "table" then
+            log.debug(log_header .. "invalid unit id")
+            valid = false
+        else
+            -- reactor build
+            if type(build.reactor) == "table" then
+                unit.reactor_data.mek_struct = build.reactor    ---@type mek_struct
+                for key, val in pairs(unit.reactor_data.mek_struct) do
+                    unit.unit_ps.publish(key, val)
+                end
+
+                if (type(unit.reactor_data.mek_struct.length) == "number") and (unit.reactor_data.mek_struct.length ~= 0) and
+                    (type(unit.reactor_data.mek_struct.width) == "number") and (unit.reactor_data.mek_struct.width ~= 0) then
+                    unit.unit_ps.publish("size", { unit.reactor_data.mek_struct.length, unit.reactor_data.mek_struct.width })
+                end
+            end
+
+            -- boiler builds
+            if type(build.boilers) == "table" then
+                for b_id, boiler in pairs(build.boilers) do
+                    if type(unit.boiler_data_tbl[b_id]) == "table" then
+                        unit.boiler_data_tbl[b_id].formed = boiler[1] ---@type boolean
+                        unit.boiler_data_tbl[b_id].build  = boiler[2] ---@type table
+
+                        unit.boiler_ps_tbl[b_id].publish("formed", boiler[1])
+
+                        for key, val in pairs(unit.boiler_data_tbl[b_id].build) do
+                            unit.boiler_ps_tbl[b_id].publish(key, val)
+                        end
+                    else
+                        log.debug(util.c(log_header, "invalid boiler id ", b_id))
+                        valid = false
+                    end
+                end
+            end
+
+            -- turbine builds
+            if type(build.turbines) == "table" then
+                for t_id, turbine in pairs(build.turbines) do
+                    if type(unit.turbine_data_tbl[t_id]) == "table" then
+                        unit.turbine_data_tbl[t_id].formed = turbine[1]   ---@type boolean
+                        unit.turbine_data_tbl[t_id].build  = turbine[2]   ---@type table
+
+                        unit.turbine_ps_tbl[t_id].publish("formed", turbine[1])
+
+                        for key, val in pairs(unit.turbine_data_tbl[t_id].build) do
+                            unit.turbine_ps_tbl[t_id].publish(key, val)
+                        end
+                    else
+                        log.debug(util.c(log_header, "invalid turbine id ", t_id))
+                        valid = false
+                    end
+                end
+            end
+        end
+    end
+
+    return valid
+end
+
+-- update facility status
+---@param status table
+---@return boolean valid
+function iocontrol.update_facility_status(status)
+    local valid = true
+    local log_header = util.c("iocontrol.update_facility_status: ")
+
+    if type(status) ~= "table" then
+        log.debug(util.c(log_header, "status not a table"))
+        valid = false
+    else
+        local fac = io.facility
+
+        -- auto control status information
+
+        local ctl_status = status[1]
+
+        if type(ctl_status) == "table" and #ctl_status == 14 then
+            fac.all_sys_ok = ctl_status[1]
+            fac.auto_ready = ctl_status[2]
+
+            if type(ctl_status[3]) == "number" then
+                fac.auto_active = ctl_status[3] > PROCESS.INACTIVE
+            else
+                fac.auto_active = false
+                valid = false
+            end
+
+            fac.auto_ramping = ctl_status[4]
+            fac.auto_saturated = ctl_status[5]
+
+            fac.auto_scram = ctl_status[6]
+            fac.ascram_status.matrix_dc = ctl_status[7]
+            fac.ascram_status.matrix_fill = ctl_status[8]
+            fac.ascram_status.crit_alarm = ctl_status[9]
+            fac.ascram_status.radiation = ctl_status[10]
+            fac.ascram_status.gen_fault = ctl_status[11]
+
+            fac.status_line_1 = ctl_status[12]
+            fac.status_line_2 = ctl_status[13]
+
+            fac.ps.publish("all_sys_ok", fac.all_sys_ok)
+            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_dc", fac.ascram_status.matrix_dc)
+            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("status_line_1", fac.status_line_1)
+            fac.ps.publish("status_line_2", fac.status_line_2)
+
+            local group_map = ctl_status[14]
+
+            if (type(group_map) == "table") and (#group_map == fac.num_units) then
+                local names = { "Manual", "Primary", "Secondary", "Tertiary", "Backup" }
+                for i = 1, #group_map do
+                    io.units[i].a_group = group_map[i]
+                    io.units[i].unit_ps.publish("auto_group_id", group_map[i])
+                    io.units[i].unit_ps.publish("auto_group", names[group_map[i] + 1])
+                end
+            end
+        else
+            log.debug(log_header .. "control status not a table or length mismatch")
+            valid = false
+        end
+
+        -- RTU statuses
+
+        local rtu_statuses = status[2]
+
+        fac.rtu_count = 0
+
+        if type(rtu_statuses) == "table" then
+            -- connected RTU count
+            fac.rtu_count = rtu_statuses.count
+
+            -- power statistics
+            if type(rtu_statuses.power) == "table" then
+                fac.induction_ps_tbl[1].publish("avg_charge", rtu_statuses.power[1])
+                fac.induction_ps_tbl[1].publish("avg_inflow", rtu_statuses.power[2])
+                fac.induction_ps_tbl[1].publish("avg_outflow", rtu_statuses.power[3])
+            else
+                log.debug(log_header .. "power statistics list not a table")
+                valid = false
+            end
+
+            -- induction matricies statuses
+            if type(rtu_statuses.induction) == "table" then
+                for id = 1, #fac.induction_ps_tbl do
+                    if rtu_statuses.induction[id] == nil then
+                        -- disconnected
+                        fac.induction_ps_tbl[id].publish("computed_status", 1)
+                    end
+                end
+
+                for id, matrix in pairs(rtu_statuses.induction) do
+                    if type(fac.induction_data_tbl[id]) == "table" then
+                        local rtu_faulted                 = matrix[1]   ---@type boolean
+                        fac.induction_data_tbl[id].formed = matrix[2]   ---@type boolean
+                        fac.induction_data_tbl[id].state  = matrix[3]   ---@type table
+                        fac.induction_data_tbl[id].tanks  = matrix[4]   ---@type table
+
+                        local data = fac.induction_data_tbl[id]         ---@type imatrix_session_db
+
+                        fac.induction_ps_tbl[id].publish("formed", data.formed)
+                        fac.induction_ps_tbl[id].publish("faulted", rtu_faulted)
+
+                        if data.formed then
+                            if rtu_faulted then
+                                fac.induction_ps_tbl[id].publish("computed_status", 3)  -- faulted
+                            elseif data.tanks.energy_fill >= 0.99 then
+                                fac.induction_ps_tbl[id].publish("computed_status", 6)  -- full
+                            elseif data.tanks.energy_fill <= 0.01 then
+                                fac.induction_ps_tbl[id].publish("computed_status", 5)  -- empty
+                            else
+                                fac.induction_ps_tbl[id].publish("computed_status", 4)  -- on-line
+                            end
+                        else
+                            fac.induction_ps_tbl[id].publish("computed_status", 2)      -- not formed
+                        end
+
+                        for key, val in pairs(fac.induction_data_tbl[id].state) do
+                            fac.induction_ps_tbl[id].publish(key, val)
+                        end
+
+                        for key, val in pairs(fac.induction_data_tbl[id].tanks) do
+                            fac.induction_ps_tbl[id].publish(key, val)
+                        end
+                    else
+                        log.debug(util.c(log_header, "invalid induction matrix id ", id))
+                    end
+                end
+            else
+                log.debug(log_header .. "induction matrix list not a table")
+                valid = false
+            end
+
+            -- environment detector status
+            if type(rtu_statuses.rad_mon) == "table" then
+                if #rtu_statuses.rad_mon > 0 then
+                    local rad_mon = rtu_statuses.rad_mon[1]
+                    local rtu_faulted = rad_mon[1]  ---@type boolean
+                    fac.radiation     = rad_mon[2]  ---@type number
+
+                    fac.ps.publish("rad_computed_status", util.trinary(rtu_faulted, 2, 3))
+                    fac.ps.publish("radiation", fac.radiation)
+                else
+                    fac.radiation = types.new_zero_radiation_reading()
+                    fac.ps.publish("rad_computed_status", 1)
+                end
+            else
+                log.debug(log_header .. "radiation monitor list not a table")
+                valid = false
+            end
+        else
+            log.debug(log_header .. "rtu statuses not a table")
+            valid = false
+        end
+
+        fac.ps.publish("rtu_count", fac.rtu_count)
+    end
+
+    return valid
+end
+
+-- update unit statuses
+---@param statuses table
+---@return boolean valid
+function iocontrol.update_unit_statuses(statuses)
+    local valid = true
+
+    if type(statuses) ~= "table" then
+        log.debug("iocontrol.update_unit_statuses: unit statuses not a table")
+        valid = false
+    elseif #statuses ~= #io.units then
+        log.debug("iocontrol.update_unit_statuses: number of provided unit statuses does not match expected number of units")
+        valid = false
+    else
+        local burn_rate_sum = 0.0
+
+        -- get all unit statuses
+        for i = 1, #statuses do
+            local log_header = util.c("iocontrol.update_unit_statuses[unit ", i, "]: ")
+
+            local unit = io.units[i]    ---@type ioctl_unit
+            local status = statuses[i]
+
+            if type(status) ~= "table" or #status ~= 5 then
+                log.debug(log_header .. "invalid status entry in unit statuses (not a table or invalid length)")
+                valid = false
+            else
+                -- reactor PLC status
+                local reactor_status = status[1]
+
+                if type(reactor_status) ~= "table" then
+                    reactor_status = {}
+                    log.debug(log_header .. "reactor status not a table")
+                end
+
+                if #reactor_status == 0 then
+                    unit.unit_ps.publish("computed_status", 1)   -- disconnected
+                elseif #reactor_status == 3 then
+                    local mek_status = reactor_status[1]
+                    local rps_status = reactor_status[2]
+                    local gen_status = reactor_status[3]
+
+                    if #gen_status == 6 then
+                        unit.reactor_data.last_status_update = gen_status[1]
+                        unit.reactor_data.control_state      = gen_status[2]
+                        unit.reactor_data.rps_tripped        = gen_status[3]
+                        unit.reactor_data.rps_trip_cause     = gen_status[4]
+                        unit.reactor_data.no_reactor         = gen_status[5]
+                        unit.reactor_data.formed             = gen_status[6]
+                    else
+                        log.debug(log_header .. "reactor general status length mismatch")
+                    end
+
+                    unit.reactor_data.rps_status = rps_status   ---@type rps_status
+                    unit.reactor_data.mek_status = mek_status   ---@type mek_status
+
+                    -- if status hasn't been received, mek_status = {}
+                    if type(unit.reactor_data.mek_status.act_burn_rate) == "number" then
+                        burn_rate_sum = burn_rate_sum + unit.reactor_data.mek_status.act_burn_rate
+                    end
+
+                    if unit.reactor_data.mek_status.status then
+                        unit.unit_ps.publish("computed_status", 5)       -- running
+                    else
+                        if unit.reactor_data.no_reactor then
+                            unit.unit_ps.publish("computed_status", 3)   -- faulted
+                        elseif not unit.reactor_data.formed then
+                            unit.unit_ps.publish("computed_status", 2)   -- multiblock not formed
+                        elseif unit.reactor_data.rps_status.force_dis then
+                            unit.unit_ps.publish("computed_status", 7)   -- reactor force disabled
+                        elseif unit.reactor_data.rps_tripped and unit.reactor_data.rps_trip_cause ~= "manual" then
+                            unit.unit_ps.publish("computed_status", 6)   -- SCRAM
+                        else
+                            unit.unit_ps.publish("computed_status", 4)   -- disabled
+                        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
+
+                    if type(unit.reactor_data.rps_status) == "table" then
+                        for key, val in pairs(unit.reactor_data.rps_status) do
+                            unit.unit_ps.publish(key, val)
+                        end
+                    end
+
+                    if type(unit.reactor_data.mek_status) == "table" then
+                        for key, val in pairs(unit.reactor_data.mek_status) do
+                            unit.unit_ps.publish(key, val)
+                        end
+                    end
+                else
+                    log.debug(log_header .. "reactor status length mismatch")
+                    valid = false
+                end
+
+                -- RTU statuses
+                local rtu_statuses = status[2]
+
+                if type(rtu_statuses) == "table" then
+                    -- boiler statuses
+                    if type(rtu_statuses.boilers) == "table" then
+                        for id = 1, #unit.boiler_ps_tbl do
+                            if rtu_statuses.boilers[i] == nil then
+                                -- disconnected
+                                unit.boiler_ps_tbl[id].publish("computed_status", 1)
+                            end
+                        end
+
+                        for id, boiler in pairs(rtu_statuses.boilers) do
+                            if type(unit.boiler_data_tbl[id]) == "table" then
+                                local rtu_faulted               = boiler[1] ---@type boolean
+                                unit.boiler_data_tbl[id].formed = boiler[2] ---@type boolean
+                                unit.boiler_data_tbl[id].state  = boiler[3] ---@type table
+                                unit.boiler_data_tbl[id].tanks  = boiler[4] ---@type table
+
+                                local data = unit.boiler_data_tbl[id]  ---@type boilerv_session_db
+
+                                unit.boiler_ps_tbl[id].publish("formed", data.formed)
+                                unit.boiler_ps_tbl[id].publish("faulted", rtu_faulted)
+
+                                if rtu_faulted then
+                                    unit.boiler_ps_tbl[id].publish("computed_status", 3)        -- faulted
+                                elseif data.formed then
+                                    if data.state.boil_rate > 0 then
+                                        unit.boiler_ps_tbl[id].publish("computed_status", 5)    -- active
+                                    else
+                                        unit.boiler_ps_tbl[id].publish("computed_status", 4)    -- idle
+                                    end
+                                else
+                                    unit.boiler_ps_tbl[id].publish("computed_status", 2)        -- not formed
+                                end
+
+                                for key, val in pairs(unit.boiler_data_tbl[id].state) do
+                                    unit.boiler_ps_tbl[id].publish(key, val)
+                                end
+
+                                for key, val in pairs(unit.boiler_data_tbl[id].tanks) do
+                                    unit.boiler_ps_tbl[id].publish(key, val)
+                                end
+                            else
+                                log.debug(util.c(log_header, "invalid boiler id ", id))
+                                valid = false
+                            end
+                        end
+                    else
+                        log.debug(log_header .. "boiler list not a table")
+                        valid = false
+                    end
+
+                    -- turbine statuses
+                    if type(rtu_statuses.turbines) == "table" then
+                        for id = 1, #unit.turbine_ps_tbl do
+                            if rtu_statuses.turbines[i] == nil then
+                                -- disconnected
+                                unit.turbine_ps_tbl[id].publish("computed_status", 1)
+                            end
+                        end
+
+                        for id, turbine in pairs(rtu_statuses.turbines) do
+                            if type(unit.turbine_data_tbl[id]) == "table" then
+                                local rtu_faulted                = turbine[1]   ---@type boolean
+                                unit.turbine_data_tbl[id].formed = turbine[2]   ---@type boolean
+                                unit.turbine_data_tbl[id].state  = turbine[3]   ---@type table
+                                unit.turbine_data_tbl[id].tanks  = turbine[4]   ---@type table
+
+                                local data = unit.turbine_data_tbl[id]  ---@type turbinev_session_db
+
+                                unit.turbine_ps_tbl[id].publish("formed", data.formed)
+                                unit.turbine_ps_tbl[id].publish("faulted", rtu_faulted)
+
+                                if rtu_faulted then
+                                    unit.turbine_ps_tbl[id].publish("computed_status", 3)       -- faulted
+                                elseif data.formed then
+                                    if data.tanks.energy_fill >= 0.99 then
+                                        unit.turbine_ps_tbl[id].publish("computed_status", 6)   -- trip
+                                    elseif data.state.flow_rate < 100 then
+                                        unit.turbine_ps_tbl[id].publish("computed_status", 4)   -- idle
+                                    else
+                                        unit.turbine_ps_tbl[id].publish("computed_status", 5)   -- active
+                                    end
+                                else
+                                    unit.turbine_ps_tbl[id].publish("computed_status", 2)       -- not formed
+                                end
+
+                                for key, val in pairs(unit.turbine_data_tbl[id].state) do
+                                    unit.turbine_ps_tbl[id].publish(key, val)
+                                end
+
+                                for key, val in pairs(unit.turbine_data_tbl[id].tanks) do
+                                    unit.turbine_ps_tbl[id].publish(key, val)
+                                end
+                            else
+                                log.debug(util.c(log_header, "invalid turbine id ", id))
+                                valid = false
+                            end
+                        end
+                    else
+                        log.debug(log_header .. "turbine list not a table")
+                        valid = false
+                    end
+
+                    -- environment detector status
+                    if type(rtu_statuses.rad_mon) == "table" then
+                        if #rtu_statuses.rad_mon > 0 then
+                            local rad_mon = rtu_statuses.rad_mon[1]
+                            local rtu_faulted = rad_mon[1]  ---@type boolean
+                            unit.radiation    = rad_mon[2]  ---@type number
+
+                            unit.unit_ps.publish("radiation", unit.radiation)
+                        else
+                            unit.radiation = types.new_zero_radiation_reading()
+                        end
+                    else
+                        log.debug(log_header .. "radiation monitor list not a table")
+                        valid = false
+                    end
+                else
+                    log.debug(log_header .. "rtu list not a table")
+                    valid = false
+                end
+
+                -- annunciator
+                unit.annunciator = status[3]
+
+                if type(unit.annunciator) ~= "table" then
+                    unit.annunciator = {}
+                    log.debug(log_header .. "annunciator state not a table")
+                    valid = false
+                end
+
+                for key, val in pairs(unit.annunciator) do
+                    if key == "TurbineTrip" then
+                        -- split up turbine trip table for all turbines and a general OR combination
+                        local trips = val
+                        local any = false
+
+                        for id = 1, #trips do
+                            any = any or trips[id]
+                            unit.turbine_ps_tbl[id].publish(key, trips[id])
+                        end
+
+                        unit.unit_ps.publish("TurbineTrip", any)
+                    elseif key == "BoilerOnline" or key == "HeatingRateLow" or key == "WaterLevelLow" then
+                        -- split up array for all boilers
+                        for id = 1, #val do
+                            unit.boiler_ps_tbl[id].publish(key, val[id])
+                        end
+                    elseif key == "TurbineOnline" or key == "SteamDumpOpen" or key == "TurbineOverSpeed" then
+                        -- split up array for all turbines
+                        for id = 1, #val do
+                            unit.turbine_ps_tbl[id].publish(key, val[id])
+                        end
+                    elseif type(val) == "table" then
+                        -- we missed one of the tables?
+                        log.debug(log_header .. "unrecognized table found in annunciator list, this is a bug")
+                        valid = false
+                    else
+                        -- non-table fields
+                        unit.unit_ps.publish(key, val)
+                    end
+                end
+
+                -- alarms
+                local alarm_states = status[4]
+
+                if type(alarm_states) == "table" then
+                    for id = 1, #alarm_states do
+                        local state = alarm_states[id]
+
+                        unit.alarms[id] = state
+
+                        if state == types.ALARM_STATE.TRIPPED or state == types.ALARM_STATE.ACKED then
+                            unit.unit_ps.publish("Alarm_" .. id, 2)
+                        elseif state == types.ALARM_STATE.RING_BACK then
+                            unit.unit_ps.publish("Alarm_" .. id, 3)
+                        else
+                            unit.unit_ps.publish("Alarm_" .. id, 1)
+                        end
+                    end
+                else
+                    log.debug(log_header .. "alarm states not a table")
+                    valid = false
+                end
+
+                -- unit state fields
+                local unit_state = status[5]
+
+                if type(unit_state) == "table" then
+                    if #unit_state == 5 then
+                        unit.unit_ps.publish("U_StatusLine1", unit_state[1])
+                        unit.unit_ps.publish("U_StatusLine2", unit_state[2])
+                        unit.unit_ps.publish("U_WasteMode", unit_state[3])
+                        unit.unit_ps.publish("U_AutoReady", unit_state[4])
+                        unit.unit_ps.publish("U_AutoDegraded", unit_state[5])
+                    else
+                        log.debug(log_header .. "unit state length mismatch")
+                        valid = false
+                    end
+                else
+                    log.debug(log_header .. "unit state not a table")
+                    valid = false
+                end
+            end
+        end
+
+        io.facility.ps.publish("burn_sum", burn_rate_sum)
+
+        -- update alarm sounder
+        sounder.eval(io.units)
+    end
+
+    return valid
+end
+
+-- get the IO controller database
+function iocontrol.get_db() return io end
+
+return iocontrol

coordinator/process.lua

@@ -0,0 +1,273 @@
+--
+-- Process Control Management
+--
+
+local comms = require("scada-common.comms")
+local log   = require("scada-common.log")
+local types = require("scada-common.types")
+local util  = require("scada-common.util")
+
+local FAC_COMMAND = comms.FAC_COMMAND
+local UNIT_COMMAND = comms.UNIT_COMMAND
+
+local PROCESS = types.PROCESS
+
+---@class process_controller
+local process = {}
+
+local self = {
+    io = nil,       ---@type ioctl
+    comms = nil,    ---@type coord_comms
+    ---@class coord_auto_config
+    config = {
+        mode = PROCESS.INACTIVE,
+        burn_target = 0.0,
+        charge_target = 0.0,
+        gen_target = 0.0,
+        limits = {}
+    }
+}
+
+--------------------------
+-- UNIT COMMAND CONTROL --
+--------------------------
+
+-- initialize the process controller
+---@param iocontrol ioctl iocontrl system
+---@param coord_comms coord_comms coordinator communications
+function process.init(iocontrol, coord_comms)
+    self.io = iocontrol
+    self.comms = coord_comms
+
+    for i = 1, self.io.facility.num_units do
+        self.config.limits[i] = 0.1
+    end
+
+    -- load settings
+    if not settings.load("/coord.settings") then
+        log.error("process.init(): failed to load coordinator settings file")
+    end
+
+    local config = settings.get("PROCESS")  ---@type coord_auto_config|nil
+
+    if type(config) == "table" then
+        self.config.mode = config.mode
+        self.config.burn_target = config.burn_target
+        self.config.charge_target = config.charge_target
+        self.config.gen_target = config.gen_target
+        self.config.limits = config.limits
+
+        self.io.facility.ps.publish("process_mode", self.config.mode)
+        self.io.facility.ps.publish("process_burn_target", self.config.burn_target)
+        self.io.facility.ps.publish("process_charge_target", self.config.charge_target)
+        self.io.facility.ps.publish("process_gen_target", self.config.gen_target)
+
+        for id = 1, math.min(#self.config.limits, self.io.facility.num_units) do
+            local unit = self.io.units[id]   ---@type ioctl_unit
+            unit.unit_ps.publish("burn_limit", self.config.limits[id])
+        end
+
+        log.info("PROCESS: loaded auto control settings from coord.settings")
+    end
+
+    local waste_mode = settings.get("WASTE_MODES")  ---@type table|nil
+
+    if type(waste_mode) == "table" then
+        for id, mode in pairs(waste_mode) do
+            self.comms.send_unit_command(UNIT_COMMAND.SET_WASTE, id, mode)
+        end
+
+        log.info("PROCESS: loaded waste mode settings from coord.settings")
+    end
+
+    local prio_groups = settings.get("PRIORITY_GROUPS") ---@type table|nil
+
+    if type(prio_groups) == "table" then
+        for id, group in pairs(prio_groups) do
+            self.comms.send_unit_command(UNIT_COMMAND.SET_GROUP, id, group)
+        end
+
+        log.info("PROCESS: loaded priority groups settings from coord.settings")
+    end
+end
+
+-- facility SCRAM command
+function process.fac_scram()
+    self.comms.send_fac_command(FAC_COMMAND.SCRAM_ALL)
+    log.debug("PROCESS: FAC SCRAM ALL")
+end
+
+-- facility alarm acknowledge command
+function process.fac_ack_alarms()
+    self.comms.send_fac_command(FAC_COMMAND.ACK_ALL_ALARMS)
+    log.debug("PROCESS: FAC ACK ALL ALARMS")
+end
+
+-- start reactor
+---@param id integer unit ID
+function process.start(id)
+    self.io.units[id].control_state = true
+    self.comms.send_unit_command(UNIT_COMMAND.START, id)
+    log.debug(util.c("PROCESS: UNIT[", id, "] START"))
+end
+
+-- SCRAM reactor
+---@param id integer unit ID
+function process.scram(id)
+    self.io.units[id].control_state = false
+    self.comms.send_unit_command(UNIT_COMMAND.SCRAM, id)
+    log.debug(util.c("PROCESS: UNIT[", id, "] SCRAM"))
+end
+
+-- reset reactor protection system
+---@param id integer unit ID
+function process.reset_rps(id)
+    self.comms.send_unit_command(UNIT_COMMAND.RESET_RPS, id)
+    log.debug(util.c("PROCESS: UNIT[", id, "] RESET RPS"))
+end
+
+-- set burn rate
+---@param id integer unit ID
+---@param rate number burn rate
+function process.set_rate(id, rate)
+    self.comms.send_unit_command(UNIT_COMMAND.SET_BURN, id, rate)
+    log.debug(util.c("PROCESS: UNIT[", id, "] SET BURN ", rate))
+end
+
+-- set waste mode
+---@param id integer unit ID
+---@param mode integer waste mode
+function process.set_waste(id, mode)
+    -- publish so that if it fails then it gets reset
+    self.io.units[id].unit_ps.publish("U_WasteMode", mode)
+
+    self.comms.send_unit_command(UNIT_COMMAND.SET_WASTE, id, mode)
+    log.debug(util.c("PROCESS: UNIT[", id, "] SET WASTE ", mode))
+
+    local waste_mode = settings.get("WASTE_MODES")  ---@type table|nil
+
+    if type(waste_mode) ~= "table" then waste_mode = {} end
+
+    waste_mode[id] = mode
+
+    settings.set("WASTE_MODES", waste_mode)
+
+    if not settings.save("/coord.settings") then
+        log.error("process.set_waste(): failed to save coordinator settings file")
+    end
+end
+
+-- acknowledge all alarms
+---@param id integer unit ID
+function process.ack_all_alarms(id)
+    self.comms.send_unit_command(UNIT_COMMAND.ACK_ALL_ALARMS, id)
+    log.debug(util.c("PROCESS: UNIT[", id, "] ACK ALL ALARMS"))
+end
+
+-- acknowledge an alarm
+---@param id integer unit ID
+---@param alarm integer alarm ID
+function process.ack_alarm(id, alarm)
+    self.comms.send_unit_command(UNIT_COMMAND.ACK_ALARM, id, alarm)
+    log.debug(util.c("PROCESS: UNIT[", id, "] ACK ALARM ", alarm))
+end
+
+-- reset an alarm
+---@param id integer unit ID
+---@param alarm integer alarm ID
+function process.reset_alarm(id, alarm)
+    self.comms.send_unit_command(UNIT_COMMAND.RESET_ALARM, id, alarm)
+    log.debug(util.c("PROCESS: UNIT[", id, "] RESET ALARM ", alarm))
+end
+
+-- assign a unit to a group
+---@param unit_id integer unit ID
+---@param group_id integer|0 group ID or 0 for independent
+function process.set_group(unit_id, group_id)
+    self.comms.send_unit_command(UNIT_COMMAND.SET_GROUP, unit_id, group_id)
+    log.debug(util.c("PROCESS: UNIT[", unit_id, "] SET GROUP ", group_id))
+
+    local prio_groups = settings.get("PRIORITY_GROUPS") ---@type table|nil
+
+    if type(prio_groups) ~= "table" then prio_groups = {} end
+
+    prio_groups[unit_id] = group_id
+
+    settings.set("PRIORITY_GROUPS", prio_groups)
+
+    if not settings.save("/coord.settings") then
+        log.error("process.set_group(): failed to save coordinator settings file")
+    end
+end
+
+--------------------------
+-- AUTO PROCESS CONTROL --
+--------------------------
+
+-- stop automatic process control
+function process.stop_auto()
+    self.comms.send_fac_command(FAC_COMMAND.STOP)
+    log.debug("PROCESS: STOP AUTO CTL")
+end
+
+-- start automatic process control
+function process.start_auto()
+    self.comms.send_auto_start(self.config)
+    log.debug("PROCESS: START AUTO CTL")
+end
+
+-- save process control settings
+---@param mode PROCESS control mode
+---@param burn_target number burn rate target
+---@param charge_target number charge target
+---@param gen_target number generation rate target
+---@param limits table unit burn rate limits
+function process.save(mode, burn_target, charge_target, gen_target, limits)
+    -- attempt to load settings
+    if not settings.load("/coord.settings") then
+        log.warning("process.save(): failed to load coordinator settings file")
+    end
+
+    -- config table
+    self.config = {
+        mode = mode,
+        burn_target = burn_target,
+        charge_target = charge_target,
+        gen_target = gen_target,
+        limits = limits
+    }
+
+    -- save config
+    settings.set("PROCESS", self.config)
+    local saved = settings.save("/coord.settings")
+
+    if not saved then
+        log.warning("process.save(): failed to save coordinator settings file")
+    end
+
+    self.io.facility.save_cfg_ack(saved)
+end
+
+-- handle a start command acknowledgement
+---@param response table ack and configuration reply
+function process.start_ack_handle(response)
+    local ack = response[1]
+
+    self.config.mode = response[2]
+    self.config.burn_target = response[3]
+    self.config.charge_target = response[4]
+    self.config.gen_target = response[5]
+
+    for i = 1, #response[6] do
+        self.config.limits[i] = response[6][i]
+    end
+
+    self.io.facility.ps.publish("auto_mode", self.config.mode)
+    self.io.facility.ps.publish("burn_target", self.config.burn_target)
+    self.io.facility.ps.publish("charge_target", self.config.charge_target)
+    self.io.facility.ps.publish("gen_target", self.config.gen_target)
+
+    self.io.facility.start_ack(ack)
+end
+
+return process

coordinator/renderer.lua

@@ -0,0 +1,188 @@
+--
+-- Graphics Rendering Control
+--
+
+local log       = require("scada-common.log")
+local util      = require("scada-common.util")
+
+local style     = require("coordinator.ui.style")
+
+local main_view = require("coordinator.ui.layout.main_view")
+local unit_view = require("coordinator.ui.layout.unit_view")
+
+local flasher   = require("graphics.flasher")
+
+local renderer = {}
+
+-- render engine
+local engine = {
+    monitors = nil,
+    dmesg_window = nil,
+    ui_ready = false
+}
+
+-- UI layouts
+local ui = {
+    main_layout = nil,
+    unit_layouts = {}
+}
+
+-- init a display to the "default", but set text scale to 0.5
+---@param monitor table monitor
+local function _init_display(monitor)
+    monitor.setTextScale(0.5)
+    monitor.setTextColor(colors.white)
+    monitor.setBackgroundColor(colors.black)
+    monitor.clear()
+    monitor.setCursorPos(1, 1)
+
+    -- set overridden colors
+    for i = 1, #style.colors do
+        monitor.setPaletteColor(style.colors[i].c, style.colors[i].hex)
+    end
+end
+
+-- link to the monitor peripherals
+---@param monitors monitors_struct
+function renderer.set_displays(monitors)
+    engine.monitors = monitors
+end
+
+-- check if the renderer is configured to use a given monitor peripheral
+---@nodiscard
+---@param periph table peripheral
+---@return boolean is_used
+function renderer.is_monitor_used(periph)
+    if engine.monitors ~= nil then
+        if engine.monitors.primary == periph then
+            return true
+        else
+            for i = 1, #engine.monitors.unit_displays do
+                if engine.monitors.unit_displays[i] == periph then
+                    return true
+                end
+            end
+        end
+    end
+
+    return false
+end
+
+-- init all displays in use by the renderer
+function renderer.init_displays()
+    -- init primary monitor
+    _init_display(engine.monitors.primary)
+
+    -- init unit displays
+    for _, monitor in pairs(engine.monitors.unit_displays) do
+        _init_display(monitor)
+    end
+end
+
+-- check main display width
+---@nodiscard
+---@return boolean width_okay
+function renderer.validate_main_display_width()
+    local w, _ = engine.monitors.primary.getSize()
+    return w == 164
+end
+
+-- check display sizes
+---@nodiscard
+---@return boolean valid all unit display dimensions OK
+function renderer.validate_unit_display_sizes()
+    local valid = true
+
+    for id, monitor in pairs(engine.monitors.unit_displays) do
+        local w, h = monitor.getSize()
+        if w ~= 79 or h ~= 52 then
+            log.warning(util.c("RENDERER: unit ", id, " display resolution not 79 wide by 52 tall: ", w, ", ", h))
+            valid = false
+        end
+    end
+
+    return valid
+end
+
+-- initialize the dmesg output window
+function renderer.init_dmesg()
+    local disp_x, disp_y = engine.monitors.primary.getSize()
+    engine.dmesg_window = window.create(engine.monitors.primary, 1, 1, disp_x, disp_y)
+
+    log.direct_dmesg(engine.dmesg_window)
+end
+
+-- start the coordinator GUI
+function renderer.start_ui()
+    if not engine.ui_ready then
+        -- hide dmesg
+        engine.dmesg_window.setVisible(false)
+
+        -- show main view on main monitor
+        ui.main_layout = main_view(engine.monitors.primary)
+
+        -- show unit views on unit displays
+        for id, monitor in pairs(engine.monitors.unit_displays) do
+            table.insert(ui.unit_layouts, unit_view(monitor, id))
+        end
+
+        -- start flasher callback task
+        flasher.run()
+
+        -- report ui as ready
+        engine.ui_ready = true
+    end
+end
+
+-- close out the UI
+function renderer.close_ui()
+    -- report ui as not ready
+    engine.ui_ready = false
+
+    -- stop blinking indicators
+    flasher.clear()
+
+    if engine.ui_ready then
+        -- hide to stop animation callbacks
+        ui.main_layout.hide()
+        for i = 1, #ui.unit_layouts do
+            ui.unit_layouts[i].hide()
+            engine.monitors.unit_displays[i].clear()
+        end
+    else
+        -- clear unit displays
+        for i = 1, #ui.unit_layouts do
+            engine.monitors.unit_displays[i].clear()
+        end
+    end
+
+    -- clear root UI elements
+    ui.main_layout = nil
+    ui.unit_layouts = {}
+
+    -- re-draw dmesg
+    engine.dmesg_window.setVisible(true)
+    engine.dmesg_window.redraw()
+end
+
+-- is the UI ready?
+---@nodiscard
+---@return boolean ready
+function renderer.ui_ready() return engine.ui_ready end
+
+-- handle a touch event
+---@param event monitor_touch
+function renderer.handle_touch(event)
+    if event.monitor == engine.monitors.primary_name then
+        ui.main_layout.handle_touch(event)
+    else
+        for id, monitor in pairs(engine.monitors.unit_name_map) do
+            if event.monitor == monitor then
+                local layout = ui.unit_layouts[id]  ---@type graphics_element
+                layout.handle_touch(event)
+            end
+        end
+    end
+end
+
+return renderer

coordinator/sounder.lua

@@ -0,0 +1,468 @@
+--
+-- Alarm Sounder
+--
+
+local log   = require("scada-common.log")
+local types = require("scada-common.types")
+local util  = require("scada-common.util")
+
+local ALARM = types.ALARM
+local ALARM_STATE = types.ALARM_STATE
+
+---@class sounder
+local sounder = {}
+
+local _2_PI        = 2 * math.pi    -- 2 whole pies, hope you're hungry
+local _DRATE       = 48000          -- 48kHz audio
+local _MAX_VAL     = 127 / 2        -- max signed integer in this 8-bit audio
+local _MAX_SAMPLES = 0x20000        -- 128 * 1024 samples
+local _05s_SAMPLES = 24000          -- half a second worth of samples
+
+local test_alarms = { false, false, false, false, false, false, false, false, false, false, false, false }
+
+local alarm_ctl = {
+    speaker = nil,
+    volume = 0.5,
+    playing = false,
+    num_active = 0,
+    next_block = 1,
+    -- split audio up into 0.5s samples so specific components can be ended quicker
+    quad_buffer = { {}, {}, {}, {} }
+}
+
+-- sounds modeled after https://www.e2s.com/references-and-guidelines/listen-and-download-alarm-tones
+
+local T_340Hz_Int_2Hz = 1
+local T_544Hz_440Hz_Alt = 2
+local T_660Hz_Int_125ms = 3
+local T_745Hz_Int_1Hz = 4
+local T_800Hz_Int = 5
+local T_800Hz_1000Hz_Alt = 6
+local T_1000Hz_Int = 7
+local T_1800Hz_Int_4Hz = 8
+
+local TONES = {
+    { active = false, component = { {}, {}, {}, {} } }, -- 340Hz @ 2Hz Intermittent
+    { active = false, component = { {}, {}, {}, {} } }, -- 544Hz 100mS / 440Hz 400mS Alternating
+    { active = false, component = { {}, {}, {}, {} } }, -- 660Hz @ 125ms On 125ms Off
+    { active = false, component = { {}, {}, {}, {} } }, -- 745Hz @ 1Hz Intermittent
+    { active = false, component = { {}, {}, {}, {} } }, -- 800Hz @ 0.25s On 1.75s Off
+    { active = false, component = { {}, {}, {}, {} } }, -- 800/1000Hz @ 0.25s Alternating
+    { active = false, component = { {}, {}, {}, {} } }, -- 1KHz 1s on, 1s off Intermittent
+    { active = false, component = { {}, {}, {}, {} } }  -- 1.8KHz @ 4Hz Intermittent
+}
+
+-- calculate how many samples are in the given number of milliseconds
+---@nodiscard
+---@param ms integer milliseconds
+---@return integer samples
+local function ms_to_samples(ms) return math.floor(ms * 48) end
+
+--#region Tone Generation (the Maths)
+
+-- 340Hz @ 2Hz Intermittent
+local function gen_tone_1()
+    local t, dt = 0, _2_PI * 340 / _DRATE
+
+    for i = 1, _05s_SAMPLES do
+        local val = math.floor(math.sin(t) * _MAX_VAL)
+        TONES[1].component[1][i] = val
+        TONES[1].component[3][i] = val
+        TONES[1].component[2][i] = 0
+        TONES[1].component[4][i] = 0
+        t = (t + dt) % _2_PI
+    end
+end
+
+-- 544Hz 100mS / 440Hz 400mS Alternating
+local function gen_tone_2()
+    local t1, dt1 = 0, _2_PI * 544 / _DRATE
+    local t2, dt2 = 0, _2_PI * 440 / _DRATE
+    local alternate_at = ms_to_samples(100)
+
+    for i = 1, _05s_SAMPLES do
+        local value
+
+        if i <= alternate_at then
+            value = math.floor(math.sin(t1) * _MAX_VAL)
+            t1 = (t1 + dt1) % _2_PI
+        else
+            value = math.floor(math.sin(t2) * _MAX_VAL)
+            t2 = (t2 + dt2) % _2_PI
+        end
+
+        TONES[2].component[1][i] = value
+        TONES[2].component[2][i] = value
+        TONES[2].component[3][i] = value
+        TONES[2].component[4][i] = value
+    end
+end
+
+-- 660Hz @ 125ms On 125ms Off
+local function gen_tone_3()
+    local elapsed_samples = 0
+    local alternate_after = ms_to_samples(125)
+    local alternate_at = alternate_after
+    local mode = true
+
+    local t, dt = 0, _2_PI * 660 / _DRATE
+
+    for set = 1, 4 do
+        for i = 1, _05s_SAMPLES do
+            if mode then
+                local val = math.floor(math.sin(t) * _MAX_VAL)
+                TONES[3].component[set][i] = val
+                t = (t + dt) % _2_PI
+            else
+                t = 0
+                TONES[3].component[set][i] = 0
+            end
+
+            if elapsed_samples == alternate_at then
+                mode = not mode
+                alternate_at = elapsed_samples + alternate_after
+            end
+
+            elapsed_samples = elapsed_samples + 1
+        end
+    end
+end
+
+-- 745Hz @ 1Hz Intermittent
+local function gen_tone_4()
+    local t, dt = 0, _2_PI * 745 / _DRATE
+
+    for i = 1, _05s_SAMPLES do
+        local val = math.floor(math.sin(t) * _MAX_VAL)
+        TONES[4].component[1][i] = val
+        TONES[4].component[3][i] = val
+        TONES[4].component[2][i] = 0
+        TONES[4].component[4][i] = 0
+        t = (t + dt) % _2_PI
+    end
+end
+
+-- 800Hz @ 0.25s On 1.75s Off
+local function gen_tone_5()
+    local t, dt = 0, _2_PI * 800 / _DRATE
+    local stop_at = ms_to_samples(250)
+
+    for i = 1, _05s_SAMPLES do
+        local val = math.floor(math.sin(t) * _MAX_VAL)
+
+        if i > stop_at then
+            TONES[5].component[1][i] = val
+        else
+            TONES[5].component[1][i] = 0
+        end
+
+        TONES[5].component[2][i] = 0
+        TONES[5].component[3][i] = 0
+        TONES[5].component[4][i] = 0
+
+        t = (t + dt) % _2_PI
+    end
+end
+
+-- 1000/800Hz @ 0.25s Alternating
+local function gen_tone_6()
+    local t1, dt1 = 0, _2_PI * 1000 / _DRATE
+    local t2, dt2 = 0, _2_PI * 800 / _DRATE
+
+    local alternate_at = ms_to_samples(250)
+
+    for i = 1, _05s_SAMPLES do
+        local val
+        if i <= alternate_at then
+            val = math.floor(math.sin(t1) * _MAX_VAL)
+            t1 = (t1 + dt1) % _2_PI
+        else
+            val = math.floor(math.sin(t2) * _MAX_VAL)
+            t2 = (t2 + dt2) % _2_PI
+        end
+
+        TONES[6].component[1][i] = val
+        TONES[6].component[2][i] = val
+        TONES[6].component[3][i] = val
+        TONES[6].component[4][i] = val
+    end
+end
+
+-- 1KHz 1s on, 1s off Intermittent
+local function gen_tone_7()
+    local t, dt = 0, _2_PI * 1000 / _DRATE
+
+    for i = 1, _05s_SAMPLES do
+        local val = math.floor(math.sin(t) * _MAX_VAL)
+        TONES[7].component[1][i] = val
+        TONES[7].component[2][i] = val
+        TONES[7].component[3][i] = 0
+        TONES[7].component[4][i] = 0
+        t = (t + dt) % _2_PI
+    end
+end
+
+-- 1800Hz @ 4Hz Intermittent
+local function gen_tone_8()
+    local t, dt = 0, _2_PI * 1800 / _DRATE
+
+    local off_at = ms_to_samples(250)
+
+    for i = 1, _05s_SAMPLES do
+        local val = 0
+
+        if i <= off_at then
+            val = math.floor(math.sin(t) * _MAX_VAL)
+            t = (t + dt) % _2_PI
+        end
+
+        TONES[8].component[1][i] = val
+        TONES[8].component[2][i] = val
+        TONES[8].component[3][i] = val
+        TONES[8].component[4][i] = val
+    end
+end
+
+--#endregion
+
+-- hard audio limiter
+---@nodiscard
+---@param output number output level
+---@return number limited -128.0 to 127.0
+local function limit(output)
+    return math.max(-128, math.min(127, output))
+end
+
+-- zero the alarm audio buffer
+local function zero()
+    for i = 1, 4 do
+        for s = 1, _05s_SAMPLES do alarm_ctl.quad_buffer[i][s] = 0 end
+    end
+end
+
+-- add an alarm to the output buffer
+---@param alarm_idx integer tone ID
+local function add(alarm_idx)
+    alarm_ctl.num_active = alarm_ctl.num_active + 1
+    TONES[alarm_idx].active = true
+
+    for i = 1, 4 do
+        for s = 1, _05s_SAMPLES do
+            alarm_ctl.quad_buffer[i][s] = limit(alarm_ctl.quad_buffer[i][s] + TONES[alarm_idx].component[i][s])
+        end
+    end
+end
+
+-- start audio or continue audio on buffer empty
+---@return boolean success successfully added buffer to audio output
+local function play()
+    if not alarm_ctl.playing then
+        alarm_ctl.playing = true
+        alarm_ctl.next_block = 1
+
+        return sounder.continue()
+    else
+        return true
+    end
+end
+
+-- initialize the annunciator alarm system
+---@param speaker table speaker peripheral
+---@param volume number speaker volume
+function sounder.init(speaker, volume)
+    alarm_ctl.speaker = speaker
+    alarm_ctl.speaker.stop()
+
+    alarm_ctl.volume = volume
+    alarm_ctl.playing = false
+    alarm_ctl.num_active = 0
+    alarm_ctl.next_block = 1
+
+    zero()
+
+    -- generate tones
+    gen_tone_1()
+    gen_tone_2()
+    gen_tone_3()
+    gen_tone_4()
+    gen_tone_5()
+    gen_tone_6()
+    gen_tone_7()
+    gen_tone_8()
+end
+
+-- reconnect the speaker peripheral
+---@param speaker table speaker peripheral
+function sounder.reconnect(speaker)
+    alarm_ctl.speaker = speaker
+    alarm_ctl.playing = false
+    alarm_ctl.next_block = 1
+    alarm_ctl.num_active = 0
+    for id = 1, #TONES do TONES[id].active = false end
+end
+
+-- check alarm state to enable/disable alarms
+---@param units table|nil unit list or nil to use test mode
+function sounder.eval(units)
+    local changed = false
+    local any_active = false
+    local new_states = { false, false, false, false, false, false, false, false }
+    local alarms = { false, false, false, false, false, false, false, false, false, false, false, false }
+
+    if units ~= nil then
+        -- check all alarms for all units
+        for i = 1, #units do
+            local unit = units[i]   ---@type ioctl_unit
+            for id = 1, #unit.alarms do
+                alarms[id] = alarms[id] or (unit.alarms[id] == ALARM_STATE.TRIPPED)
+            end
+        end
+    else
+        alarms = test_alarms
+    end
+
+    -- containment breach is worst case CRITICAL alarm, this takes priority
+    if alarms[ALARM.ContainmentBreach] then
+        new_states[T_1800Hz_Int_4Hz] = true
+    else
+        -- critical damage is highest priority CRITICAL level alarm
+        if alarms[ALARM.CriticalDamage] then
+            new_states[T_660Hz_Int_125ms] = true
+        else
+            -- EMERGENCY level alarms + URGENT over temp
+            if alarms[ALARM.ReactorDamage] or alarms[ALARM.ReactorOverTemp] or alarms[ALARM.ReactorWasteLeak] then
+                new_states[T_544Hz_440Hz_Alt] = true
+            -- URGENT level turbine trip
+            elseif alarms[ALARM.TurbineTrip] then
+                new_states[T_745Hz_Int_1Hz] = true
+            -- URGENT level reactor lost
+            elseif alarms[ALARM.ReactorLost] then
+                new_states[T_340Hz_Int_2Hz] = true
+            -- TIMELY level alarms
+            elseif alarms[ALARM.ReactorHighTemp] or alarms[ALARM.ReactorHighWaste] or alarms[ALARM.RCSTransient] then
+                new_states[T_800Hz_Int] = true
+            end
+        end
+
+        -- check RPS transient URGENT level alarm
+        if alarms[ALARM.RPSTransient] then
+            new_states[T_1000Hz_Int] = true
+            -- disable really painful audio combination
+            new_states[T_340Hz_Int_2Hz] = false
+        end
+    end
+
+    -- radiation is a big concern, always play this CRITICAL level alarm if active
+    if alarms[ALARM.ContainmentRadiation] then
+        new_states[T_800Hz_1000Hz_Alt] = true
+        -- we are going to disable the RPS trip alarm audio due to conflict, and if it was enabled
+        -- then we can re-enable the reactor lost alarm audio since it doesn't painfully combine with this one
+        if new_states[T_1000Hz_Int] and alarms[ALARM.ReactorLost] then new_states[T_340Hz_Int_2Hz] = true end
+        -- it sounds *really* bad if this is in conjunction with these other tones, so disable them
+        new_states[T_745Hz_Int_1Hz] = false
+        new_states[T_800Hz_Int] = false
+        new_states[T_1000Hz_Int] = false
+    end
+
+    -- check if any changed, check if any active, update active flags
+    for id = 1, #TONES do
+        if new_states[id] ~= TONES[id].active then
+            TONES[id].active = new_states[id]
+            changed = true
+        end
+
+        if TONES[id].active then any_active = true end
+    end
+
+    -- zero and re-add tones if changed
+    if changed then
+        zero()
+
+        for id = 1, #TONES do
+            if TONES[id].active then add(id) end
+        end
+    end
+
+    if any_active then play() else sounder.stop() end
+end
+
+-- stop all audio and clear output buffer
+function sounder.stop()
+    alarm_ctl.playing = false
+    alarm_ctl.speaker.stop()
+    alarm_ctl.next_block = 1
+    alarm_ctl.num_active = 0
+    for id = 1, #TONES do TONES[id].active = false end
+    zero()
+end
+
+-- continue audio on buffer empty
+---@return boolean success successfully added buffer to audio output
+function sounder.continue()
+    if alarm_ctl.playing then
+        if alarm_ctl.speaker ~= nil and #alarm_ctl.quad_buffer[alarm_ctl.next_block] > 0 then
+            local success = alarm_ctl.speaker.playAudio(alarm_ctl.quad_buffer[alarm_ctl.next_block], alarm_ctl.volume)
+
+            alarm_ctl.next_block = alarm_ctl.next_block + 1
+            if alarm_ctl.next_block > 4 then alarm_ctl.next_block = 1 end
+
+            if not success then
+                log.debug("SOUNDER: error playing audio")
+            end
+
+            return success
+        else
+            return false
+        end
+    else
+        return false
+    end
+end
+
+--#region Test Functions
+
+function sounder.test_1() add(1) play() end -- play tone T_340Hz_Int_2Hz
+function sounder.test_2() add(2) play() end -- play tone T_544Hz_440Hz_Alt
+function sounder.test_3() add(3) play() end -- play tone T_660Hz_Int_125ms
+function sounder.test_4() add(4) play() end -- play tone T_745Hz_Int_1Hz
+function sounder.test_5() add(5) play() end -- play tone T_800Hz_Int
+function sounder.test_6() add(6) play() end -- play tone T_800Hz_1000Hz_Alt
+function sounder.test_7() add(7) play() end -- play tone T_1000Hz_Int
+function sounder.test_8() add(8) play() end -- play tone T_1800Hz_Int_4Hz
+
+function sounder.test_breach(active)    test_alarms[ALARM.ContainmentBreach]    = active end    ---@param active boolean
+function sounder.test_rad(active)       test_alarms[ALARM.ContainmentRadiation] = active end    ---@param active boolean
+function sounder.test_lost(active)      test_alarms[ALARM.ReactorLost]          = active end    ---@param active boolean
+function sounder.test_crit(active)      test_alarms[ALARM.CriticalDamage]       = active end    ---@param active boolean
+function sounder.test_dmg(active)       test_alarms[ALARM.ReactorDamage]        = active end    ---@param active boolean
+function sounder.test_overtemp(active)  test_alarms[ALARM.ReactorOverTemp]      = active end    ---@param active boolean
+function sounder.test_hightemp(active)  test_alarms[ALARM.ReactorHighTemp]      = active end    ---@param active boolean
+function sounder.test_wasteleak(active) test_alarms[ALARM.ReactorWasteLeak]     = active end    ---@param active boolean
+function sounder.test_highwaste(active) test_alarms[ALARM.ReactorHighWaste]     = active end    ---@param active boolean
+function sounder.test_rps(active)       test_alarms[ALARM.RPSTransient]         = active end    ---@param active boolean
+function sounder.test_rcs(active)       test_alarms[ALARM.RCSTransient]         = active end    ---@param active boolean
+function sounder.test_turbinet(active)  test_alarms[ALARM.TurbineTrip]          = active end    ---@param active boolean
+
+-- power rescaling limiter test
+function sounder.test_power_scale()
+    local start = util.time_ms()
+
+    zero()
+
+    for id = 1, #TONES do
+        if TONES[id].active then
+            for i = 1, 4 do
+                for s = 1, _05s_SAMPLES do
+                    alarm_ctl.quad_buffer[i][s] = limit(alarm_ctl.quad_buffer[i][s] +
+                        (TONES[id].component[i][s] / math.sqrt(alarm_ctl.num_active)))
+                end
+            end
+        end
+    end
+
+    log.debug("SOUNDER: power rescale test took " .. (util.time_ms() - start) .. "ms")
+end
+
+--#endregion
+
+return sounder

coordinator/startup.lua

@@ -4,34 +4,385 @@
 
 require("/initenv").init_env()
 
-local log = require("scada-common.log")
-local ppm = require("scada-common.ppm")
-local util = require("scada-common.util")
+local crash        = require("scada-common.crash")
+local log          = require("scada-common.log")
+local ppm          = require("scada-common.ppm")
+local tcallbackdsp = require("scada-common.tcallbackdsp")
+local util         = require("scada-common.util")
 
-local config = require("coordinator.config")
-local coordinator = require("coordinator.coordinator")
+local core         = require("graphics.core")
 
-local COORDINATOR_VERSION = "alpha-v0.1.2"
+local apisessions  = require("coordinator.apisessions")
+local config       = require("coordinator.config")
+local coordinator  = require("coordinator.coordinator")
+local iocontrol    = require("coordinator.iocontrol")
+local renderer     = require("coordinator.renderer")
+local sounder      = require("coordinator.sounder")
+
+local COORDINATOR_VERSION = "v0.12.2"
 
 local print = util.print
 local println = util.println
 local print_ts = util.print_ts
 local println_ts = util.println_ts
 
-log.init("/log.txt", log.MODE.APPEND)
+local log_graphics = coordinator.log_graphics
+local log_sys = coordinator.log_sys
+local log_boot = coordinator.log_boot
+local log_comms = coordinator.log_comms
+local log_comms_connecting = coordinator.log_comms_connecting
+
+----------------------------------------
+-- config validation
+----------------------------------------
+
+local cfv = util.new_validator()
+
+cfv.assert_port(config.SCADA_SV_PORT)
+cfv.assert_port(config.SCADA_SV_LISTEN)
+cfv.assert_port(config.SCADA_API_LISTEN)
+cfv.assert_type_int(config.TRUSTED_RANGE)
+cfv.assert_type_num(config.COMMS_TIMEOUT)
+cfv.assert_min(config.COMMS_TIMEOUT, 2)
+cfv.assert_type_int(config.NUM_UNITS)
+cfv.assert_type_num(config.SOUNDER_VOLUME)
+cfv.assert_type_bool(config.TIME_24_HOUR)
+cfv.assert_type_str(config.LOG_PATH)
+cfv.assert_type_int(config.LOG_MODE)
+
+assert(cfv.valid(), "bad config file: missing/invalid fields")
+
+----------------------------------------
+-- log init
+----------------------------------------
+
+log.init(config.LOG_PATH, config.LOG_MODE)
 
 log.info("========================================")
 log.info("BOOTING coordinator.startup " .. COORDINATOR_VERSION)
 log.info("========================================")
 println(">> SCADA Coordinator " .. COORDINATOR_VERSION .. " <<")
 
--- mount connected devices
-ppm.mount_all()
+crash.set_env("coordinator", COORDINATOR_VERSION)
 
-local modem = ppm.get_wireless_modem()
+----------------------------------------
+-- main application
+----------------------------------------
 
--- we need a modem
-if modem == nil then
-    println("please connect a wireless modem")
-    return
+local function main()
+    ----------------------------------------
+    -- system startup
+    ----------------------------------------
+
+    -- mount connected devices
+    ppm.mount_all()
+
+    -- setup monitors
+    local configured, monitors = coordinator.configure_monitors(config.NUM_UNITS)
+    if not configured or monitors == nil then
+        println("startup> monitor setup failed")
+        log.fatal("monitor configuration failed")
+        return
+    end
+
+    -- init renderer
+    renderer.set_displays(monitors)
+    renderer.init_displays()
+
+    if not renderer.validate_main_display_width() then
+        println("startup> main display must be 8 blocks wide")
+        log.fatal("main display not wide enough")
+        return
+    elseif not renderer.validate_unit_display_sizes() then
+        println("startup> one or more unit display dimensions incorrect; they must be 4x4 blocks")
+        log.fatal("unit display dimensions incorrect")
+        return
+    end
+
+    renderer.init_dmesg()
+
+    -- lets get started!
+    log.info("monitors ready, dmesg output incoming...")
+
+    log_graphics("displays connected and reset")
+    log_sys("system start on " .. os.date("%c"))
+    log_boot("starting " .. COORDINATOR_VERSION)
+
+    ----------------------------------------
+    -- setup alarm sounder subsystem
+    ----------------------------------------
+
+    local speaker = ppm.get_device("speaker")
+    if speaker == nil then
+        log_boot("annunciator alarm speaker not found")
+        println("startup> speaker not found")
+        log.fatal("no annunciator alarm speaker found")
+        return
+    else
+        local sounder_start = util.time_ms()
+        log_boot("annunciator alarm speaker connected")
+        sounder.init(speaker, config.SOUNDER_VOLUME)
+        log_boot("tone generation took " .. (util.time_ms() - sounder_start) .. "ms")
+        log_sys("annunciator alarm configured")
+    end
+
+    ----------------------------------------
+    -- setup communications
+    ----------------------------------------
+
+    -- get the communications modem
+    local modem = ppm.get_wireless_modem()
+    if modem == nil then
+        log_comms("wireless modem not found")
+        println("startup> wireless modem not found")
+        log.fatal("no wireless modem on startup")
+        return
+    else
+        log_comms("wireless modem connected")
+    end
+
+    -- create connection watchdog
+    local conn_watchdog = util.new_watchdog(config.COMMS_TIMEOUT)
+    conn_watchdog.cancel()
+    log.debug("startup> conn watchdog created")
+
+    -- start comms, open all channels
+    local coord_comms = coordinator.comms(COORDINATOR_VERSION, modem, config.SCADA_SV_PORT, config.SCADA_SV_LISTEN,
+                                            config.SCADA_API_LISTEN, config.TRUSTED_RANGE, 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)
+
+    ----------------------------------------
+    -- connect to the supervisor
+    ----------------------------------------
+
+    -- attempt to connect to the supervisor or exit
+    local function init_connect_sv()
+        local tick_waiting, task_done = log_comms_connecting("attempting to connect to configured supervisor on channel " .. config.SCADA_SV_PORT)
+
+        -- attempt to establish a connection with the supervisory computer
+        if not coord_comms.sv_connect(60, tick_waiting, task_done) then
+            log_sys("supervisor connection failed, shutting down...")
+            log.fatal("failed to connect to supervisor")
+            return false
+        end
+
+        return true
+    end
+
+    if not init_connect_sv() then
+        println("startup> failed to connect to supervisor")
+        log_sys("system shutdown")
+        return
+    else
+        log_sys("supervisor connected, proceeding to UI start")
+    end
+
+    ----------------------------------------
+    -- start the UI
+    ----------------------------------------
+
+    -- start up the UI
+    ---@return boolean ui_ok started ok
+    local function init_start_ui()
+        log_graphics("starting UI...")
+
+        local draw_start = util.time_ms()
+
+        local ui_ok, message = pcall(renderer.start_ui)
+        if not ui_ok then
+            renderer.close_ui()
+            log_graphics(util.c("UI crashed: ", message))
+            println_ts("UI crashed")
+            log.fatal(util.c("GUI crashed with error ", message))
+        else
+            log_graphics("first UI draw took " .. (util.time_ms() - draw_start) .. "ms")
+
+            -- start clock
+            loop_clock.start()
+        end
+
+        return ui_ok
+    end
+
+    local ui_ok = init_start_ui()
+
+    ----------------------------------------
+    -- main event loop
+    ----------------------------------------
+
+    local date_format = util.trinary(config.TIME_24_HOUR, "%X \x04 %A, %B %d %Y", "%r \x04 %A, %B %d %Y")
+
+    local no_modem = false
+
+    if ui_ok then
+        -- start connection watchdog
+        conn_watchdog.feed()
+        log.debug("startup> conn watchdog started")
+
+        log_sys("system started successfully")
+    end
+
+    -- main event loop
+    while ui_ok 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 device == modem then
+                        no_modem = true
+                        log_sys("comms modem disconnected")
+                        println_ts("wireless modem disconnected!")
+
+                        -- close out UI
+                        renderer.close_ui()
+
+                        -- alert user to status
+                        log_sys("awaiting comms modem reconnect...")
+                    else
+                        log_sys("non-comms modem disconnected")
+                    end
+                elseif type == "monitor" then
+                    if renderer.is_monitor_used(device) then
+                        -- "halt and catch fire" style handling
+                        local msg = "lost a configured monitor, system will now exit"
+                        println_ts(msg)
+                        log_sys(msg)
+                        break
+                    else
+                        log_sys("lost unused monitor, ignoring")
+                    end
+                elseif type == "speaker" then
+                    local msg = "lost alarm sounder speaker"
+                    println_ts(msg)
+                    log_sys(msg)
+                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() then
+                        -- reconnected modem
+                        no_modem = false
+                        modem = device
+                        coord_comms.reconnect_modem(modem)
+
+                        log_sys("comms modem reconnected")
+                        println_ts("wireless modem reconnected.")
+
+                        -- re-init system
+                        if not init_connect_sv() then break end
+                        ui_ok = init_start_ui()
+                    else
+                        log_sys("wired modem reconnected")
+                    end
+                elseif type == "monitor" then
+                    -- not supported, system will exit on loss of in-use monitors
+                elseif type == "speaker" then
+                    local msg = "alarm sounder speaker reconnected"
+                    println_ts(msg)
+                    log_sys(msg)
+                    sounder.reconnect(device)
+                end
+            end
+        elseif event == "timer" then
+            if loop_clock.is_clock(param1) then
+                -- main loop tick
+
+                -- free any closed sessions
+                apisessions.free_all_closed()
+
+                -- update date and time string for main display
+                iocontrol.get_db().facility.ps.publish("date_time", os.date(date_format))
+
+                loop_clock.start()
+            elseif conn_watchdog.is_timer(param1) then
+                -- supervisor watchdog timeout
+                local msg = "supervisor server timeout"
+                log_comms(msg)
+                println_ts(msg)
+
+                -- close connection, UI, and stop sounder
+                coord_comms.close()
+                renderer.close_ui()
+                sounder.stop()
+
+                if not no_modem then
+                    -- try to re-connect to the supervisor
+                    if not init_connect_sv() then break end
+                    ui_ok = init_start_ui()
+                end
+            else
+                -- a non-clock/main watchdog timer event
+
+                --check API watchdogs
+                apisessions.check_all_watchdogs(param1)
+
+                -- notify timer callback dispatcher
+                tcallbackdsp.handle(param1)
+            end
+        elseif event == "modem_message" then
+            -- got a packet
+            local packet = coord_comms.parse_packet(param1, param2, param3, param4, param5)
+            coord_comms.handle_packet(packet)
+
+            -- check if it was a disconnect
+            if not coord_comms.is_linked() then
+                log_comms("supervisor closed connection")
+
+                -- close connection, UI, and stop sounder
+                coord_comms.close()
+                renderer.close_ui()
+                sounder.stop()
+
+                if not no_modem then
+                    -- try to re-connect to the supervisor
+                    if not init_connect_sv() then break end
+                    ui_ok = init_start_ui()
+                end
+            end
+        elseif event == "monitor_touch" then
+            -- handle a monitor touch event
+            renderer.handle_touch(core.events.touch(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
+            println_ts("terminate requested, closing connections...")
+            log_comms("terminate requested, closing supervisor connection...")
+            coord_comms.close()
+            log_comms("supervisor connection closed")
+            log_comms("closing api sessions...")
+            apisessions.close_all()
+            log_comms("api sessions closed")
+            break
+        end
+    end
+
+    renderer.close_ui()
+    sounder.stop()
+    log_sys("system shutdown")
+
+    println_ts("exited")
+    log.info("exited")
+end
+
+if not xpcall(main, crash.handler) then
+    pcall(renderer.close_ui)
+    pcall(sounder.stop)
+    crash.exit()
 end

coordinator/ui/components/boiler.lua

@@ -0,0 +1,50 @@
+local style          = require("coordinator.ui.style")
+
+local core           = require("graphics.core")
+
+local Rectangle      = require("graphics.elements.rectangle")
+local TextBox        = require("graphics.elements.textbox")
+
+local DataIndicator  = require("graphics.elements.indicators.data")
+local StateIndicator = require("graphics.elements.indicators.state")
+local VerticalBar    = require("graphics.elements.indicators.vbar")
+
+local cpair = core.graphics.cpair
+local border = core.graphics.border
+
+-- new boiler view
+---@param root graphics_element parent
+---@param x integer top left x
+---@param y integer top left y
+---@param ps psil ps interface
+local function new_view(root, x, y, ps)
+    local boiler = Rectangle{parent=root,border=border(1, colors.gray, true),width=31,height=7,x=x,y=y}
+
+    local text_fg_bg = cpair(colors.black, colors.lightGray)
+    local lu_col = cpair(colors.gray, colors.gray)
+
+    local status = StateIndicator{parent=boiler,x=9,y=1,states=style.boiler.states,value=1,min_width=12}
+    local temp   = DataIndicator{parent=boiler,x=5,y=3,lu_colors=lu_col,label="Temp:",unit="K",format="%10.2f",value=0,width=22,fg_bg=text_fg_bg}
+    local boil_r = DataIndicator{parent=boiler,x=5,y=4,lu_colors=lu_col,label="Boil:",unit="mB/t",format="%10.0f",value=0,commas=true,width=22,fg_bg=text_fg_bg}
+
+    ps.subscribe("computed_status", status.update)
+    ps.subscribe("temperature", temp.update)
+    ps.subscribe("boil_rate", boil_r.update)
+
+    TextBox{parent=boiler,text="H",x=2,y=5,height=1,width=1,fg_bg=text_fg_bg}
+    TextBox{parent=boiler,text="W",x=3,y=5,height=1,width=1,fg_bg=text_fg_bg}
+    TextBox{parent=boiler,text="S",x=27,y=5,height=1,width=1,fg_bg=text_fg_bg}
+    TextBox{parent=boiler,text="C",x=28,y=5,height=1,width=1,fg_bg=text_fg_bg}
+
+    local hcool = VerticalBar{parent=boiler,x=2,y=1,fg_bg=cpair(colors.orange,colors.gray),height=4,width=1}
+    local water = VerticalBar{parent=boiler,x=3,y=1,fg_bg=cpair(colors.blue,colors.gray),height=4,width=1}
+    local steam = VerticalBar{parent=boiler,x=27,y=1,fg_bg=cpair(colors.white,colors.gray),height=4,width=1}
+    local ccool = VerticalBar{parent=boiler,x=28,y=1,fg_bg=cpair(colors.lightBlue,colors.gray),height=4,width=1}
+
+    ps.subscribe("hcool_fill", hcool.update)
+    ps.subscribe("water_fill", water.update)
+    ps.subscribe("steam_fill", steam.update)
+    ps.subscribe("ccool_fill", ccool.update)
+end
+
+return new_view

coordinator/ui/components/imatrix.lua

@@ -0,0 +1,96 @@
+local util           = require("scada-common.util")
+
+local style          = require("coordinator.ui.style")
+
+local core           = require("graphics.core")
+
+local Div            = require("graphics.elements.div")
+local Rectangle      = require("graphics.elements.rectangle")
+local TextBox        = require("graphics.elements.textbox")
+
+local DataIndicator  = require("graphics.elements.indicators.data")
+local PowerIndicator = require("graphics.elements.indicators.power")
+local StateIndicator = require("graphics.elements.indicators.state")
+local VerticalBar    = require("graphics.elements.indicators.vbar")
+
+local cpair = core.graphics.cpair
+local border = core.graphics.border
+
+local TEXT_ALIGN = core.graphics.TEXT_ALIGN
+
+-- new induction matrix view
+---@param root graphics_element parent
+---@param x integer top left x
+---@param y integer top left y
+---@param data imatrix_session_db matrix data
+---@param ps psil ps interface
+---@param id number? matrix ID
+local function new_view(root, x, y, data, ps, id)
+    local title = "INDUCTION MATRIX"
+    if type(id) == "number" then title = title .. id end
+
+    local matrix = Div{parent=root,fg_bg=style.root,width=33,height=24,x=x,y=y}
+
+    TextBox{parent=matrix,text=" ",width=33,height=1,x=1,y=1,fg_bg=cpair(colors.lightGray,colors.gray)}
+    TextBox{parent=matrix,text=title,alignment=TEXT_ALIGN.CENTER,width=33,height=1,x=1,y=2,fg_bg=cpair(colors.lightGray,colors.gray)}
+
+    local rect = Rectangle{parent=matrix,border=border(1,colors.gray,true),width=33,height=22,x=1,y=3}
+
+    local text_fg_bg = cpair(colors.black, colors.lightGray)
+    local label_fg_bg = cpair(colors.gray, colors.lightGray)
+    local lu_col = cpair(colors.gray, colors.gray)
+
+    local status   = StateIndicator{parent=rect,x=10,y=1,states=style.imatrix.states,value=1,min_width=14}
+    local energy   = PowerIndicator{parent=rect,x=7,y=3,lu_colors=lu_col,label="Energy:  ",format="%8.2f",value=0,width=26,fg_bg=text_fg_bg}
+    local capacity = PowerIndicator{parent=rect,x=7,y=4,lu_colors=lu_col,label="Capacity:",format="%8.2f",value=0,width=26,fg_bg=text_fg_bg}
+    local input    = PowerIndicator{parent=rect,x=7,y=5,lu_colors=lu_col,label="Input:   ",format="%8.2f",rate=true,value=0,width=26,fg_bg=text_fg_bg}
+    local output   = PowerIndicator{parent=rect,x=7,y=6,lu_colors=lu_col,label="Output:  ",format="%8.2f",rate=true,value=0,width=26,fg_bg=text_fg_bg}
+
+    local avg_chg  = PowerIndicator{parent=rect,x=7,y=8,lu_colors=lu_col,label="Avg. Chg:",format="%8.2f",value=0,width=26,fg_bg=text_fg_bg}
+    local avg_in   = PowerIndicator{parent=rect,x=7,y=9,lu_colors=lu_col,label="Avg. In: ",format="%8.2f",rate=true,value=0,width=26,fg_bg=text_fg_bg}
+    local avg_out  = PowerIndicator{parent=rect,x=7,y=10,lu_colors=lu_col,label="Avg. Out:",format="%8.2f",rate=true,value=0,width=26,fg_bg=text_fg_bg}
+
+    ps.subscribe("computed_status", status.update)
+    ps.subscribe("energy", function (val) energy.update(util.joules_to_fe(val)) end)
+    ps.subscribe("max_energy", function (val) capacity.update(util.joules_to_fe(val)) end)
+    ps.subscribe("last_input", function (val) input.update(util.joules_to_fe(val)) end)
+    ps.subscribe("last_output", function (val) output.update(util.joules_to_fe(val)) end)
+
+    ps.subscribe("avg_charge", avg_chg.update)
+    ps.subscribe("avg_inflow", avg_in.update)
+    ps.subscribe("avg_outflow", avg_out.update)
+
+    local fill      = DataIndicator{parent=rect,x=11,y=12,lu_colors=lu_col,label="Fill:",unit="%",format="%8.2f",value=0,width=18,fg_bg=text_fg_bg}
+
+    local cells     = DataIndicator{parent=rect,x=11,y=14,lu_colors=lu_col,label="Cells:    ",format="%7d",value=0,width=18,fg_bg=text_fg_bg}
+    local providers = DataIndicator{parent=rect,x=11,y=15,lu_colors=lu_col,label="Providers:",format="%7d",value=0,width=18,fg_bg=text_fg_bg}
+
+    TextBox{parent=rect,text="Transfer Capacity",x=11,y=17,height=1,width=17,fg_bg=label_fg_bg}
+    local trans_cap = PowerIndicator{parent=rect,x=19,y=18,lu_colors=lu_col,label="",format="%5.2f",rate=true,value=0,width=12,fg_bg=text_fg_bg}
+
+    ps.subscribe("cells", cells.update)
+    ps.subscribe("providers", providers.update)
+    ps.subscribe("energy_fill", function (val) fill.update(val * 100) end)
+    ps.subscribe("transfer_cap", function (val) trans_cap.update(util.joules_to_fe(val)) end)
+
+    local charge  = VerticalBar{parent=rect,x=2,y=2,fg_bg=cpair(colors.green,colors.gray),height=17,width=4}
+    local in_cap  = VerticalBar{parent=rect,x=7,y=12,fg_bg=cpair(colors.red,colors.gray),height=7,width=1}
+    local out_cap = VerticalBar{parent=rect,x=9,y=12,fg_bg=cpair(colors.blue,colors.gray),height=7,width=1}
+
+    TextBox{parent=rect,text="FILL",x=2,y=20,height=1,width=4,fg_bg=text_fg_bg}
+    TextBox{parent=rect,text="I/O",x=7,y=20,height=1,width=3,fg_bg=text_fg_bg}
+
+    local function calc_saturation(val)
+        if (type(data.build) == "table") and (type(data.build.transfer_cap) == "number") and (data.build.transfer_cap > 0) then
+            return val / data.build.transfer_cap
+        else
+            return 0
+        end
+    end
+
+    ps.subscribe("energy_fill", charge.update)
+    ps.subscribe("last_input", function (val) in_cap.update(calc_saturation(val)) end)
+    ps.subscribe("last_output", function (val) out_cap.update(calc_saturation(val)) end)
+end
+
+return new_view

coordinator/ui/components/processctl.lua

@@ -0,0 +1,267 @@
+local tcd               = require("scada-common.tcallbackdsp")
+local util              = require("scada-common.util")
+
+local iocontrol         = require("coordinator.iocontrol")
+local process           = require("coordinator.process")
+
+local style             = require("coordinator.ui.style")
+
+local core              = require("graphics.core")
+
+local Div               = require("graphics.elements.div")
+local Rectangle         = require("graphics.elements.rectangle")
+local TextBox           = require("graphics.elements.textbox")
+
+local DataIndicator     = require("graphics.elements.indicators.data")
+local IndicatorLight    = require("graphics.elements.indicators.light")
+local RadIndicator      = require("graphics.elements.indicators.rad")
+local TriIndicatorLight = require("graphics.elements.indicators.trilight")
+
+local HazardButton      = require("graphics.elements.controls.hazard_button")
+local RadioButton       = require("graphics.elements.controls.radio_button")
+local SpinboxNumeric    = require("graphics.elements.controls.spinbox_numeric")
+
+local TEXT_ALIGN = core.graphics.TEXT_ALIGN
+
+local cpair = core.graphics.cpair
+local border = core.graphics.border
+
+local period = core.flasher.PERIOD
+
+-- new process control view
+---@param root graphics_element parent
+---@param x integer top left x
+---@param y integer top left y
+local function new_view(root, x, y)
+    assert(root.height() >= (y + 24), "main display not of sufficient vertical resolution (add an additional row of monitors)")
+
+    local facility = iocontrol.get_db().facility
+    local units = iocontrol.get_db().units
+
+    local bw_fg_bg   = cpair(colors.black, colors.white)
+    local hzd_fg_bg  = cpair(colors.white, colors.gray)
+    local lu_cpair   = cpair(colors.gray, colors.gray)
+    local dis_colors = cpair(colors.white, colors.lightGray)
+
+    local main = Div{parent=root,width=104,height=24,x=x,y=y}
+
+    local scram = HazardButton{parent=main,x=1,y=1,text="FAC SCRAM",accent=colors.yellow,dis_colors=dis_colors,callback=process.fac_scram,fg_bg=hzd_fg_bg}
+    local ack_a = HazardButton{parent=main,x=16,y=1,text="ACK \x13",accent=colors.orange,dis_colors=dis_colors,callback=process.fac_ack_alarms,fg_bg=hzd_fg_bg}
+
+    facility.scram_ack = scram.on_response
+    facility.ack_alarms_ack = ack_a.on_response
+
+    local all_ok  = IndicatorLight{parent=main,y=5,label="Unit Systems Online",colors=cpair(colors.green,colors.red)}
+    local ind_mat = IndicatorLight{parent=main,label="Induction Matrix",colors=cpair(colors.green,colors.gray)}
+    local rad_mon = TriIndicatorLight{parent=main,label="Radiation Monitor",c1=colors.gray,c2=colors.yellow,c3=colors.green}
+
+    facility.ps.subscribe("all_sys_ok", all_ok.update)
+    facility.induction_ps_tbl[1].subscribe("computed_status", function (status) ind_mat.update(status > 1) end)
+    facility.ps.subscribe("rad_computed_status", rad_mon.update)
+
+    main.line_break()
+
+    local auto_ready = IndicatorLight{parent=main,label="Configured Units Ready",colors=cpair(colors.green,colors.red)}
+    local auto_act   = IndicatorLight{parent=main,label="Process Active",colors=cpair(colors.green,colors.gray)}
+    local auto_ramp  = IndicatorLight{parent=main,label="Process Ramping",colors=cpair(colors.white,colors.gray),flash=true,period=period.BLINK_250_MS}
+    local auto_sat   = IndicatorLight{parent=main,label="Min/Max Burn Rate",colors=cpair(colors.yellow,colors.gray)}
+
+    facility.ps.subscribe("auto_ready", auto_ready.update)
+    facility.ps.subscribe("auto_active", auto_act.update)
+    facility.ps.subscribe("auto_ramping", auto_ramp.update)
+    facility.ps.subscribe("auto_saturated", auto_sat.update)
+
+    main.line_break()
+
+    local auto_scram  = IndicatorLight{parent=main,label="Automatic SCRAM",colors=cpair(colors.red,colors.gray),flash=true,period=period.BLINK_250_MS}
+    local matrix_dc   = IndicatorLight{parent=main,label="Matrix Disconnected",colors=cpair(colors.yellow,colors.gray),flash=true,period=period.BLINK_500_MS}
+    local matrix_fill = IndicatorLight{parent=main,label="Matrix Charge High",colors=cpair(colors.red,colors.gray),flash=true,period=period.BLINK_500_MS}
+    local unit_crit   = IndicatorLight{parent=main,label="Unit Critical Alarm",colors=cpair(colors.red,colors.gray),flash=true,period=period.BLINK_250_MS}
+    local fac_rad_h   = IndicatorLight{parent=main,label="Facility Radiation High",colors=cpair(colors.red,colors.gray),flash=true,period=period.BLINK_250_MS}
+    local gen_fault   = IndicatorLight{parent=main,label="Gen. Control Fault",colors=cpair(colors.yellow,colors.gray),flash=true,period=period.BLINK_500_MS}
+
+    facility.ps.subscribe("auto_scram", auto_scram.update)
+    facility.ps.subscribe("as_matrix_dc", matrix_dc.update)
+    facility.ps.subscribe("as_matrix_fill", matrix_fill.update)
+    facility.ps.subscribe("as_crit_alarm", unit_crit.update)
+    facility.ps.subscribe("as_radiation", fac_rad_h.update)
+    facility.ps.subscribe("as_gen_fault", gen_fault.update)
+
+    TextBox{parent=main,y=23,text="Radiation",height=1,width=13,fg_bg=style.label}
+    local radiation = RadIndicator{parent=main,label="",format="%9.3f",lu_colors=lu_cpair,width=13,fg_bg=bw_fg_bg}
+    facility.ps.subscribe("radiation", radiation.update)
+
+    TextBox{parent=main,x=15,y=23,text="Linked RTUs",height=1,width=11,fg_bg=style.label}
+    local rtu_count = DataIndicator{parent=main,x=15,y=24,label="",format="%11d",value=0,lu_colors=lu_cpair,width=11,fg_bg=bw_fg_bg}
+    facility.ps.subscribe("rtu_count", rtu_count.update)
+
+    ---------------------
+    -- process control --
+    ---------------------
+
+    local proc = Div{parent=main,width=78,height=24,x=27,y=1}
+
+    -----------------------------
+    -- process control targets --
+    -----------------------------
+
+    local targets = Div{parent=proc,width=31,height=24,x=1,y=1}
+
+    local burn_tag = Div{parent=targets,x=1,y=1,width=8,height=4,fg_bg=cpair(colors.black,colors.purple)}
+    TextBox{parent=burn_tag,x=2,y=2,text="Burn Target",width=7,height=2}
+
+    local burn_target = Div{parent=targets,x=9,y=1,width=23,height=3,fg_bg=cpair(colors.gray,colors.white)}
+    local b_target = SpinboxNumeric{parent=burn_target,x=11,y=1,whole_num_precision=4,fractional_precision=1,min=0.1,arrow_fg_bg=cpair(colors.gray,colors.white),fg_bg=bw_fg_bg}
+    TextBox{parent=burn_target,x=18,y=2,text="mB/t"}
+    local burn_sum = DataIndicator{parent=targets,x=9,y=4,label="",format="%18.1f",value=0,unit="mB/t",commas=true,lu_colors=cpair(colors.black,colors.black),width=23,fg_bg=cpair(colors.black,colors.brown)}
+
+    facility.ps.subscribe("process_burn_target", b_target.set_value)
+    facility.ps.subscribe("burn_sum", burn_sum.update)
+
+    local chg_tag = Div{parent=targets,x=1,y=6,width=8,height=4,fg_bg=cpair(colors.black,colors.purple)}
+    TextBox{parent=chg_tag,x=2,y=2,text="Charge Target",width=7,height=2}
+
+    local chg_target = Div{parent=targets,x=9,y=6,width=23,height=3,fg_bg=cpair(colors.gray,colors.white)}
+    local c_target = SpinboxNumeric{parent=chg_target,x=2,y=1,whole_num_precision=15,fractional_precision=0,min=0,arrow_fg_bg=cpair(colors.gray,colors.white),fg_bg=bw_fg_bg}
+    TextBox{parent=chg_target,x=18,y=2,text="MFE"}
+    local cur_charge = DataIndicator{parent=targets,x=9,y=9,label="",format="%19d",value=0,unit="MFE",commas=true,lu_colors=cpair(colors.black,colors.black),width=23,fg_bg=cpair(colors.black,colors.brown)}
+
+    facility.ps.subscribe("process_charge_target", c_target.set_value)
+    facility.induction_ps_tbl[1].subscribe("energy", function (j) cur_charge.update(util.joules_to_fe(j) / 1000000) end)
+
+    local gen_tag = Div{parent=targets,x=1,y=11,width=8,height=4,fg_bg=cpair(colors.black,colors.purple)}
+    TextBox{parent=gen_tag,x=2,y=2,text="Gen. Target",width=7,height=2}
+
+    local gen_target = Div{parent=targets,x=9,y=11,width=23,height=3,fg_bg=cpair(colors.gray,colors.white)}
+    local g_target = SpinboxNumeric{parent=gen_target,x=8,y=1,whole_num_precision=9,fractional_precision=0,min=0,arrow_fg_bg=cpair(colors.gray,colors.white),fg_bg=bw_fg_bg}
+    TextBox{parent=gen_target,x=18,y=2,text="kFE/t"}
+    local cur_gen = DataIndicator{parent=targets,x=9,y=14,label="",format="%17d",value=0,unit="kFE/t",commas=true,lu_colors=cpair(colors.black,colors.black),width=23,fg_bg=cpair(colors.black,colors.brown)}
+
+    facility.ps.subscribe("process_gen_target", g_target.set_value)
+    facility.induction_ps_tbl[1].subscribe("last_input", function (j) cur_gen.update(util.round(util.joules_to_fe(j) / 1000)) end)
+
+    -----------------
+    -- unit limits --
+    -----------------
+
+    local limit_div = Div{parent=proc,width=21,height=19,x=34,y=6}
+
+    local rate_limits = {}
+
+    for i = 1, facility.num_units do
+        local unit = units[i]   ---@type ioctl_unit
+
+        local _y = ((i - 1) * 5) + 1
+
+        local unit_tag = Div{parent=limit_div,x=1,y=_y,width=8,height=4,fg_bg=cpair(colors.black,colors.lightBlue)}
+        TextBox{parent=unit_tag,x=2,y=2,text="Unit "..i.." Limit",width=7,height=2}
+
+        local lim_ctl = Div{parent=limit_div,x=9,y=_y,width=14,height=3,fg_bg=cpair(colors.gray,colors.white)}
+        rate_limits[i] = SpinboxNumeric{parent=lim_ctl,x=2,y=1,whole_num_precision=4,fractional_precision=1,min=0.1,arrow_fg_bg=cpair(colors.gray,colors.white),fg_bg=bw_fg_bg}
+        TextBox{parent=lim_ctl,x=9,y=2,text="mB/t",width=4,height=1}
+
+        unit.unit_ps.subscribe("max_burn", rate_limits[i].set_max)
+        unit.unit_ps.subscribe("burn_limit", rate_limits[i].set_value)
+
+        local cur_burn = DataIndicator{parent=limit_div,x=9,y=_y+3,label="",format="%7.1f",value=0,unit="mB/t",commas=false,lu_colors=cpair(colors.black,colors.black),width=14,fg_bg=cpair(colors.black,colors.brown)}
+
+        unit.unit_ps.subscribe("act_burn_rate", cur_burn.update)
+    end
+
+    -------------------
+    -- unit statuses --
+    -------------------
+
+    local stat_div = Div{parent=proc,width=38,height=19,x=57,y=6}
+
+    for i = 1, facility.num_units do
+        local unit = units[i]   ---@type ioctl_unit
+
+        local _y = ((i - 1) * 5) + 1
+
+        local unit_tag = Div{parent=stat_div,x=1,y=_y,width=8,height=4,fg_bg=cpair(colors.black,colors.lightBlue)}
+        TextBox{parent=unit_tag,x=2,y=2,text="Unit "..i.." Status",width=7,height=2}
+
+        local lights   = Div{parent=stat_div,x=9,y=_y,width=12,height=4,fg_bg=bw_fg_bg}
+        local ready    = IndicatorLight{parent=lights,x=2,y=2,label="Ready",colors=cpair(colors.green,colors.gray)}
+        local degraded = IndicatorLight{parent=lights,x=2,y=3,label="Degraded",colors=cpair(colors.red,colors.gray),flash=true,period=period.BLINK_250_MS}
+
+        unit.unit_ps.subscribe("U_AutoReady", ready.update)
+        unit.unit_ps.subscribe("U_AutoDegraded", degraded.update)
+    end
+
+    -------------------------
+    -- controls and status --
+    -------------------------
+
+    local ctl_opts = { "Monitored Max Burn", "Combined Burn Rate", "Charge Level", "Generation Rate" }
+    local mode = RadioButton{parent=proc,x=34,y=1,options=ctl_opts,callback=function()end,radio_colors=cpair(colors.purple,colors.black),radio_bg=colors.gray}
+
+    facility.ps.subscribe("process_mode", mode.set_value)
+
+    local u_stat = Rectangle{parent=proc,border=border(1,colors.gray,true),thin=true,width=31,height=4,x=1,y=16,fg_bg=bw_fg_bg}
+    local stat_line_1 = TextBox{parent=u_stat,x=1,y=1,text="UNKNOWN",width=31,height=1,alignment=TEXT_ALIGN.CENTER,fg_bg=bw_fg_bg}
+    local stat_line_2 = TextBox{parent=u_stat,x=1,y=2,text="awaiting data...",width=31,height=1,alignment=TEXT_ALIGN.CENTER,fg_bg=cpair(colors.gray, colors.white)}
+
+    facility.ps.subscribe("status_line_1", stat_line_1.set_value)
+    facility.ps.subscribe("status_line_2", stat_line_2.set_value)
+
+    local auto_controls = Div{parent=proc,x=1,y=20,width=31,height=5,fg_bg=cpair(colors.gray,colors.white)}
+
+    -- save the automatic process control configuration without starting
+    local function _save_cfg()
+        local limits = {}
+        for i = 1, #rate_limits do limits[i] = rate_limits[i].get_value() end
+
+        process.save(mode.get_value(), b_target.get_value(), c_target.get_value(), g_target.get_value(), limits)
+    end
+
+    -- start automatic control after saving process control settings
+    local function _start_auto()
+        _save_cfg()
+        process.start_auto()
+    end
+
+    local save  = HazardButton{parent=auto_controls,x=2,y=2,text="SAVE",accent=colors.purple,dis_colors=dis_colors,callback=_save_cfg,fg_bg=hzd_fg_bg}
+    local start = HazardButton{parent=auto_controls,x=13,y=2,text="START",accent=colors.lightBlue,dis_colors=dis_colors,callback=_start_auto,fg_bg=hzd_fg_bg}
+    local stop  = HazardButton{parent=auto_controls,x=23,y=2,text="STOP",accent=colors.red,dis_colors=dis_colors,callback=process.stop_auto,fg_bg=hzd_fg_bg}
+
+    facility.start_ack = start.on_response
+    facility.stop_ack = stop.on_response
+
+    function facility.save_cfg_ack(ack)
+        tcd.dispatch(0.2, function () save.on_response(ack) end)
+    end
+
+    facility.ps.subscribe("auto_ready", function (ready)
+        if ready and (not facility.auto_active) then start.enable() else start.disable() end
+    end)
+
+    facility.ps.subscribe("auto_active", function (active)
+        if active then
+            b_target.disable()
+            c_target.disable()
+            g_target.disable()
+
+            mode.disable()
+            start.disable()
+
+            for i = 1, #rate_limits do
+                rate_limits[i].disable()
+            end
+        else
+            b_target.enable()
+            c_target.enable()
+            g_target.enable()
+
+            mode.enable()
+            if facility.auto_ready then start.enable() end
+
+            for i = 1, #rate_limits do
+                rate_limits[i].enable()
+            end
+        end
+    end)
+end
+
+return new_view

coordinator/ui/components/reactor.lua

@@ -0,0 +1,73 @@
+local types          = require("scada-common.types")
+
+local style          = require("coordinator.ui.style")
+
+local core           = require("graphics.core")
+
+local Rectangle      = require("graphics.elements.rectangle")
+local TextBox        = require("graphics.elements.textbox")
+
+local DataIndicator  = require("graphics.elements.indicators.data")
+local HorizontalBar  = require("graphics.elements.indicators.hbar")
+local StateIndicator = require("graphics.elements.indicators.state")
+
+local cpair = core.graphics.cpair
+local border = core.graphics.border
+
+-- create new reactor view
+---@param root graphics_element parent
+---@param x integer top left x
+---@param y integer top left y
+---@param data reactor_db reactor data
+---@param ps psil ps interface
+local function new_view(root, x, y, data, ps)
+    local reactor = Rectangle{parent=root,border=border(1, colors.gray, true),width=30,height=7,x=x,y=y}
+
+    local text_fg_bg = cpair(colors.black, colors.lightGray)
+    local lu_col = cpair(colors.gray, colors.gray)
+
+    local status    = StateIndicator{parent=reactor,x=6,y=1,states=style.reactor.states,value=1,min_width=16}
+    local core_temp = DataIndicator{parent=reactor,x=2,y=3,lu_colors=lu_col,label="Core Temp:",unit="K",format="%10.2f",value=0,width=26,fg_bg=text_fg_bg}
+    local burn_r    = DataIndicator{parent=reactor,x=2,y=4,lu_colors=lu_col,label="Burn Rate:",unit="mB/t",format="%10.2f",value=0,width=26,fg_bg=text_fg_bg}
+    local heating_r = DataIndicator{parent=reactor,x=2,y=5,lu_colors=lu_col,label="Heating:",unit="mB/t",format="%12.0f",value=0,commas=true,width=26,fg_bg=text_fg_bg}
+
+    ps.subscribe("computed_status", status.update)
+    ps.subscribe("temp", core_temp.update)
+    ps.subscribe("act_burn_rate", burn_r.update)
+    ps.subscribe("heating_rate", heating_r.update)
+
+    local reactor_fills = Rectangle{parent=root,border=border(1, colors.gray, true),width=24,height=7,x=(x + 29),y=y}
+
+    TextBox{parent=reactor_fills,text="FUEL",x=2,y=1,height=1,fg_bg=text_fg_bg}
+    TextBox{parent=reactor_fills,text="COOL",x=2,y=2,height=1,fg_bg=text_fg_bg}
+    TextBox{parent=reactor_fills,text="HCOOL",x=2,y=4,height=1,fg_bg=text_fg_bg}
+    TextBox{parent=reactor_fills,text="WASTE",x=2,y=5,height=1,fg_bg=text_fg_bg}
+
+    local fuel  = HorizontalBar{parent=reactor_fills,x=8,y=1,show_percent=true,bar_fg_bg=cpair(colors.black,colors.gray),height=1,width=14}
+    local ccool = HorizontalBar{parent=reactor_fills,x=8,y=2,show_percent=true,bar_fg_bg=cpair(colors.blue,colors.gray),height=1,width=14}
+    local hcool = HorizontalBar{parent=reactor_fills,x=8,y=4,show_percent=true,bar_fg_bg=cpair(colors.white,colors.gray),height=1,width=14}
+    local waste = HorizontalBar{parent=reactor_fills,x=8,y=5,show_percent=true,bar_fg_bg=cpair(colors.brown,colors.gray),height=1,width=14}
+
+    ps.subscribe("ccool_type", function (type)
+        if type == types.FLUID.SODIUM then
+            ccool.recolor(cpair(colors.lightBlue, colors.gray))
+        else
+            ccool.recolor(cpair(colors.blue, colors.gray))
+        end
+    end)
+
+    ps.subscribe("hcool_type", function (type)
+        if type == types.FLUID.SUPERHEATED_SODIUM then
+            hcool.recolor(cpair(colors.orange, colors.gray))
+        else
+            hcool.recolor(cpair(colors.white, colors.gray))
+        end
+    end)
+
+    ps.subscribe("fuel_fill", fuel.update)
+    ps.subscribe("ccool_fill", ccool.update)
+    ps.subscribe("hcool_fill", hcool.update)
+    ps.subscribe("waste_fill", waste.update)
+end
+
+return new_view

coordinator/ui/components/turbine.lua

@@ -0,0 +1,47 @@
+local util           = require("scada-common.util")
+
+local style          = require("coordinator.ui.style")
+
+local core           = require("graphics.core")
+
+local Rectangle      = require("graphics.elements.rectangle")
+local TextBox        = require("graphics.elements.textbox")
+
+local DataIndicator  = require("graphics.elements.indicators.data")
+local PowerIndicator = require("graphics.elements.indicators.power")
+local StateIndicator = require("graphics.elements.indicators.state")
+local VerticalBar    = require("graphics.elements.indicators.vbar")
+
+local cpair = core.graphics.cpair
+local border = core.graphics.border
+
+-- new turbine view
+---@param root graphics_element parent
+---@param x integer top left x
+---@param y integer top left y
+---@param ps psil ps interface
+local function new_view(root, x, y, ps)
+    local turbine = Rectangle{parent=root,border=border(1, colors.gray, true),width=23,height=7,x=x,y=y}
+
+    local text_fg_bg = cpair(colors.black, colors.lightGray)
+    local lu_col = cpair(colors.gray, colors.gray)
+
+    local status    = StateIndicator{parent=turbine,x=7,y=1,states=style.turbine.states,value=1,min_width=12}
+    local prod_rate = PowerIndicator{parent=turbine,x=5,y=3,lu_colors=lu_col,label="",format="%10.2f",value=0,rate=true,width=16,fg_bg=text_fg_bg}
+    local flow_rate = DataIndicator{parent=turbine,x=5,y=4,lu_colors=lu_col,label="",unit="mB/t",format="%10.0f",value=0,commas=true,width=16,fg_bg=text_fg_bg}
+
+    ps.subscribe("computed_status", status.update)
+    ps.subscribe("prod_rate", function (val) prod_rate.update(util.joules_to_fe(val)) end)
+    ps.subscribe("flow_rate", flow_rate.update)
+
+    local steam  = VerticalBar{parent=turbine,x=2,y=1,fg_bg=cpair(colors.white,colors.gray),height=4,width=1}
+    local energy = VerticalBar{parent=turbine,x=3,y=1,fg_bg=cpair(colors.green,colors.gray),height=4,width=1}
+
+    TextBox{parent=turbine,text="S",x=2,y=5,height=1,width=1,fg_bg=text_fg_bg}
+    TextBox{parent=turbine,text="E",x=3,y=5,height=1,width=1,fg_bg=text_fg_bg}
+
+    ps.subscribe("steam_fill", steam.update)
+    ps.subscribe("energy_fill", energy.update)
+end
+
+return new_view

coordinator/ui/components/unit_detail.lua

@@ -0,0 +1,520 @@
+--
+-- Reactor Unit SCADA Coordinator GUI
+--
+
+local iocontrol         = require("coordinator.iocontrol")
+
+local style             = require("coordinator.ui.style")
+
+local core              = require("graphics.core")
+
+local Div               = require("graphics.elements.div")
+local Rectangle         = require("graphics.elements.rectangle")
+local TextBox           = require("graphics.elements.textbox")
+
+local AlarmLight        = require("graphics.elements.indicators.alight")
+local CoreMap           = require("graphics.elements.indicators.coremap")
+local DataIndicator     = require("graphics.elements.indicators.data")
+local IndicatorLight    = require("graphics.elements.indicators.light")
+local RadIndicator      = require("graphics.elements.indicators.rad")
+local TriIndicatorLight = require("graphics.elements.indicators.trilight")
+local VerticalBar       = require("graphics.elements.indicators.vbar")
+
+local HazardButton      = require("graphics.elements.controls.hazard_button")
+local MultiButton       = require("graphics.elements.controls.multi_button")
+local PushButton        = require("graphics.elements.controls.push_button")
+local RadioButton       = require("graphics.elements.controls.radio_button")
+local SpinboxNumeric    = require("graphics.elements.controls.spinbox_numeric")
+
+local TEXT_ALIGN = core.graphics.TEXT_ALIGN
+
+local cpair = core.graphics.cpair
+local border = core.graphics.border
+
+local period = core.flasher.PERIOD
+
+local waste_opts = {
+    {
+        text = "Auto",
+        fg_bg = cpair(colors.black, colors.lightGray),
+        active_fg_bg = cpair(colors.white, colors.gray)
+    },
+    {
+        text = "Pu",
+        fg_bg = cpair(colors.black, colors.lightGray),
+        active_fg_bg = cpair(colors.black, colors.green)
+    },
+    {
+        text = "Po",
+        fg_bg = cpair(colors.black, colors.lightGray),
+        active_fg_bg = cpair(colors.black, colors.cyan)
+    },
+    {
+        text = "AM",
+        fg_bg = cpair(colors.black, colors.lightGray),
+        active_fg_bg = cpair(colors.black, colors.purple)
+    }
+}
+
+-- create a unit view
+---@param parent graphics_element parent
+---@param id integer
+local function init(parent, id)
+    local unit = iocontrol.get_db().units[id]   ---@type ioctl_unit
+    local f_ps = iocontrol.get_db().facility.ps
+    local u_ps = unit.unit_ps
+    local b_ps = unit.boiler_ps_tbl
+    local t_ps = unit.turbine_ps_tbl
+
+    local main = Div{parent=parent,x=1,y=1}
+
+    TextBox{parent=main,text="Reactor Unit #" .. id,alignment=TEXT_ALIGN.CENTER,height=1,fg_bg=style.header}
+
+    local bw_fg_bg  = cpair(colors.black, colors.white)
+    local hzd_fg_bg = cpair(colors.white, colors.gray)
+    local lu_cpair  = cpair(colors.gray, colors.gray)
+
+    -----------------------------
+    -- main stats and core map --
+    -----------------------------
+
+    local core_map = CoreMap{parent=main,x=2,y=3,reactor_l=18,reactor_w=18}
+    u_ps.subscribe("temp", core_map.update)
+    u_ps.subscribe("size", function (s) core_map.resize(s[1], s[2]) end)
+
+    TextBox{parent=main,x=12,y=22,text="Heating Rate",height=1,width=12,fg_bg=style.label}
+    local heating_r = DataIndicator{parent=main,x=12,label="",format="%14.0f",value=0,unit="mB/t",commas=true,lu_colors=lu_cpair,width=19,fg_bg=bw_fg_bg}
+    u_ps.subscribe("heating_rate", heating_r.update)
+
+    TextBox{parent=main,x=12,y=25,text="Commanded Burn Rate",height=1,width=19,fg_bg=style.label}
+    local burn_r = DataIndicator{parent=main,x=12,label="",format="%14.2f",value=0,unit="mB/t",lu_colors=lu_cpair,width=19,fg_bg=bw_fg_bg}
+    u_ps.subscribe("burn_rate", burn_r.update)
+
+    TextBox{parent=main,text="F",x=2,y=22,width=1,height=1,fg_bg=style.label}
+    TextBox{parent=main,text="C",x=4,y=22,width=1,height=1,fg_bg=style.label}
+    TextBox{parent=main,text="\x1a",x=6,y=24,width=1,height=1,fg_bg=style.label}
+    TextBox{parent=main,text="\x1a",x=6,y=25,width=1,height=1,fg_bg=style.label}
+    TextBox{parent=main,text="H",x=8,y=22,width=1,height=1,fg_bg=style.label}
+    TextBox{parent=main,text="W",x=10,y=22,width=1,height=1,fg_bg=style.label}
+
+    local fuel  = VerticalBar{parent=main,x=2,y=23,fg_bg=cpair(colors.black,colors.gray),height=4,width=1}
+    local ccool = VerticalBar{parent=main,x=4,y=23,fg_bg=cpair(colors.blue,colors.gray),height=4,width=1}
+    local hcool = VerticalBar{parent=main,x=8,y=23,fg_bg=cpair(colors.white,colors.gray),height=4,width=1}
+    local waste = VerticalBar{parent=main,x=10,y=23,fg_bg=cpair(colors.brown,colors.gray),height=4,width=1}
+
+    u_ps.subscribe("fuel_fill", fuel.update)
+    u_ps.subscribe("ccool_fill", ccool.update)
+    u_ps.subscribe("hcool_fill", hcool.update)
+    u_ps.subscribe("waste_fill", waste.update)
+
+    u_ps.subscribe("ccool_type", function (type)
+        if type == "mekanism:sodium" then
+            ccool.recolor(cpair(colors.lightBlue, colors.gray))
+        else
+            ccool.recolor(cpair(colors.blue, colors.gray))
+        end
+    end)
+
+    u_ps.subscribe("hcool_type", function (type)
+        if type == "mekanism:superheated_sodium" then
+            hcool.recolor(cpair(colors.orange, colors.gray))
+        else
+            hcool.recolor(cpair(colors.white, colors.gray))
+        end
+    end)
+
+    TextBox{parent=main,x=32,y=22,text="Core Temp",height=1,width=9,fg_bg=style.label}
+    local core_temp = DataIndicator{parent=main,x=32,label="",format="%11.2f",value=0,unit="K",lu_colors=lu_cpair,width=13,fg_bg=bw_fg_bg}
+    u_ps.subscribe("temp", core_temp.update)
+
+    TextBox{parent=main,x=32,y=25,text="Burn Rate",height=1,width=9,fg_bg=style.label}
+    local act_burn_r = DataIndicator{parent=main,x=32,label="",format="%8.2f",value=0,unit="mB/t",lu_colors=lu_cpair,width=13,fg_bg=bw_fg_bg}
+    u_ps.subscribe("act_burn_rate", act_burn_r.update)
+
+    TextBox{parent=main,x=32,y=28,text="Damage",height=1,width=6,fg_bg=style.label}
+    local damage_p = DataIndicator{parent=main,x=32,label="",format="%11.0f",value=0,unit="%",lu_colors=lu_cpair,width=13,fg_bg=bw_fg_bg}
+    u_ps.subscribe("damage", damage_p.update)
+
+    TextBox{parent=main,x=32,y=31,text="Radiation",height=1,width=21,fg_bg=style.label}
+    local radiation = RadIndicator{parent=main,x=32,label="",format="%9.3f",lu_colors=lu_cpair,width=13,fg_bg=bw_fg_bg}
+    u_ps.subscribe("radiation", radiation.update)
+
+    -------------------
+    -- system status --
+    -------------------
+
+    local u_stat = Rectangle{parent=main,border=border(1,colors.gray,true),thin=true,width=33,height=4,x=46,y=3,fg_bg=bw_fg_bg}
+    local stat_line_1 = TextBox{parent=u_stat,x=1,y=1,text="UNKNOWN",width=33,height=1,alignment=TEXT_ALIGN.CENTER,fg_bg=bw_fg_bg}
+    local stat_line_2 = TextBox{parent=u_stat,x=1,y=2,text="awaiting data...",width=33,height=1,alignment=TEXT_ALIGN.CENTER,fg_bg=cpair(colors.gray, colors.white)}
+
+    u_ps.subscribe("U_StatusLine1", stat_line_1.set_value)
+    u_ps.subscribe("U_StatusLine2", stat_line_2.set_value)
+
+    -----------------
+    -- annunciator --
+    -----------------
+
+    -- annunciator colors (generally) per IAEA-TECDOC-812 recommendations
+
+    local annunciator = Div{parent=main,width=23,height=18,x=22,y=3}
+
+    -- connectivity
+    local plc_online = IndicatorLight{parent=annunciator,label="PLC Online",colors=cpair(colors.green,colors.red)}
+    local plc_hbeat  = IndicatorLight{parent=annunciator,label="PLC Heartbeat",colors=cpair(colors.white,colors.gray)}
+    local rad_mon    = TriIndicatorLight{parent=annunciator,label="Radiation Monitor",c1=colors.gray,c2=colors.yellow,c3=colors.green}
+
+    u_ps.subscribe("PLCOnline", plc_online.update)
+    u_ps.subscribe("PLCHeartbeat", plc_hbeat.update)
+    u_ps.subscribe("RadiationMonitor", rad_mon.update)
+
+    annunciator.line_break()
+
+    -- operating state
+    local r_active = IndicatorLight{parent=annunciator,label="Active",colors=cpair(colors.green,colors.gray)}
+    local r_auto   = IndicatorLight{parent=annunciator,label="Automatic Control",colors=cpair(colors.white,colors.gray)}
+
+    u_ps.subscribe("status", r_active.update)
+    u_ps.subscribe("AutoControl", r_auto.update)
+
+    -- main unit transient/warning annunciator panel
+    local r_scram = IndicatorLight{parent=annunciator,label="Reactor SCRAM",colors=cpair(colors.red,colors.gray)}
+    local r_mscrm = IndicatorLight{parent=annunciator,label="Manual Reactor SCRAM",colors=cpair(colors.red,colors.gray)}
+    local r_ascrm = IndicatorLight{parent=annunciator,label="Auto Reactor SCRAM",colors=cpair(colors.red,colors.gray)}
+    local rad_wrn = IndicatorLight{parent=annunciator,label="Radiation Warning",colors=cpair(colors.yellow,colors.gray)}
+    local r_rtrip = IndicatorLight{parent=annunciator,label="RCP Trip",colors=cpair(colors.red,colors.gray)}
+    local r_cflow = IndicatorLight{parent=annunciator,label="RCS Flow Low",colors=cpair(colors.yellow,colors.gray)}
+    local r_clow  = IndicatorLight{parent=annunciator,label="Coolant  Level Low",colors=cpair(colors.yellow,colors.gray)}
+    local r_temp  = IndicatorLight{parent=annunciator,label="Reactor Temp. High",colors=cpair(colors.red,colors.gray)}
+    local r_rhdt  = IndicatorLight{parent=annunciator,label="Reactor High Delta T",colors=cpair(colors.yellow,colors.gray)}
+    local r_firl  = IndicatorLight{parent=annunciator,label="Fuel Input Rate Low",colors=cpair(colors.yellow,colors.gray)}
+    local r_wloc  = IndicatorLight{parent=annunciator,label="Waste Line Occlusion",colors=cpair(colors.yellow,colors.gray)}
+    local r_hsrt  = IndicatorLight{parent=annunciator,label="Startup Rate High",colors=cpair(colors.yellow,colors.gray)}
+
+    u_ps.subscribe("ReactorSCRAM", r_scram.update)
+    u_ps.subscribe("ManualReactorSCRAM", r_mscrm.update)
+    u_ps.subscribe("AutoReactorSCRAM", r_ascrm.update)
+    u_ps.subscribe("RadiationWarning", rad_wrn.update)
+    u_ps.subscribe("RCPTrip", r_rtrip.update)
+    u_ps.subscribe("RCSFlowLow", r_cflow.update)
+    u_ps.subscribe("CoolantLevelLow", r_clow.update)
+    u_ps.subscribe("ReactorTempHigh", r_temp.update)
+    u_ps.subscribe("ReactorHighDeltaT", r_rhdt.update)
+    u_ps.subscribe("FuelInputRateLow", r_firl.update)
+    u_ps.subscribe("WasteLineOcclusion", r_wloc.update)
+    u_ps.subscribe("HighStartupRate", r_hsrt.update)
+
+    -- RPS annunciator panel
+
+    TextBox{parent=main,text="REACTOR PROTECTION SYSTEM",fg_bg=cpair(colors.black,colors.cyan),alignment=TEXT_ALIGN.CENTER,width=33,height=1,x=46,y=8}
+    local rps = Rectangle{parent=main,border=border(1,colors.cyan,true),thin=true,width=33,height=12,x=46,y=9}
+    local rps_annunc = Div{parent=rps,width=31,height=10,x=2,y=1}
+
+    local rps_trp = IndicatorLight{parent=rps_annunc,label="RPS Trip",colors=cpair(colors.red,colors.gray),flash=true,period=period.BLINK_250_MS}
+    local rps_dmg = IndicatorLight{parent=rps_annunc,label="Damage Level High",colors=cpair(colors.red,colors.gray),flash=true,period=period.BLINK_250_MS}
+    local rps_exh = IndicatorLight{parent=rps_annunc,label="Excess Heated Coolant",colors=cpair(colors.yellow,colors.gray)}
+    local rps_exw = IndicatorLight{parent=rps_annunc,label="Excess Waste",colors=cpair(colors.yellow,colors.gray)}
+    local rps_tmp = IndicatorLight{parent=rps_annunc,label="Core Temperature High",colors=cpair(colors.red,colors.gray),flash=true,period=period.BLINK_250_MS}
+    local rps_nof = IndicatorLight{parent=rps_annunc,label="No Fuel",colors=cpair(colors.yellow,colors.gray)}
+    local rps_loc = IndicatorLight{parent=rps_annunc,label="Coolant Level Low Low",colors=cpair(colors.yellow,colors.gray)}
+    local rps_flt = IndicatorLight{parent=rps_annunc,label="PPM Fault",colors=cpair(colors.yellow,colors.gray),flash=true,period=period.BLINK_500_MS}
+    local rps_tmo = IndicatorLight{parent=rps_annunc,label="Connection Timeout",colors=cpair(colors.yellow,colors.gray),flash=true,period=period.BLINK_500_MS}
+    local rps_sfl = IndicatorLight{parent=rps_annunc,label="System Failure",colors=cpair(colors.orange,colors.gray),flash=true,period=period.BLINK_500_MS}
+
+    u_ps.subscribe("rps_tripped", rps_trp.update)
+    u_ps.subscribe("high_dmg", rps_dmg.update)
+    u_ps.subscribe("ex_hcool", rps_exh.update)
+    u_ps.subscribe("ex_waste", rps_exw.update)
+    u_ps.subscribe("high_temp", rps_tmp.update)
+    u_ps.subscribe("no_fuel", rps_nof.update)
+    u_ps.subscribe("low_cool", rps_loc.update)
+    u_ps.subscribe("fault", rps_flt.update)
+    u_ps.subscribe("timeout", rps_tmo.update)
+    u_ps.subscribe("sys_fail", rps_sfl.update)
+
+    -- cooling annunciator panel
+
+    TextBox{parent=main,text="REACTOR COOLANT SYSTEM",fg_bg=cpair(colors.black,colors.blue),alignment=TEXT_ALIGN.CENTER,width=33,height=1,x=46,y=22}
+    local rcs = Rectangle{parent=main,border=border(1,colors.blue,true),thin=true,width=33,height=24,x=46,y=23}
+    local rcs_annunc = Div{parent=rcs,width=27,height=23,x=2,y=1}
+    local rcs_tags = Div{parent=rcs,width=2,height=14,x=29,y=9}
+
+    local c_flt  = IndicatorLight{parent=rcs_annunc,label="RCS Hardware Fault",colors=cpair(colors.yellow,colors.gray)}
+    local c_emg  = TriIndicatorLight{parent=rcs_annunc,label="Emergency Coolant",c1=colors.gray,c2=colors.white,c3=colors.green}
+    local c_cfm  = IndicatorLight{parent=rcs_annunc,label="Coolant Feed Mismatch",colors=cpair(colors.yellow,colors.gray)}
+    local c_brm  = IndicatorLight{parent=rcs_annunc,label="Boil Rate Mismatch",colors=cpair(colors.yellow,colors.gray)}
+    local c_sfm  = IndicatorLight{parent=rcs_annunc,label="Steam Feed Mismatch",colors=cpair(colors.yellow,colors.gray)}
+    local c_mwrf = IndicatorLight{parent=rcs_annunc,label="Max Water Return Feed",colors=cpair(colors.yellow,colors.gray)}
+    local c_tbnt = IndicatorLight{parent=rcs_annunc,label="Turbine Trip",colors=cpair(colors.red,colors.gray),flash=true,period=period.BLINK_250_MS}
+
+    u_ps.subscribe("RCSFault", c_flt.update)
+    u_ps.subscribe("EmergencyCoolant", c_emg.update)
+    u_ps.subscribe("CoolantFeedMismatch", c_cfm.update)
+    u_ps.subscribe("BoilRateMismatch", c_brm.update)
+    u_ps.subscribe("SteamFeedMismatch", c_sfm.update)
+    u_ps.subscribe("MaxWaterReturnFeed", c_mwrf.update)
+    u_ps.subscribe("TurbineTrip", c_tbnt.update)
+
+    rcs_annunc.line_break()
+
+    -- boiler annunciator panel(s)
+
+    if unit.num_boilers > 0 then
+        TextBox{parent=rcs_tags,x=1,text="B1",width=2,height=1,fg_bg=bw_fg_bg}
+        local b1_wll = IndicatorLight{parent=rcs_annunc,label="Water Level Low",colors=cpair(colors.red,colors.gray)}
+        b_ps[1].subscribe("WasterLevelLow", b1_wll.update)
+
+        TextBox{parent=rcs_tags,text="B1",width=2,height=1,fg_bg=bw_fg_bg}
+        local b1_hr = IndicatorLight{parent=rcs_annunc,label="Heating Rate Low",colors=cpair(colors.yellow,colors.gray)}
+        b_ps[1].subscribe("HeatingRateLow", b1_hr.update)
+    end
+    if unit.num_boilers > 1 then
+        TextBox{parent=rcs_tags,text="B2",width=2,height=1,fg_bg=bw_fg_bg}
+        local b2_wll = IndicatorLight{parent=rcs_annunc,label="Water Level Low",colors=cpair(colors.red,colors.gray)}
+        b_ps[2].subscribe("WasterLevelLow", b2_wll.update)
+
+        TextBox{parent=rcs_tags,text="B2",width=2,height=1,fg_bg=bw_fg_bg}
+        local b2_hr = IndicatorLight{parent=rcs_annunc,label="Heating Rate Low",colors=cpair(colors.yellow,colors.gray)}
+        b_ps[2].subscribe("HeatingRateLow", b2_hr.update)
+    end
+
+    -- turbine annunciator panels
+
+    if unit.num_boilers == 0 then
+        TextBox{parent=rcs_tags,text="T1",width=2,height=1,fg_bg=bw_fg_bg}
+    else
+        rcs_tags.line_break()
+        rcs_annunc.line_break()
+        TextBox{parent=rcs_tags,text="T1",width=2,height=1,fg_bg=bw_fg_bg}
+    end
+
+    local t1_sdo = TriIndicatorLight{parent=rcs_annunc,label="Steam Relief Valve Open",c1=colors.gray,c2=colors.yellow,c3=colors.red}
+    t_ps[1].subscribe("SteamDumpOpen", t1_sdo.update)
+
+    TextBox{parent=rcs_tags,text="T1",width=2,height=1,fg_bg=bw_fg_bg}
+    local t1_tos = IndicatorLight{parent=rcs_annunc,label="Turbine Over Speed",colors=cpair(colors.red,colors.gray)}
+    t_ps[1].subscribe("TurbineOverSpeed", t1_tos.update)
+
+    TextBox{parent=rcs_tags,text="T1",width=2,height=1,fg_bg=bw_fg_bg}
+    local t1_trp = IndicatorLight{parent=rcs_annunc,label="Turbine Trip",colors=cpair(colors.red,colors.gray),flash=true,period=period.BLINK_250_MS}
+    t_ps[1].subscribe("TurbineTrip", t1_trp.update)
+
+    if unit.num_turbines > 1 then
+        TextBox{parent=rcs_tags,text="T2",width=2,height=1,fg_bg=bw_fg_bg}
+        local t2_sdo = TriIndicatorLight{parent=rcs_annunc,label="Steam Relief Valve Open",c1=colors.gray,c2=colors.yellow,c3=colors.red}
+        t_ps[2].subscribe("SteamDumpOpen", t2_sdo.update)
+
+        TextBox{parent=rcs_tags,text="T2",width=2,height=1,fg_bg=bw_fg_bg}
+        local t2_tos = IndicatorLight{parent=rcs_annunc,label="Turbine Over Speed",colors=cpair(colors.red,colors.gray)}
+        t_ps[2].subscribe("TurbineOverSpeed", t2_tos.update)
+
+        TextBox{parent=rcs_tags,text="T2",width=2,height=1,fg_bg=bw_fg_bg}
+        local t2_trp = IndicatorLight{parent=rcs_annunc,label="Turbine Trip",colors=cpair(colors.red,colors.gray),flash=true,period=period.BLINK_250_MS}
+        t_ps[2].subscribe("TurbineTrip", t2_trp.update)
+    end
+
+    if unit.num_turbines > 2 then
+        TextBox{parent=rcs_tags,text="T3",width=2,height=1,fg_bg=bw_fg_bg}
+        local t3_sdo = TriIndicatorLight{parent=rcs_annunc,label="Steam Relief Valve Open",c1=colors.gray,c2=colors.yellow,c3=colors.red}
+        t_ps[3].subscribe("SteamDumpOpen", t3_sdo.update)
+
+        TextBox{parent=rcs_tags,text="T3",width=2,height=1,fg_bg=bw_fg_bg}
+        local t3_tos = IndicatorLight{parent=rcs_annunc,label="Turbine Over Speed",colors=cpair(colors.red,colors.gray)}
+        t_ps[3].subscribe("TurbineOverSpeed", t3_tos.update)
+
+        TextBox{parent=rcs_tags,text="T3",width=2,height=1,fg_bg=bw_fg_bg}
+        local t3_trp = IndicatorLight{parent=rcs_annunc,label="Turbine Trip",colors=cpair(colors.red,colors.gray),flash=true,period=period.BLINK_250_MS}
+        t_ps[3].subscribe("TurbineTrip", t3_trp.update)
+    end
+
+    ----------------------
+    -- reactor controls --
+    ----------------------
+
+    local dis_colors = cpair(colors.white, colors.lightGray)
+
+    local burn_control = Div{parent=main,x=12,y=28,width=19,height=3,fg_bg=cpair(colors.gray,colors.white)}
+    local burn_rate = SpinboxNumeric{parent=burn_control,x=2,y=1,whole_num_precision=4,fractional_precision=1,min=0.1,arrow_fg_bg=cpair(colors.gray,colors.white),fg_bg=bw_fg_bg}
+    TextBox{parent=burn_control,x=9,y=2,text="mB/t"}
+
+    local set_burn = function () unit.set_burn(burn_rate.get_value()) end
+    local set_burn_btn = PushButton{parent=burn_control,x=14,y=2,text="SET",min_width=5,fg_bg=cpair(colors.black,colors.yellow),active_fg_bg=cpair(colors.white,colors.gray),dis_fg_bg=dis_colors,callback=set_burn}
+
+    u_ps.subscribe("burn_rate", burn_rate.set_value)
+    u_ps.subscribe("max_burn", burn_rate.set_max)
+
+    local start = HazardButton{parent=main,x=2,y=28,text="START",accent=colors.lightBlue,dis_colors=dis_colors,callback=unit.start,fg_bg=hzd_fg_bg}
+    local ack_a = HazardButton{parent=main,x=12,y=32,text="ACK \x13",accent=colors.orange,dis_colors=dis_colors,callback=unit.ack_alarms,fg_bg=hzd_fg_bg}
+    local scram = HazardButton{parent=main,x=2,y=32,text="SCRAM",accent=colors.yellow,dis_colors=dis_colors,callback=unit.scram,fg_bg=hzd_fg_bg}
+    local reset = HazardButton{parent=main,x=22,y=32,text="RESET",accent=colors.red,dis_colors=dis_colors,callback=unit.reset_rps,fg_bg=hzd_fg_bg}
+
+    unit.start_ack = start.on_response
+    unit.scram_ack = scram.on_response
+    unit.reset_rps_ack = reset.on_response
+    unit.ack_alarms_ack = ack_a.on_response
+
+    local function start_button_en_check()
+        if (unit.reactor_data ~= nil) and (unit.reactor_data.mek_status ~= nil) then
+            local can_start = (not unit.reactor_data.mek_status.status) and
+                                (not unit.reactor_data.rps_tripped) and
+                                (unit.a_group == 0)
+            if can_start then start.enable() else start.disable() end
+        end
+    end
+
+    u_ps.subscribe("status", start_button_en_check)
+    u_ps.subscribe("rps_tripped", start_button_en_check)
+    u_ps.subscribe("rps_tripped", function (active) if active then reset.enable() else reset.disable() end end)
+
+    TextBox{parent=main,text="WASTE PROCESSING",fg_bg=cpair(colors.black,colors.brown),alignment=TEXT_ALIGN.CENTER,width=33,height=1,x=46,y=48}
+    local waste_proc = Rectangle{parent=main,border=border(1,colors.brown,true),thin=true,width=33,height=3,x=46,y=49}
+    local waste_div = Div{parent=waste_proc,x=2,y=1,width=31,height=1}
+
+    local waste_mode = MultiButton{parent=waste_div,x=1,y=1,options=waste_opts,callback=unit.set_waste,min_width=6}
+
+    u_ps.subscribe("U_WasteMode", waste_mode.set_value)
+
+    ----------------------
+    -- alarm management --
+    ----------------------
+
+    local alarm_panel = Div{parent=main,x=2,y=36,width=29,height=16,fg_bg=bw_fg_bg}
+
+    local a_brc = AlarmLight{parent=alarm_panel,x=6,y=2,label="Containment Breach",c1=colors.gray,c2=colors.red,c3=colors.green,flash=true,period=period.BLINK_250_MS}
+    local a_rad = AlarmLight{parent=alarm_panel,x=6,label="Containment Radiation",c1=colors.gray,c2=colors.red,c3=colors.green,flash=true,period=period.BLINK_250_MS}
+    local a_dmg = AlarmLight{parent=alarm_panel,x=6,label="Critical Damage",c1=colors.gray,c2=colors.red,c3=colors.green,flash=true,period=period.BLINK_250_MS}
+    alarm_panel.line_break()
+    local a_rcl = AlarmLight{parent=alarm_panel,x=6,label="Reactor Lost",c1=colors.gray,c2=colors.red,c3=colors.green,flash=true,period=period.BLINK_250_MS}
+    local a_rcd = AlarmLight{parent=alarm_panel,x=6,label="Reactor Damage",c1=colors.gray,c2=colors.red,c3=colors.green,flash=true,period=period.BLINK_250_MS}
+    local a_rot = AlarmLight{parent=alarm_panel,x=6,label="Reactor Over Temp",c1=colors.gray,c2=colors.red,c3=colors.green,flash=true,period=period.BLINK_250_MS}
+    local a_rht = AlarmLight{parent=alarm_panel,x=6,label="Reactor High Temp",c1=colors.gray,c2=colors.yellow,c3=colors.green,flash=true,period=period.BLINK_500_MS}
+    local a_rwl = AlarmLight{parent=alarm_panel,x=6,label="Reactor Waste Leak",c1=colors.gray,c2=colors.red,c3=colors.green,flash=true,period=period.BLINK_250_MS}
+    local a_rwh = AlarmLight{parent=alarm_panel,x=6,label="Reactor Waste High",c1=colors.gray,c2=colors.yellow,c3=colors.green,flash=true,period=period.BLINK_500_MS}
+    alarm_panel.line_break()
+    local a_rps = AlarmLight{parent=alarm_panel,x=6,label="RPS Transient",c1=colors.gray,c2=colors.yellow,c3=colors.green,flash=true,period=period.BLINK_500_MS}
+    local a_clt = AlarmLight{parent=alarm_panel,x=6,label="RCS Transient",c1=colors.gray,c2=colors.yellow,c3=colors.green,flash=true,period=period.BLINK_500_MS}
+    local a_tbt = AlarmLight{parent=alarm_panel,x=6,label="Turbine Trip",c1=colors.gray,c2=colors.red,c3=colors.green,flash=true,period=period.BLINK_250_MS}
+
+    u_ps.subscribe("Alarm_1", a_brc.update)
+    u_ps.subscribe("Alarm_2", a_rad.update)
+    u_ps.subscribe("Alarm_4", a_dmg.update)
+
+    u_ps.subscribe("Alarm_3", a_rcl.update)
+    u_ps.subscribe("Alarm_5", a_rcd.update)
+    u_ps.subscribe("Alarm_6", a_rot.update)
+    u_ps.subscribe("Alarm_7", a_rht.update)
+    u_ps.subscribe("Alarm_8", a_rwl.update)
+    u_ps.subscribe("Alarm_9", a_rwh.update)
+
+    u_ps.subscribe("Alarm_10", a_rps.update)
+    u_ps.subscribe("Alarm_11", a_clt.update)
+    u_ps.subscribe("Alarm_12", a_tbt.update)
+
+    -- ack's and resets
+
+    local c = unit.alarm_callbacks
+    local ack_fg_bg = cpair(colors.black, colors.orange)
+    local rst_fg_bg = cpair(colors.black, colors.lime)
+    local active_fg_bg = cpair(colors.white, colors.gray)
+
+    PushButton{parent=alarm_panel,x=2,y=2,text="\x13",callback=c.c_breach.ack,fg_bg=ack_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=4,y=2,text="R",callback=c.c_breach.reset,fg_bg=rst_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=2,y=3,text="\x13",callback=c.radiation.ack,fg_bg=ack_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=4,y=3,text="R",callback=c.radiation.reset,fg_bg=rst_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=2,y=4,text="\x13",callback=c.dmg_crit.ack,fg_bg=ack_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=4,y=4,text="R",callback=c.dmg_crit.reset,fg_bg=rst_fg_bg,active_fg_bg=active_fg_bg}
+
+    PushButton{parent=alarm_panel,x=2,y=6,text="\x13",callback=c.r_lost.ack,fg_bg=ack_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=4,y=6,text="R",callback=c.r_lost.reset,fg_bg=rst_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=2,y=7,text="\x13",callback=c.damage.ack,fg_bg=ack_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=4,y=7,text="R",callback=c.damage.reset,fg_bg=rst_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=2,y=8,text="\x13",callback=c.over_temp.ack,fg_bg=ack_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=4,y=8,text="R",callback=c.over_temp.reset,fg_bg=rst_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=2,y=9,text="\x13",callback=c.high_temp.ack,fg_bg=ack_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=4,y=9,text="R",callback=c.high_temp.reset,fg_bg=rst_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=2,y=10,text="\x13",callback=c.waste_leak.ack,fg_bg=ack_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=4,y=10,text="R",callback=c.waste_leak.reset,fg_bg=rst_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=2,y=11,text="\x13",callback=c.waste_high.ack,fg_bg=ack_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=4,y=11,text="R",callback=c.waste_high.reset,fg_bg=rst_fg_bg,active_fg_bg=active_fg_bg}
+
+    PushButton{parent=alarm_panel,x=2,y=13,text="\x13",callback=c.rps_trans.ack,fg_bg=ack_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=4,y=13,text="R",callback=c.rps_trans.reset,fg_bg=rst_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=2,y=14,text="\x13",callback=c.rcs_trans.ack,fg_bg=ack_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=4,y=14,text="R",callback=c.rcs_trans.reset,fg_bg=rst_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=2,y=15,text="\x13",callback=c.t_trip.ack,fg_bg=ack_fg_bg,active_fg_bg=active_fg_bg}
+    PushButton{parent=alarm_panel,x=4,y=15,text="R",callback=c.t_trip.reset,fg_bg=rst_fg_bg,active_fg_bg=active_fg_bg}
+
+    -- color tags
+
+    TextBox{parent=alarm_panel,x=5,y=13,text="\x95",width=1,height=1,fg_bg=cpair(colors.white,colors.cyan)}
+    TextBox{parent=alarm_panel,x=5,text="\x95",width=1,height=1,fg_bg=cpair(colors.white,colors.blue)}
+    TextBox{parent=alarm_panel,x=5,text="\x95",width=1,height=1,fg_bg=cpair(colors.white,colors.blue)}
+
+    --------------------------------
+    -- automatic control settings --
+    --------------------------------
+
+    TextBox{parent=main,text="AUTO CTRL",fg_bg=cpair(colors.black,colors.purple),alignment=TEXT_ALIGN.CENTER,width=13,height=1,x=32,y=36}
+    local auto_ctl = Rectangle{parent=main,border=border(1,colors.purple,true),thin=true,width=13,height=15,x=32,y=37}
+    local auto_div = Div{parent=auto_ctl,width=13,height=15,x=1,y=1}
+
+    local ctl_opts = { "Manual", "Primary", "Secondary", "Tertiary", "Backup" }
+
+    local group = RadioButton{parent=auto_div,options=ctl_opts,callback=function()end,radio_colors=cpair(colors.blue,colors.white),radio_bg=colors.gray}
+
+    u_ps.subscribe("auto_group_id", function (gid) group.set_value(gid + 1) end)
+
+    auto_div.line_break()
+
+    local function set_group() unit.set_group(group.get_value() - 1) end
+    local set_grp_btn = PushButton{parent=auto_div,text="SET",x=4,min_width=5,fg_bg=cpair(colors.black,colors.yellow),active_fg_bg=cpair(colors.white,colors.gray),dis_fg_bg=cpair(colors.gray,colors.white),callback=set_group}
+
+    auto_div.line_break()
+
+    TextBox{parent=auto_div,text="Prio. Group",height=1,width=11,fg_bg=style.label}
+    local auto_grp = TextBox{parent=auto_div,text="Manual",height=1,width=11,fg_bg=bw_fg_bg}
+
+    u_ps.subscribe("auto_group", auto_grp.set_value)
+
+    auto_div.line_break()
+
+    local a_rdy = IndicatorLight{parent=auto_div,label="Ready",x=2,colors=cpair(colors.green,colors.gray)}
+    local a_stb = IndicatorLight{parent=auto_div,label="Standby",x=2,colors=cpair(colors.white,colors.gray),flash=true,period=period.BLINK_1000_MS}
+
+    u_ps.subscribe("U_AutoReady", a_rdy.update)
+
+    -- update standby indicator
+    u_ps.subscribe("status", function (active)
+        a_stb.update(unit.annunciator.AutoControl and (not active))
+    end)
+
+    -- enable and disable controls based on group assignment
+    u_ps.subscribe("auto_group_id", function (gid)
+        start_button_en_check()
+
+        if gid == 0 then
+            burn_rate.enable()
+            set_burn_btn.enable()
+        else
+            burn_rate.disable()
+            set_burn_btn.disable()
+        end
+    end)
+
+    -- enable and disable controls based on auto control state (start button is handled separately)
+    u_ps.subscribe("AutoControl", function (auto_active)
+        start_button_en_check()
+
+        if auto_active then
+            a_stb.update(unit.reactor_data.mek_status.status == false)
+        else a_stb.update(false) end
+    end)
+
+    -- can't change group if auto is engaged regardless of if this unit is part of auto control
+    f_ps.subscribe("auto_active", function (auto_active)
+        if auto_active then set_grp_btn.disable() else set_grp_btn.enable() end
+    end)
+
+    return main
+end
+
+return init

coordinator/ui/components/unit_overview.lua

@@ -0,0 +1,176 @@
+--
+-- Basic Unit Overview
+--
+
+local core         = require("graphics.core")
+
+local style        = require("coordinator.ui.style")
+
+local reactor_view = require("coordinator.ui.components.reactor")
+local boiler_view  = require("coordinator.ui.components.boiler")
+local turbine_view = require("coordinator.ui.components.turbine")
+
+local Div          = require("graphics.elements.div")
+local PipeNetwork  = require("graphics.elements.pipenet")
+local TextBox      = require("graphics.elements.textbox")
+
+local TEXT_ALIGN = core.graphics.TEXT_ALIGN
+
+local pipe = core.graphics.pipe
+
+-- make a new unit overview window
+---@param parent graphics_element parent
+---@param x integer top left x
+---@param y integer top left y
+---@param unit ioctl_unit unit database entry
+local function make(parent, x, y, unit)
+    local height = 0
+    local num_boilers = #unit.boiler_data_tbl
+    local num_turbines = #unit.turbine_data_tbl
+
+    assert(num_boilers  >= 0 and num_boilers  <= 2, "minimum 0 boilers, maximum 2 boilers")
+    assert(num_turbines >= 1 and num_turbines <= 3, "minimum 1 turbine, maximum 3 turbines")
+
+    if num_boilers == 0 and num_turbines == 1 then
+        height = 9
+    elseif num_boilers == 1 and num_turbines <= 2 then
+        height = 17
+    else
+        height = 25
+    end
+
+    assert(parent.height() >= (y + height), "main display not of sufficient vertical resolution (add an additional row of monitors)")
+
+    -- bounding box div
+    local root = Div{parent=parent,x=x,y=y,width=80,height=height}
+
+    -- unit header message
+    TextBox{parent=root,text="Unit #"..unit.unit_id,alignment=TEXT_ALIGN.CENTER,height=1,fg_bg=style.header}
+
+    -------------
+    -- REACTOR --
+    -------------
+
+    reactor_view(root, 1, 3, unit.reactor_data, unit.unit_ps)
+
+    if num_boilers > 0 then
+        local coolant_pipes = {}
+
+        if num_boilers >= 2 then
+            table.insert(coolant_pipes, pipe(0, 0, 11, 12, colors.lightBlue))
+        end
+
+        table.insert(coolant_pipes, pipe(0, 0, 11, 3, colors.lightBlue))
+        table.insert(coolant_pipes, pipe(2, 0, 11, 2, colors.orange))
+
+        if num_boilers >= 2 then
+            table.insert(coolant_pipes, pipe(2, 0, 11, 11, colors.orange))
+        end
+
+        PipeNetwork{parent=root,x=4,y=10,pipes=coolant_pipes,bg=colors.lightGray}
+    end
+
+    -------------
+    -- BOILERS --
+    -------------
+
+    if num_boilers >= 1 then boiler_view(root, 16, 11, unit.boiler_ps_tbl[1]) end
+    if num_boilers >= 2 then boiler_view(root, 16, 19, unit.boiler_ps_tbl[2]) end
+
+    --------------
+    -- TURBINES --
+    --------------
+
+    local t_idx = 1
+    local no_boilers = num_boilers == 0
+
+    if (num_turbines >= 3) or no_boilers or (num_boilers == 1 and num_turbines >= 2) then
+        turbine_view(root, 58, 3, unit.turbine_ps_tbl[t_idx])
+        t_idx = t_idx + 1
+    end
+
+    if (num_turbines >= 1 and not no_boilers) or num_turbines >= 2 then
+        turbine_view(root, 58, 11, unit.turbine_ps_tbl[t_idx])
+        t_idx = t_idx + 1
+    end
+
+    if (num_turbines >= 2 and num_boilers >= 2) or num_turbines >= 3 then
+        turbine_view(root, 58, 19, unit.turbine_ps_tbl[t_idx])
+    end
+
+    local steam_pipes_b = {}
+
+    if no_boilers then
+        table.insert(steam_pipes_b, pipe(0, 1, 3, 1, colors.white))         -- steam to turbine 1
+        table.insert(steam_pipes_b, pipe(0, 2, 3, 2, colors.blue))          -- water to turbine 1
+
+        if num_turbines >= 2 then
+            table.insert(steam_pipes_b, pipe(1, 2, 3, 9, colors.white))     -- steam to turbine 2
+            table.insert(steam_pipes_b, pipe(2, 3, 3, 10, colors.blue))     -- water to turbine 2
+        end
+
+        if num_turbines >= 3 then
+            table.insert(steam_pipes_b, pipe(1, 9, 3, 17, colors.white))    -- steam boiler 1 to turbine 1 junction end
+            table.insert(steam_pipes_b, pipe(2, 10, 3, 18, colors.blue))    -- water boiler 1 to turbine 1 junction start
+        end
+    else
+        -- boiler side pipes
+        local steam_pipes_a = {
+            -- boiler 1 steam/water pipes
+            pipe(0, 1, 6, 1, colors.white, false, true),    -- steam boiler 1 to turbine junction
+            pipe(0, 2, 6, 2, colors.blue, false, true)      -- water boiler 1 to turbine junction
+        }
+
+        if num_boilers >= 2 then
+            -- boiler 2 steam/water pipes
+            table.insert(steam_pipes_a, pipe(0, 9, 6, 9, colors.white, false, true))    -- steam boiler 2 to turbine junction
+            table.insert(steam_pipes_a, pipe(0, 10, 6, 10, colors.blue, false, true))   -- water boiler 2 to turbine junction
+        end
+
+        -- turbine side pipes
+
+        if num_turbines >= 3 or (num_boilers == 1 and num_turbines == 2) then
+            table.insert(steam_pipes_b, pipe(0, 9, 1, 2, colors.white, false, true))    -- steam boiler 1 to turbine 1 junction start
+            table.insert(steam_pipes_b, pipe(1, 1, 3, 1, colors.white, false, false))   -- steam boiler 1 to turbine 1 junction end
+        end
+
+        table.insert(steam_pipes_b, pipe(0, 9, 3, 9, colors.white, false, true))        -- steam boiler 1 to turbine 2
+
+        if num_turbines >= 3 or (num_boilers == 1 and num_turbines == 2) then
+            table.insert(steam_pipes_b, pipe(0, 10, 2, 3, colors.blue, false, true))    -- water boiler 1 to turbine 1 junction start
+            table.insert(steam_pipes_b, pipe(2, 2, 3, 2, colors.blue, false, false))    -- water boiler 1 to turbine 1 junction end
+        end
+
+        table.insert(steam_pipes_b, pipe(0, 10, 3, 10, colors.blue, false, true))       -- water boiler 1 to turbine 2
+
+        if num_turbines >= 3 or (num_turbines >= 2 and num_boilers >= 2) then
+            if num_boilers >= 2 then
+                table.insert(steam_pipes_b, pipe(0, 17, 1, 9, colors.white, false, true))   -- steam boiler 2 to turbine 2 junction
+                table.insert(steam_pipes_b, pipe(0, 17, 3, 17, colors.white, false, true))  -- steam boiler 2 to turbine 3
+
+                table.insert(steam_pipes_b, pipe(0, 18, 2, 10, colors.blue, false, true))   -- water boiler 2 to turbine 3
+                table.insert(steam_pipes_b, pipe(0, 18, 3, 18, colors.blue, false, true))   -- water boiler 2 to turbine 2 junction
+            else
+                table.insert(steam_pipes_b, pipe(1, 17, 1, 9, colors.white, false, true))   -- steam boiler 2 to turbine 2 junction
+                table.insert(steam_pipes_b, pipe(1, 17, 3, 17, colors.white, false, true))  -- steam boiler 2 to turbine 3
+
+                table.insert(steam_pipes_b, pipe(2, 18, 2, 10, colors.blue, false, true))   -- water boiler 2 to turbine 3
+                table.insert(steam_pipes_b, pipe(2, 18, 3, 18, colors.blue, false, true))   -- water boiler 2 to turbine 2 junction
+            end
+        elseif num_turbines == 1 and num_boilers >= 2 then
+            table.insert(steam_pipes_b, pipe(0, 17, 1, 9, colors.white, false, true))       -- steam boiler 2 to turbine 2 junction
+            table.insert(steam_pipes_b, pipe(0, 17, 1, 17, colors.white, false, true))      -- steam boiler 2 to turbine 3
+
+            table.insert(steam_pipes_b, pipe(0, 18, 2, 10, colors.blue, false, true))       -- water boiler 2 to turbine 3
+            table.insert(steam_pipes_b, pipe(0, 18, 2, 18, colors.blue, false, true))       -- water boiler 2 to turbine 2 junction
+        end
+
+        PipeNetwork{parent=root,x=47,y=11,pipes=steam_pipes_a,bg=colors.lightGray}
+    end
+
+    PipeNetwork{parent=root,x=54,y=3,pipes=steam_pipes_b,bg=colors.lightGray}
+
+    return root
+end
+
+return make

coordinator/ui/components/unit_waiting.lua

@@ -0,0 +1,33 @@
+--
+-- Reactor Unit Waiting Spinner
+--
+
+local style       = require("coordinator.ui.style")
+
+local core        = require("graphics.core")
+
+local Div         = require("graphics.elements.div")
+local TextBox     = require("graphics.elements.textbox")
+
+local WaitingAnim = require("graphics.elements.animations.waiting")
+
+local TEXT_ALIGN = core.graphics.TEXT_ALIGN
+
+local cpair = core.graphics.cpair
+
+-- create a unit waiting view
+---@param parent graphics_element parent
+---@param y integer y offset
+local function init(parent, y)
+    -- bounding box div
+    local root = Div{parent=parent,x=1,y=y,height=5}
+
+    local waiting_x = math.floor(parent.width() / 2) - 2
+
+    TextBox{parent=root,text="Waiting for status...",alignment=TEXT_ALIGN.CENTER,y=1,height=1,fg_bg=cpair(colors.black,style.root.bkg)}
+    WaitingAnim{parent=root,x=waiting_x,y=3,fg_bg=cpair(colors.blue,style.root.bkg)}
+
+    return root
+end
+
+return init

coordinator/ui/dialog.lua

@@ -0,0 +1,52 @@
+local completion = require("cc.completion")
+
+local util       = require("scada-common.util")
+
+local print = util.print
+
+local dialog = {}
+
+-- ask the user yes or no
+---@nodiscard
+---@param question string
+---@param default boolean
+---@return boolean|nil
+function dialog.ask_y_n(question, default)
+    print(question)
+
+    if default == true then
+        print(" (Y/n)? ")
+    else
+        print(" (y/N)? ")
+    end
+
+    local response = read(nil, nil)
+
+    if response == "" then
+        return default
+    elseif response == "Y" or response == "y" then
+        return true
+    elseif response == "N" or response == "n" then
+        return false
+    else
+        return nil
+    end
+end
+
+-- ask the user for an input within a set of options
+---@nodiscard
+---@param options table
+---@param cancel string
+---@return boolean|string|nil
+function dialog.ask_options(options, cancel)
+    print("> ")
+    local response = read(nil, nil, function(text) return completion.choice(text, options) end)
+
+    if response == cancel then return false end
+
+    if util.table_contains(options, response) then
+        return response
+    else return nil end
+end
+
+return dialog

coordinator/ui/layout/main_view.lua

@@ -0,0 +1,100 @@
+--
+-- Main SCADA Coordinator GUI
+--
+
+local util          = require("scada-common.util")
+
+local iocontrol     = require("coordinator.iocontrol")
+local sounder       = require("coordinator.sounder")
+
+local style         = require("coordinator.ui.style")
+
+local imatrix       = require("coordinator.ui.components.imatrix")
+local process_ctl   = require("coordinator.ui.components.processctl")
+local unit_overview = require("coordinator.ui.components.unit_overview")
+
+local core          = require("graphics.core")
+
+local ColorMap      = require("graphics.elements.colormap")
+local DisplayBox    = require("graphics.elements.displaybox")
+local Div           = require("graphics.elements.div")
+local TextBox       = require("graphics.elements.textbox")
+
+local PushButton    = require("graphics.elements.controls.push_button")
+local SwitchButton  = require("graphics.elements.controls.switch_button")
+
+local DataIndicator = require("graphics.elements.indicators.data")
+
+local TEXT_ALIGN = core.graphics.TEXT_ALIGN
+
+local cpair = core.graphics.cpair
+
+-- create new main view
+---@param monitor table main viewscreen
+local function init(monitor)
+    local facility = iocontrol.get_db().facility
+    local units = iocontrol.get_db().units
+
+    local main = DisplayBox{window=monitor,fg_bg=style.root}
+
+    -- window header message
+    local header = TextBox{parent=main,y=1,text="Nuclear Generation Facility SCADA Coordinator",alignment=TEXT_ALIGN.CENTER,height=1,fg_bg=style.header}
+    local ping = DataIndicator{parent=main,x=1,y=1,label="SVTT",format="%d",value=0,unit="ms",lu_colors=cpair(colors.lightGray, colors.white),width=12,fg_bg=style.header}
+    -- max length example: "01:23:45 AM - Wednesday, September 28 2022"
+    local datetime = TextBox{parent=main,x=(header.width()-42),y=1,text="",alignment=TEXT_ALIGN.RIGHT,width=42,height=1,fg_bg=style.header}
+
+    facility.ps.subscribe("sv_ping", ping.update)
+    facility.ps.subscribe("date_time", datetime.set_value)
+
+    local uo_1, uo_2, uo_3, uo_4    ---@type graphics_element
+
+    local cnc_y_start = 3
+    local row_1_height = 0
+
+    -- unit overviews
+    if facility.num_units >= 1 then
+        uo_1 = unit_overview(main, 2, 3, units[1])
+        row_1_height = uo_1.height()
+    end
+
+    if facility.num_units >= 2 then
+        uo_2 = unit_overview(main, 84, 3, units[2])
+        row_1_height = math.max(row_1_height, uo_2.height())
+    end
+
+    cnc_y_start = cnc_y_start + row_1_height + 1
+
+    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
+
+        uo_3 = unit_overview(main, 2, row_2_offset, units[3])
+        cnc_y_start = row_2_offset + uo_3.height() + 1
+
+        if facility.num_units == 4 then
+            uo_4 = unit_overview(main, 84, row_2_offset, units[4])
+            cnc_y_start = math.max(cnc_y_start, row_2_offset + uo_4.height() + 1)
+        end
+    end
+
+    -- command & control
+
+    cnc_y_start = cnc_y_start
+
+    -- induction matrix and process control interfaces are 24 tall + space needed for divider
+    local cnc_bottom_align_start = main.height() - 26
+
+    assert(cnc_bottom_align_start >= cnc_y_start, "main display not of sufficient vertical resolution (add an additional row of monitors)")
+
+    TextBox{parent=main,y=cnc_bottom_align_start,text=util.strrep("\x8c", header.width()),alignment=TEXT_ALIGN.CENTER,height=1,fg_bg=cpair(colors.lightGray,colors.gray)}
+
+    cnc_bottom_align_start = cnc_bottom_align_start + 2
+
+    process_ctl(main, 2, cnc_bottom_align_start)
+
+    imatrix(main, 131, cnc_bottom_align_start, facility.induction_data_tbl[1], facility.induction_ps_tbl[1])
+
+    return main
+end
+
+return init

coordinator/ui/layout/unit_view.lua

@@ -0,0 +1,22 @@
+--
+-- Reactor Unit SCADA Coordinator GUI
+--
+
+local style       = require("coordinator.ui.style")
+
+local unit_detail = require("coordinator.ui.components.unit_detail")
+
+local DisplayBox  = require("graphics.elements.displaybox")
+
+-- create a unit view
+---@param monitor table
+---@param id integer
+local function init(monitor, id)
+    local main = DisplayBox{window=monitor,fg_bg=style.root}
+
+    unit_detail(main, id)
+
+    return main
+end
+
+return init

coordinator/ui/style.lua

@@ -0,0 +1,158 @@
+--
+-- Graphics Style Options
+--
+
+local core = require("graphics.core")
+
+local style = {}
+
+local cpair = core.graphics.cpair
+
+-- GLOBAL --
+
+style.root = cpair(colors.black, colors.lightGray)
+style.header = cpair(colors.white, colors.gray)
+style.label = cpair(colors.gray, colors.lightGray)
+
+style.colors = {
+    { c = colors.red,       hex = 0xdf4949 },
+    { c = colors.orange,    hex = 0xffb659 },
+    { c = colors.yellow,    hex = 0xfffc79 },
+    { c = colors.lime,      hex = 0x80ff80 },
+    { c = colors.green,     hex = 0x4aee8a },
+    { c = colors.cyan,      hex = 0x34bac8 },
+    { c = colors.lightBlue, hex = 0x6cc0f2 },
+    { c = colors.blue,      hex = 0x0096ff },
+    { c = colors.purple,    hex = 0xb156ee },
+    { c = colors.pink,      hex = 0xf26ba2 },
+    { c = colors.magenta,   hex = 0xf9488a },
+    -- { c = colors.white,     hex = 0xf0f0f0 },
+    { c = colors.lightGray, hex = 0xcacaca },
+    { c = colors.gray,      hex = 0x575757 },
+    -- { c = colors.black,     hex = 0x191919 },
+    -- { c = colors.brown,     hex = 0x7f664c }
+}
+
+-- MAIN LAYOUT --
+
+style.reactor = {
+    -- reactor states
+    states = {
+        {
+            color = cpair(colors.black, colors.yellow),
+            text = "PLC OFF-LINE"
+        },
+        {
+            color = cpair(colors.black, colors.orange),
+            text = "NOT FORMED"
+        },
+        {
+            color = cpair(colors.black, colors.orange),
+            text = "PLC  FAULT"
+        },
+        {
+            color = cpair(colors.white, colors.gray),
+            text = "DISABLED"
+        },
+        {
+            color = cpair(colors.black, colors.green),
+            text = "ACTIVE"
+        },
+        {
+            color = cpair(colors.black, colors.red),
+            text = "SCRAMMED"
+        },
+        {
+            color = cpair(colors.black, colors.red),
+            text = "FORCE DISABLED"
+        }
+    }
+}
+
+style.boiler = {
+    -- boiler states
+    states = {
+        {
+            color = cpair(colors.black, colors.yellow),
+            text = "OFF-LINE"
+        },
+        {
+            color = cpair(colors.black, colors.orange),
+            text = "NOT FORMED"
+        },
+        {
+            color = cpair(colors.black, colors.orange),
+            text = "RTU  FAULT"
+        },
+        {
+            color = cpair(colors.white, colors.gray),
+            text = "IDLE"
+        },
+        {
+            color = cpair(colors.black, colors.green),
+            text = "ACTIVE"
+        }
+    }
+}
+
+style.turbine = {
+    -- turbine states
+    states = {
+        {
+            color = cpair(colors.black, colors.yellow),
+            text = "OFF-LINE"
+        },
+        {
+            color = cpair(colors.black, colors.orange),
+            text = "NOT FORMED"
+        },
+        {
+            color = cpair(colors.black, colors.orange),
+            text = "RTU  FAULT"
+        },
+        {
+            color = cpair(colors.white, colors.gray),
+            text = "IDLE"
+        },
+        {
+            color = cpair(colors.black, colors.green),
+            text = "ACTIVE"
+        },
+        {
+            color = cpair(colors.black, colors.red),
+            text = "TRIP"
+        }
+    }
+}
+
+style.imatrix = {
+    -- induction matrix states
+    states = {
+        {
+            color = cpair(colors.black, colors.yellow),
+            text = "OFF-LINE"
+        },
+        {
+            color = cpair(colors.black, colors.orange),
+            text = "NOT FORMED"
+        },
+        {
+            color = cpair(colors.black, colors.orange),
+            text = "RTU  FAULT"
+        },
+        {
+            color = cpair(colors.black, colors.green),
+            text = "ONLINE"
+        },
+        {
+            color = cpair(colors.black, colors.yellow),
+            text = "LOW CHARGE"
+        },
+        {
+            color = cpair(colors.black, colors.yellow),
+            text = "HIGH  CHARGE"
+        },
+    }
+}
+
+return style

graphics/core.lua

@@ -0,0 +1,154 @@
+--
+-- Graphics Core Functions and Objects
+--
+
+local core = {}
+
+local flasher = require("graphics.flasher")
+
+core.flasher = flasher
+
+local events = {}
+
+---@class monitor_touch
+---@field monitor string
+---@field x integer
+---@field y integer
+
+-- create a new touch event definition
+---@nodiscard
+---@param monitor string
+---@param x integer
+---@param y integer
+---@return monitor_touch
+function events.touch(monitor, x, y)
+    return {
+        monitor = monitor,
+        x = x,
+        y = y
+    }
+end
+
+core.events = events
+
+local graphics = {}
+
+---@enum TEXT_ALIGN
+graphics.TEXT_ALIGN = {
+    LEFT = 1,
+    CENTER = 2,
+    RIGHT = 3
+}
+
+---@class graphics_border
+---@field width integer
+---@field color color
+---@field even boolean
+
+---@alias element_id string|integer
+
+-- create a new border definition
+---@nodiscard
+---@param width integer border width
+---@param color color border color
+---@param even? boolean whether to pad width extra to account for rectangular pixels, defaults to false
+---@return graphics_border
+function graphics.border(width, color, even)
+    return {
+        width = width,
+        color = color,
+        even = even or false    -- convert nil to false
+    }
+end
+
+---@class graphics_frame
+---@field x integer
+---@field y integer
+---@field w integer
+---@field h integer
+
+-- create a new graphics frame definition
+---@nodiscard
+---@param x integer
+---@param y integer
+---@param w integer
+---@param h integer
+---@return graphics_frame
+function graphics.gframe(x, y, w, h)
+    return {
+        x = x,
+        y = y,
+        w = w,
+        h = h
+    }
+end
+
+---@class cpair
+---@field color_a color
+---@field color_b color
+---@field blit_a string
+---@field blit_b string
+---@field fgd color
+---@field bkg color
+---@field blit_fgd string
+---@field blit_bkg string
+
+-- create a new color pair definition
+---@nodiscard
+---@param a color
+---@param b color
+---@return cpair
+function graphics.cpair(a, b)
+    return {
+        -- color pairs
+        color_a = a,
+        color_b = b,
+        blit_a = colors.toBlit(a),
+        blit_b = colors.toBlit(b),
+        -- aliases
+        fgd = a,
+        bkg = b,
+        blit_fgd = colors.toBlit(a),
+        blit_bkg = colors.toBlit(b)
+    }
+end
+
+---@class pipe
+---@field x1 integer starting x, origin is 0
+---@field y1 integer starting y, origin is 0
+---@field x2 integer ending x, origin is 0
+---@field y2 integer ending y, origin is 0
+---@field w integer width
+---@field h integer height
+---@field color color pipe color
+---@field thin boolean true for 1 subpixel, false (default) for 2
+---@field align_tr boolean false to align bottom left (default), true to align top right
+
+-- create a new pipe<br>
+-- note: pipe coordinate origin is (0, 0)
+---@nodiscard
+---@param x1 integer starting x, origin is 0
+---@param y1 integer starting y, origin is 0
+---@param x2 integer ending x, origin is 0
+---@param y2 integer ending y, origin is 0
+---@param color color pipe color
+---@param thin? boolean true for 1 subpixel, false (default) for 2
+---@param align_tr? boolean false to align bottom left (default), true to align top right
+---@return pipe
+function graphics.pipe(x1, y1, x2, y2, color, thin, align_tr)
+    return {
+        x1 = x1,
+        y1 = y1,
+        x2 = x2,
+        y2 = y2,
+        w = math.abs(x2 - x1) + 1,
+        h = math.abs(y2 - y1) + 1,
+        color = color,
+        thin = thin or false,
+        align_tr = align_tr or false
+    }
+end
+
+core.graphics = graphics
+
+return core

graphics/element.lua

@@ -0,0 +1,458 @@
+--
+-- Generic Graphics Element
+--
+
+local core = require("graphics.core")
+
+local element = {}
+
+---@class graphics_args_generic
+---@field window? table
+---@field parent? graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer next line if omitted
+---@field offset_x? integer 0 if omitted
+---@field offset_y? integer 0 if omitted
+---@field width? integer parent width if omitted
+---@field height? integer parent height if omitted
+---@field gframe? graphics_frame frame instead of x/y/width/height
+---@field fg_bg? cpair foreground/background colors
+
+---@alias graphics_args graphics_args_generic
+---|waiting_args
+---|hazard_button_args
+---|multi_button_args
+---|push_button_args
+---|radio_button_args
+---|spinbox_args
+---|switch_button_args
+---|alarm_indicator_light
+---|core_map_args
+---|data_indicator_args
+---|hbar_args
+---|icon_indicator_args
+---|indicator_light_args
+---|power_indicator_args
+---|rad_indicator_args
+---|state_indicator_args
+---|tristate_indicator_light_args
+---|vbar_args
+---|colormap_args
+---|displaybox_args
+---|div_args
+---|pipenet_args
+---|rectangle_args
+---|textbox_args
+---|tiling_args
+
+-- a base graphics element, should not be created on its own
+---@nodiscard
+---@param args graphics_args arguments
+function element.new(args)
+    local self = {
+        id = -1,
+        elem_type = debug.getinfo(2).name,
+        define_completed = false,
+        p_window = nil, ---@type table
+        position = { x = 1, y = 1 },
+        child_offset = { x = 0, y = 0 },
+        bounds = { x1 = 1, y1 = 1, x2 = 1, y2 = 1},
+        next_y = 1,
+        children = {},
+        mt = {}
+    }
+
+    ---@class graphics_template
+    local protected = {
+        enabled = true,
+        value = nil,    ---@type any
+        window = nil,   ---@type table
+        fg_bg = core.graphics.cpair(colors.white, colors.black),
+        frame = core.graphics.gframe(1, 1, 1, 1)
+    }
+
+    -- element as string
+    function self.mt.__tostring()
+        return "graphics.element{" .. self.elem_type .. "} @ " .. tostring(self)
+    end
+
+    ---@class graphics_element
+    local public = {}
+
+    setmetatable(public, self.mt)
+
+    -------------------------
+    -- PROTECTED FUNCTIONS --
+    -------------------------
+
+    -- prepare the template
+    ---@param offset_x integer x offset
+    ---@param offset_y integer y offset
+    ---@param next_y integer next line if no y was provided
+    function protected.prepare_template(offset_x, offset_y, next_y)
+        -- get frame coordinates/size
+        if args.gframe ~= nil then
+            protected.frame.x = args.gframe.x
+            protected.frame.y = args.gframe.y
+            protected.frame.w = args.gframe.w
+            protected.frame.h = args.gframe.h
+        else
+            local w, h = self.p_window.getSize()
+            protected.frame.x = args.x or 1
+            protected.frame.y = args.y or next_y
+            protected.frame.w = args.width or w
+            protected.frame.h = args.height or h
+        end
+
+        -- inner offsets
+        if args.offset_x ~= nil then self.child_offset.x = args.offset_x end
+        if args.offset_y ~= nil then self.child_offset.y = args.offset_y end
+
+        -- adjust window frame if applicable
+        local f = protected.frame
+        local x = f.x
+        local y = f.y
+
+        -- apply offsets
+        if args.parent ~= nil then
+            -- constrain to parent inner width/height
+            local w, h = self.p_window.getSize()
+            f.w = math.min(f.w, w - ((2 * offset_x) + (f.x - 1)))
+            f.h = math.min(f.h, h - ((2 * offset_y) + (f.y - 1)))
+
+            -- offset x/y
+            f.x = x + offset_x
+            f.y = y + offset_y
+        end
+
+        -- check frame
+        assert(f.x >= 1, "graphics.element{" .. self.elem_type .. "}: frame x not >= 1")
+        assert(f.y >= 1, "graphics.element{" .. self.elem_type .. "}: frame y not >= 1")
+        assert(f.w >= 1, "graphics.element{" .. self.elem_type .. "}: frame width not >= 1")
+        assert(f.h >= 1, "graphics.element{" .. self.elem_type .. "}: frame height not >= 1")
+
+        -- create window
+        protected.window = window.create(self.p_window, f.x, f.y, f.w, f.h, true)
+
+        -- init colors
+        if args.fg_bg ~= nil then
+            protected.fg_bg = args.fg_bg
+        elseif args.parent ~= nil then
+            protected.fg_bg = args.parent.get_fg_bg()
+        end
+
+        -- set colors
+        protected.window.setBackgroundColor(protected.fg_bg.bkg)
+        protected.window.setTextColor(protected.fg_bg.fgd)
+        protected.window.clear()
+
+        -- record position
+        self.position.x, self.position.y = protected.window.getPosition()
+
+        -- calculate bounds
+        self.bounds.x1 = self.position.x
+        self.bounds.x2 = self.position.x + f.w - 1
+        self.bounds.y1 = self.position.y
+        self.bounds.y2 = self.position.y + f.h - 1
+    end
+
+    -- handle a touch event
+    ---@param event table monitor_touch event
+    function protected.handle_touch(event)
+    end
+
+    -- handle data value changes
+    ---@vararg any value(s)
+    function protected.on_update(...)
+    end
+
+    -- callback on control press responses
+    ---@param result any
+    function protected.response_callback(result)
+    end
+
+    -- get value
+    ---@nodiscard
+    function protected.get_value()
+        return protected.value
+    end
+
+    -- set value
+    ---@param value any value to set
+    function protected.set_value(value)
+    end
+
+    -- set minimum input value
+    ---@param min integer minimum allowed value
+    function protected.set_min(min)
+    end
+
+    -- set maximum input value
+    ---@param max integer maximum allowed value
+    function protected.set_max(max)
+    end
+
+    -- enable the control
+    function protected.enable()
+    end
+
+    -- disable the control
+    function protected.disable()
+    end
+
+    -- custom recolor command, varies by element if implemented
+    ---@vararg cpair|color color(s)
+    function protected.recolor(...)
+    end
+
+    -- custom resize command, varies by element if implemented
+    ---@vararg integer sizing
+    function protected.resize(...)
+    end
+
+    -- start animations
+    function protected.start_anim()
+    end
+
+    -- stop animations
+    function protected.stop_anim()
+    end
+
+    -- get public interface
+    ---@nodiscard
+    ---@return graphics_element element, element_id id
+    function protected.get() return public, self.id end
+
+    -----------
+    -- SETUP --
+    -----------
+
+    -- get the parent window
+    self.p_window = args.window
+    if self.p_window == nil and args.parent ~= nil then
+        self.p_window = args.parent.window()
+    end
+
+    -- check window
+    assert(self.p_window, "graphics.element{" .. self.elem_type .. "}: no parent window provided")
+
+    -- prepare the template
+    if args.parent == nil then
+        protected.prepare_template(0, 0, 1)
+    else
+        self.id = args.parent.__add_child(args.id, protected)
+    end
+
+    ----------------------
+    -- PUBLIC FUNCTIONS --
+    ----------------------
+
+    -- get the window object
+    ---@nodiscard
+    function public.window() return protected.window end
+
+    -- CHILD ELEMENTS --
+
+    -- add a child element
+    ---@nodiscard
+    ---@param key string|nil id
+    ---@param child graphics_template
+    ---@return integer|string key
+    function public.__add_child(key, child)
+        child.prepare_template(self.child_offset.x, self.child_offset.y, self.next_y)
+
+        self.next_y = child.frame.y + child.frame.h
+
+        local child_element = child.get()
+
+        if key == nil then
+            table.insert(self.children, child_element)
+            return #self.children
+        else
+            self.children[key] = child_element
+            return key
+        end
+    end
+
+    -- get a child element
+    ---@nodiscard
+    ---@return graphics_element
+    function public.get_child(key) return self.children[key] end
+
+    -- remove child
+    ---@param key string|integer
+    function public.remove(key) self.children[key] = nil end
+
+    -- attempt to get a child element by ID (does not include this element itself)
+    ---@nodiscard
+    ---@param id element_id
+    ---@return graphics_element|nil element
+    function public.get_element_by_id(id)
+        if self.children[id] == nil then
+            for _, child in pairs(self.children) do
+                local elem = child.get_element_by_id(id)
+                if elem ~= nil then return elem end
+            end
+        else
+            return self.children[id]
+        end
+
+        return nil
+    end
+
+    -- AUTO-PLACEMENT --
+
+    -- skip a line for automatically placed elements
+    function public.line_break()
+        self.next_y = self.next_y + 1
+    end
+
+    -- PROPERTIES --
+
+    -- get the foreground/background colors
+    ---@nodiscard
+    ---@return cpair fg_bg
+    function public.get_fg_bg()
+        return protected.fg_bg
+    end
+
+    -- get element x
+    ---@nodiscard
+    ---@return integer x
+    function public.get_x()
+        return protected.frame.x
+    end
+
+    -- get element y
+    ---@nodiscard
+    ---@return integer y
+    function public.get_y()
+        return protected.frame.y
+    end
+
+    -- get element width
+    ---@nodiscard
+    ---@return integer width
+    function public.width()
+        return protected.frame.w
+    end
+
+    -- get element height
+    ---@nodiscard
+    ---@return integer height
+    function public.height()
+        return protected.frame.h
+    end
+
+    -- get the element value
+    ---@nodiscard
+    ---@return any value
+    function public.get_value()
+        return protected.get_value()
+    end
+
+    -- set the element value
+    ---@param value any new value
+    function public.set_value(value)
+        protected.set_value(value)
+    end
+
+    -- set minimum input value
+    ---@param min integer minimum allowed value
+    function public.set_min(min)
+        protected.set_min(min)
+    end
+
+    -- set maximum input value
+    ---@param max integer maximum allowed value
+    function public.set_max(max)
+        protected.set_max(max)
+    end
+
+    -- enable the element
+    function public.enable()
+        protected.enabled = true
+        protected.enable()
+    end
+
+    -- disable the element
+    function public.disable()
+        protected.enabled = false
+        protected.disable()
+    end
+
+    -- custom recolor command, varies by element if implemented
+    ---@vararg cpair|color color(s)
+    function public.recolor(...)
+        protected.recolor(...)
+    end
+
+    -- resize attributes of the element value if supported
+    ---@vararg number dimensions (element specific)
+    function public.resize(...)
+        protected.resize(...)
+    end
+
+    -- FUNCTION CALLBACKS --
+
+    -- handle a monitor touch
+    ---@param event monitor_touch monitor touch event
+    function public.handle_touch(event)
+        local in_x = event.x >= self.bounds.x1 and event.x <= self.bounds.x2
+        local in_y = event.y >= self.bounds.y1 and event.y <= self.bounds.y2
+
+        if in_x and in_y then
+            local event_T = core.events.touch(event.monitor, (event.x - self.position.x) + 1, (event.y - self.position.y) + 1)
+
+            -- handle the touch event, transformed into the window frame
+            protected.handle_touch(event_T)
+
+            -- pass on touch event to children
+            for _, val in pairs(self.children) do val.handle_touch(event_T) end
+        end
+    end
+
+    -- draw the element given new data
+    ---@vararg any new data
+    function public.update(...)
+        protected.on_update(...)
+    end
+
+    -- on a control request response
+    ---@param result any
+    function public.on_response(result)
+        protected.response_callback(result)
+    end
+
+    -- VISIBILITY --
+
+    -- show the element
+    function public.show()
+        protected.window.setVisible(true)
+        protected.start_anim()
+
+        for i = 1, #self.children do
+            self.children[i].show()
+        end
+    end
+
+    -- hide the element
+    function public.hide()
+        protected.stop_anim()
+        for i = 1, #self.children do
+            self.children[i].hide()
+        end
+
+        protected.window.setVisible(false)
+    end
+
+    -- re-draw the element
+    function public.redraw()
+        protected.window.redraw()
+    end
+
+    return protected
+end
+
+return element

graphics/elements/animations/waiting.lua

@@ -0,0 +1,108 @@
+-- Loading/Waiting Animation Graphics Element
+
+local tcd     = require("scada-common.tcallbackdsp")
+
+local element = require("graphics.element")
+
+---@class waiting_args
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field fg_bg? cpair foreground/background colors
+
+-- new waiting animation element
+---@param args waiting_args
+---@return graphics_element element, element_id id
+local function waiting(args)
+    local state = 0
+    local run_animation = false
+
+    args.width = 4
+    args.height = 3
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    local blit_fg = e.fg_bg.blit_fgd
+    local blit_bg = e.fg_bg.blit_bkg
+    local blit_fg_2x = e.fg_bg.blit_fgd .. e.fg_bg.blit_fgd
+    local blit_bg_2x = e.fg_bg.blit_bkg .. e.fg_bg.blit_bkg
+
+    -- tick the animation
+    local function animate()
+        e.window.clear()
+
+        if state >= 0 and state < 7 then
+            -- top
+            e.window.setCursorPos(1 + math.floor(state / 2), 1)
+            if state % 2 == 0 then
+                e.window.blit("\x8f", blit_fg, blit_bg)
+            else
+                e.window.blit("\x8a\x85", blit_fg_2x, blit_bg_2x)
+            end
+
+            -- bottom
+            e.window.setCursorPos(4 - math.ceil(state / 2), 3)
+            if state % 2 == 0 then
+                e.window.blit("\x8f", blit_fg, blit_bg)
+            else
+                e.window.blit("\x8a\x85", blit_fg_2x, blit_bg_2x)
+            end
+        else
+            local st = state - 7
+
+            -- right
+            if st % 3 == 0 then
+                e.window.setCursorPos(4, 1 + math.floor(st / 3))
+                e.window.blit("\x83", blit_bg, blit_fg)
+            elseif st % 3 == 1 then
+                e.window.setCursorPos(4, 1 + math.floor(st / 3))
+                e.window.blit("\x8f", blit_bg, blit_fg)
+                e.window.setCursorPos(4, 2 + math.floor(st / 3))
+                e.window.blit("\x83", blit_fg, blit_bg)
+            else
+                e.window.setCursorPos(4, 2 + math.floor(st / 3))
+                e.window.blit("\x8f", blit_fg, blit_bg)
+            end
+
+            -- left
+            if st % 3 == 0 then
+                e.window.setCursorPos(1, 3 - math.floor(st / 3))
+                e.window.blit("\x83", blit_fg, blit_bg)
+                e.window.setCursorPos(1, 2 - math.floor(st / 3))
+                e.window.blit("\x8f", blit_bg, blit_fg)
+            elseif st % 3 == 1 then
+                e.window.setCursorPos(1, 2 - math.floor(st / 3))
+                e.window.blit("\x83", blit_bg, blit_fg)
+            else
+                e.window.setCursorPos(1, 2 - math.floor(st / 3))
+                e.window.blit("\x8f", blit_fg, blit_bg)
+            end
+        end
+
+        state = state + 1
+        if state >= 12 then state = 0 end
+
+        if run_animation then
+            tcd.dispatch_unique(0.5, animate)
+        end
+    end
+
+    -- start the animation
+    function e.start_anim()
+        run_animation = true
+        animate()
+    end
+
+    -- stop the animation
+    function e.stop_anim()
+        run_animation = false
+    end
+
+    e.start_anim()
+
+    return e.get()
+end
+
+return waiting

graphics/elements/colormap.lua

@@ -0,0 +1,33 @@
+-- Color Map Graphics Element
+
+local util    = require("scada-common.util")
+
+local element = require("graphics.element")
+
+---@class colormap_args
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+
+-- new color map
+---@param args colormap_args
+---@return graphics_element element, element_id id
+local function colormap(args)
+    local bkg = "008877FFCCEE114455DD9933BBAA2266"
+    local spaces = util.spaces(32)
+
+    args.width = 32
+    args.height = 1
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- draw color map
+    e.window.setCursorPos(1, 1)
+    e.window.blit(spaces, bkg, bkg)
+
+    return e.get()
+end
+
+return colormap

graphics/elements/controls/hazard_button.lua

@@ -0,0 +1,208 @@
+-- Hazard-bordered Button Graphics Element
+
+local tcd     = require("scada-common.tcallbackdsp")
+local util    = require("scada-common.util")
+
+local core    = require("graphics.core")
+local element = require("graphics.element")
+
+---@class hazard_button_args
+---@field text string text to show on button
+---@field accent color accent color for hazard border
+---@field dis_colors? cpair text color and border color when disabled
+---@field callback function function to call on touch
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field fg_bg? cpair foreground/background colors
+
+-- new hazard button
+---@param args hazard_button_args
+---@return graphics_element element, element_id id
+local function hazard_button(args)
+    assert(type(args.text) == "string", "graphics.elements.controls.hazard_button: text is a required field")
+    assert(type(args.accent) == "number", "graphics.elements.controls.hazard_button: accent is a required field")
+    assert(type(args.callback) == "function", "graphics.elements.controls.hazard_button: callback is a required field")
+
+    -- static dimensions
+    args.height = 3
+    args.width = string.len(args.text) + 4
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- write the button text
+    e.window.setCursorPos(3, 2)
+    e.window.write(args.text)
+
+    -- draw border
+    ---@param accent color accent color
+    local function draw_border(accent)
+        -- top
+        e.window.setTextColor(accent)
+        e.window.setBackgroundColor(args.fg_bg.bkg)
+        e.window.setCursorPos(1, 1)
+        e.window.write("\x99" .. util.strrep("\x89", args.width - 2) .. "\x99")
+
+        -- center left
+        e.window.setCursorPos(1, 2)
+        e.window.setTextColor(args.fg_bg.bkg)
+        e.window.setBackgroundColor(accent)
+        e.window.write("\x99")
+
+        -- center right
+        e.window.setTextColor(args.fg_bg.bkg)
+        e.window.setBackgroundColor(accent)
+        e.window.setCursorPos(args.width, 2)
+        e.window.write("\x99")
+
+        -- bottom
+        e.window.setTextColor(accent)
+        e.window.setBackgroundColor(args.fg_bg.bkg)
+        e.window.setCursorPos(1, 3)
+        e.window.write("\x99" .. util.strrep("\x98", args.width - 2) .. "\x99")
+    end
+
+    -- on request timeout: recursively calls itself to double flash button text
+    ---@param n integer call count
+    local function on_timeout(n)
+        -- start at 0
+        if n == nil then n = 0 end
+
+        if n == 0 then
+            -- go back off
+            e.window.setTextColor(args.fg_bg.fgd)
+            e.window.setCursorPos(3, 2)
+            e.window.write(args.text)
+        end
+
+        if n >= 4 then
+            -- done
+        elseif n % 2 == 0 then
+            -- toggle text color on after 0.25 seconds
+            tcd.dispatch(0.25, function ()
+                e.window.setTextColor(args.accent)
+                e.window.setCursorPos(3, 2)
+                e.window.write(args.text)
+                on_timeout(n + 1)
+                on_timeout(n + 1)
+            end)
+        elseif n % 1 then
+            -- toggle text color off after 0.25 seconds
+            tcd.dispatch(0.25, function ()
+                e.window.setTextColor(args.fg_bg.fgd)
+                e.window.setCursorPos(3, 2)
+                e.window.write(args.text)
+                on_timeout(n + 1)
+            end)
+        end
+    end
+
+    -- blink routine for success indication
+    local function on_success()
+        e.window.setTextColor(args.fg_bg.fgd)
+        e.window.setCursorPos(3, 2)
+        e.window.write(args.text)
+    end
+
+    -- blink routine for failure indication
+    ---@param n integer call count
+    local function on_failure(n)
+        -- start at 0
+        if n == nil then n = 0 end
+
+        if n == 0 then
+            -- go back off
+            e.window.setTextColor(args.fg_bg.fgd)
+            e.window.setCursorPos(3, 2)
+            e.window.write(args.text)
+        end
+
+        if n >= 2 then
+            -- done
+        elseif n % 2 == 0 then
+            -- toggle text color on after 0.5 seconds
+            tcd.dispatch(0.5, function ()
+                e.window.setTextColor(args.accent)
+                e.window.setCursorPos(3, 2)
+                e.window.write(args.text)
+                on_failure(n + 1)
+            end)
+        elseif n % 1 then
+            -- toggle text color off after 0.25 seconds
+            tcd.dispatch(0.25, function ()
+                e.window.setTextColor(args.fg_bg.fgd)
+                e.window.setCursorPos(3, 2)
+                e.window.write(args.text)
+                on_failure(n + 1)
+            end)
+        end
+    end
+
+    -- handle touch
+    ---@param event monitor_touch monitor touch event
+---@diagnostic disable-next-line: unused-local
+    function e.handle_touch(event)
+        if e.enabled then
+            -- change text color to indicate clicked
+            e.window.setTextColor(args.accent)
+            e.window.setCursorPos(3, 2)
+            e.window.write(args.text)
+
+            -- abort any other callbacks
+            tcd.abort(on_timeout)
+            tcd.abort(on_success)
+            tcd.abort(on_failure)
+
+            -- 1.5 second timeout
+            tcd.dispatch(1.5, on_timeout)
+
+            -- call the touch callback
+            args.callback()
+        end
+    end
+
+    -- callback on request response
+    ---@param result boolean true for success, false for failure
+    function e.response_callback(result)
+        tcd.abort(on_timeout)
+
+        if result then
+            on_success()
+        else
+            on_failure(0)
+        end
+    end
+
+    -- set the value (true simulates pressing the button)
+    ---@param val boolean new value
+    function e.set_value(val)
+        if val then e.handle_touch(core.events.touch("", 1, 1)) end
+    end
+
+    -- show the button as disabled
+    function e.disable()
+        if args.dis_colors then
+            draw_border(args.dis_colors.color_a)
+            e.window.setTextColor(args.dis_colors.color_b)
+            e.window.setCursorPos(3, 2)
+            e.window.write(args.text)
+        end
+    end
+
+    -- show the button as enabled
+    function e.enable()
+        draw_border(args.accent)
+        e.window.setTextColor(args.fg_bg.fgd)
+        e.window.setCursorPos(3, 2)
+        e.window.write(args.text)
+    end
+
+    -- initial draw of border
+    draw_border(args.accent)
+
+    return e.get()
+end
+
+return hazard_button

graphics/elements/controls/multi_button.lua

@@ -0,0 +1,125 @@
+-- Multi Button Graphics Element
+
+local util    = require("scada-common.util")
+
+local element = require("graphics.element")
+
+---@class button_option
+---@field text string
+---@field fg_bg cpair
+---@field active_fg_bg cpair
+---@field _lpad integer automatically calculated left pad
+---@field _start_x integer starting touch x range (inclusive)
+---@field _end_x integer ending touch x range (inclusive)
+
+---@class multi_button_args
+---@field options table button options
+---@field callback function function to call on touch
+---@field default? integer default state, defaults to options[1]
+---@field min_width? integer text length + 2 if omitted
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field height? integer parent height if omitted
+---@field fg_bg? cpair foreground/background colors
+
+-- new multi button (latch selection, exclusively one button at a time)
+---@param args multi_button_args
+---@return graphics_element element, element_id id
+local function multi_button(args)
+    assert(type(args.options) == "table", "graphics.elements.controls.multi_button: options is a required field")
+    assert(#args.options > 0, "graphics.elements.controls.multi_button: at least one option is required")
+    assert(type(args.callback) == "function", "graphics.elements.controls.multi_button: callback is a required field")
+    assert(type(args.default) == "nil" or (type(args.default) == "number" and args.default > 0),
+        "graphics.elements.controls.multi_button: default must be nil or a number > 0")
+    assert(type(args.min_width) == "nil" or (type(args.min_width) == "number" and args.min_width > 0),
+        "graphics.elements.controls.multi_button: min_width must be nil or a number > 0")
+
+    -- single line
+    args.height = 1
+
+    -- determine widths
+    local max_width = 1
+    for i = 1, #args.options do
+        local opt = args.options[i] ---@type button_option
+        if string.len(opt.text) > max_width then
+            max_width = string.len(opt.text)
+        end
+    end
+
+    local button_width = math.max(max_width, args.min_width or 0)
+
+    args.width = (button_width * #args.options) + #args.options + 1
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- button state (convert nil to 1 if missing)
+    e.value = args.default or 1
+
+    -- calculate required button information
+    local next_x = 2
+    for i = 1, #args.options do
+        local opt = args.options[i] ---@type button_option
+        local w = string.len(opt.text)
+
+        opt._lpad = math.floor((e.frame.w - w) / 2)
+        opt._start_x = next_x
+        opt._end_x = next_x + button_width - 1
+
+        next_x = next_x + (button_width + 1)
+    end
+
+    -- show the button state
+    local function draw()
+        for i = 1, #args.options do
+            local opt = args.options[i] ---@type button_option
+
+            e.window.setCursorPos(opt._start_x, 1)
+
+            if e.value == i then
+                -- show as pressed
+                e.window.setTextColor(opt.active_fg_bg.fgd)
+                e.window.setBackgroundColor(opt.active_fg_bg.bkg)
+            else
+                -- show as unpressed
+                e.window.setTextColor(opt.fg_bg.fgd)
+                e.window.setBackgroundColor(opt.fg_bg.bkg)
+            end
+
+            e.window.write(util.pad(opt.text, button_width))
+        end
+    end
+
+    -- handle touch
+    ---@param event monitor_touch monitor touch event
+    function e.handle_touch(event)
+        -- determine what was pressed
+        if e.enabled and event.y == 1 then
+            for i = 1, #args.options do
+                local opt = args.options[i] ---@type button_option
+
+                if event.x >= opt._start_x and event.x <= opt._end_x then
+                    e.value = i
+                    draw()
+                    args.callback(e.value)
+                end
+            end
+        end
+    end
+
+    -- set the value
+    ---@param val integer new value
+    function e.set_value(val)
+        e.value = val
+        draw()
+    end
+
+    -- initial draw
+    draw()
+
+    return e.get()
+end
+
+return multi_button

graphics/elements/controls/push_button.lua

@@ -0,0 +1,110 @@
+-- Button Graphics Element
+
+local tcd     = require("scada-common.tcallbackdsp")
+
+local core    = require("graphics.core")
+local element = require("graphics.element")
+
+---@class push_button_args
+---@field text string button text
+---@field callback function function to call on touch
+---@field min_width? integer text length + 2 if omitted
+---@field active_fg_bg? cpair foreground/background colors when pressed
+---@field dis_fg_bg? cpair foreground/background colors when disabled
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field height? integer parent height if omitted
+---@field fg_bg? cpair foreground/background colors
+
+-- new push button
+---@param args push_button_args
+---@return graphics_element element, element_id id
+local function push_button(args)
+    assert(type(args.text) == "string", "graphics.elements.controls.push_button: text is a required field")
+    assert(type(args.callback) == "function", "graphics.elements.controls.push_button: callback is a required field")
+
+    local text_width = string.len(args.text)
+
+    -- single line height, calculate width
+    args.height = 1
+    args.min_width = args.min_width or 0
+    args.width = math.max(text_width, args.min_width)
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    local h_pad = math.floor((e.frame.w - text_width) / 2) + 1
+    local v_pad = math.floor(e.frame.h / 2) + 1
+
+    -- draw the button
+    local function draw()
+        e.window.clear()
+
+        -- write the button text
+        e.window.setCursorPos(h_pad, v_pad)
+        e.window.write(args.text)
+    end
+
+    -- handle touch
+    ---@param event monitor_touch monitor touch event
+---@diagnostic disable-next-line: unused-local
+    function e.handle_touch(event)
+        if e.enabled then
+            if args.active_fg_bg ~= nil then
+                -- show as pressed
+                e.value = true
+                e.window.setTextColor(args.active_fg_bg.fgd)
+                e.window.setBackgroundColor(args.active_fg_bg.bkg)
+                draw()
+
+                -- show as unpressed in 0.25 seconds
+                tcd.dispatch(0.25, function ()
+                    e.value = false
+                    if e.enabled then
+                        e.window.setTextColor(e.fg_bg.fgd)
+                        e.window.setBackgroundColor(e.fg_bg.bkg)
+                    end
+                    draw()
+                end)
+            end
+
+            -- call the touch callback
+            args.callback()
+        end
+    end
+
+    -- set the value (true simulates pressing the button)
+    ---@param val boolean new value
+    function e.set_value(val)
+        if val then e.handle_touch(core.events.touch("", 1, 1)) end
+    end
+
+    -- show butten as enabled
+    function e.enable()
+        if args.dis_fg_bg ~= nil then
+            e.value = false
+            e.window.setTextColor(e.fg_bg.fgd)
+            e.window.setBackgroundColor(e.fg_bg.bkg)
+            draw()
+        end
+    end
+
+    -- show button as disabled
+    function e.disable()
+        if args.dis_fg_bg ~= nil then
+            e.value = false
+            e.window.setTextColor(args.dis_fg_bg.fgd)
+            e.window.setBackgroundColor(args.dis_fg_bg.bkg)
+            draw()
+        end
+    end
+
+    -- initial draw
+    draw()
+
+    return e.get()
+end
+
+return push_button

graphics/elements/controls/radio_button.lua

@@ -0,0 +1,108 @@
+-- Radio Button Graphics Element
+
+local element = require("graphics.element")
+
+---@class radio_button_args
+---@field options table button options
+---@field callback function function to call on touch
+---@field radio_colors cpair colors for radio button center dot when active (a) or inactive (b)
+---@field radio_bg color background color of radio button
+---@field default? integer default state, defaults to options[1]
+---@field min_width? integer text length + 2 if omitted
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field fg_bg? cpair foreground/background colors
+
+-- new radio button list (latch selection, exclusively one button at a time)
+---@param args radio_button_args
+---@return graphics_element element, element_id id
+local function radio_button(args)
+    assert(type(args.options) == "table", "graphics.elements.controls.radio_button: options is a required field")
+    assert(#args.options > 0, "graphics.elements.controls.radio_button: at least one option is required")
+    assert(type(args.callback) == "function", "graphics.elements.controls.radio_button: callback is a required field")
+    assert(type(args.default) == "nil" or (type(args.default) == "number" and args.default > 0),
+        "graphics.elements.controls.radio_button: default must be nil or a number > 0")
+    assert(type(args.min_width) == "nil" or (type(args.min_width) == "number" and args.min_width > 0),
+        "graphics.elements.controls.radio_button: min_width must be nil or a number > 0")
+
+    -- one line per option
+    args.height = #args.options
+
+    -- determine widths
+    local max_width = 1
+    for i = 1, #args.options do
+        local opt = args.options[i] ---@type string
+        if string.len(opt) > max_width then
+            max_width = string.len(opt)
+        end
+    end
+
+    local button_text_width = math.max(max_width, args.min_width or 0)
+
+    args.width = button_text_width + 2
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- button state (convert nil to 1 if missing)
+    e.value = args.default or 1
+
+    -- show the button state
+    local function draw()
+        for i = 1, #args.options do
+            local opt = args.options[i] ---@type string
+
+            e.window.setCursorPos(1, i)
+
+            if e.value == i then
+                -- show as selected
+                e.window.setTextColor(args.radio_colors.color_a)
+                e.window.setBackgroundColor(args.radio_bg)
+            else
+                -- show as unselected
+                e.window.setTextColor(args.radio_colors.color_b)
+                e.window.setBackgroundColor(args.radio_bg)
+            end
+
+            e.window.write("\x88")
+
+            e.window.setTextColor(args.radio_bg)
+            e.window.setBackgroundColor(e.fg_bg.bkg)
+            e.window.write("\x95")
+
+            -- write button text
+            e.window.setTextColor(e.fg_bg.fgd)
+            e.window.setBackgroundColor(e.fg_bg.bkg)
+            e.window.write(opt)
+        end
+    end
+
+    -- handle touch
+    ---@param event monitor_touch monitor touch event
+    function e.handle_touch(event)
+        -- determine what was pressed
+        if e.enabled then
+            if args.options[event.y] ~= nil then
+                e.value = event.y
+                draw()
+                args.callback(e.value)
+            end
+        end
+    end
+
+    -- set the value
+    ---@param val integer new value
+    function e.set_value(val)
+        e.value = val
+        draw()
+    end
+
+    -- initial draw
+    draw()
+
+    return e.get()
+end
+
+return radio_button

graphics/elements/controls/spinbox_numeric.lua

@@ -0,0 +1,191 @@
+-- Spinbox Numeric Graphics Element
+
+local util    = require("scada-common.util")
+
+local element = require("graphics.element")
+
+---@class spinbox_args
+---@field default? number default value, defaults to 0.0
+---@field min? number default 0, currently must be 0 or greater
+---@field max? number default max number that can be displayed with the digits configuration
+---@field whole_num_precision integer number of whole number digits
+---@field fractional_precision integer number of fractional digits
+---@field arrow_fg_bg cpair arrow foreground/background colors
+---@field arrow_disable? color color when disabled (default light gray)
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field fg_bg? cpair foreground/background colors
+
+-- new spinbox control (minimum value is 0)
+---@param args spinbox_args
+---@return graphics_element element, element_id id
+local function spinbox(args)
+    -- properties
+    local digits = {}
+    local wn_prec = args.whole_num_precision
+    local fr_prec = args.fractional_precision
+
+    assert(util.is_int(wn_prec), "graphics.element.controls.spinbox_numeric: whole number precision must be an integer")
+    assert(util.is_int(fr_prec), "graphics.element.controls.spinbox_numeric: fractional precision must be an integer")
+
+    local fmt = ""
+    local fmt_init = ""
+
+    if fr_prec > 0 then
+        fmt = "%" .. (wn_prec + fr_prec + 1) .. "." .. fr_prec .. "f"
+        fmt_init = "%0" .. (wn_prec + fr_prec + 1) .. "." .. fr_prec .. "f"
+    else
+        fmt = "%" .. wn_prec .. "d"
+        fmt_init = "%0" .. wn_prec .. "d"
+    end
+
+    local dec_point_x = args.whole_num_precision + 1
+
+    assert(type(args.arrow_fg_bg) == "table", "graphics.element.spinbox_numeric: arrow_fg_bg is a required field")
+
+    -- determine widths
+    args.width = wn_prec + fr_prec + util.trinary(fr_prec > 0, 1, 0)
+    args.height = 3
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- set initial value
+    e.value = args.default or 0
+
+    -- draw the arrows
+    local function draw_arrows(color)
+        e.window.setBackgroundColor(args.arrow_fg_bg.bkg)
+        e.window.setTextColor(color)
+        e.window.setCursorPos(1, 1)
+        e.window.write(util.strrep("\x1e", wn_prec))
+        e.window.setCursorPos(1, 3)
+        e.window.write(util.strrep("\x1f", wn_prec))
+        if fr_prec > 0 then
+            e.window.setCursorPos(1 + wn_prec, 1)
+            e.window.write(" " .. util.strrep("\x1e", fr_prec))
+            e.window.setCursorPos(1 + wn_prec, 3)
+            e.window.write(" " .. util.strrep("\x1f", fr_prec))
+        end
+    end
+
+    draw_arrows(args.arrow_fg_bg.fgd)
+
+    -- populate digits from current value
+    local function set_digits()
+        local initial_str = util.sprintf(fmt_init, e.value)
+
+        digits = {}
+---@diagnostic disable-next-line: discard-returns
+        initial_str:gsub("%d", function (char) table.insert(digits, char) end)
+    end
+
+    -- update the value per digits table
+    local function update_value()
+        e.value = 0
+        for i = 1, #digits do
+            local pow = math.abs(wn_prec - i)
+            if i <= wn_prec then
+                e.value = e.value + (digits[i] * (10 ^ pow))
+            else
+                e.value = e.value + (digits[i] * (10 ^ -pow))
+            end
+        end
+    end
+
+    -- print out the current value
+    local function show_num()
+        -- enforce limits
+        if (type(args.min) == "number") and (e.value < args.min) then
+            e.value = args.min
+            set_digits()
+        elseif e.value < 0 then
+            e.value = 0
+            set_digits()
+        else
+            if string.len(util.sprintf(fmt, e.value)) > args.width then
+                -- max printable exceeded, so max out to all 9s
+                for i = 1, #digits do digits[i] = 9 end
+                update_value()
+            elseif (type(args.max) == "number") and (e.value > args.max) then
+                e.value = args.max
+                set_digits()
+            else
+                set_digits()
+            end
+        end
+
+        -- draw
+        e.window.setBackgroundColor(e.fg_bg.bkg)
+        e.window.setTextColor(e.fg_bg.fgd)
+        e.window.setCursorPos(1, 2)
+        e.window.write(util.sprintf(fmt, e.value))
+    end
+
+    -- init with the default value
+    show_num()
+
+    -- handle touch
+    ---@param event monitor_touch monitor touch event
+    function e.handle_touch(event)
+        -- only handle if on an increment or decrement arrow
+        if e.enabled and event.x ~= dec_point_x then
+            local idx = util.trinary(event.x > dec_point_x, event.x - 1, event.x)
+            if digits[idx] ~= nil then
+                if event.y == 1 then
+                    -- increment
+                    digits[idx] = digits[idx] + 1
+                elseif event.y == 3 then
+                    -- decrement
+                    digits[idx] = digits[idx] - 1
+                end
+
+                update_value()
+                show_num()
+            end
+        end
+    end
+
+    -- set the value
+    ---@param val number number to show
+    function e.set_value(val)
+        e.value = val
+        show_num()
+    end
+
+    -- set minimum input value
+    ---@param min integer minimum allowed value
+    function e.set_min(min)
+        if min >= 0 then
+            args.min = min
+            show_num()
+        end
+    end
+
+    -- set maximum input value
+    ---@param max integer maximum allowed value
+    function e.set_max(max)
+        args.max = max
+        show_num()
+    end
+
+    -- enable this input
+    function e.enable()
+        draw_arrows(args.arrow_fg_bg.fgd)
+    end
+
+    -- disable this input
+    function e.disable()
+        draw_arrows(args.arrow_disable or colors.lightGray)
+    end
+
+    -- default to zero, init digits table
+    e.value = 0
+    set_digits()
+
+    return e.get()
+end
+
+return spinbox

graphics/elements/controls/switch_button.lua

@@ -0,0 +1,90 @@
+-- Button Graphics Element
+
+local element = require("graphics.element")
+
+---@class switch_button_args
+---@field text string button text
+---@field callback function function to call on touch
+---@field default? boolean default state, defaults to off (false)
+---@field min_width? integer text length + 2 if omitted
+---@field active_fg_bg cpair foreground/background colors when pressed
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field height? integer parent height if omitted
+---@field fg_bg? cpair foreground/background colors
+
+-- new switch button (latch high/low)
+---@param args switch_button_args
+---@return graphics_element element, element_id id
+local function switch_button(args)
+    assert(type(args.text) == "string", "graphics.elements.controls.switch_button: text is a required field")
+    assert(type(args.callback) == "function", "graphics.elements.controls.switch_button: callback is a required field")
+    assert(type(args.active_fg_bg) == "table", "graphics.elements.controls.switch_button: active_fg_bg is a required field")
+
+    -- single line
+    args.height = 1
+
+    -- determine widths
+    local text_width = string.len(args.text)
+    args.width = math.max(text_width + 2, args.min_width)
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- button state (convert nil to false if missing)
+    e.value = args.default or false
+
+    local h_pad = math.floor((e.frame.w - text_width) / 2) + 1
+    local v_pad = math.floor(e.frame.h / 2) + 1
+
+    -- show the button state
+    local function draw_state()
+        if e.value then
+            -- show as pressed
+            e.window.setTextColor(args.active_fg_bg.fgd)
+            e.window.setBackgroundColor(args.active_fg_bg.bkg)
+        else
+            -- show as unpressed
+            e.window.setTextColor(e.fg_bg.fgd)
+            e.window.setBackgroundColor(e.fg_bg.bkg)
+        end
+
+        -- clear to redraw background
+        e.window.clear()
+
+        -- write the button text
+        e.window.setCursorPos(h_pad, v_pad)
+        e.window.write(args.text)
+    end
+
+    -- initial draw
+    draw_state()
+
+    -- handle touch
+    ---@param event monitor_touch monitor touch event
+---@diagnostic disable-next-line: unused-local
+    function e.handle_touch(event)
+        if e.enabled then
+            -- toggle state
+            e.value = not e.value
+            draw_state()
+
+            -- call the touch callback with state
+            args.callback(e.value)
+        end
+    end
+
+    -- set the value
+    ---@param val boolean new value
+    function e.set_value(val)
+        -- set state
+        e.value = val
+        draw_state()
+    end
+
+    return e.get()
+end
+
+return switch_button

graphics/elements/displaybox.lua

@@ -0,0 +1,22 @@
+-- Root Display Box Graphics Element
+
+local element = require("graphics.element")
+
+---@class displaybox_args
+---@field window table
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field width? integer parent width if omitted
+---@field height? integer parent height if omitted
+---@field gframe? graphics_frame frame instead of x/y/width/height
+---@field fg_bg? cpair foreground/background colors
+
+-- new root display box
+---@nodiscard
+---@param args displaybox_args
+local function displaybox(args)
+    -- create new graphics element base object
+    return element.new(args).get()
+end
+
+return displaybox

graphics/elements/div.lua

@@ -0,0 +1,24 @@
+-- Div (Division, like in HTML) Graphics Element
+
+local element = require("graphics.element")
+
+---@class div_args
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field width? integer parent width if omitted
+---@field height? integer parent height if omitted
+---@field gframe? graphics_frame frame instead of x/y/width/height
+---@field fg_bg? cpair foreground/background colors
+
+-- new div element
+---@nodiscard
+---@param args div_args
+---@return graphics_element element, element_id id
+local function div(args)
+    -- create new graphics element base object
+    return element.new(args).get()
+end
+
+return div

graphics/elements/indicators/alight.lua

@@ -0,0 +1,114 @@
+-- Tri-State Alarm Indicator Light Graphics Element
+
+local util    = require("scada-common.util")
+
+local element = require("graphics.element")
+local flasher = require("graphics.flasher")
+
+---@class alarm_indicator_light
+---@field label string indicator label
+---@field c1 color color for off state
+---@field c2 color color for alarm state
+---@field c3 color color for ring-back state
+---@field min_label_width? integer label length if omitted
+---@field flash? boolean whether to flash on alarm state rather than stay on
+---@field period? PERIOD flash period
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field fg_bg? cpair foreground/background colors
+
+-- new alarm indicator light
+---@nodiscard
+---@param args alarm_indicator_light
+---@return graphics_element element, element_id id
+local function alarm_indicator_light(args)
+    assert(type(args.label) == "string", "graphics.elements.indicators.alight: label is a required field")
+    assert(type(args.c1) == "number", "graphics.elements.indicators.alight: c1 is a required field")
+    assert(type(args.c2) == "number", "graphics.elements.indicators.alight: c2 is a required field")
+    assert(type(args.c3) == "number", "graphics.elements.indicators.alight: c3 is a required field")
+
+    if args.flash then
+        assert(util.is_int(args.period), "graphics.elements.indicators.alight: period is a required field if flash is enabled")
+    end
+
+    -- single line
+    args.height = 1
+
+    -- determine width
+    args.width = math.max(args.min_label_width or 1, string.len(args.label)) + 2
+
+    -- flasher state
+    local flash_on = true
+
+    -- blit translations
+    local c1 = colors.toBlit(args.c1)
+    local c2 = colors.toBlit(args.c2)
+    local c3 = colors.toBlit(args.c3)
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- called by flasher when enabled
+    local function flash_callback()
+        e.window.setCursorPos(1, 1)
+
+        if flash_on then
+            if e.value == 2 then
+                e.window.blit(" \x95", "0" .. c2, c2 .. e.fg_bg.blit_bkg)
+            end
+        else
+            if e.value == 3 then
+                e.window.blit(" \x95", "0" .. c3, c3 .. e.fg_bg.blit_bkg)
+            else
+                e.window.blit(" \x95", "0" .. c1, c1 .. e.fg_bg.blit_bkg)
+            end
+        end
+
+        flash_on = not flash_on
+    end
+
+    -- on state change
+    ---@param new_state integer indicator state
+    function e.on_update(new_state)
+        local was_off = e.value ~= 2
+
+        e.value = new_state
+        e.window.setCursorPos(1, 1)
+
+        if args.flash then
+            if was_off and (new_state == 2) then
+                flash_on = true
+                flasher.start(flash_callback, args.period)
+            elseif new_state ~= 2 then
+                flash_on = false
+                flasher.stop(flash_callback)
+
+                if new_state == 3 then
+                    e.window.blit(" \x95", "0" .. c3, c3 .. e.fg_bg.blit_bkg)
+                else
+                    e.window.blit(" \x95", "0" .. c1, c1 .. e.fg_bg.blit_bkg)
+                end
+            end
+        elseif new_state == 2 then
+            e.window.blit(" \x95", "0" .. c2, c2 .. e.fg_bg.blit_bkg)
+        elseif new_state == 3 then
+            e.window.blit(" \x95", "0" .. c3, c3 .. e.fg_bg.blit_bkg)
+        else
+            e.window.blit(" \x95", "0" .. c1, c1 .. e.fg_bg.blit_bkg)
+        end
+    end
+
+    -- set indicator state
+    ---@param val integer indicator state
+    function e.set_value(val) e.on_update(val) end
+
+    -- write label and initial indicator light
+    e.on_update(1)
+    e.window.write(args.label)
+
+    return e.get()
+end
+
+return alarm_indicator_light

graphics/elements/indicators/coremap.lua

@@ -0,0 +1,169 @@
+-- Reactor Core View Graphics Element
+
+local util    = require("scada-common.util")
+
+local core    = require("graphics.core")
+local element = require("graphics.element")
+
+---@class core_map_args
+---@field reactor_l integer reactor length
+---@field reactor_w integer reactor width
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+
+-- new core map box
+---@nodiscard
+---@param args core_map_args
+---@return graphics_element element, element_id id
+local function core_map(args)
+    assert(util.is_int(args.reactor_l), "graphics.elements.indicators.coremap: reactor_l is a required field")
+    assert(util.is_int(args.reactor_w), "graphics.elements.indicators.coremap: reactor_w is a required field")
+
+    -- require max dimensions
+    args.width = 18
+    args.height = 18
+
+    -- inherit only foreground color
+    args.fg_bg = core.graphics.cpair(args.parent.get_fg_bg().fgd, colors.gray)
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    local alternator = true
+
+    local core_l = args.reactor_l - 2
+    local core_w = args.reactor_w - 2
+
+    local shift_x = 8 - math.floor(core_l / 2)
+    local shift_y = 8 - math.floor(core_w / 2)
+
+    local start_x = 2 + shift_x
+    local start_y = 2 + shift_y
+
+    local inner_width = core_l
+    local inner_height = core_w
+
+    -- create coordinate grid and frame
+    local function draw_frame()
+        e.window.setTextColor(colors.white)
+
+        for x = 0, (inner_width - 1) do
+            e.window.setCursorPos(x + start_x, 1)
+            e.window.write(util.sprintf("%X", x))
+        end
+
+        for y = 0, (inner_height - 1) do
+            e.window.setCursorPos(1, y + start_y)
+            e.window.write(util.sprintf("%X", y))
+        end
+
+        -- even out bottom edge
+        e.window.setTextColor(e.fg_bg.bkg)
+        e.window.setBackgroundColor(args.parent.get_fg_bg().bkg)
+        e.window.setCursorPos(1, e.frame.h)
+        e.window.write(util.strrep("\x8f", e.frame.w))
+        e.window.setTextColor(e.fg_bg.fgd)
+        e.window.setBackgroundColor(e.fg_bg.bkg)
+    end
+
+    -- draw the core
+    ---@param t number temperature in K
+    local function draw_core(t)
+        local i = 1
+        local back_c = "F"
+        local text_c = "8"
+
+        -- determine fuel assembly coloring
+        if t <= 300 then
+            -- gray
+            text_c = "8"
+        elseif t <= 350 then
+            -- blue
+            text_c = "3"
+        elseif t < 600 then
+            -- green
+            text_c = "D"
+        elseif t < 1000 then
+            -- yellow
+            text_c = "4"
+            -- back_c = "8"
+        elseif t < 1200 then
+            -- orange
+            text_c = "1"
+        elseif t < 1300 then
+            -- red
+            text_c = "E"
+        else
+            -- pink
+            text_c = "2"
+        end
+
+        -- draw pattern
+        for y = start_y, inner_height + (start_y - 1) do
+            e.window.setCursorPos(start_x, y)
+            for _ = 1, inner_width do
+                if alternator then
+                    i = i + 1
+                    e.window.blit("\x07", text_c, back_c)
+                else
+                    e.window.blit("\x07", "7", "8")
+                end
+
+                alternator = not alternator
+            end
+
+            if inner_width % 2 == 0 then alternator = not alternator end
+        end
+
+        -- reset alternator
+        alternator = true
+    end
+
+    -- on state change
+    ---@param temperature number temperature in Kelvin
+    function e.on_update(temperature)
+        e.value = temperature
+        draw_core(e.value)
+    end
+
+    -- set temperature to display
+    ---@param val number degrees K
+    function e.set_value(val) e.on_update(val) end
+
+    -- resize reactor dimensions
+    ---@param reactor_l integer reactor length (rendered in 2D top-down as width)
+    ---@param reactor_w integer reactor width (rendered in 2D top-down as height)
+    function e.resize(reactor_l, reactor_w)
+        -- enforce possible dimensions
+        if reactor_l > 18 then reactor_l = 18 elseif reactor_l < 3 then reactor_l = 3 end
+        if reactor_w > 18 then reactor_w = 18 elseif reactor_w < 3 then reactor_w = 3 end
+
+        -- update dimensions
+        core_l = reactor_l - 2
+        core_w = reactor_w - 2
+        shift_x = 8 - math.floor(core_l / 2)
+        shift_y = 8 - math.floor(core_w / 2)
+        start_x = 2 + shift_x
+        start_y = 2 + shift_y
+        inner_width = core_l
+        inner_height = core_w
+
+        e.window.clear()
+
+        -- re-draw
+        draw_frame()
+        e.on_update(e.value)
+    end
+
+    -- initial (one-time except for resize()) frame draw
+    draw_frame()
+
+    -- initial draw
+    e.on_update(0)
+
+    return e.get()
+end
+
+return core_map

graphics/elements/indicators/data.lua

@@ -0,0 +1,93 @@
+-- Data Indicator Graphics Element
+
+local util    = require("scada-common.util")
+
+local element = require("graphics.element")
+
+---@class data_indicator_args
+---@field label string indicator label
+---@field unit? string indicator unit
+---@field format string data format (lua string format)
+---@field commas? boolean whether to use commas if a number is given (default to false)
+---@field lu_colors? cpair label foreground color (a), unit foreground color (b)
+---@field value any default value
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field width integer length
+---@field fg_bg? cpair foreground/background colors
+
+-- new data indicator
+---@nodiscard
+---@param args data_indicator_args
+---@return graphics_element element, element_id id
+local function data(args)
+    assert(type(args.label) == "string", "graphics.elements.indicators.data: label is a required field")
+    assert(type(args.format) == "string", "graphics.elements.indicators.data: format is a required field")
+    assert(args.value ~= nil, "graphics.elements.indicators.data: value is a required field")
+    assert(util.is_int(args.width), "graphics.elements.indicators.data: width is a required field")
+
+    -- single line
+    args.height = 1
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- label color
+    if args.lu_colors ~= nil then
+        e.window.setTextColor(args.lu_colors.color_a)
+    end
+
+    -- write label
+    e.window.setCursorPos(1, 1)
+    e.window.write(args.label)
+
+    local label_len = string.len(args.label)
+    local data_start = 1
+    local clear_width = args.width
+
+    if label_len > 0 then
+        data_start = data_start + (label_len + 1)
+        clear_width = args.width - (label_len + 1)
+    end
+
+    -- on state change
+    ---@param value any new value
+    function e.on_update(value)
+        e.value = value
+
+        -- clear old data and label
+        e.window.setCursorPos(data_start, 1)
+        e.window.write(util.spaces(clear_width))
+
+        -- write data
+        local data_str = util.sprintf(args.format, value)
+        e.window.setCursorPos(data_start, 1)
+        e.window.setTextColor(e.fg_bg.fgd)
+        if args.commas then
+            e.window.write(util.comma_format(data_str))
+        else
+            e.window.write(data_str)
+        end
+
+        -- write label
+        if args.unit ~= nil then
+            if args.lu_colors ~= nil then
+                e.window.setTextColor(args.lu_colors.color_b)
+            end
+            e.window.write(" " .. args.unit)
+        end
+    end
+
+    -- set the value
+    ---@param val any new value
+    function e.set_value(val) e.on_update(val) end
+
+    -- initial value draw
+    e.on_update(args.value)
+
+    return e.get()
+end
+
+return data

graphics/elements/indicators/hbar.lua

@@ -0,0 +1,125 @@
+-- Horizontal Bar Graphics Element
+
+local util    = require("scada-common.util")
+
+local element = require("graphics.element")
+
+---@class hbar_args
+---@field show_percent? boolean whether or not to show the percent
+---@field bar_fg_bg? cpair bar foreground/background colors if showing percent
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field width? integer parent width if omitted
+---@field height? integer parent height if omitted
+---@field gframe? graphics_frame frame instead of x/y/width/height
+---@field fg_bg? cpair foreground/background colors
+
+-- new horizontal bar
+---@nodiscard
+---@param args hbar_args
+---@return graphics_element element, element_id id
+local function hbar(args)
+    -- properties/state
+    local last_num_bars = -1
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- bar width is width - 5 characters for " 100%" if showing percent
+    local bar_width = util.trinary(args.show_percent, e.frame.w - 5, e.frame.w)
+
+    assert(bar_width > 0, "graphics.elements.indicators.hbar: too small for bar")
+
+    -- determine bar colors
+    local bar_bkg = e.fg_bg.blit_bkg
+    local bar_fgd = e.fg_bg.blit_fgd
+    if args.bar_fg_bg ~= nil then
+        bar_bkg = args.bar_fg_bg.blit_bkg
+        bar_fgd = args.bar_fg_bg.blit_fgd
+    end
+
+    -- handle data changes
+    ---@param fraction number 0.0 to 1.0
+    function e.on_update(fraction)
+        e.value = fraction
+
+        -- enforce minimum and maximum
+        if fraction < 0 then
+            fraction = 0.0
+        elseif fraction > 1 then
+            fraction = 1.0
+        end
+
+        -- compute number of bars
+        local num_bars = util.round(fraction * (bar_width * 2))
+
+        -- redraw bar if changed
+        if num_bars ~= last_num_bars then
+            last_num_bars = num_bars
+
+            local fgd = ""
+            local bkg = ""
+            local spaces = ""
+
+            -- fill percentage
+            for _ = 1, num_bars / 2 do
+                spaces = spaces .. " "
+                fgd = fgd .. bar_fgd
+                bkg = bkg .. bar_bkg
+            end
+
+            -- add fractional bar if needed
+            if num_bars % 2 == 1 then
+                spaces = spaces .. "\x95"
+                fgd = fgd .. bar_bkg
+                bkg = bkg .. bar_fgd
+            end
+
+            -- pad background
+            for _ = 1, ((bar_width * 2) - num_bars) / 2 do
+                spaces = spaces .. " "
+                fgd = fgd .. bar_bkg
+                bkg = bkg .. bar_bkg
+            end
+
+            -- draw bar
+            for y = 1, e.frame.h do
+                e.window.setCursorPos(1, y)
+                -- intentionally swapped fgd/bkg since we use spaces as fill, but they are the opposite
+                e.window.blit(spaces, bkg, fgd)
+            end
+        end
+
+        -- update percentage
+        if args.show_percent then
+            e.window.setCursorPos(bar_width + 2, math.max(1, math.ceil(e.frame.h / 2)))
+            e.window.write(util.sprintf("%3.0f%%", fraction * 100))
+        end
+    end
+
+    -- change bar color
+    ---@param bar_fg_bg cpair new bar colors
+    function e.recolor(bar_fg_bg)
+        bar_bkg = bar_fg_bg.blit_bkg
+        bar_fgd = bar_fg_bg.blit_fgd
+
+        -- re-draw
+        last_num_bars = 0
+        if type(e.value) == "number" then
+            e.on_update(e.value)
+        end
+    end
+
+    -- set the percentage value
+    ---@param val number 0.0 to 1.0
+    function e.set_value(val) e.on_update(val) end
+
+    -- initialize to 0
+    e.on_update(0)
+
+    return e.get()
+end
+
+return hbar

graphics/elements/indicators/icon.lua

@@ -0,0 +1,74 @@
+-- Icon Indicator Graphics Element
+
+local util    = require("scada-common.util")
+
+local element = require("graphics.element")
+
+---@class icon_sym_color
+---@field color cpair
+---@field symbol string
+
+---@class icon_indicator_args
+---@field label string indicator label
+---@field states table state color and symbol table
+---@field value? integer default state, defaults to 1
+---@field min_label_width? integer label length if omitted
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field fg_bg? cpair foreground/background colors
+
+-- new icon indicator
+---@nodiscard
+---@param args icon_indicator_args
+---@return graphics_element element, element_id id
+local function icon(args)
+    assert(type(args.label) == "string", "graphics.elements.indicators.icon: label is a required field")
+    assert(type(args.states) == "table", "graphics.elements.indicators.icon: states is a required field")
+
+    -- single line
+    args.height = 1
+
+    -- determine width
+    args.width = math.max(args.min_label_width or 1, string.len(args.label)) + 4
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- state blit strings
+    local state_blit_cmds = {}
+    for i = 1, #args.states do
+        local sym_color = args.states[i]    ---@type icon_sym_color
+
+        table.insert(state_blit_cmds, {
+            text = " " .. sym_color.symbol .. " ",
+            fgd = util.strrep(sym_color.color.blit_fgd, 3),
+            bkg = util.strrep(sym_color.color.blit_bkg, 3)
+        })
+    end
+
+    -- write label and initial indicator light
+    e.window.setCursorPos(5, 1)
+    e.window.write(args.label)
+
+    -- on state change
+    ---@param new_state integer indicator state
+    function e.on_update(new_state)
+        local blit_cmd = state_blit_cmds[new_state]
+        e.value = new_state
+        e.window.setCursorPos(1, 1)
+        e.window.blit(blit_cmd.text, blit_cmd.fgd, blit_cmd.bkg)
+    end
+
+    -- set indicator state
+    ---@param val integer indicator state
+    function e.set_value(val) e.on_update(val) end
+
+    -- initial icon draw
+    e.on_update(args.value or 1)
+
+    return e.get()
+end
+
+return icon

graphics/elements/indicators/light.lua

@@ -0,0 +1,98 @@
+-- Indicator Light Graphics Element
+
+local util    = require("scada-common.util")
+
+local element = require("graphics.element")
+local flasher = require("graphics.flasher")
+
+---@class indicator_light_args
+---@field label string indicator label
+---@field colors cpair on/off colors (a/b respectively)
+---@field min_label_width? integer label length if omitted
+---@field flash? boolean whether to flash on true rather than stay on
+---@field period? PERIOD flash period
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field fg_bg? cpair foreground/background colors
+
+-- new indicator light
+---@nodiscard
+---@param args indicator_light_args
+---@return graphics_element element, element_id id
+local function indicator_light(args)
+    assert(type(args.label) == "string", "graphics.elements.indicators.light: label is a required field")
+    assert(type(args.colors) == "table", "graphics.elements.indicators.light: colors is a required field")
+
+    if args.flash then
+        assert(util.is_int(args.period), "graphics.elements.indicators.light: period is a required field if flash is enabled")
+    end
+
+    -- single line
+    args.height = 1
+
+    -- determine width
+    args.width = math.max(args.min_label_width or 1, string.len(args.label)) + 2
+
+    -- flasher state
+    local flash_on = true
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- called by flasher when enabled
+    local function flash_callback()
+        e.window.setCursorPos(1, 1)
+
+        if flash_on then
+            e.window.blit(" \x95", "0" .. args.colors.blit_a, args.colors.blit_a .. e.fg_bg.blit_bkg)
+        else
+            e.window.blit(" \x95", "0" .. args.colors.blit_b, args.colors.blit_b .. e.fg_bg.blit_bkg)
+        end
+
+        flash_on = not flash_on
+    end
+
+    -- enable light or start flashing
+    local function enable()
+        if args.flash then
+            flash_on = true
+            flasher.start(flash_callback, args.period)
+        else
+            e.window.setCursorPos(1, 1)
+            e.window.blit(" \x95", "0" .. args.colors.blit_a, args.colors.blit_a .. e.fg_bg.blit_bkg)
+        end
+    end
+
+    -- disable light or stop flashing
+    local function disable()
+        if args.flash then
+            flash_on = false
+            flasher.stop(flash_callback)
+        end
+
+        e.window.setCursorPos(1, 1)
+        e.window.blit(" \x95", "0" .. args.colors.blit_b, args.colors.blit_b .. e.fg_bg.blit_bkg)
+    end
+
+    -- on state change
+    ---@param new_state boolean indicator state
+    function e.on_update(new_state)
+        e.value = new_state
+        if new_state then enable() else disable() end
+    end
+
+    -- set indicator state
+    ---@param val boolean indicator state
+    function e.set_value(val) e.on_update(val) end
+
+    -- write label and initial indicator light
+    e.on_update(false)
+    e.window.setCursorPos(3, 1)
+    e.window.write(args.label)
+
+    return e.get()
+end
+
+return indicator_light

graphics/elements/indicators/power.lua

@@ -0,0 +1,85 @@
+-- Power Indicator Graphics Element
+
+local util    = require("scada-common.util")
+
+local element = require("graphics.element")
+
+---@class power_indicator_args
+---@field label string indicator label
+---@field format string power format override (lua string format)
+---@field rate boolean? whether to append /t to the end (power per tick)
+---@field lu_colors? cpair label foreground color (a), unit foreground color (b)
+---@field value any default value
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field width integer length
+---@field fg_bg? cpair foreground/background colors
+
+-- new power indicator
+---@nodiscard
+---@param args power_indicator_args
+---@return graphics_element element, element_id id
+local function power(args)
+    assert(args.value ~= nil, "graphics.elements.indicators.power: value is a required field")
+    assert(util.is_int(args.width), "graphics.elements.indicators.power: width is a required field")
+
+    -- single line
+    args.height = 1
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- label color
+    if args.lu_colors ~= nil then
+        e.window.setTextColor(args.lu_colors.color_a)
+    end
+
+    -- write label
+    e.window.setCursorPos(1, 1)
+    e.window.write(args.label)
+
+    local data_start = string.len(args.label) + 2
+    if string.len(args.label) == 0 then data_start = 1 end
+
+    -- on state change
+    ---@param value any new value
+    function e.on_update(value)
+        e.value = value
+
+        local data_str, unit = util.power_format(value, false, args.format)
+
+        -- write data
+        e.window.setCursorPos(data_start, 1)
+        e.window.setTextColor(e.fg_bg.fgd)
+        e.window.write(util.comma_format(data_str))
+
+        -- write unit
+        if args.lu_colors ~= nil then
+            e.window.setTextColor(args.lu_colors.color_b)
+        end
+
+        -- append per tick if rate is set
+        -- add space to FE so we don't end up with FEE (after having kFE for example)
+        if args.rate == true then
+            unit = unit .. "/t"
+            if unit == "FE/t" then unit = "FE/t " end
+        else
+            if unit == "FE" then unit = "FE " end
+        end
+
+        e.window.write(" " .. unit)
+    end
+
+    -- set the value
+    ---@param val any new value
+    function e.set_value(val) e.on_update(val) end
+
+    -- initial value draw
+    e.on_update(args.value)
+
+    return e.get()
+end
+
+return power

graphics/elements/indicators/rad.lua

@@ -0,0 +1,90 @@
+-- Radiation Indicator Graphics Element
+
+local types   = require("scada-common.types")
+local util    = require("scada-common.util")
+
+local element = require("graphics.element")
+
+---@class rad_indicator_args
+---@field label string indicator label
+---@field format string data format (lua string format)
+---@field commas? boolean whether to use commas if a number is given (default to false)
+---@field lu_colors? cpair label foreground color (a), unit foreground color (b)
+---@field value any default value
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field width integer length
+---@field fg_bg? cpair foreground/background colors
+
+-- new radiation indicator
+---@nodiscard
+---@param args rad_indicator_args
+---@return graphics_element element, element_id id
+local function rad(args)
+    assert(type(args.label) == "string", "graphics.elements.indicators.rad: label is a required field")
+    assert(type(args.format) == "string", "graphics.elements.indicators.rad: format is a required field")
+    assert(util.is_int(args.width), "graphics.elements.indicators.rad: width is a required field")
+
+    -- single line
+    args.height = 1
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- label color
+    if args.lu_colors ~= nil then
+        e.window.setTextColor(args.lu_colors.color_a)
+    end
+
+    -- write label
+    e.window.setCursorPos(1, 1)
+    e.window.write(args.label)
+
+    local label_len = string.len(args.label)
+    local data_start = 1
+    local clear_width = args.width
+
+    if label_len > 0 then
+        data_start = data_start + (label_len + 1)
+        clear_width = args.width - (label_len + 1)
+    end
+
+    -- on state change
+    ---@param value any new value
+    function e.on_update(value)
+        e.value = value.radiation
+
+        -- clear old data and label
+        e.window.setCursorPos(data_start, 1)
+        e.window.write(util.spaces(clear_width))
+
+        -- write data
+        local data_str = util.sprintf(args.format, e.value)
+        e.window.setCursorPos(data_start, 1)
+        e.window.setTextColor(e.fg_bg.fgd)
+        if args.commas then
+            e.window.write(util.comma_format(data_str))
+        else
+            e.window.write(data_str)
+        end
+
+        -- write unit
+        if args.lu_colors ~= nil then
+            e.window.setTextColor(args.lu_colors.color_b)
+        end
+        e.window.write(" " .. value.unit)
+    end
+
+    -- set the value
+    ---@param val any new value
+    function e.set_value(val) e.on_update(val) end
+
+    -- initial value draw
+    e.on_update(types.new_zero_radiation_reading())
+
+    return e.get()
+end
+
+return rad

graphics/elements/indicators/state.lua

@@ -0,0 +1,80 @@
+-- State (Text) Indicator Graphics Element
+
+local util    = require("scada-common.util")
+
+local element = require("graphics.element")
+
+---@class state_text_color
+---@field color cpair
+---@field text string
+
+---@class state_indicator_args
+---@field states table state color and text table
+---@field value? integer default state, defaults to 1
+---@field min_width? integer max state text length if omitted
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field height? integer 1 if omitted, must be an odd number
+---@field fg_bg? cpair foreground/background colors
+
+-- new state indicator
+---@nodiscard
+---@param args state_indicator_args
+---@return graphics_element element, element_id id
+local function state_indicator(args)
+    assert(type(args.states) == "table", "graphics.elements.indicators.state: states is a required field")
+
+    -- determine height
+    if util.is_int(args.height) then
+        assert(args.height % 2 == 1, "graphics.elements.indicators.state: height should be an odd number")
+    else
+        args.height = 1
+    end
+
+    -- initial guess at width
+    args.width = args.min_width or 1
+
+    -- state blit strings
+    local state_blit_cmds = {}
+    for i = 1, #args.states do
+        local state_def = args.states[i]    ---@type state_text_color
+
+        -- re-determine width
+        if string.len(state_def.text) > args.width then
+            args.width = string.len(state_def.text)
+        end
+
+        local text = util.pad(state_def.text, args.width)
+
+        table.insert(state_blit_cmds, {
+            text = text,
+            fgd = util.strrep(state_def.color.blit_fgd, string.len(text)),
+            bkg = util.strrep(state_def.color.blit_bkg, string.len(text))
+        })
+    end
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- on state change
+    ---@param new_state integer indicator state
+    function e.on_update(new_state)
+        local blit_cmd = state_blit_cmds[new_state]
+        e.value = new_state
+        e.window.setCursorPos(1, 1)
+        e.window.blit(blit_cmd.text, blit_cmd.fgd, blit_cmd.bkg)
+    end
+
+    -- set indicator state
+    ---@param val integer indicator state
+    function e.set_value(val) e.on_update(val) end
+
+    -- initial draw
+    e.on_update(args.value or 1)
+
+    return e.get()
+end
+
+return state_indicator

graphics/elements/indicators/trilight.lua

@@ -0,0 +1,111 @@
+-- Tri-State Indicator Light Graphics Element
+
+local util    = require("scada-common.util")
+
+local element = require("graphics.element")
+local flasher = require("graphics.flasher")
+
+---@class tristate_indicator_light_args
+---@field label string indicator label
+---@field c1 color color for state 1
+---@field c2 color color for state 2
+---@field c3 color color for state 3
+---@field min_label_width? integer label length if omitted
+---@field flash? boolean whether to flash on state 2 or 3 rather than stay on
+---@field period? PERIOD flash period
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field fg_bg? cpair foreground/background colors
+
+-- new tri-state indicator light
+---@nodiscard
+---@param args tristate_indicator_light_args
+---@return graphics_element element, element_id id
+local function tristate_indicator_light(args)
+    assert(type(args.label) == "string", "graphics.elements.indicators.trilight: label is a required field")
+    assert(type(args.c1) == "number", "graphics.elements.indicators.trilight: c1 is a required field")
+    assert(type(args.c2) == "number", "graphics.elements.indicators.trilight: c2 is a required field")
+    assert(type(args.c3) == "number", "graphics.elements.indicators.trilight: c3 is a required field")
+
+    if args.flash then
+        assert(util.is_int(args.period), "graphics.elements.indicators.trilight: period is a required field if flash is enabled")
+    end
+
+    -- single line
+    args.height = 1
+
+    -- determine width
+    args.width = math.max(args.min_label_width or 1, string.len(args.label)) + 2
+
+    -- flasher state
+    local flash_on = true
+
+    -- blit translations
+    local c1 = colors.toBlit(args.c1)
+    local c2 = colors.toBlit(args.c2)
+    local c3 = colors.toBlit(args.c3)
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- init value for initial check in on_update
+    e.value = 1
+
+    -- called by flasher when enabled
+    local function flash_callback()
+        e.window.setCursorPos(1, 1)
+
+        if flash_on then
+            if e.value == 2 then
+                e.window.blit(" \x95", "0" .. c2, c2 .. e.fg_bg.blit_bkg)
+            elseif e.value == 3 then
+                e.window.blit(" \x95", "0" .. c3, c3 .. e.fg_bg.blit_bkg)
+            end
+        else
+            e.window.blit(" \x95", "0" .. c1, c1 .. e.fg_bg.blit_bkg)
+        end
+
+        flash_on = not flash_on
+    end
+
+    -- on state change
+    ---@param new_state integer indicator state
+    function e.on_update(new_state)
+        local was_off = e.value <= 1
+
+        e.value = new_state
+        e.window.setCursorPos(1, 1)
+
+        if args.flash then
+            if was_off and (new_state > 1) then
+                flash_on = true
+                flasher.start(flash_callback, args.period)
+            elseif new_state <= 1 then
+                flash_on = false
+                flasher.stop(flash_callback)
+
+                e.window.blit(" \x95", "0" .. c1, c1 .. e.fg_bg.blit_bkg)
+            end
+        elseif new_state == 2 then
+            e.window.blit(" \x95", "0" .. c2, c2 .. e.fg_bg.blit_bkg)
+        elseif new_state == 3 then
+            e.window.blit(" \x95", "0" .. c3, c3 .. e.fg_bg.blit_bkg)
+        else
+            e.window.blit(" \x95", "0" .. c1, c1 .. e.fg_bg.blit_bkg)
+        end
+    end
+
+    -- set indicator state
+    ---@param val integer indicator state
+    function e.set_value(val) e.on_update(val) end
+
+    -- write label and initial indicator light
+    e.on_update(1)
+    e.window.write(args.label)
+
+    return e.get()
+end
+
+return tristate_indicator_light

graphics/elements/indicators/vbar.lua

@@ -0,0 +1,105 @@
+-- Vertical Bar Graphics Element
+
+local util    = require("scada-common.util")
+
+local element = require("graphics.element")
+
+---@class vbar_args
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field width? integer parent width if omitted
+---@field height? integer parent height if omitted
+---@field gframe? graphics_frame frame instead of x/y/width/height
+---@field fg_bg? cpair foreground/background colors
+
+-- new vertical bar
+---@nodiscard
+---@param args vbar_args
+---@return graphics_element element, element_id id
+local function vbar(args)
+    -- properties/state
+    local last_num_bars = -1
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- blit strings
+    local fgd = util.strrep(e.fg_bg.blit_fgd, e.frame.w)
+    local bkg = util.strrep(e.fg_bg.blit_bkg, e.frame.w)
+    local spaces = util.spaces(e.frame.w)
+    local one_third = util.strrep("\x8f", e.frame.w)
+    local two_thirds = util.strrep("\x83", e.frame.w)
+
+    -- handle data changes
+    ---@param fraction number 0.0 to 1.0
+    function e.on_update(fraction)
+        e.value = fraction
+
+        -- enforce minimum and maximum
+        if fraction < 0 then
+            fraction = 0.0
+        elseif fraction > 1 then
+            fraction = 1.0
+        end
+
+        -- compute number of bars
+        local num_bars = util.round(fraction * (e.frame.h * 3))
+
+        -- redraw only if number of bars has changed
+        if num_bars ~= last_num_bars then
+            last_num_bars = num_bars
+
+            -- start bottom up
+            local y = e.frame.h
+
+            -- start at base of vertical bar
+            e.window.setCursorPos(1, y)
+
+            -- fill percentage
+            for _ = 1, num_bars / 3 do
+                e.window.blit(spaces, bkg, fgd)
+                y = y - 1
+                e.window.setCursorPos(1, y)
+            end
+
+            -- add fractional bar if needed
+            if num_bars % 3 == 1 then
+                e.window.blit(one_third, bkg, fgd)
+                y = y - 1
+            elseif num_bars % 3 == 2 then
+                e.window.blit(two_thirds, bkg, fgd)
+                y = y - 1
+            end
+
+            -- fill the rest blank
+            while y > 0 do
+                e.window.setCursorPos(1, y)
+                e.window.blit(spaces, fgd, bkg)
+                y = y - 1
+            end
+        end
+    end
+
+    -- change bar color
+    ---@param fg_bg cpair new bar colors
+    function e.recolor(fg_bg)
+        fgd = util.strrep(fg_bg.blit_fgd, e.frame.w)
+        bkg = util.strrep(fg_bg.blit_bkg, e.frame.w)
+
+        -- re-draw
+        last_num_bars = 0
+        if type(e.value) == "number" then
+            e.on_update(e.value)
+        end
+    end
+
+    -- set the percentage value
+    ---@param val number 0.0 to 1.0
+    function e.set_value(val) e.on_update(val) end
+
+    return e.get()
+end
+
+return vbar

graphics/elements/pipenet.lua

@@ -0,0 +1,147 @@
+-- Pipe Graphics Element
+
+local util    = require("scada-common.util")
+
+local core    = require("graphics.core")
+local element = require("graphics.element")
+
+---@class pipenet_args
+---@field pipes table pipe list
+---@field bg? color background color
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+
+-- new pipe network
+---@param args pipenet_args
+---@return graphics_element element, element_id id
+local function pipenet(args)
+    assert(type(args.pipes) == "table", "graphics.elements.indicators.pipenet: pipes is a required field")
+
+    args.width = 0
+    args.height = 0
+
+    -- determine width/height
+    for i = 1, #args.pipes do
+        local pipe = args.pipes[i]  ---@type pipe
+
+        local true_w = pipe.w + math.min(pipe.x1, pipe.x2)
+        local true_h = pipe.h + math.min(pipe.y1, pipe.y2)
+
+        if true_w > args.width  then args.width  = true_w end
+        if true_h > args.height then args.height = true_h end
+    end
+
+    args.x = args.x or 1
+    args.y = args.y or 1
+
+    if args.bg ~= nil then
+        args.fg_bg = core.graphics.cpair(args.bg, args.bg)
+    end
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- draw all pipes
+    for p = 1, #args.pipes do
+        local pipe = args.pipes[p]  ---@type pipe
+
+        local x = 1 + pipe.x1
+        local y = 1 + pipe.y1
+
+        local x_step = util.trinary(pipe.x1 >= pipe.x2, -1, 1)
+        local y_step = util.trinary(pipe.y1 >= pipe.y2, -1, 1)
+
+        e.window.setCursorPos(x, y)
+
+        local c = core.graphics.cpair(pipe.color, e.fg_bg.bkg)
+
+        if pipe.align_tr then
+            -- cross width then height
+            for i = 1, pipe.w do
+                if pipe.thin then
+                    if i == pipe.w then
+                        -- corner
+                        if y_step > 0 then
+                            e.window.blit("\x93", c.blit_bkg, c.blit_fgd)
+                        else
+                            e.window.blit("\x8e", c.blit_fgd, c.blit_bkg)
+                        end
+                    else
+                        e.window.blit("\x8c", c.blit_fgd, c.blit_bkg)
+                    end
+                else
+                    if i == pipe.w and y_step > 0 then
+                        -- corner
+                        e.window.blit(" ", c.blit_bkg, c.blit_fgd)
+                    else
+                        e.window.blit("\x8f", c.blit_fgd, c.blit_bkg)
+                    end
+                end
+
+                x = x + x_step
+                e.window.setCursorPos(x, y)
+            end
+
+            -- back up one
+            x = x - x_step
+
+            for _ = 1, pipe.h - 1 do
+                y = y + y_step
+                e.window.setCursorPos(x, y)
+
+                if pipe.thin then
+                    e.window.blit("\x95", c.blit_bkg, c.blit_fgd)
+                else
+                    e.window.blit(" ", c.blit_bkg, c.blit_fgd)
+                end
+            end
+        else
+            -- cross height then width
+            for i = 1, pipe.h do
+                if pipe.thin then
+                    if i == pipe.h then
+                        -- corner
+                        if y_step < 0 then
+                            e.window.blit("\x97", c.blit_bkg, c.blit_fgd)
+                        else
+                            e.window.blit("\x8d", c.blit_fgd, c.blit_bkg)
+                        end
+                    else
+                        e.window.blit("\x95", c.blit_fgd, c.blit_bkg)
+                    end
+                else
+                    if i == pipe.h and y_step < 0 then
+                        -- corner
+                        e.window.blit("\x83", c.blit_bkg, c.blit_fgd)
+                    else
+                        e.window.blit(" ", c.blit_bkg, c.blit_fgd)
+                    end
+                end
+
+                y = y + y_step
+                e.window.setCursorPos(x, y)
+            end
+
+            -- back up one
+            y = y - y_step
+
+            for _ = 1, pipe.w - 1 do
+                x = x + x_step
+                e.window.setCursorPos(x, y)
+
+                if pipe.thin then
+                    e.window.blit("\x8c", c.blit_fgd, c.blit_bkg)
+                else
+                    e.window.blit("\x83", c.blit_bkg, c.blit_fgd)
+                end
+            end
+        end
+
+    end
+
+    return e.get()
+end
+
+return pipenet

graphics/elements/rectangle.lua

@@ -0,0 +1,159 @@
+-- Rectangle Graphics Element
+
+local util    = require("scada-common.util")
+
+local element = require("graphics.element")
+
+---@class rectangle_args
+---@field border? graphics_border
+---@field thin? boolean true to use extra thin even borders
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field width? integer parent width if omitted
+---@field height? integer parent height if omitted
+---@field gframe? graphics_frame frame instead of x/y/width/height
+---@field fg_bg? cpair foreground/background colors
+
+-- new rectangle
+---@param args rectangle_args
+---@return graphics_element element, element_id id
+local function rectangle(args)
+    assert(args.border ~= nil or args.thin ~= true, "graphics.elements.rectangle: thin requires border to be provided")
+
+    -- if thin, then width will always need to be 1
+    if args.thin == true then
+        args.border.width = 1
+        args.border.even = true
+    end
+
+    -- offset children
+    if args.border ~= nil then
+        args.offset_x = args.border.width
+        args.offset_y = args.border.width
+
+        -- slightly different y offset if the border is set to even
+        if args.border.even then
+            local width_x2 = (2 * args.border.width)
+            args.offset_y = math.floor(width_x2 / 3) + util.trinary(width_x2 % 3 > 0, 1, 0)
+        end
+    end
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- draw bordered box if requested
+    -- element constructor will have drawn basic colored rectangle regardless
+    if args.border ~= nil then
+        e.window.setCursorPos(1, 1)
+
+        local border_width = args.offset_x
+        local border_height = args.offset_y
+        local border_blit = colors.toBlit(args.border.color)
+        local width_x2 = border_width * 2
+        local inner_width = e.frame.w - width_x2
+
+        -- check dimensions
+        assert(width_x2 <= e.frame.w, "graphics.elements.rectangle: border too thick for width")
+        assert(width_x2 <= e.frame.h, "graphics.elements.rectangle: border too thick for height")
+
+        -- form the basic line strings and top/bottom blit strings
+        local spaces = util.spaces(e.frame.w)
+        local blit_fg = util.strrep(e.fg_bg.blit_fgd, e.frame.w)
+        local blit_fg_sides = blit_fg
+        local blit_bg_sides = ""
+        local blit_bg_top_bot = util.strrep(border_blit, e.frame.w)
+
+        -- partial bars
+        local p_a = util.spaces(border_width) .. util.strrep("\x8f", inner_width) .. util.spaces(border_width)
+        local p_b = util.spaces(border_width) .. util.strrep("\x83", inner_width) .. util.spaces(border_width)
+        local p_s = spaces
+
+        if args.thin == true then
+            p_a = "\x97" .. util.strrep("\x83", inner_width) .. "\x94"
+            p_b = "\x8a" .. util.strrep("\x8f", inner_width) .. "\x85"
+            p_s = "\x95" .. util.spaces(inner_width) .. "\x95"
+        end
+
+        local p_inv_fg = util.strrep(border_blit, border_width) .. util.strrep(e.fg_bg.blit_bkg, inner_width) ..
+                            util.strrep(border_blit, border_width)
+        local p_inv_bg = util.strrep(e.fg_bg.blit_bkg, border_width) .. util.strrep(border_blit, inner_width) ..
+                            util.strrep(e.fg_bg.blit_bkg, border_width)
+
+        if args.thin == true then
+            p_inv_fg = e.fg_bg.blit_bkg .. util.strrep(e.fg_bg.blit_bkg, inner_width) .. util.strrep(border_blit, border_width)
+            p_inv_bg = border_blit .. util.strrep(border_blit, inner_width) .. util.strrep(e.fg_bg.blit_bkg, border_width)
+
+            blit_fg_sides = border_blit .. util.strrep(e.fg_bg.blit_bkg, inner_width) .. e.fg_bg.blit_bkg
+        end
+
+        -- form the body blit strings (sides are border, inside is normal)
+        for x = 1, e.frame.w do
+            -- edges get border color, center gets normal
+            if x <= border_width or x > (e.frame.w - border_width) then
+                if args.thin and x == 1 then
+                    blit_bg_sides = blit_bg_sides .. e.fg_bg.blit_bkg
+                else
+                    blit_bg_sides = blit_bg_sides .. border_blit
+                end
+            else
+                blit_bg_sides = blit_bg_sides .. e.fg_bg.blit_bkg
+            end
+        end
+
+        -- draw rectangle with borders
+        for y = 1, e.frame.h do
+            e.window.setCursorPos(1, y)
+            -- top border
+            if y <= border_height then
+                -- partial pixel fill
+                if args.border.even and y == border_height then
+                    if args.thin == true then
+                        e.window.blit(p_a, p_inv_bg, p_inv_fg)
+                    else
+                        if width_x2 % 3 == 1 then
+                            e.window.blit(p_b, p_inv_bg, p_inv_fg)
+                        elseif width_x2 % 3 == 2 then
+                            e.window.blit(p_a, p_inv_bg, p_inv_fg)
+                        else
+                            -- skip line
+                            e.window.blit(spaces, blit_fg, blit_bg_sides)
+                        end
+                    end
+                else
+                    e.window.blit(spaces, blit_fg, blit_bg_top_bot)
+                end
+            -- bottom border
+            elseif y > (e.frame.h - border_width) then
+                -- partial pixel fill
+                if args.border.even and y == ((e.frame.h - border_width) + 1) then
+                    if args.thin == true then
+                        e.window.blit(p_b, util.strrep(e.fg_bg.blit_bkg, e.frame.w), blit_bg_top_bot)
+                    else
+                        if width_x2 % 3 == 1 then
+                            e.window.blit(p_a, p_inv_fg, blit_bg_top_bot)
+                        elseif width_x2 % 3 == 2 or (args.thin == true) then
+                            e.window.blit(p_b, p_inv_fg, blit_bg_top_bot)
+                        else
+                            -- skip line
+                            e.window.blit(spaces, blit_fg, blit_bg_sides)
+                        end
+                    end
+                else
+                    e.window.blit(spaces, blit_fg, blit_bg_top_bot)
+                end
+            else
+                if args.thin == true then
+                    e.window.blit(p_s, blit_fg_sides, blit_bg_sides)
+                else
+                    e.window.blit(p_s, blit_fg, blit_bg_sides)
+                end
+            end
+        end
+    end
+
+    return e.get()
+end
+
+return rectangle

graphics/elements/textbox.lua

@@ -0,0 +1,70 @@
+-- Text Box Graphics Element
+
+local util    = require("scada-common.util")
+
+local core    = require("graphics.core")
+local element = require("graphics.element")
+
+local TEXT_ALIGN = core.graphics.TEXT_ALIGN
+
+---@class textbox_args
+---@field text string text to show
+---@field alignment? TEXT_ALIGN text alignment, left by default
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field width? integer parent width if omitted
+---@field height? integer parent height if omitted
+---@field gframe? graphics_frame frame instead of x/y/width/height
+---@field fg_bg? cpair foreground/background colors
+
+-- new text box
+---@param args textbox_args
+---@return graphics_element element, element_id id
+local function textbox(args)
+    assert(type(args.text) == "string", "graphics.elements.textbox: text is a required field")
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    local alignment = args.alignment or TEXT_ALIGN.LEFT
+
+    -- draw textbox
+
+    local function display_text(text)
+        e.value = text
+
+        local lines = util.strwrap(text, e.frame.w)
+
+        for i = 1, #lines do
+            if i > e.frame.h then break end
+
+            local len = string.len(lines[i])
+
+            -- use cursor position to align this line
+            if alignment == TEXT_ALIGN.CENTER then
+                e.window.setCursorPos(math.floor((e.frame.w - len) / 2) + 1, i)
+            elseif alignment == TEXT_ALIGN.RIGHT then
+                e.window.setCursorPos((e.frame.w - len) + 1, i)
+            else
+                e.window.setCursorPos(1, i)
+            end
+
+            e.window.write(lines[i])
+        end
+    end
+
+    display_text(args.text)
+
+    -- set the string value and re-draw the text
+    ---@param val string value
+    function e.set_value(val)
+        e.window.clear()
+        display_text(val)
+    end
+
+    return e.get()
+end
+
+return textbox

graphics/elements/tiling.lua

@@ -0,0 +1,87 @@
+-- "Basketweave" Tiling Graphics Element
+
+local util    = require("scada-common.util")
+
+local element = require("graphics.element")
+
+---@class tiling_args
+---@field fill_c cpair colors to fill with
+---@field even? boolean whether to account for rectangular pixels
+---@field border_c? color optional frame color
+---@field parent graphics_element
+---@field id? string element id
+---@field x? integer 1 if omitted
+---@field y? integer 1 if omitted
+---@field width? integer parent width if omitted
+---@field height? integer parent height if omitted
+---@field gframe? graphics_frame frame instead of x/y/width/height
+---@field fg_bg? cpair foreground/background colors
+
+-- new tiling box
+---@param args tiling_args
+---@return graphics_element element, element_id id
+local function tiling(args)
+    assert(type(args.fill_c) == "table", "graphics.elements.tiling: fill_c is a required field")
+
+    -- create new graphics element base object
+    local e = element.new(args)
+
+    -- draw tiling box
+
+    local fill_a = args.fill_c.blit_a
+    local fill_b = args.fill_c.blit_b
+
+    local even = args.even == true
+
+    local start_x = 1
+    local start_y = 1
+    local inner_width = math.floor(e.frame.w / util.trinary(even, 2, 1))
+    local inner_height = e.frame.h
+    local alternator = true
+
+    -- border
+    if args.border_c ~= nil then
+        e.window.setBackgroundColor(args.border_c)
+        e.window.clear()
+
+        start_x = 1 + util.trinary(even, 2, 1)
+        start_y = 2
+
+        inner_width = math.floor((e.frame.w - 2 * util.trinary(even, 2, 1)) / util.trinary(even, 2, 1))
+        inner_height = e.frame.h - 2
+    end
+
+    -- check dimensions
+    assert(inner_width > 0, "graphics.elements.tiling: inner_width <= 0")
+    assert(inner_height > 0, "graphics.elements.tiling: inner_height <= 0")
+    assert(start_x <= inner_width, "graphics.elements.tiling: start_x > inner_width")
+    assert(start_y <= inner_height, "graphics.elements.tiling: start_y > inner_height")
+
+    -- create pattern
+    for y = start_y, inner_height + (start_y - 1) do
+        e.window.setCursorPos(start_x, y)
+        for _ = 1, inner_width do
+            if alternator then
+                if even then
+                    e.window.blit("  ", "00", fill_a .. fill_a)
+                else
+                    e.window.blit(" ", "0", fill_a)
+                end
+            else
+                if even then
+                    e.window.blit("  ", "00", fill_b .. fill_b)
+                else
+                    e.window.blit(" ", "0", fill_b)
+                end
+            end
+
+            alternator = not alternator
+        end
+
+        if inner_width % 2 == 0 then alternator = not alternator end
+    end
+
+    return e.get()
+end
+
+return tiling

graphics/flasher.lua

@@ -0,0 +1,80 @@
+--
+-- Indicator Light Flasher
+--
+
+local tcd = require("scada-common.tcallbackdsp")
+
+local flasher = {}
+
+-- note: no additional call needs to be made in a main loop as this class automatically uses the TCD to operate
+
+---@alias PERIOD integer
+local PERIOD = {
+    BLINK_250_MS = 1,
+    BLINK_500_MS = 2,
+    BLINK_1000_MS = 3
+}
+
+flasher.PERIOD = PERIOD
+
+local active = false
+local registry = { {}, {}, {} } -- one registry table per period
+local callback_counter = 0
+
+-- blink registered indicators<br>
+-- this assumes it is called every 250ms, it does no checking of time on its own
+local function callback_250ms()
+    if active then
+        for _, f in ipairs(registry[PERIOD.BLINK_250_MS]) do f() end
+
+        if callback_counter % 2 == 0 then
+            for _, f in ipairs(registry[PERIOD.BLINK_500_MS]) do f() end
+        end
+
+        if callback_counter % 4 == 0 then
+            for _, f in ipairs(registry[PERIOD.BLINK_1000_MS]) do f() end
+        end
+
+        callback_counter = callback_counter + 1
+
+        tcd.dispatch_unique(0.25, callback_250ms)
+    end
+end
+
+-- start/resume the flasher periodic
+function flasher.run()
+    active = true
+    callback_250ms()
+end
+
+-- clear all blinking indicators and stop the flasher periodic
+function flasher.clear()
+    active = false
+    callback_counter = 0
+    registry = { {}, {}, {} }
+end
+
+-- register a function to be called on the selected blink period<br>
+-- times are not strictly enforced, but all with a given period will be set at the same time
+---@param f function function to call each period
+---@param period PERIOD time period option (1, 2, or 3)
+function flasher.start(f, period)
+    if type(registry[period]) == "table" then
+        table.insert(registry[period], f)
+    end
+end
+
+-- stop a function from being called at the blink period
+---@param f function function callback registered
+function flasher.stop(f)
+    for i = 1, #registry do
+        for key, val in ipairs(registry[i]) do
+            if val == f then
+                table.remove(registry[i], key)
+                return
+            end
+        end
+    end
+end
+
+return flasher

imgen.py

@@ -0,0 +1,106 @@
+import json
+import os
+
+# list files in a directory
+def list_files(path):
+    list = []
+
+    for (root, dirs, files) in os.walk(path):
+        for f in files:
+            list.append(root[2:] + "/" + f)
+
+    return list
+
+# get size of all files in a directory
+def dir_size(path):
+    total = 0
+
+    for (root, dirs, files) in os.walk(path):
+        for f in files:
+            total += os.path.getsize(root + "/" + f)
+
+    return total
+
+# get the version of an application at the provided path
+def get_version(path, is_comms = False):
+    ver = ""
+    string = "comms.version = \""
+
+    if not is_comms:
+        string = "_VERSION = \""
+
+    f = open(path, "r")
+
+    for line in f:
+        pos = line.find(string)
+        if pos >= 0:
+            ver = line[(pos + len(string)):(len(line) - 2)]
+            break
+
+    f.close()
+
+    return ver
+
+# generate installation manifest object
+def make_manifest(size):
+    manifest = {
+        "versions" : {
+            "installer" : get_version("./ccmsi.lua"),
+            "bootloader" : get_version("./startup.lua"),
+            "comms" : get_version("./scada-common/comms.lua", True),
+            "reactor-plc" : get_version("./reactor-plc/startup.lua"),
+            "rtu" : get_version("./rtu/startup.lua"),
+            "supervisor" : get_version("./supervisor/startup.lua"),
+            "coordinator" : get_version("./coordinator/startup.lua"),
+            "pocket" : get_version("./pocket/startup.lua")
+        },
+        "files" : {
+            # common files
+            "system" : [ "initenv.lua", "startup.lua" ],
+            "common" : list_files("./scada-common"),
+            "graphics" : list_files("./graphics"),
+            "lockbox" : list_files("./lockbox"),
+            # platform files
+            "reactor-plc" : list_files("./reactor-plc"),
+            "rtu" : list_files("./rtu"),
+            "supervisor" : list_files("./supervisor"),
+            "coordinator" : list_files("./coordinator"),
+            "pocket" : list_files("./pocket"),
+        },
+        "depends" : {
+            "reactor-plc" : [ "system", "common" ],
+            "rtu" : [ "system", "common" ],
+            "supervisor" : [ "system", "common" ],
+            "coordinator" : [ "system", "common", "graphics" ],
+            "pocket" : [ "system", "common", "graphics" ]
+        },
+        "sizes" : {
+            # manifest file estimate
+            "manifest" : size,
+            # common files
+            "system" : os.path.getsize("initenv.lua") + os.path.getsize("startup.lua"),
+            "common" : dir_size("./scada-common"),
+            "graphics" : dir_size("./graphics"),
+            "lockbox" : dir_size("./lockbox"),
+            # platform files
+            "reactor-plc" : dir_size("./reactor-plc"),
+            "rtu" : dir_size("./rtu"),
+            "supervisor" : dir_size("./supervisor"),
+            "coordinator" : dir_size("./coordinator"),
+            "pocket" : dir_size("./pocket"),
+        }
+    }
+
+    return manifest
+
+# write initial manifest with placeholder size
+f = open("install_manifest.json", "w")
+json.dump(make_manifest("-----"), f)
+f.close()
+
+manifest_size = os.path.getsize("install_manifest.json")
+
+# calculate file size then regenerate with embedded size
+f = open("install_manifest.json", "w")
+json.dump(make_manifest(manifest_size), f)
+f.close()

initenv.lua

@@ -2,17 +2,17 @@
 -- Initialize the Post-Boot Module Environment
 --
 
--- initialize booted environment
-local init_env = function ()
-    local _require = require("cc.require")
-    local _env = setmetatable({}, { __index = _ENV })
+return {
+    -- initialize booted environment
+    init_env = function ()
+        local _require = require("cc.require")
+        local _env = setmetatable({}, { __index = _ENV })
 
-    -- overwrite require/package globals
-    require, package = _require.make(_env, "/")
+        -- overwrite require/package globals
+        require, package = _require.make(_env, "/")
 
-    -- reset terminal
-    term.clear()
-    term.setCursorPos(1, 1)
-end
-
-return { init_env = init_env }
+        -- reset terminal
+        term.clear()
+        term.setCursorPos(1, 1)
+    end
+}

install_manifest.json

@@ -0,0 +1 @@
+{"versions": {"installer": "v1.0", "bootloader": "0.2", "comms": "1.4.0", "reactor-plc": "v1.0.0", "rtu": "v0.13.0", "supervisor": "v0.14.0", "coordinator": "v0.12.2", "pocket": "alpha-v0.0.0"}, "files": {"system": ["initenv.lua", "startup.lua"], "common": ["scada-common/crypto.lua", "scada-common/ppm.lua", "scada-common/comms.lua", "scada-common/psil.lua", "scada-common/tcallbackdsp.lua", "scada-common/rsio.lua", "scada-common/constants.lua", "scada-common/mqueue.lua", "scada-common/crash.lua", "scada-common/log.lua", "scada-common/types.lua", "scada-common/util.lua"], "graphics": ["graphics/element.lua", "graphics/flasher.lua", "graphics/core.lua", "graphics/elements/textbox.lua", "graphics/elements/displaybox.lua", "graphics/elements/pipenet.lua", "graphics/elements/rectangle.lua", "graphics/elements/div.lua", "graphics/elements/tiling.lua", "graphics/elements/colormap.lua", "graphics/elements/indicators/alight.lua", "graphics/elements/indicators/icon.lua", "graphics/elements/indicators/power.lua", "graphics/elements/indicators/rad.lua", "graphics/elements/indicators/state.lua", "graphics/elements/indicators/light.lua", "graphics/elements/indicators/vbar.lua", "graphics/elements/indicators/coremap.lua", "graphics/elements/indicators/data.lua", "graphics/elements/indicators/hbar.lua", "graphics/elements/indicators/trilight.lua", "graphics/elements/controls/switch_button.lua", "graphics/elements/controls/spinbox_numeric.lua", "graphics/elements/controls/hazard_button.lua", "graphics/elements/controls/push_button.lua", "graphics/elements/controls/radio_button.lua", "graphics/elements/controls/multi_button.lua", "graphics/elements/animations/waiting.lua"], "lockbox": ["lockbox/init.lua", "lockbox/LICENSE", "lockbox/kdf/pbkdf2.lua", "lockbox/util/bit.lua", "lockbox/util/array.lua", "lockbox/util/stream.lua", "lockbox/util/queue.lua", "lockbox/digest/sha2_224.lua", "lockbox/digest/sha1.lua", "lockbox/digest/sha2_256.lua", "lockbox/cipher/aes128.lua", "lockbox/cipher/aes256.lua", "lockbox/cipher/aes192.lua", "lockbox/cipher/mode/ofb.lua", "lockbox/cipher/mode/cbc.lua", "lockbox/cipher/mode/ctr.lua", "lockbox/cipher/mode/cfb.lua", "lockbox/mac/hmac.lua", "lockbox/padding/ansix923.lua", "lockbox/padding/pkcs7.lua", "lockbox/padding/zero.lua", "lockbox/padding/isoiec7816.lua"], "reactor-plc": ["reactor-plc/threads.lua", "reactor-plc/plc.lua", "reactor-plc/config.lua", "reactor-plc/startup.lua"], "rtu": ["rtu/threads.lua", "rtu/rtu.lua", "rtu/modbus.lua", "rtu/config.lua", "rtu/startup.lua", "rtu/dev/sps_rtu.lua", "rtu/dev/envd_rtu.lua", "rtu/dev/boilerv_rtu.lua", "rtu/dev/redstone_rtu.lua", "rtu/dev/sna_rtu.lua", "rtu/dev/imatrix_rtu.lua", "rtu/dev/turbinev_rtu.lua"], "supervisor": ["supervisor/supervisor.lua", "supervisor/unit.lua", "supervisor/config.lua", "supervisor/startup.lua", "supervisor/unitlogic.lua", "supervisor/facility.lua", "supervisor/session/coordinator.lua", "supervisor/session/svqtypes.lua", "supervisor/session/svsessions.lua", "supervisor/session/rtu.lua", "supervisor/session/plc.lua", "supervisor/session/rsctl.lua", "supervisor/session/rtu/boilerv.lua", "supervisor/session/rtu/txnctrl.lua", "supervisor/session/rtu/unit_session.lua", "supervisor/session/rtu/turbinev.lua", "supervisor/session/rtu/envd.lua", "supervisor/session/rtu/imatrix.lua", "supervisor/session/rtu/sps.lua", "supervisor/session/rtu/qtypes.lua", "supervisor/session/rtu/sna.lua", "supervisor/session/rtu/redstone.lua"], "coordinator": ["coordinator/coordinator.lua", "coordinator/renderer.lua", "coordinator/iocontrol.lua", "coordinator/sounder.lua", "coordinator/config.lua", "coordinator/startup.lua", "coordinator/apisessions.lua", "coordinator/process.lua", "coordinator/ui/dialog.lua", "coordinator/ui/style.lua", "coordinator/ui/layout/main_view.lua", "coordinator/ui/layout/unit_view.lua", "coordinator/ui/components/reactor.lua", "coordinator/ui/components/processctl.lua", "coordinator/ui/components/unit_overview.lua", "coordinator/ui/components/boiler.lua", "coordinator/ui/components/unit_detail.lua", "coordinator/ui/components/imatrix.lua", "coordinator/ui/components/unit_waiting.lua", "coordinator/ui/components/turbine.lua"], "pocket": ["pocket/config.lua", "pocket/startup.lua"]}, "depends": {"reactor-plc": ["system", "common"], "rtu": ["system", "common"], "supervisor": ["system", "common"], "coordinator": ["system", "common", "graphics"], "pocket": ["system", "common", "graphics"]}, "sizes": {"manifest": 4646, "system": 1982, "common": 91084, "graphics": 99858, "lockbox": 100797, "reactor-plc": 75529, "rtu": 82913, "supervisor": 274491, "coordinator": 180346, "pocket": 335}}

lockbox/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 James L.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

lockbox/cipher/aes128.lua

@@ -0,0 +1,415 @@
+local Array = require("lockbox.util.array");
+local Bit = require("lockbox.util.bit");
+
+local XOR = Bit.bxor;
+
+local SBOX = {
+ [0] = 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
+ 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
+ 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
+ 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
+ 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
+ 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
+ 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
+ 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
+ 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
+ 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
+ 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
+ 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
+ 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
+ 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
+ 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
+ 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16};
+
+local ISBOX = {
+ [0] = 0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
+ 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
+ 0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
+ 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
+ 0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
+ 0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
+ 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
+ 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
+ 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
+ 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
+ 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
+ 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
+ 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
+ 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
+ 0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
+ 0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D};
+
+local ROW_SHIFT =  {  1,  6, 11, 16,  5, 10, 15,  4,  9, 14,  3,  8, 13,  2,  7, 12, };
+local IROW_SHIFT = {  1, 14, 11,  8,  5,  2, 15, 12,  9,  6,  3, 16, 13, 10,  7,  4, };
+
+local ETABLE = {
+ [0] = 0x01, 0x03, 0x05, 0x0F, 0x11, 0x33, 0x55, 0xFF, 0x1A, 0x2E, 0x72, 0x96, 0xA1, 0xF8, 0x13, 0x35,
+ 0x5F, 0xE1, 0x38, 0x48, 0xD8, 0x73, 0x95, 0xA4, 0xF7, 0x02, 0x06, 0x0A, 0x1E, 0x22, 0x66, 0xAA,
+ 0xE5, 0x34, 0x5C, 0xE4, 0x37, 0x59, 0xEB, 0x26, 0x6A, 0xBE, 0xD9, 0x70, 0x90, 0xAB, 0xE6, 0x31,
+ 0x53, 0xF5, 0x04, 0x0C, 0x14, 0x3C, 0x44, 0xCC, 0x4F, 0xD1, 0x68, 0xB8, 0xD3, 0x6E, 0xB2, 0xCD,
+ 0x4C, 0xD4, 0x67, 0xA9, 0xE0, 0x3B, 0x4D, 0xD7, 0x62, 0xA6, 0xF1, 0x08, 0x18, 0x28, 0x78, 0x88,
+ 0x83, 0x9E, 0xB9, 0xD0, 0x6B, 0xBD, 0xDC, 0x7F, 0x81, 0x98, 0xB3, 0xCE, 0x49, 0xDB, 0x76, 0x9A,
+ 0xB5, 0xC4, 0x57, 0xF9, 0x10, 0x30, 0x50, 0xF0, 0x0B, 0x1D, 0x27, 0x69, 0xBB, 0xD6, 0x61, 0xA3,
+ 0xFE, 0x19, 0x2B, 0x7D, 0x87, 0x92, 0xAD, 0xEC, 0x2F, 0x71, 0x93, 0xAE, 0xE9, 0x20, 0x60, 0xA0,
+ 0xFB, 0x16, 0x3A, 0x4E, 0xD2, 0x6D, 0xB7, 0xC2, 0x5D, 0xE7, 0x32, 0x56, 0xFA, 0x15, 0x3F, 0x41,
+ 0xC3, 0x5E, 0xE2, 0x3D, 0x47, 0xC9, 0x40, 0xC0, 0x5B, 0xED, 0x2C, 0x74, 0x9C, 0xBF, 0xDA, 0x75,
+ 0x9F, 0xBA, 0xD5, 0x64, 0xAC, 0xEF, 0x2A, 0x7E, 0x82, 0x9D, 0xBC, 0xDF, 0x7A, 0x8E, 0x89, 0x80,
+ 0x9B, 0xB6, 0xC1, 0x58, 0xE8, 0x23, 0x65, 0xAF, 0xEA, 0x25, 0x6F, 0xB1, 0xC8, 0x43, 0xC5, 0x54,
+ 0xFC, 0x1F, 0x21, 0x63, 0xA5, 0xF4, 0x07, 0x09, 0x1B, 0x2D, 0x77, 0x99, 0xB0, 0xCB, 0x46, 0xCA,
+ 0x45, 0xCF, 0x4A, 0xDE, 0x79, 0x8B, 0x86, 0x91, 0xA8, 0xE3, 0x3E, 0x42, 0xC6, 0x51, 0xF3, 0x0E,
+ 0x12, 0x36, 0x5A, 0xEE, 0x29, 0x7B, 0x8D, 0x8C, 0x8F, 0x8A, 0x85, 0x94, 0xA7, 0xF2, 0x0D, 0x17,
+ 0x39, 0x4B, 0xDD, 0x7C, 0x84, 0x97, 0xA2, 0xFD, 0x1C, 0x24, 0x6C, 0xB4, 0xC7, 0x52, 0xF6, 0x01};
+
+local LTABLE = {
+ [0] = 0x00, 0x00, 0x19, 0x01, 0x32, 0x02, 0x1A, 0xC6, 0x4B, 0xC7, 0x1B, 0x68, 0x33, 0xEE, 0xDF, 0x03,
+ 0x64, 0x04, 0xE0, 0x0E, 0x34, 0x8D, 0x81, 0xEF, 0x4C, 0x71, 0x08, 0xC8, 0xF8, 0x69, 0x1C, 0xC1,
+ 0x7D, 0xC2, 0x1D, 0xB5, 0xF9, 0xB9, 0x27, 0x6A, 0x4D, 0xE4, 0xA6, 0x72, 0x9A, 0xC9, 0x09, 0x78,
+ 0x65, 0x2F, 0x8A, 0x05, 0x21, 0x0F, 0xE1, 0x24, 0x12, 0xF0, 0x82, 0x45, 0x35, 0x93, 0xDA, 0x8E,
+ 0x96, 0x8F, 0xDB, 0xBD, 0x36, 0xD0, 0xCE, 0x94, 0x13, 0x5C, 0xD2, 0xF1, 0x40, 0x46, 0x83, 0x38,
+ 0x66, 0xDD, 0xFD, 0x30, 0xBF, 0x06, 0x8B, 0x62, 0xB3, 0x25, 0xE2, 0x98, 0x22, 0x88, 0x91, 0x10,
+ 0x7E, 0x6E, 0x48, 0xC3, 0xA3, 0xB6, 0x1E, 0x42, 0x3A, 0x6B, 0x28, 0x54, 0xFA, 0x85, 0x3D, 0xBA,
+ 0x2B, 0x79, 0x0A, 0x15, 0x9B, 0x9F, 0x5E, 0xCA, 0x4E, 0xD4, 0xAC, 0xE5, 0xF3, 0x73, 0xA7, 0x57,
+ 0xAF, 0x58, 0xA8, 0x50, 0xF4, 0xEA, 0xD6, 0x74, 0x4F, 0xAE, 0xE9, 0xD5, 0xE7, 0xE6, 0xAD, 0xE8,
+ 0x2C, 0xD7, 0x75, 0x7A, 0xEB, 0x16, 0x0B, 0xF5, 0x59, 0xCB, 0x5F, 0xB0, 0x9C, 0xA9, 0x51, 0xA0,
+ 0x7F, 0x0C, 0xF6, 0x6F, 0x17, 0xC4, 0x49, 0xEC, 0xD8, 0x43, 0x1F, 0x2D, 0xA4, 0x76, 0x7B, 0xB7,
+ 0xCC, 0xBB, 0x3E, 0x5A, 0xFB, 0x60, 0xB1, 0x86, 0x3B, 0x52, 0xA1, 0x6C, 0xAA, 0x55, 0x29, 0x9D,
+ 0x97, 0xB2, 0x87, 0x90, 0x61, 0xBE, 0xDC, 0xFC, 0xBC, 0x95, 0xCF, 0xCD, 0x37, 0x3F, 0x5B, 0xD1,
+ 0x53, 0x39, 0x84, 0x3C, 0x41, 0xA2, 0x6D, 0x47, 0x14, 0x2A, 0x9E, 0x5D, 0x56, 0xF2, 0xD3, 0xAB,
+ 0x44, 0x11, 0x92, 0xD9, 0x23, 0x20, 0x2E, 0x89, 0xB4, 0x7C, 0xB8, 0x26, 0x77, 0x99, 0xE3, 0xA5,
+ 0x67, 0x4A, 0xED, 0xDE, 0xC5, 0x31, 0xFE, 0x18, 0x0D, 0x63, 0x8C, 0x80, 0xC0, 0xF7, 0x70, 0x07};
+
+local MIXTABLE = {
+ 0x02, 0x03, 0x01, 0x01,
+ 0x01, 0x02, 0x03, 0x01,
+ 0x01, 0x01, 0x02, 0x03,
+ 0x03, 0x01, 0x01, 0x02};
+
+local IMIXTABLE = {
+ 0x0E, 0x0B, 0x0D, 0x09,
+ 0x09, 0x0E, 0x0B, 0x0D,
+ 0x0D, 0x09, 0x0E, 0x0B,
+ 0x0B, 0x0D, 0x09, 0x0E};
+
+local RCON = {
+[0] = 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
+0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39,
+0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
+0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
+0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,
+0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
+0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b,
+0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,
+0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
+0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
+0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35,
+0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
+0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,
+0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63,
+0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
+0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d};
+
+
+local GMUL = function(A, B)
+    if(A == 0x01) then return B; end
+    if(B == 0x01) then return A; end
+    if(A == 0x00) then return 0; end
+    if(B == 0x00) then return 0; end
+
+    local LA = LTABLE[A];
+    local LB = LTABLE[B];
+
+    local sum = LA + LB;
+    if (sum > 0xFF) then sum = sum - 0xFF; end
+
+    return ETABLE[sum];
+end
+
+local byteSub = Array.substitute;
+
+local shiftRow = Array.permute;
+
+local mixCol = function(i, mix)
+    local out = {};
+
+    local a, b, c, d;
+
+    a = GMUL(i[ 1], mix[ 1]);
+    b = GMUL(i[ 2], mix[ 2]);
+    c = GMUL(i[ 3], mix[ 3]);
+    d = GMUL(i[ 4], mix[ 4]);
+    out[ 1] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 1], mix[ 5]);
+    b = GMUL(i[ 2], mix[ 6]);
+    c = GMUL(i[ 3], mix[ 7]);
+    d = GMUL(i[ 4], mix[ 8]);
+    out[ 2] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 1], mix[ 9]);
+    b = GMUL(i[ 2], mix[10]);
+    c = GMUL(i[ 3], mix[11]);
+    d = GMUL(i[ 4], mix[12]);
+    out[ 3] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 1], mix[13]);
+    b = GMUL(i[ 2], mix[14]);
+    c = GMUL(i[ 3], mix[15]);
+    d = GMUL(i[ 4], mix[16]);
+    out[ 4] = XOR(XOR(a, b), XOR(c, d));
+
+
+    a = GMUL(i[ 5], mix[ 1]);
+    b = GMUL(i[ 6], mix[ 2]);
+    c = GMUL(i[ 7], mix[ 3]);
+    d = GMUL(i[ 8], mix[ 4]);
+    out[ 5] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 5], mix[ 5]);
+    b = GMUL(i[ 6], mix[ 6]);
+    c = GMUL(i[ 7], mix[ 7]);
+    d = GMUL(i[ 8], mix[ 8]);
+    out[ 6] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 5], mix[ 9]);
+    b = GMUL(i[ 6], mix[10]);
+    c = GMUL(i[ 7], mix[11]);
+    d = GMUL(i[ 8], mix[12]);
+    out[ 7] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 5], mix[13]);
+    b = GMUL(i[ 6], mix[14]);
+    c = GMUL(i[ 7], mix[15]);
+    d = GMUL(i[ 8], mix[16]);
+    out[ 8] = XOR(XOR(a, b), XOR(c, d));
+
+
+    a = GMUL(i[ 9], mix[ 1]);
+    b = GMUL(i[10], mix[ 2]);
+    c = GMUL(i[11], mix[ 3]);
+    d = GMUL(i[12], mix[ 4]);
+    out[ 9] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 9], mix[ 5]);
+    b = GMUL(i[10], mix[ 6]);
+    c = GMUL(i[11], mix[ 7]);
+    d = GMUL(i[12], mix[ 8]);
+    out[10] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 9], mix[ 9]);
+    b = GMUL(i[10], mix[10]);
+    c = GMUL(i[11], mix[11]);
+    d = GMUL(i[12], mix[12]);
+    out[11] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 9], mix[13]);
+    b = GMUL(i[10], mix[14]);
+    c = GMUL(i[11], mix[15]);
+    d = GMUL(i[12], mix[16]);
+    out[12] = XOR(XOR(a, b), XOR(c, d));
+
+
+    a = GMUL(i[13], mix[ 1]);
+    b = GMUL(i[14], mix[ 2]);
+    c = GMUL(i[15], mix[ 3]);
+    d = GMUL(i[16], mix[ 4]);
+    out[13] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[13], mix[ 5]);
+    b = GMUL(i[14], mix[ 6]);
+    c = GMUL(i[15], mix[ 7]);
+    d = GMUL(i[16], mix[ 8]);
+    out[14] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[13], mix[ 9]);
+    b = GMUL(i[14], mix[10]);
+    c = GMUL(i[15], mix[11]);
+    d = GMUL(i[16], mix[12]);
+    out[15] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[13], mix[13]);
+    b = GMUL(i[14], mix[14]);
+    c = GMUL(i[15], mix[15]);
+    d = GMUL(i[16], mix[16]);
+    out[16] = XOR(XOR(a, b), XOR(c, d));
+
+    return out;
+end
+
+local keyRound = function(key, round)
+    local out = {};
+
+    out[ 1] = XOR(key[ 1], XOR(SBOX[key[14]], RCON[round]));
+    out[ 2] = XOR(key[ 2], SBOX[key[15]]);
+    out[ 3] = XOR(key[ 3], SBOX[key[16]]);
+    out[ 4] = XOR(key[ 4], SBOX[key[13]]);
+
+    out[ 5] = XOR(out[ 1], key[ 5]);
+    out[ 6] = XOR(out[ 2], key[ 6]);
+    out[ 7] = XOR(out[ 3], key[ 7]);
+    out[ 8] = XOR(out[ 4], key[ 8]);
+
+    out[ 9] = XOR(out[ 5], key[ 9]);
+    out[10] = XOR(out[ 6], key[10]);
+    out[11] = XOR(out[ 7], key[11]);
+    out[12] = XOR(out[ 8], key[12]);
+
+    out[13] = XOR(out[ 9], key[13]);
+    out[14] = XOR(out[10], key[14]);
+    out[15] = XOR(out[11], key[15]);
+    out[16] = XOR(out[12], key[16]);
+
+    return out;
+end
+
+local keyExpand = function(key)
+    local keys = {};
+
+    local temp = key;
+
+    keys[1] = temp;
+
+    for i = 1, 10 do
+        temp = keyRound(temp, i);
+        keys[i + 1] = temp;
+    end
+
+    return keys;
+
+end
+
+local addKey = Array.XOR;
+
+
+
+local AES = {};
+
+AES.blockSize = 16;
+
+AES.encrypt = function(_key, block)
+
+    local key = keyExpand(_key);
+
+    --round 0
+    block = addKey(block, key[1]);
+
+    --round 1
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[2]);
+
+    --round 2
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[3]);
+
+    --round 3
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[4]);
+
+    --round 4
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[5]);
+
+    --round 5
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[6]);
+
+    --round 6
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[7]);
+
+    --round 7
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[8]);
+
+    --round 8
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[9]);
+
+    --round 9
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[10]);
+
+    --round 10
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = addKey(block, key[11]);
+
+    return block;
+
+end
+
+AES.decrypt = function(_key, block)
+
+    local key = keyExpand(_key);
+
+    --round 0
+    block = addKey(block, key[11]);
+
+    --round 1
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[10]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 2
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[9]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 3
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[8]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 4
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[7]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 5
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[6]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 6
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[5]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 7
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[4]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 8
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[3]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 9
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[2]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 10
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[1]);
+
+    return block;
+end
+
+return AES;

lockbox/cipher/aes192.lua

@@ -0,0 +1,462 @@
+
+local Array = require("lockbox.util.array");
+local Bit = require("lockbox.util.bit");
+
+local XOR = Bit.bxor;
+
+local SBOX = {
+ [0] = 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
+ 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
+ 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
+ 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
+ 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
+ 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
+ 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
+ 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
+ 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
+ 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
+ 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
+ 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
+ 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
+ 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
+ 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
+ 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16};
+
+local ISBOX = {
+ [0] = 0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
+ 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
+ 0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
+ 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
+ 0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
+ 0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
+ 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
+ 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
+ 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
+ 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
+ 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
+ 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
+ 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
+ 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
+ 0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
+ 0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D};
+
+local ROW_SHIFT =  {  1,  6, 11, 16,  5, 10, 15,  4,  9, 14,  3,  8, 13,  2,  7, 12, };
+local IROW_SHIFT = {  1, 14, 11,  8,  5,  2, 15, 12,  9,  6,  3, 16, 13, 10,  7,  4, };
+
+local ETABLE = {
+ [0] = 0x01, 0x03, 0x05, 0x0F, 0x11, 0x33, 0x55, 0xFF, 0x1A, 0x2E, 0x72, 0x96, 0xA1, 0xF8, 0x13, 0x35,
+ 0x5F, 0xE1, 0x38, 0x48, 0xD8, 0x73, 0x95, 0xA4, 0xF7, 0x02, 0x06, 0x0A, 0x1E, 0x22, 0x66, 0xAA,
+ 0xE5, 0x34, 0x5C, 0xE4, 0x37, 0x59, 0xEB, 0x26, 0x6A, 0xBE, 0xD9, 0x70, 0x90, 0xAB, 0xE6, 0x31,
+ 0x53, 0xF5, 0x04, 0x0C, 0x14, 0x3C, 0x44, 0xCC, 0x4F, 0xD1, 0x68, 0xB8, 0xD3, 0x6E, 0xB2, 0xCD,
+ 0x4C, 0xD4, 0x67, 0xA9, 0xE0, 0x3B, 0x4D, 0xD7, 0x62, 0xA6, 0xF1, 0x08, 0x18, 0x28, 0x78, 0x88,
+ 0x83, 0x9E, 0xB9, 0xD0, 0x6B, 0xBD, 0xDC, 0x7F, 0x81, 0x98, 0xB3, 0xCE, 0x49, 0xDB, 0x76, 0x9A,
+ 0xB5, 0xC4, 0x57, 0xF9, 0x10, 0x30, 0x50, 0xF0, 0x0B, 0x1D, 0x27, 0x69, 0xBB, 0xD6, 0x61, 0xA3,
+ 0xFE, 0x19, 0x2B, 0x7D, 0x87, 0x92, 0xAD, 0xEC, 0x2F, 0x71, 0x93, 0xAE, 0xE9, 0x20, 0x60, 0xA0,
+ 0xFB, 0x16, 0x3A, 0x4E, 0xD2, 0x6D, 0xB7, 0xC2, 0x5D, 0xE7, 0x32, 0x56, 0xFA, 0x15, 0x3F, 0x41,
+ 0xC3, 0x5E, 0xE2, 0x3D, 0x47, 0xC9, 0x40, 0xC0, 0x5B, 0xED, 0x2C, 0x74, 0x9C, 0xBF, 0xDA, 0x75,
+ 0x9F, 0xBA, 0xD5, 0x64, 0xAC, 0xEF, 0x2A, 0x7E, 0x82, 0x9D, 0xBC, 0xDF, 0x7A, 0x8E, 0x89, 0x80,
+ 0x9B, 0xB6, 0xC1, 0x58, 0xE8, 0x23, 0x65, 0xAF, 0xEA, 0x25, 0x6F, 0xB1, 0xC8, 0x43, 0xC5, 0x54,
+ 0xFC, 0x1F, 0x21, 0x63, 0xA5, 0xF4, 0x07, 0x09, 0x1B, 0x2D, 0x77, 0x99, 0xB0, 0xCB, 0x46, 0xCA,
+ 0x45, 0xCF, 0x4A, 0xDE, 0x79, 0x8B, 0x86, 0x91, 0xA8, 0xE3, 0x3E, 0x42, 0xC6, 0x51, 0xF3, 0x0E,
+ 0x12, 0x36, 0x5A, 0xEE, 0x29, 0x7B, 0x8D, 0x8C, 0x8F, 0x8A, 0x85, 0x94, 0xA7, 0xF2, 0x0D, 0x17,
+ 0x39, 0x4B, 0xDD, 0x7C, 0x84, 0x97, 0xA2, 0xFD, 0x1C, 0x24, 0x6C, 0xB4, 0xC7, 0x52, 0xF6, 0x01};
+
+local LTABLE = {
+ [0] = 0x00, 0x00, 0x19, 0x01, 0x32, 0x02, 0x1A, 0xC6, 0x4B, 0xC7, 0x1B, 0x68, 0x33, 0xEE, 0xDF, 0x03,
+ 0x64, 0x04, 0xE0, 0x0E, 0x34, 0x8D, 0x81, 0xEF, 0x4C, 0x71, 0x08, 0xC8, 0xF8, 0x69, 0x1C, 0xC1,
+ 0x7D, 0xC2, 0x1D, 0xB5, 0xF9, 0xB9, 0x27, 0x6A, 0x4D, 0xE4, 0xA6, 0x72, 0x9A, 0xC9, 0x09, 0x78,
+ 0x65, 0x2F, 0x8A, 0x05, 0x21, 0x0F, 0xE1, 0x24, 0x12, 0xF0, 0x82, 0x45, 0x35, 0x93, 0xDA, 0x8E,
+ 0x96, 0x8F, 0xDB, 0xBD, 0x36, 0xD0, 0xCE, 0x94, 0x13, 0x5C, 0xD2, 0xF1, 0x40, 0x46, 0x83, 0x38,
+ 0x66, 0xDD, 0xFD, 0x30, 0xBF, 0x06, 0x8B, 0x62, 0xB3, 0x25, 0xE2, 0x98, 0x22, 0x88, 0x91, 0x10,
+ 0x7E, 0x6E, 0x48, 0xC3, 0xA3, 0xB6, 0x1E, 0x42, 0x3A, 0x6B, 0x28, 0x54, 0xFA, 0x85, 0x3D, 0xBA,
+ 0x2B, 0x79, 0x0A, 0x15, 0x9B, 0x9F, 0x5E, 0xCA, 0x4E, 0xD4, 0xAC, 0xE5, 0xF3, 0x73, 0xA7, 0x57,
+ 0xAF, 0x58, 0xA8, 0x50, 0xF4, 0xEA, 0xD6, 0x74, 0x4F, 0xAE, 0xE9, 0xD5, 0xE7, 0xE6, 0xAD, 0xE8,
+ 0x2C, 0xD7, 0x75, 0x7A, 0xEB, 0x16, 0x0B, 0xF5, 0x59, 0xCB, 0x5F, 0xB0, 0x9C, 0xA9, 0x51, 0xA0,
+ 0x7F, 0x0C, 0xF6, 0x6F, 0x17, 0xC4, 0x49, 0xEC, 0xD8, 0x43, 0x1F, 0x2D, 0xA4, 0x76, 0x7B, 0xB7,
+ 0xCC, 0xBB, 0x3E, 0x5A, 0xFB, 0x60, 0xB1, 0x86, 0x3B, 0x52, 0xA1, 0x6C, 0xAA, 0x55, 0x29, 0x9D,
+ 0x97, 0xB2, 0x87, 0x90, 0x61, 0xBE, 0xDC, 0xFC, 0xBC, 0x95, 0xCF, 0xCD, 0x37, 0x3F, 0x5B, 0xD1,
+ 0x53, 0x39, 0x84, 0x3C, 0x41, 0xA2, 0x6D, 0x47, 0x14, 0x2A, 0x9E, 0x5D, 0x56, 0xF2, 0xD3, 0xAB,
+ 0x44, 0x11, 0x92, 0xD9, 0x23, 0x20, 0x2E, 0x89, 0xB4, 0x7C, 0xB8, 0x26, 0x77, 0x99, 0xE3, 0xA5,
+ 0x67, 0x4A, 0xED, 0xDE, 0xC5, 0x31, 0xFE, 0x18, 0x0D, 0x63, 0x8C, 0x80, 0xC0, 0xF7, 0x70, 0x07};
+
+local MIXTABLE = {
+ 0x02, 0x03, 0x01, 0x01,
+ 0x01, 0x02, 0x03, 0x01,
+ 0x01, 0x01, 0x02, 0x03,
+ 0x03, 0x01, 0x01, 0x02};
+
+local IMIXTABLE = {
+ 0x0E, 0x0B, 0x0D, 0x09,
+ 0x09, 0x0E, 0x0B, 0x0D,
+ 0x0D, 0x09, 0x0E, 0x0B,
+ 0x0B, 0x0D, 0x09, 0x0E};
+
+local RCON = {
+[0] = 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
+0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39,
+0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
+0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
+0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,
+0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
+0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b,
+0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,
+0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
+0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
+0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35,
+0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
+0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,
+0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63,
+0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
+0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d};
+
+
+local GMUL = function(A, B)
+    if(A == 0x01) then return B; end
+    if(B == 0x01) then return A; end
+    if(A == 0x00) then return 0; end
+    if(B == 0x00) then return 0; end
+
+    local LA = LTABLE[A];
+    local LB = LTABLE[B];
+
+    local sum = LA + LB;
+    if (sum > 0xFF) then sum = sum - 0xFF; end
+
+    return ETABLE[sum];
+end
+
+local byteSub = Array.substitute;
+
+local shiftRow = Array.permute;
+
+local mixCol = function(i, mix)
+    local out = {};
+
+    local a, b, c, d;
+
+    a = GMUL(i[ 1], mix[ 1]);
+    b = GMUL(i[ 2], mix[ 2]);
+    c = GMUL(i[ 3], mix[ 3]);
+    d = GMUL(i[ 4], mix[ 4]);
+    out[ 1] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 1], mix[ 5]);
+    b = GMUL(i[ 2], mix[ 6]);
+    c = GMUL(i[ 3], mix[ 7]);
+    d = GMUL(i[ 4], mix[ 8]);
+    out[ 2] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 1], mix[ 9]);
+    b = GMUL(i[ 2], mix[10]);
+    c = GMUL(i[ 3], mix[11]);
+    d = GMUL(i[ 4], mix[12]);
+    out[ 3] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 1], mix[13]);
+    b = GMUL(i[ 2], mix[14]);
+    c = GMUL(i[ 3], mix[15]);
+    d = GMUL(i[ 4], mix[16]);
+    out[ 4] = XOR(XOR(a, b), XOR(c, d));
+
+
+    a = GMUL(i[ 5], mix[ 1]);
+    b = GMUL(i[ 6], mix[ 2]);
+    c = GMUL(i[ 7], mix[ 3]);
+    d = GMUL(i[ 8], mix[ 4]);
+    out[ 5] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 5], mix[ 5]);
+    b = GMUL(i[ 6], mix[ 6]);
+    c = GMUL(i[ 7], mix[ 7]);
+    d = GMUL(i[ 8], mix[ 8]);
+    out[ 6] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 5], mix[ 9]);
+    b = GMUL(i[ 6], mix[10]);
+    c = GMUL(i[ 7], mix[11]);
+    d = GMUL(i[ 8], mix[12]);
+    out[ 7] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 5], mix[13]);
+    b = GMUL(i[ 6], mix[14]);
+    c = GMUL(i[ 7], mix[15]);
+    d = GMUL(i[ 8], mix[16]);
+    out[ 8] = XOR(XOR(a, b), XOR(c, d));
+
+
+    a = GMUL(i[ 9], mix[ 1]);
+    b = GMUL(i[10], mix[ 2]);
+    c = GMUL(i[11], mix[ 3]);
+    d = GMUL(i[12], mix[ 4]);
+    out[ 9] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 9], mix[ 5]);
+    b = GMUL(i[10], mix[ 6]);
+    c = GMUL(i[11], mix[ 7]);
+    d = GMUL(i[12], mix[ 8]);
+    out[10] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 9], mix[ 9]);
+    b = GMUL(i[10], mix[10]);
+    c = GMUL(i[11], mix[11]);
+    d = GMUL(i[12], mix[12]);
+    out[11] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 9], mix[13]);
+    b = GMUL(i[10], mix[14]);
+    c = GMUL(i[11], mix[15]);
+    d = GMUL(i[12], mix[16]);
+    out[12] = XOR(XOR(a, b), XOR(c, d));
+
+
+    a = GMUL(i[13], mix[ 1]);
+    b = GMUL(i[14], mix[ 2]);
+    c = GMUL(i[15], mix[ 3]);
+    d = GMUL(i[16], mix[ 4]);
+    out[13] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[13], mix[ 5]);
+    b = GMUL(i[14], mix[ 6]);
+    c = GMUL(i[15], mix[ 7]);
+    d = GMUL(i[16], mix[ 8]);
+    out[14] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[13], mix[ 9]);
+    b = GMUL(i[14], mix[10]);
+    c = GMUL(i[15], mix[11]);
+    d = GMUL(i[16], mix[12]);
+    out[15] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[13], mix[13]);
+    b = GMUL(i[14], mix[14]);
+    c = GMUL(i[15], mix[15]);
+    d = GMUL(i[16], mix[16]);
+    out[16] = XOR(XOR(a, b), XOR(c, d));
+
+    return out;
+end
+
+local keyRound = function(key, round)
+    local i = (round - 1) * 24;
+    local out = key;
+
+    out[25 + i] = XOR(key[ 1 + i], XOR(SBOX[key[22 + i]], RCON[round]));
+    out[26 + i] = XOR(key[ 2 + i], SBOX[key[23 + i]]);
+    out[27 + i] = XOR(key[ 3 + i], SBOX[key[24 + i]]);
+    out[28 + i] = XOR(key[ 4 + i], SBOX[key[21 + i]]);
+
+    out[29 + i] = XOR(out[25 + i], key[ 5 + i]);
+    out[30 + i] = XOR(out[26 + i], key[ 6 + i]);
+    out[31 + i] = XOR(out[27 + i], key[ 7 + i]);
+    out[32 + i] = XOR(out[28 + i], key[ 8 + i]);
+
+    out[33 + i] = XOR(out[29 + i], key[ 9 + i]);
+    out[34 + i] = XOR(out[30 + i], key[10 + i]);
+    out[35 + i] = XOR(out[31 + i], key[11 + i]);
+    out[36 + i] = XOR(out[32 + i], key[12 + i]);
+
+    out[37 + i] = XOR(out[33 + i], key[13 + i]);
+    out[38 + i] = XOR(out[34 + i], key[14 + i]);
+    out[39 + i] = XOR(out[35 + i], key[15 + i]);
+    out[40 + i] = XOR(out[36 + i], key[16 + i]);
+
+    out[41 + i] = XOR(out[37 + i], key[17 + i]);
+    out[42 + i] = XOR(out[38 + i], key[18 + i]);
+    out[43 + i] = XOR(out[39 + i], key[19 + i]);
+    out[44 + i] = XOR(out[40 + i], key[20 + i]);
+
+    out[45 + i] = XOR(out[41 + i], key[21 + i]);
+    out[46 + i] = XOR(out[42 + i], key[22 + i]);
+    out[47 + i] = XOR(out[43 + i], key[23 + i]);
+    out[48 + i] = XOR(out[44 + i], key[24 + i]);
+
+    return out;
+end
+
+local keyExpand = function(key)
+    local bytes = Array.copy(key);
+
+    for i = 1, 8 do
+        keyRound(bytes, i);
+    end
+
+    local keys = {};
+
+    keys[ 1] = Array.slice(bytes, 1, 16);
+    keys[ 2] = Array.slice(bytes, 17, 32);
+    keys[ 3] = Array.slice(bytes, 33, 48);
+    keys[ 4] = Array.slice(bytes, 49, 64);
+    keys[ 5] = Array.slice(bytes, 65, 80);
+    keys[ 6] = Array.slice(bytes, 81, 96);
+    keys[ 7] = Array.slice(bytes, 97, 112);
+    keys[ 8] = Array.slice(bytes, 113, 128);
+    keys[ 9] = Array.slice(bytes, 129, 144);
+    keys[10] = Array.slice(bytes, 145, 160);
+    keys[11] = Array.slice(bytes, 161, 176);
+    keys[12] = Array.slice(bytes, 177, 192);
+    keys[13] = Array.slice(bytes, 193, 208);
+
+    return keys;
+
+end
+
+local addKey = Array.XOR;
+
+
+
+local AES = {};
+
+AES.blockSize = 16;
+
+AES.encrypt = function(_key, block)
+
+    local key = keyExpand(_key);
+
+    --round 0
+    block = addKey(block, key[1]);
+
+    --round 1
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[2]);
+
+    --round 2
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[3]);
+
+    --round 3
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[4]);
+
+    --round 4
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[5]);
+
+    --round 5
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[6]);
+
+    --round 6
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[7]);
+
+    --round 7
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[8]);
+
+    --round 8
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[9]);
+
+    --round 9
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[10]);
+
+    --round 10
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[11]);
+
+    --round 11
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[12]);
+
+    --round 12
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = addKey(block, key[13]);
+
+    return block;
+
+end
+
+AES.decrypt = function(_key, block)
+
+    local key = keyExpand(_key);
+
+    --round 0
+    block = addKey(block, key[13]);
+
+    --round 1
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[12]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 2
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[11]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 3
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[10]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 4
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[9]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 5
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[8]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 6
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[7]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 7
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[6]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 8
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[5]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 9
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[4]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 10
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[3]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 11
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[2]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 12
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[1]);
+
+    return block;
+end
+
+return AES;

lockbox/cipher/aes256.lua

@@ -0,0 +1,498 @@
+local Array = require("lockbox.util.array");
+local Bit = require("lockbox.util.bit");
+
+local XOR = Bit.bxor;
+
+local SBOX = {
+ [0] = 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
+ 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
+ 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
+ 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
+ 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
+ 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
+ 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
+ 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
+ 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
+ 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
+ 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
+ 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
+ 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
+ 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
+ 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
+ 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16};
+
+local ISBOX = {
+ [0] = 0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
+ 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
+ 0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
+ 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
+ 0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
+ 0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
+ 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
+ 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
+ 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
+ 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
+ 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
+ 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
+ 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
+ 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
+ 0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
+ 0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D};
+
+local ROW_SHIFT =  {  1,  6, 11, 16,  5, 10, 15,  4,  9, 14,  3,  8, 13,  2,  7, 12, };
+local IROW_SHIFT = {  1, 14, 11,  8,  5,  2, 15, 12,  9,  6,  3, 16, 13, 10,  7,  4, };
+
+local ETABLE = {
+ [0] = 0x01, 0x03, 0x05, 0x0F, 0x11, 0x33, 0x55, 0xFF, 0x1A, 0x2E, 0x72, 0x96, 0xA1, 0xF8, 0x13, 0x35,
+ 0x5F, 0xE1, 0x38, 0x48, 0xD8, 0x73, 0x95, 0xA4, 0xF7, 0x02, 0x06, 0x0A, 0x1E, 0x22, 0x66, 0xAA,
+ 0xE5, 0x34, 0x5C, 0xE4, 0x37, 0x59, 0xEB, 0x26, 0x6A, 0xBE, 0xD9, 0x70, 0x90, 0xAB, 0xE6, 0x31,
+ 0x53, 0xF5, 0x04, 0x0C, 0x14, 0x3C, 0x44, 0xCC, 0x4F, 0xD1, 0x68, 0xB8, 0xD3, 0x6E, 0xB2, 0xCD,
+ 0x4C, 0xD4, 0x67, 0xA9, 0xE0, 0x3B, 0x4D, 0xD7, 0x62, 0xA6, 0xF1, 0x08, 0x18, 0x28, 0x78, 0x88,
+ 0x83, 0x9E, 0xB9, 0xD0, 0x6B, 0xBD, 0xDC, 0x7F, 0x81, 0x98, 0xB3, 0xCE, 0x49, 0xDB, 0x76, 0x9A,
+ 0xB5, 0xC4, 0x57, 0xF9, 0x10, 0x30, 0x50, 0xF0, 0x0B, 0x1D, 0x27, 0x69, 0xBB, 0xD6, 0x61, 0xA3,
+ 0xFE, 0x19, 0x2B, 0x7D, 0x87, 0x92, 0xAD, 0xEC, 0x2F, 0x71, 0x93, 0xAE, 0xE9, 0x20, 0x60, 0xA0,
+ 0xFB, 0x16, 0x3A, 0x4E, 0xD2, 0x6D, 0xB7, 0xC2, 0x5D, 0xE7, 0x32, 0x56, 0xFA, 0x15, 0x3F, 0x41,
+ 0xC3, 0x5E, 0xE2, 0x3D, 0x47, 0xC9, 0x40, 0xC0, 0x5B, 0xED, 0x2C, 0x74, 0x9C, 0xBF, 0xDA, 0x75,
+ 0x9F, 0xBA, 0xD5, 0x64, 0xAC, 0xEF, 0x2A, 0x7E, 0x82, 0x9D, 0xBC, 0xDF, 0x7A, 0x8E, 0x89, 0x80,
+ 0x9B, 0xB6, 0xC1, 0x58, 0xE8, 0x23, 0x65, 0xAF, 0xEA, 0x25, 0x6F, 0xB1, 0xC8, 0x43, 0xC5, 0x54,
+ 0xFC, 0x1F, 0x21, 0x63, 0xA5, 0xF4, 0x07, 0x09, 0x1B, 0x2D, 0x77, 0x99, 0xB0, 0xCB, 0x46, 0xCA,
+ 0x45, 0xCF, 0x4A, 0xDE, 0x79, 0x8B, 0x86, 0x91, 0xA8, 0xE3, 0x3E, 0x42, 0xC6, 0x51, 0xF3, 0x0E,
+ 0x12, 0x36, 0x5A, 0xEE, 0x29, 0x7B, 0x8D, 0x8C, 0x8F, 0x8A, 0x85, 0x94, 0xA7, 0xF2, 0x0D, 0x17,
+ 0x39, 0x4B, 0xDD, 0x7C, 0x84, 0x97, 0xA2, 0xFD, 0x1C, 0x24, 0x6C, 0xB4, 0xC7, 0x52, 0xF6, 0x01};
+
+local LTABLE = {
+ [0] = 0x00, 0x00, 0x19, 0x01, 0x32, 0x02, 0x1A, 0xC6, 0x4B, 0xC7, 0x1B, 0x68, 0x33, 0xEE, 0xDF, 0x03,
+ 0x64, 0x04, 0xE0, 0x0E, 0x34, 0x8D, 0x81, 0xEF, 0x4C, 0x71, 0x08, 0xC8, 0xF8, 0x69, 0x1C, 0xC1,
+ 0x7D, 0xC2, 0x1D, 0xB5, 0xF9, 0xB9, 0x27, 0x6A, 0x4D, 0xE4, 0xA6, 0x72, 0x9A, 0xC9, 0x09, 0x78,
+ 0x65, 0x2F, 0x8A, 0x05, 0x21, 0x0F, 0xE1, 0x24, 0x12, 0xF0, 0x82, 0x45, 0x35, 0x93, 0xDA, 0x8E,
+ 0x96, 0x8F, 0xDB, 0xBD, 0x36, 0xD0, 0xCE, 0x94, 0x13, 0x5C, 0xD2, 0xF1, 0x40, 0x46, 0x83, 0x38,
+ 0x66, 0xDD, 0xFD, 0x30, 0xBF, 0x06, 0x8B, 0x62, 0xB3, 0x25, 0xE2, 0x98, 0x22, 0x88, 0x91, 0x10,
+ 0x7E, 0x6E, 0x48, 0xC3, 0xA3, 0xB6, 0x1E, 0x42, 0x3A, 0x6B, 0x28, 0x54, 0xFA, 0x85, 0x3D, 0xBA,
+ 0x2B, 0x79, 0x0A, 0x15, 0x9B, 0x9F, 0x5E, 0xCA, 0x4E, 0xD4, 0xAC, 0xE5, 0xF3, 0x73, 0xA7, 0x57,
+ 0xAF, 0x58, 0xA8, 0x50, 0xF4, 0xEA, 0xD6, 0x74, 0x4F, 0xAE, 0xE9, 0xD5, 0xE7, 0xE6, 0xAD, 0xE8,
+ 0x2C, 0xD7, 0x75, 0x7A, 0xEB, 0x16, 0x0B, 0xF5, 0x59, 0xCB, 0x5F, 0xB0, 0x9C, 0xA9, 0x51, 0xA0,
+ 0x7F, 0x0C, 0xF6, 0x6F, 0x17, 0xC4, 0x49, 0xEC, 0xD8, 0x43, 0x1F, 0x2D, 0xA4, 0x76, 0x7B, 0xB7,
+ 0xCC, 0xBB, 0x3E, 0x5A, 0xFB, 0x60, 0xB1, 0x86, 0x3B, 0x52, 0xA1, 0x6C, 0xAA, 0x55, 0x29, 0x9D,
+ 0x97, 0xB2, 0x87, 0x90, 0x61, 0xBE, 0xDC, 0xFC, 0xBC, 0x95, 0xCF, 0xCD, 0x37, 0x3F, 0x5B, 0xD1,
+ 0x53, 0x39, 0x84, 0x3C, 0x41, 0xA2, 0x6D, 0x47, 0x14, 0x2A, 0x9E, 0x5D, 0x56, 0xF2, 0xD3, 0xAB,
+ 0x44, 0x11, 0x92, 0xD9, 0x23, 0x20, 0x2E, 0x89, 0xB4, 0x7C, 0xB8, 0x26, 0x77, 0x99, 0xE3, 0xA5,
+ 0x67, 0x4A, 0xED, 0xDE, 0xC5, 0x31, 0xFE, 0x18, 0x0D, 0x63, 0x8C, 0x80, 0xC0, 0xF7, 0x70, 0x07};
+
+local MIXTABLE = {
+ 0x02, 0x03, 0x01, 0x01,
+ 0x01, 0x02, 0x03, 0x01,
+ 0x01, 0x01, 0x02, 0x03,
+ 0x03, 0x01, 0x01, 0x02};
+
+local IMIXTABLE = {
+ 0x0E, 0x0B, 0x0D, 0x09,
+ 0x09, 0x0E, 0x0B, 0x0D,
+ 0x0D, 0x09, 0x0E, 0x0B,
+ 0x0B, 0x0D, 0x09, 0x0E};
+
+local RCON = {
+[0] = 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
+0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39,
+0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
+0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
+0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,
+0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
+0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b,
+0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,
+0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
+0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
+0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35,
+0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
+0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,
+0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63,
+0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
+0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d};
+
+
+local GMUL = function(A, B)
+    if(A == 0x01) then return B; end
+    if(B == 0x01) then return A; end
+    if(A == 0x00) then return 0; end
+    if(B == 0x00) then return 0; end
+
+    local LA = LTABLE[A];
+    local LB = LTABLE[B];
+
+    local sum = LA + LB;
+    if (sum > 0xFF) then sum = sum - 0xFF; end
+
+    return ETABLE[sum];
+end
+
+local byteSub = Array.substitute;
+
+local shiftRow = Array.permute;
+
+local mixCol = function(i, mix)
+    local out = {};
+
+    local a, b, c, d;
+
+    a = GMUL(i[ 1], mix[ 1]);
+    b = GMUL(i[ 2], mix[ 2]);
+    c = GMUL(i[ 3], mix[ 3]);
+    d = GMUL(i[ 4], mix[ 4]);
+    out[ 1] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 1], mix[ 5]);
+    b = GMUL(i[ 2], mix[ 6]);
+    c = GMUL(i[ 3], mix[ 7]);
+    d = GMUL(i[ 4], mix[ 8]);
+    out[ 2] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 1], mix[ 9]);
+    b = GMUL(i[ 2], mix[10]);
+    c = GMUL(i[ 3], mix[11]);
+    d = GMUL(i[ 4], mix[12]);
+    out[ 3] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 1], mix[13]);
+    b = GMUL(i[ 2], mix[14]);
+    c = GMUL(i[ 3], mix[15]);
+    d = GMUL(i[ 4], mix[16]);
+    out[ 4] = XOR(XOR(a, b), XOR(c, d));
+
+
+    a = GMUL(i[ 5], mix[ 1]);
+    b = GMUL(i[ 6], mix[ 2]);
+    c = GMUL(i[ 7], mix[ 3]);
+    d = GMUL(i[ 8], mix[ 4]);
+    out[ 5] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 5], mix[ 5]);
+    b = GMUL(i[ 6], mix[ 6]);
+    c = GMUL(i[ 7], mix[ 7]);
+    d = GMUL(i[ 8], mix[ 8]);
+    out[ 6] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 5], mix[ 9]);
+    b = GMUL(i[ 6], mix[10]);
+    c = GMUL(i[ 7], mix[11]);
+    d = GMUL(i[ 8], mix[12]);
+    out[ 7] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 5], mix[13]);
+    b = GMUL(i[ 6], mix[14]);
+    c = GMUL(i[ 7], mix[15]);
+    d = GMUL(i[ 8], mix[16]);
+    out[ 8] = XOR(XOR(a, b), XOR(c, d));
+
+
+    a = GMUL(i[ 9], mix[ 1]);
+    b = GMUL(i[10], mix[ 2]);
+    c = GMUL(i[11], mix[ 3]);
+    d = GMUL(i[12], mix[ 4]);
+    out[ 9] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 9], mix[ 5]);
+    b = GMUL(i[10], mix[ 6]);
+    c = GMUL(i[11], mix[ 7]);
+    d = GMUL(i[12], mix[ 8]);
+    out[10] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 9], mix[ 9]);
+    b = GMUL(i[10], mix[10]);
+    c = GMUL(i[11], mix[11]);
+    d = GMUL(i[12], mix[12]);
+    out[11] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[ 9], mix[13]);
+    b = GMUL(i[10], mix[14]);
+    c = GMUL(i[11], mix[15]);
+    d = GMUL(i[12], mix[16]);
+    out[12] = XOR(XOR(a, b), XOR(c, d));
+
+
+    a = GMUL(i[13], mix[ 1]);
+    b = GMUL(i[14], mix[ 2]);
+    c = GMUL(i[15], mix[ 3]);
+    d = GMUL(i[16], mix[ 4]);
+    out[13] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[13], mix[ 5]);
+    b = GMUL(i[14], mix[ 6]);
+    c = GMUL(i[15], mix[ 7]);
+    d = GMUL(i[16], mix[ 8]);
+    out[14] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[13], mix[ 9]);
+    b = GMUL(i[14], mix[10]);
+    c = GMUL(i[15], mix[11]);
+    d = GMUL(i[16], mix[12]);
+    out[15] = XOR(XOR(a, b), XOR(c, d));
+    a = GMUL(i[13], mix[13]);
+    b = GMUL(i[14], mix[14]);
+    c = GMUL(i[15], mix[15]);
+    d = GMUL(i[16], mix[16]);
+    out[16] = XOR(XOR(a, b), XOR(c, d));
+
+    return out;
+end
+
+local keyRound = function(key, round)
+    local i = (round - 1) * 32;
+    local out = key;
+
+    out[33 + i] = XOR(key[ 1 + i], XOR(SBOX[key[30 + i]], RCON[round]));
+    out[34 + i] = XOR(key[ 2 + i], SBOX[key[31 + i]]);
+    out[35 + i] = XOR(key[ 3 + i], SBOX[key[32 + i]]);
+    out[36 + i] = XOR(key[ 4 + i], SBOX[key[29 + i]]);
+
+    out[37 + i] = XOR(out[33 + i], key[ 5 + i]);
+    out[38 + i] = XOR(out[34 + i], key[ 6 + i]);
+    out[39 + i] = XOR(out[35 + i], key[ 7 + i]);
+    out[40 + i] = XOR(out[36 + i], key[ 8 + i]);
+
+    out[41 + i] = XOR(out[37 + i], key[ 9 + i]);
+    out[42 + i] = XOR(out[38 + i], key[10 + i]);
+    out[43 + i] = XOR(out[39 + i], key[11 + i]);
+    out[44 + i] = XOR(out[40 + i], key[12 + i]);
+
+    out[45 + i] = XOR(out[41 + i], key[13 + i]);
+    out[46 + i] = XOR(out[42 + i], key[14 + i]);
+    out[47 + i] = XOR(out[43 + i], key[15 + i]);
+    out[48 + i] = XOR(out[44 + i], key[16 + i]);
+
+
+    out[49 + i] = XOR(SBOX[out[45 + i]], key[17 + i]);
+    out[50 + i] = XOR(SBOX[out[46 + i]], key[18 + i]);
+    out[51 + i] = XOR(SBOX[out[47 + i]], key[19 + i]);
+    out[52 + i] = XOR(SBOX[out[48 + i]], key[20 + i]);
+
+    out[53 + i] = XOR(out[49 + i], key[21 + i]);
+    out[54 + i] = XOR(out[50 + i], key[22 + i]);
+    out[55 + i] = XOR(out[51 + i], key[23 + i]);
+    out[56 + i] = XOR(out[52 + i], key[24 + i]);
+
+    out[57 + i] = XOR(out[53 + i], key[25 + i]);
+    out[58 + i] = XOR(out[54 + i], key[26 + i]);
+    out[59 + i] = XOR(out[55 + i], key[27 + i]);
+    out[60 + i] = XOR(out[56 + i], key[28 + i]);
+
+    out[61 + i] = XOR(out[57 + i], key[29 + i]);
+    out[62 + i] = XOR(out[58 + i], key[30 + i]);
+    out[63 + i] = XOR(out[59 + i], key[31 + i]);
+    out[64 + i] = XOR(out[60 + i], key[32 + i]);
+
+    return out;
+end
+
+local keyExpand = function(key)
+    local bytes = Array.copy(key);
+
+    for i = 1, 7 do
+        keyRound(bytes, i);
+    end
+
+    local keys = {};
+
+    keys[ 1] = Array.slice(bytes, 1, 16);
+    keys[ 2] = Array.slice(bytes, 17, 32);
+    keys[ 3] = Array.slice(bytes, 33, 48);
+    keys[ 4] = Array.slice(bytes, 49, 64);
+    keys[ 5] = Array.slice(bytes, 65, 80);
+    keys[ 6] = Array.slice(bytes, 81, 96);
+    keys[ 7] = Array.slice(bytes, 97, 112);
+    keys[ 8] = Array.slice(bytes, 113, 128);
+    keys[ 9] = Array.slice(bytes, 129, 144);
+    keys[10] = Array.slice(bytes, 145, 160);
+    keys[11] = Array.slice(bytes, 161, 176);
+    keys[12] = Array.slice(bytes, 177, 192);
+    keys[13] = Array.slice(bytes, 193, 208);
+    keys[14] = Array.slice(bytes, 209, 224);
+    keys[15] = Array.slice(bytes, 225, 240);
+
+    return keys;
+
+end
+
+local addKey = Array.XOR;
+
+
+
+local AES = {};
+
+AES.blockSize = 16;
+
+AES.encrypt = function(_key, block)
+
+    local key = keyExpand(_key);
+
+    --round 0
+    block = addKey(block, key[1]);
+
+    --round 1
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[2]);
+
+    --round 2
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[3]);
+
+    --round 3
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[4]);
+
+    --round 4
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[5]);
+
+    --round 5
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[6]);
+
+    --round 6
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[7]);
+
+    --round 7
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[8]);
+
+    --round 8
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[9]);
+
+    --round 9
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[10]);
+
+    --round 10
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[11]);
+
+    --round 11
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[12]);
+
+    --round 12
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[13]);
+
+    --round 13
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = mixCol(block, MIXTABLE);
+    block = addKey(block, key[14]);
+
+    --round 14
+    block = byteSub(block, SBOX);
+    block = shiftRow(block, ROW_SHIFT);
+    block = addKey(block, key[15]);
+
+    return block;
+
+end
+
+AES.decrypt = function(_key, block)
+
+    local key = keyExpand(_key);
+
+    --round 0
+    block = addKey(block, key[15]);
+
+    --round 1
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[14]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 2
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[13]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 3
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[12]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 4
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[11]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 5
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[10]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 6
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[9]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 7
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[8]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 8
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[7]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 9
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[6]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 10
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[5]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 11
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[4]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 12
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[3]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 13
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[2]);
+    block = mixCol(block, IMIXTABLE);
+
+    --round 14
+    block = shiftRow(block, IROW_SHIFT);
+    block = byteSub(block, ISBOX);
+    block = addKey(block, key[1]);
+
+    return block;
+end
+
+return AES;

lockbox/cipher/mode/cbc.lua

@@ -0,0 +1,164 @@
+local Array = require("lockbox.util.array");
+local Stream = require("lockbox.util.stream");
+local Queue = require("lockbox.util.queue");
+
+local CBC = {};
+
+CBC.Cipher = function()
+
+    local public = {};
+
+    local key;
+    local blockCipher;
+    local padding;
+    local inputQueue;
+    local outputQueue;
+    local iv;
+
+    public.setKey = function(keyBytes)
+        key = keyBytes;
+        return public;
+    end
+
+    public.setBlockCipher = function(cipher)
+        blockCipher = cipher;
+        return public;
+    end
+
+    public.setPadding = function(paddingMode)
+        padding = paddingMode;
+        return public;
+    end
+
+    public.init = function()
+        inputQueue = Queue();
+        outputQueue = Queue();
+        iv = nil;
+        return public;
+    end
+
+    public.update = function(messageStream)
+        local byte = messageStream();
+        while (byte ~= nil) do
+            inputQueue.push(byte);
+            if(inputQueue.size() >= blockCipher.blockSize) then
+                local block = Array.readFromQueue(inputQueue, blockCipher.blockSize);
+
+                if(iv == nil) then
+                    iv = block;
+                else
+                    local out = Array.XOR(iv, block);
+                    out = blockCipher.encrypt(key, out);
+                    Array.writeToQueue(outputQueue, out);
+                    iv = out;
+                end
+            end
+            byte = messageStream();
+        end
+        return public;
+    end
+
+    public.finish = function()
+        local paddingStream = padding(blockCipher.blockSize, inputQueue.getHead());
+        public.update(paddingStream);
+
+        return public;
+    end
+
+    public.getOutputQueue = function()
+        return outputQueue;
+    end
+
+    public.asHex = function()
+        return Stream.toHex(outputQueue.pop);
+    end
+
+    public.asBytes = function()
+        return Stream.toArray(outputQueue.pop);
+    end
+
+    return public;
+
+end
+
+
+CBC.Decipher = function()
+
+    local public = {};
+
+    local key;
+    local blockCipher;
+    local padding;
+    local inputQueue;
+    local outputQueue;
+    local iv;
+
+    public.setKey = function(keyBytes)
+        key = keyBytes;
+        return public;
+    end
+
+    public.setBlockCipher = function(cipher)
+        blockCipher = cipher;
+        return public;
+    end
+
+    public.setPadding = function(paddingMode)
+        padding = paddingMode;
+        return public;
+    end
+
+    public.init = function()
+        inputQueue = Queue();
+        outputQueue = Queue();
+        iv = nil;
+        return public;
+    end
+
+    public.update = function(messageStream)
+        local byte = messageStream();
+        while (byte ~= nil) do
+            inputQueue.push(byte);
+            if(inputQueue.size() >= blockCipher.blockSize) then
+                local block = Array.readFromQueue(inputQueue, blockCipher.blockSize);
+
+                if(iv == nil) then
+                    iv = block;
+                else
+                    local out = block;
+                    out = blockCipher.decrypt(key, out);
+                    out = Array.XOR(iv, out);
+                    Array.writeToQueue(outputQueue, out);
+                    iv = block;
+                end
+            end
+            byte = messageStream();
+        end
+        return public;
+    end
+
+    public.finish = function()
+        local paddingStream = padding(blockCipher.blockSize, inputQueue.getHead());
+        public.update(paddingStream);
+
+        return public;
+    end
+
+    public.getOutputQueue = function()
+        return outputQueue;
+    end
+
+    public.asHex = function()
+        return Stream.toHex(outputQueue.pop);
+    end
+
+    public.asBytes = function()
+        return Stream.toArray(outputQueue.pop);
+    end
+
+    return public;
+
+end
+
+return CBC;
+

lockbox/cipher/mode/cfb.lua

@@ -0,0 +1,163 @@
+local Array = require("lockbox.util.array");
+local Stream = require("lockbox.util.stream");
+local Queue = require("lockbox.util.queue");
+
+local CFB = {};
+
+CFB.Cipher = function()
+
+    local public = {};
+
+    local key;
+    local blockCipher;
+    local padding;
+    local inputQueue;
+    local outputQueue;
+    local iv;
+
+    public.setKey = function(keyBytes)
+        key = keyBytes;
+        return public;
+    end
+
+    public.setBlockCipher = function(cipher)
+        blockCipher = cipher;
+        return public;
+    end
+
+    public.setPadding = function(paddingMode)
+        padding = paddingMode;
+        return public;
+    end
+
+    public.init = function()
+        inputQueue = Queue();
+        outputQueue = Queue();
+        iv = nil;
+        return public;
+    end
+
+    public.update = function(messageStream)
+        local byte = messageStream();
+        while (byte ~= nil) do
+            inputQueue.push(byte);
+            if(inputQueue.size() >= blockCipher.blockSize) then
+                local block = Array.readFromQueue(inputQueue, blockCipher.blockSize);
+
+                if(iv == nil) then
+                    iv = block;
+                else
+                    local out = iv;
+                    out = blockCipher.encrypt(key, out);
+                    out = Array.XOR(out, block);
+                    Array.writeToQueue(outputQueue, out);
+                    iv = out;
+                end
+            end
+            byte = messageStream();
+        end
+        return public;
+    end
+
+    public.finish = function()
+        local paddingStream = padding(blockCipher.blockSize, inputQueue.getHead());
+        public.update(paddingStream);
+
+        return public;
+    end
+
+    public.getOutputQueue = function()
+        return outputQueue;
+    end
+
+    public.asHex = function()
+        return Stream.toHex(outputQueue.pop);
+    end
+
+    public.asBytes = function()
+        return Stream.toArray(outputQueue.pop);
+    end
+
+    return public;
+
+end
+
+CFB.Decipher = function()
+
+    local public = {};
+
+    local key;
+    local blockCipher;
+    local padding;
+    local inputQueue;
+    local outputQueue;
+    local iv;
+
+    public.setKey = function(keyBytes)
+        key = keyBytes;
+        return public;
+    end
+
+    public.setBlockCipher = function(cipher)
+        blockCipher = cipher;
+        return public;
+    end
+
+    public.setPadding = function(paddingMode)
+        padding = paddingMode;
+        return public;
+    end
+
+    public.init = function()
+        inputQueue = Queue();
+        outputQueue = Queue();
+        iv = nil;
+        return public;
+    end
+
+    public.update = function(messageStream)
+        local byte = messageStream();
+        while (byte ~= nil) do
+            inputQueue.push(byte);
+            if(inputQueue.size() >= blockCipher.blockSize) then
+                local block = Array.readFromQueue(inputQueue, blockCipher.blockSize);
+
+                if(iv == nil) then
+                    iv = block;
+                else
+                    local out = iv;
+                    out = blockCipher.encrypt(key, out);
+                    out = Array.XOR(out, block);
+                    Array.writeToQueue(outputQueue, out);
+                    iv = block;
+                end
+            end
+            byte = messageStream();
+        end
+        return public;
+    end
+
+    public.finish = function()
+        local paddingStream = padding(blockCipher.blockSize, inputQueue.getHead());
+        public.update(paddingStream);
+
+        return public;
+    end
+
+    public.getOutputQueue = function()
+        return outputQueue;
+    end
+
+    public.asHex = function()
+        return Stream.toHex(outputQueue.pop);
+    end
+
+    public.asBytes = function()
+        return Stream.toArray(outputQueue.pop);
+    end
+
+    return public;
+
+end
+
+return CFB;

lockbox/cipher/mode/ctr.lua

@@ -0,0 +1,248 @@
+local Array = require("lockbox.util.array");
+local Stream = require("lockbox.util.stream");
+local Queue = require("lockbox.util.queue");
+
+local Bit = require("lockbox.util.bit");
+
+local AND = Bit.band;
+
+local CTR = {};
+
+CTR.Cipher = function()
+
+    local public = {};
+
+    local key;
+    local blockCipher;
+    local padding;
+    local inputQueue;
+    local outputQueue;
+    local iv;
+
+    public.setKey = function(keyBytes)
+        key = keyBytes;
+        return public;
+    end
+
+    public.setBlockCipher = function(cipher)
+        blockCipher = cipher;
+        return public;
+    end
+
+    public.setPadding = function(paddingMode)
+        padding = paddingMode;
+        return public;
+    end
+
+    public.init = function()
+        inputQueue = Queue();
+        outputQueue = Queue();
+        iv = nil;
+        return public;
+    end
+
+    local updateIV = function()
+        iv[16] = iv[16] + 1;
+        if iv[16] <= 0xFF then return; end
+        iv[16] = AND(iv[16], 0xFF);
+
+        iv[15] = iv[15] + 1;
+        if iv[15] <= 0xFF then return; end
+        iv[15] = AND(iv[15], 0xFF);
+
+        iv[14] = iv[14] + 1;
+        if iv[14] <= 0xFF then return; end
+        iv[14] = AND(iv[14], 0xFF);
+
+        iv[13] = iv[13] + 1;
+        if iv[13] <= 0xFF then return; end
+        iv[13] = AND(iv[13], 0xFF);
+
+        iv[12] = iv[12] + 1;
+        if iv[12] <= 0xFF then return; end
+        iv[12] = AND(iv[12], 0xFF);
+
+        iv[11] = iv[11] + 1;
+        if iv[11] <= 0xFF then return; end
+        iv[11] = AND(iv[11], 0xFF);
+
+        iv[10] = iv[10] + 1;
+        if iv[10] <= 0xFF then return; end
+        iv[10] = AND(iv[10], 0xFF);
+
+        iv[9] = iv[9] + 1;
+        if iv[9] <= 0xFF then return; end
+        iv[9] = AND(iv[9], 0xFF);
+
+        return;
+    end
+
+    public.update = function(messageStream)
+        local byte = messageStream();
+        while (byte ~= nil) do
+            inputQueue.push(byte);
+
+            if(inputQueue.size() >= blockCipher.blockSize) then
+                local block = Array.readFromQueue(inputQueue, blockCipher.blockSize);
+
+                if(iv == nil) then
+                    iv = block;
+                else
+                    local out = iv;
+                    out = blockCipher.encrypt(key, out);
+
+                    out = Array.XOR(out, block);
+                    Array.writeToQueue(outputQueue, out);
+                    updateIV();
+                end
+            end
+            byte = messageStream();
+        end
+        return public;
+    end
+
+    public.finish = function()
+        local paddingStream = padding(blockCipher.blockSize, inputQueue.getHead());
+        public.update(paddingStream);
+
+        return public;
+    end
+
+    public.getOutputQueue = function()
+        return outputQueue;
+    end
+
+    public.asHex = function()
+        return Stream.toHex(outputQueue.pop);
+    end
+
+    public.asBytes = function()
+        return Stream.toArray(outputQueue.pop);
+    end
+
+    return public;
+
+end
+
+
+CTR.Decipher = function()
+
+    local public = {};
+
+    local key;
+    local blockCipher;
+    local padding;
+    local inputQueue;
+    local outputQueue;
+    local iv;
+
+    public.setKey = function(keyBytes)
+        key = keyBytes;
+        return public;
+    end
+
+    public.setBlockCipher = function(cipher)
+        blockCipher = cipher;
+        return public;
+    end
+
+    public.setPadding = function(paddingMode)
+        padding = paddingMode;
+        return public;
+    end
+
+    public.init = function()
+        inputQueue = Queue();
+        outputQueue = Queue();
+        iv = nil;
+        return public;
+    end
+
+    local updateIV = function()
+        iv[16] = iv[16] + 1;
+        if iv[16] <= 0xFF then return; end
+        iv[16] = AND(iv[16], 0xFF);
+
+        iv[15] = iv[15] + 1;
+        if iv[15] <= 0xFF then return; end
+        iv[15] = AND(iv[15], 0xFF);
+
+        iv[14] = iv[14] + 1;
+        if iv[14] <= 0xFF then return; end
+        iv[14] = AND(iv[14], 0xFF);
+
+        iv[13] = iv[13] + 1;
+        if iv[13] <= 0xFF then return; end
+        iv[13] = AND(iv[13], 0xFF);
+
+        iv[12] = iv[12] + 1;
+        if iv[12] <= 0xFF then return; end
+        iv[12] = AND(iv[12], 0xFF);
+
+        iv[11] = iv[11] + 1;
+        if iv[11] <= 0xFF then return; end
+        iv[11] = AND(iv[11], 0xFF);
+
+        iv[10] = iv[10] + 1;
+        if iv[10] <= 0xFF then return; end
+        iv[10] = AND(iv[10], 0xFF);
+
+        iv[9] = iv[9] + 1;
+        if iv[9] <= 0xFF then return; end
+        iv[9] = AND(iv[9], 0xFF);
+
+        return;
+    end
+
+    public.update = function(messageStream)
+        local byte = messageStream();
+        while (byte ~= nil) do
+            inputQueue.push(byte);
+
+            if(inputQueue.size() >= blockCipher.blockSize) then
+                local block = Array.readFromQueue(inputQueue, blockCipher.blockSize);
+
+                if(iv == nil) then
+                    iv = block;
+                else
+                    local out = iv;
+                    out = blockCipher.encrypt(key, out);
+
+                    out = Array.XOR(out, block);
+                    Array.writeToQueue(outputQueue, out);
+                    updateIV();
+                end
+            end
+            byte = messageStream();
+        end
+        return public;
+    end
+
+    public.finish = function()
+        local paddingStream = padding(blockCipher.blockSize, inputQueue.getHead());
+        public.update(paddingStream);
+
+        return public;
+    end
+
+    public.getOutputQueue = function()
+        return outputQueue;
+    end
+
+    public.asHex = function()
+        return Stream.toHex(outputQueue.pop);
+    end
+
+    public.asBytes = function()
+        return Stream.toArray(outputQueue.pop);
+    end
+
+    return public;
+
+end
+
+
+
+
+return CTR;
+

lockbox/cipher/mode/ofb.lua

@@ -0,0 +1,164 @@
+local Array = require("lockbox.util.array");
+local Stream = require("lockbox.util.stream");
+local Queue = require("lockbox.util.queue");
+
+local OFB = {};
+
+OFB.Cipher = function()
+
+    local public = {};
+
+    local key;
+    local blockCipher;
+    local padding;
+    local inputQueue;
+    local outputQueue;
+    local iv;
+
+    public.setKey = function(keyBytes)
+        key = keyBytes;
+        return public;
+    end
+
+    public.setBlockCipher = function(cipher)
+        blockCipher = cipher;
+        return public;
+    end
+
+    public.setPadding = function(paddingMode)
+        padding = paddingMode;
+        return public;
+    end
+
+    public.init = function()
+        inputQueue = Queue();
+        outputQueue = Queue();
+        iv = nil;
+        return public;
+    end
+
+    public.update = function(messageStream)
+        local byte = messageStream();
+        while (byte ~= nil) do
+            inputQueue.push(byte);
+            if(inputQueue.size() >= blockCipher.blockSize) then
+                local block = Array.readFromQueue(inputQueue, blockCipher.blockSize);
+
+                if(iv == nil) then
+                    iv = block;
+                else
+                    local out = iv;
+                    out = blockCipher.encrypt(key, out);
+                    iv = out;
+                    out = Array.XOR(out, block);
+                    Array.writeToQueue(outputQueue, out);
+                end
+            end
+            byte = messageStream();
+        end
+        return public;
+    end
+
+    public.finish = function()
+        local paddingStream = padding(blockCipher.blockSize, inputQueue.getHead());
+        public.update(paddingStream);
+
+        return public;
+    end
+
+    public.getOutputQueue = function()
+        return outputQueue;
+    end
+
+    public.asHex = function()
+        return Stream.toHex(outputQueue.pop);
+    end
+
+    public.asBytes = function()
+        return Stream.toArray(outputQueue.pop);
+    end
+
+    return public;
+
+end
+
+OFB.Decipher = function()
+
+    local public = {};
+
+    local key;
+    local blockCipher;
+    local padding;
+    local inputQueue;
+    local outputQueue;
+    local iv;
+
+    public.setKey = function(keyBytes)
+        key = keyBytes;
+        return public;
+    end
+
+    public.setBlockCipher = function(cipher)
+        blockCipher = cipher;
+        return public;
+    end
+
+    public.setPadding = function(paddingMode)
+        padding = paddingMode;
+        return public;
+    end
+
+    public.init = function()
+        inputQueue = Queue();
+        outputQueue = Queue();
+        iv = nil;
+        return public;
+    end
+
+    public.update = function(messageStream)
+        local byte = messageStream();
+        while (byte ~= nil) do
+            inputQueue.push(byte);
+            if(inputQueue.size() >= blockCipher.blockSize) then
+                local block = Array.readFromQueue(inputQueue, blockCipher.blockSize);
+
+                if(iv == nil) then
+                    iv = block;
+                else
+                    local out = iv;
+                    out = blockCipher.encrypt(key, out);
+                    iv = out;
+                    out = Array.XOR(out, block);
+                    Array.writeToQueue(outputQueue, out);
+                end
+            end
+            byte = messageStream();
+        end
+        return public;
+    end
+
+    public.finish = function()
+        local paddingStream = padding(blockCipher.blockSize, inputQueue.getHead());
+        public.update(paddingStream);
+
+        return public;
+    end
+
+    public.getOutputQueue = function()
+        return outputQueue;
+    end
+
+    public.asHex = function()
+        return Stream.toHex(outputQueue.pop);
+    end
+
+    public.asBytes = function()
+        return Stream.toArray(outputQueue.pop);
+    end
+
+    return public;
+
+end
+
+
+return OFB;

lockbox/digest/sha1.lua

@@ -0,0 +1,173 @@
+require("lockbox").insecure();
+
+local Bit = require("lockbox.util.bit");
+local String = require("string");
+local Math = require("math");
+local Queue = require("lockbox.util.queue");
+
+local AND = Bit.band;
+local OR  = Bit.bor;
+local XOR = Bit.bxor;
+local LROT = Bit.lrotate;
+local LSHIFT = Bit.lshift;
+local RSHIFT = Bit.rshift;
+
+--SHA1 is big-endian
+local bytes2word = function(b0, b1, b2, b3)
+    local i = b0; i = LSHIFT(i, 8);
+    i = OR(i, b1); i = LSHIFT(i, 8);
+    i = OR(i, b2); i = LSHIFT(i, 8);
+    i = OR(i, b3);
+    return i;
+end
+
+local word2bytes = function(word)
+    local b0, b1, b2, b3;
+    b3 = AND(word, 0xFF); word = RSHIFT(word, 8);
+    b2 = AND(word, 0xFF); word = RSHIFT(word, 8);
+    b1 = AND(word, 0xFF); word = RSHIFT(word, 8);
+    b0 = AND(word, 0xFF);
+    return b0, b1, b2, b3;
+end
+
+local dword2bytes = function(i)
+    local b4, b5, b6, b7 = word2bytes(i);
+    local b0, b1, b2, b3 = word2bytes(Math.floor(i / 0x100000000));
+    return b0, b1, b2, b3, b4, b5, b6, b7;
+end
+
+local F = function(x, y, z) return XOR(z, AND(x, XOR(y, z))); end
+local G = function(x, y, z) return XOR(x, XOR(y, z)); end
+local H = function(x, y, z) return OR(AND(x, OR(y, z)), AND(y, z)); end
+local I = function(x, y, z) return XOR(x, XOR(y, z)); end
+
+local SHA1 = function()
+
+    local queue = Queue();
+
+    local h0 = 0x67452301;
+    local h1 = 0xEFCDAB89;
+    local h2 = 0x98BADCFE;
+    local h3 = 0x10325476;
+    local h4 = 0xC3D2E1F0;
+
+    local public = {};
+
+    local processBlock = function()
+        local a = h0;
+        local b = h1;
+        local c = h2;
+        local d = h3;
+        local e = h4;
+        local temp;
+        local k;
+
+        local w = {};
+        for i = 0, 15 do
+            w[i] = bytes2word(queue.pop(), queue.pop(), queue.pop(), queue.pop());
+        end
+
+        for i = 16, 79 do
+            w[i] = LROT((XOR(XOR(w[i - 3], w[i - 8]), XOR(w[i - 14], w[i - 16]))), 1);
+        end
+
+        for i = 0, 79 do
+            if (i <= 19) then
+                temp = F(b, c, d);
+                k = 0x5A827999;
+            elseif (i <= 39) then
+                temp = G(b, c, d);
+                k = 0x6ED9EBA1;
+            elseif (i <= 59) then
+                temp = H(b, c, d);
+                k = 0x8F1BBCDC;
+            else
+                temp = I(b, c, d);
+                k = 0xCA62C1D6;
+            end
+            temp = LROT(a, 5) + temp + e + k + w[i];
+            e = d;
+            d = c;
+            c = LROT(b, 30);
+            b = a;
+            a = temp;
+        end
+
+        h0 = AND(h0 + a, 0xFFFFFFFF);
+        h1 = AND(h1 + b, 0xFFFFFFFF);
+        h2 = AND(h2 + c, 0xFFFFFFFF);
+        h3 = AND(h3 + d, 0xFFFFFFFF);
+        h4 = AND(h4 + e, 0xFFFFFFFF);
+    end
+
+    public.init = function()
+        queue.reset();
+        h0 = 0x67452301;
+        h1 = 0xEFCDAB89;
+        h2 = 0x98BADCFE;
+        h3 = 0x10325476;
+        h4 = 0xC3D2E1F0;
+        return public;
+    end
+
+
+    public.update = function(bytes)
+        for b in bytes do
+            queue.push(b);
+            if queue.size() >= 64 then processBlock(); end
+        end
+
+        return public;
+    end
+
+    public.finish = function()
+        local bits = queue.getHead() * 8;
+
+        queue.push(0x80);
+        while ((queue.size() + 7) % 64) < 63 do
+            queue.push(0x00);
+        end
+
+        local b0, b1, b2, b3, b4, b5, b6, b7 = dword2bytes(bits);
+
+        queue.push(b0);
+        queue.push(b1);
+        queue.push(b2);
+        queue.push(b3);
+        queue.push(b4);
+        queue.push(b5);
+        queue.push(b6);
+        queue.push(b7);
+
+        while queue.size() > 0 do
+            processBlock();
+        end
+
+        return public;
+    end
+
+    public.asBytes = function()
+        local  b0, b1, b2, b3 = word2bytes(h0);
+        local  b4, b5, b6, b7 = word2bytes(h1);
+        local  b8, b9, b10, b11 = word2bytes(h2);
+        local b12, b13, b14, b15 = word2bytes(h3);
+        local b16, b17, b18, b19 = word2bytes(h4);
+
+        return {b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19};
+    end
+
+    public.asHex = function()
+        local  b0, b1, b2, b3 = word2bytes(h0);
+        local  b4, b5, b6, b7 = word2bytes(h1);
+        local  b8, b9, b10, b11 = word2bytes(h2);
+        local b12, b13, b14, b15 = word2bytes(h3);
+        local b16, b17, b18, b19 = word2bytes(h4);
+
+        return String.format("%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
+                b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19);
+    end
+
+    return public;
+end
+
+return SHA1;

lockbox/digest/sha2_224.lua

@@ -0,0 +1,200 @@
+local Bit = require("lockbox.util.bit");
+local String = require("string");
+local Math = require("math");
+local Queue = require("lockbox.util.queue");
+
+local CONSTANTS = {
+   0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+   0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+   0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+   0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+   0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+   0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+   0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+   0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2  };
+
+local fmt = "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x" ..
+            "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x"
+
+local AND = Bit.band;
+local OR  = Bit.bor;
+local NOT = Bit.bnot;
+local XOR = Bit.bxor;
+local RROT = Bit.rrotate;
+local LSHIFT = Bit.lshift;
+local RSHIFT = Bit.rshift;
+
+--SHA2 is big-endian
+local bytes2word = function(b0, b1, b2, b3)
+    local i = b0; i = LSHIFT(i, 8);
+    i = OR(i, b1); i = LSHIFT(i, 8);
+    i = OR(i, b2); i = LSHIFT(i, 8);
+    i = OR(i, b3);
+    return i;
+end
+
+local word2bytes = function(word)
+    local b0, b1, b2, b3;
+    b3 = AND(word, 0xFF); word = RSHIFT(word, 8);
+    b2 = AND(word, 0xFF); word = RSHIFT(word, 8);
+    b1 = AND(word, 0xFF); word = RSHIFT(word, 8);
+    b0 = AND(word, 0xFF);
+    return b0, b1, b2, b3;
+end
+
+local dword2bytes = function(i)
+    local b4, b5, b6, b7 = word2bytes(i);
+    local b0, b1, b2, b3 = word2bytes(Math.floor(i / 0x100000000));
+    return b0, b1, b2, b3, b4, b5, b6, b7;
+end
+
+
+
+
+local SHA2_224 = function()
+
+    local queue = Queue();
+
+    local h0 = 0xc1059ed8;
+    local h1 = 0x367cd507;
+    local h2 = 0x3070dd17;
+    local h3 = 0xf70e5939;
+    local h4 = 0xffc00b31;
+    local h5 = 0x68581511;
+    local h6 = 0x64f98fa7;
+    local h7 = 0xbefa4fa4;
+
+    local public = {};
+
+    local processBlock = function()
+        local a = h0;
+        local b = h1;
+        local c = h2;
+        local d = h3;
+        local e = h4;
+        local f = h5;
+        local g = h6;
+        local h = h7;
+
+        local w = {};
+
+        for i = 0, 15 do
+            w[i] = bytes2word(queue.pop(), queue.pop(), queue.pop(), queue.pop());
+        end
+
+        for i = 16, 63 do
+            local s0 = XOR(RROT(w[i - 15], 7), XOR(RROT(w[i - 15], 18), RSHIFT(w[i - 15], 3)));
+            local s1 = XOR(RROT(w[i - 2], 17), XOR(RROT(w[i - 2], 19), RSHIFT(w[i - 2], 10)));
+            w[i] = AND(w[i - 16] + s0 + w[i - 7] + s1, 0xFFFFFFFF);
+        end
+
+        for i = 0, 63 do
+            local s1 = XOR(RROT(e, 6), XOR(RROT(e, 11), RROT(e, 25)));
+            local ch = XOR(AND(e, f), AND(NOT(e), g));
+            local temp1 = h + s1 + ch + CONSTANTS[i + 1] + w[i];
+            local s0 = XOR(RROT(a, 2), XOR(RROT(a, 13), RROT(a, 22)));
+            local maj = XOR(AND(a, b), XOR(AND(a, c), AND(b, c)));
+            local temp2 = s0 + maj;
+
+            h = g;
+            g = f;
+            f = e;
+            e = d + temp1;
+            d = c;
+            c = b;
+            b = a;
+            a = temp1 + temp2;
+        end
+
+        h0 = AND(h0 + a, 0xFFFFFFFF);
+        h1 = AND(h1 + b, 0xFFFFFFFF);
+        h2 = AND(h2 + c, 0xFFFFFFFF);
+        h3 = AND(h3 + d, 0xFFFFFFFF);
+        h4 = AND(h4 + e, 0xFFFFFFFF);
+        h5 = AND(h5 + f, 0xFFFFFFFF);
+        h6 = AND(h6 + g, 0xFFFFFFFF);
+        h7 = AND(h7 + h, 0xFFFFFFFF);
+    end
+
+    public.init = function()
+        queue.reset();
+
+        h0 = 0xc1059ed8;
+        h1 = 0x367cd507;
+        h2 = 0x3070dd17;
+        h3 = 0xf70e5939;
+        h4 = 0xffc00b31;
+        h5 = 0x68581511;
+        h6 = 0x64f98fa7;
+        h7 = 0xbefa4fa4;
+
+        return public;
+    end
+
+    public.update = function(bytes)
+        for b in bytes do
+            queue.push(b);
+            if queue.size() >= 64 then processBlock(); end
+        end
+
+        return public;
+    end
+
+    public.finish = function()
+        local bits = queue.getHead() * 8;
+
+        queue.push(0x80);
+        while ((queue.size() + 7) % 64) < 63 do
+            queue.push(0x00);
+        end
+
+        local b0, b1, b2, b3, b4, b5, b6, b7 = dword2bytes(bits);
+
+        queue.push(b0);
+        queue.push(b1);
+        queue.push(b2);
+        queue.push(b3);
+        queue.push(b4);
+        queue.push(b5);
+        queue.push(b6);
+        queue.push(b7);
+
+        while queue.size() > 0 do
+            processBlock();
+        end
+
+        return public;
+    end
+
+    public.asBytes = function()
+        local  b0, b1, b2, b3 = word2bytes(h0);
+        local  b4, b5, b6, b7 = word2bytes(h1);
+        local  b8, b9, b10, b11 = word2bytes(h2);
+        local b12, b13, b14, b15 = word2bytes(h3);
+        local b16, b17, b18, b19 = word2bytes(h4);
+        local b20, b21, b22, b23 = word2bytes(h5);
+        local b24, b25, b26, b27 = word2bytes(h6);
+
+        return {  b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15
+                , b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27};
+    end
+
+    public.asHex = function()
+        local  b0, b1, b2, b3 = word2bytes(h0);
+        local  b4, b5, b6, b7 = word2bytes(h1);
+        local  b8, b9, b10, b11 = word2bytes(h2);
+        local b12, b13, b14, b15 = word2bytes(h3);
+        local b16, b17, b18, b19 = word2bytes(h4);
+        local b20, b21, b22, b23 = word2bytes(h5);
+        local b24, b25, b26, b27 = word2bytes(h6);
+
+        return String.format(fmt, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15
+                , b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27);
+    end
+
+    return public;
+
+end
+
+return SHA2_224;
+

lockbox/digest/sha2_256.lua

@@ -0,0 +1,203 @@
+local Bit = require("lockbox.util.bit");
+local String = require("string");
+local Math = require("math");
+local Queue = require("lockbox.util.queue");
+
+local CONSTANTS = {
+   0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+   0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+   0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+   0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+   0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+   0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+   0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+   0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2  };
+
+local fmt = "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x" ..
+            "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x"
+
+local AND = Bit.band;
+local OR  = Bit.bor;
+local NOT = Bit.bnot;
+local XOR = Bit.bxor;
+local RROT = Bit.rrotate;
+local LSHIFT = Bit.lshift;
+local RSHIFT = Bit.rshift;
+
+--SHA2 is big-endian
+local bytes2word = function(b0, b1, b2, b3)
+    local i = b0; i = LSHIFT(i, 8);
+    i = OR(i, b1); i = LSHIFT(i, 8);
+    i = OR(i, b2); i = LSHIFT(i, 8);
+    i = OR(i, b3);
+    return i;
+end
+
+local word2bytes = function(word)
+    local b0, b1, b2, b3;
+    b3 = AND(word, 0xFF); word = RSHIFT(word, 8);
+    b2 = AND(word, 0xFF); word = RSHIFT(word, 8);
+    b1 = AND(word, 0xFF); word = RSHIFT(word, 8);
+    b0 = AND(word, 0xFF);
+    return b0, b1, b2, b3;
+end
+
+local dword2bytes = function(i)
+    local b4, b5, b6, b7 = word2bytes(i);
+    local b0, b1, b2, b3 = word2bytes(Math.floor(i / 0x100000000));
+    return b0, b1, b2, b3, b4, b5, b6, b7;
+end
+
+
+
+
+local SHA2_256 = function()
+
+    local queue = Queue();
+
+    local h0 = 0x6a09e667;
+    local h1 = 0xbb67ae85;
+    local h2 = 0x3c6ef372;
+    local h3 = 0xa54ff53a;
+    local h4 = 0x510e527f;
+    local h5 = 0x9b05688c;
+    local h6 = 0x1f83d9ab;
+    local h7 = 0x5be0cd19;
+
+    local public = {};
+
+    local processBlock = function()
+        local a = h0;
+        local b = h1;
+        local c = h2;
+        local d = h3;
+        local e = h4;
+        local f = h5;
+        local g = h6;
+        local h = h7;
+
+        local w = {};
+
+        for i = 0, 15 do
+            w[i] = bytes2word(queue.pop(), queue.pop(), queue.pop(), queue.pop());
+        end
+
+        for i = 16, 63 do
+            local s0 = XOR(RROT(w[i - 15], 7), XOR(RROT(w[i - 15], 18), RSHIFT(w[i - 15], 3)));
+            local s1 = XOR(RROT(w[i - 2], 17), XOR(RROT(w[i -  2], 19), RSHIFT(w[i - 2], 10)));
+            w[i] = AND(w[i - 16] + s0 + w[i - 7] + s1, 0xFFFFFFFF);
+        end
+
+        for i = 0, 63 do
+            local s1 = XOR(RROT(e, 6), XOR(RROT(e, 11), RROT(e, 25)));
+            local ch = XOR(AND(e, f), AND(NOT(e), g));
+            local temp1 = h + s1 + ch + CONSTANTS[i + 1] + w[i];
+            local s0 = XOR(RROT(a, 2), XOR(RROT(a, 13), RROT(a, 22)));
+            local maj = XOR(AND(a, b), XOR(AND(a, c), AND(b, c)));
+            local temp2 = s0 + maj;
+
+            h = g;
+            g = f;
+            f = e;
+            e = d + temp1;
+            d = c;
+            c = b;
+            b = a;
+            a = temp1 + temp2;
+        end
+
+        h0 = AND(h0 + a, 0xFFFFFFFF);
+        h1 = AND(h1 + b, 0xFFFFFFFF);
+        h2 = AND(h2 + c, 0xFFFFFFFF);
+        h3 = AND(h3 + d, 0xFFFFFFFF);
+        h4 = AND(h4 + e, 0xFFFFFFFF);
+        h5 = AND(h5 + f, 0xFFFFFFFF);
+        h6 = AND(h6 + g, 0xFFFFFFFF);
+        h7 = AND(h7 + h, 0xFFFFFFFF);
+    end
+
+    public.init = function()
+        queue.reset();
+
+        h0 = 0x6a09e667;
+        h1 = 0xbb67ae85;
+        h2 = 0x3c6ef372;
+        h3 = 0xa54ff53a;
+        h4 = 0x510e527f;
+        h5 = 0x9b05688c;
+        h6 = 0x1f83d9ab;
+        h7 = 0x5be0cd19;
+
+        return public;
+    end
+
+    public.update = function(bytes)
+        for b in bytes do
+            queue.push(b);
+            if queue.size() >= 64 then processBlock(); end
+        end
+
+        return public;
+    end
+
+    public.finish = function()
+        local bits = queue.getHead() * 8;
+
+        queue.push(0x80);
+        while ((queue.size() + 7) % 64) < 63 do
+            queue.push(0x00);
+        end
+
+        local b0, b1, b2, b3, b4, b5, b6, b7 = dword2bytes(bits);
+
+        queue.push(b0);
+        queue.push(b1);
+        queue.push(b2);
+        queue.push(b3);
+        queue.push(b4);
+        queue.push(b5);
+        queue.push(b6);
+        queue.push(b7);
+
+        while queue.size() > 0 do
+            processBlock();
+        end
+
+        return public;
+    end
+
+    public.asBytes = function()
+        local  b0, b1, b2, b3 = word2bytes(h0);
+        local  b4, b5, b6, b7 = word2bytes(h1);
+        local  b8, b9, b10, b11 = word2bytes(h2);
+        local b12, b13, b14, b15 = word2bytes(h3);
+        local b16, b17, b18, b19 = word2bytes(h4);
+        local b20, b21, b22, b23 = word2bytes(h5);
+        local b24, b25, b26, b27 = word2bytes(h6);
+        local b28, b29, b30, b31 = word2bytes(h7);
+
+
+        return {  b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15
+                , b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31};
+    end
+
+    public.asHex = function()
+        local  b0, b1, b2, b3 = word2bytes(h0);
+        local  b4, b5, b6, b7 = word2bytes(h1);
+        local  b8, b9, b10, b11 = word2bytes(h2);
+        local b12, b13, b14, b15 = word2bytes(h3);
+        local b16, b17, b18, b19 = word2bytes(h4);
+        local b20, b21, b22, b23 = word2bytes(h5);
+        local b24, b25, b26, b27 = word2bytes(h6);
+        local b28, b29, b30, b31 = word2bytes(h7);
+
+        return String.format(fmt, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15
+                , b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31);
+    end
+
+    return public;
+
+end
+
+return SHA2_256;
+

lockbox/init.lua

@@ -0,0 +1,22 @@
+local Lockbox = {};
+
+--[[
+package.path =  "./?.lua;"
+                .. "./cipher/?.lua;"
+                .. "./digest/?.lua;"
+                .. "./kdf/?.lua;"
+                .. "./mac/?.lua;"
+                .. "./padding/?.lua;"
+                .. "./test/?.lua;"
+                .. "./util/?.lua;"
+                .. package.path;
+--]]
+Lockbox.ALLOW_INSECURE = true;
+
+Lockbox.insecure = function()
+    assert(Lockbox.ALLOW_INSECURE,
+            "This module is insecure!  It should not be used in production." ..
+            "If you really want to use it, set Lockbox.ALLOW_INSECURE to true before importing it");
+end
+
+return Lockbox;

lockbox/kdf/pbkdf2.lua

@@ -0,0 +1,114 @@
+local Bit = require("lockbox.util.bit");
+local Array = require("lockbox.util.array");
+local Stream = require("lockbox.util.stream");
+local Math = require("math");
+
+local AND = Bit.band;
+local RSHIFT = Bit.rshift;
+
+local word2bytes = function(word)
+    local b0, b1, b2, b3;
+    b3 = AND(word, 0xFF); word = RSHIFT(word, 8);
+    b2 = AND(word, 0xFF); word = RSHIFT(word, 8);
+    b1 = AND(word, 0xFF); word = RSHIFT(word, 8);
+    b0 = AND(word, 0xFF);
+    return b0, b1, b2, b3;
+end
+
+local PBKDF2 = function()
+
+    local public = {};
+
+    local blockLen = 16;
+    local dKeyLen = 256;
+    local iterations = 4096;
+
+    local salt;
+    local password;
+
+
+    local PRF;
+
+    local dKey;
+
+
+    public.setBlockLen = function(len)
+        blockLen = len;
+        return public;
+    end
+
+    public.setDKeyLen = function(len)
+        dKeyLen = len
+        return public;
+    end
+
+    public.setIterations = function(iter)
+        iterations = iter;
+        return public;
+    end
+
+    public.setSalt = function(saltBytes)
+        salt = saltBytes;
+        return public;
+    end
+
+    public.setPassword = function(passwordBytes)
+        password = passwordBytes;
+        return public;
+    end
+
+    public.setPRF = function(prf)
+        PRF = prf;
+        return public;
+    end
+
+    local buildBlock = function(i)
+        local b0, b1, b2, b3 = word2bytes(i);
+        local ii = {b0, b1, b2, b3};
+        local s = Array.concat(salt, ii);
+
+        local out = {};
+
+        PRF.setKey(password);
+        for c = 1, iterations do
+            PRF.init()
+                .update(Stream.fromArray(s));
+
+            s = PRF.finish().asBytes();
+            if(c > 1) then
+                out = Array.XOR(out, s);
+            else
+                out = s;
+            end
+        end
+
+        return out;
+    end
+
+    public.finish = function()
+        local blocks = Math.ceil(dKeyLen / blockLen);
+
+        dKey = {};
+
+        for b = 1, blocks do
+            local block = buildBlock(b);
+            dKey = Array.concat(dKey, block);
+        end
+
+        if(Array.size(dKey) > dKeyLen) then dKey = Array.truncate(dKey, dKeyLen); end
+
+        return public;
+    end
+
+    public.asBytes = function()
+        return dKey;
+    end
+
+    public.asHex = function()
+        return Array.toHex(dKey);
+    end
+
+    return public;
+end
+
+return PBKDF2;

lockbox/mac/hmac.lua

@@ -0,0 +1,85 @@
+local Bit = require("lockbox.util.bit");
+local Stream = require("lockbox.util.stream");
+local Array = require("lockbox.util.array");
+
+local XOR = Bit.bxor;
+
+local HMAC = function()
+
+    local public = {};
+    local blockSize = 64;
+    local Digest = nil;
+    local outerPadding = {};
+    local innerPadding = {}
+    local digest;
+
+    public.setBlockSize = function(bytes)
+        blockSize = bytes;
+        return public;
+    end
+
+    public.setDigest = function(digestModule)
+        Digest = digestModule;
+        digest = Digest();
+        return public;
+    end
+
+    public.setKey = function(key)
+        local keyStream;
+
+        if(Array.size(key) > blockSize) then
+            keyStream = Stream.fromArray(Digest()
+                        .update(Stream.fromArray(key))
+                        .finish()
+                        .asBytes());
+        else
+            keyStream = Stream.fromArray(key);
+        end
+
+        outerPadding = {};
+        innerPadding = {};
+
+        for i = 1, blockSize do
+            local byte = keyStream();
+            if byte == nil then byte = 0x00; end
+            outerPadding[i] = XOR(0x5C, byte);
+            innerPadding[i] = XOR(0x36, byte);
+        end
+
+        return public;
+    end
+
+    public.init = function()
+        digest.init()
+              .update(Stream.fromArray(innerPadding));
+        return public;
+    end
+
+    public.update = function(messageStream)
+        digest.update(messageStream);
+        return public;
+    end
+
+    public.finish = function()
+        local inner = digest.finish().asBytes();
+        digest.init()
+              .update(Stream.fromArray(outerPadding))
+              .update(Stream.fromArray(inner))
+              .finish();
+
+        return public;
+    end
+
+    public.asBytes = function()
+        return digest.asBytes();
+    end
+
+    public.asHex = function()
+        return digest.asHex();
+    end
+
+    return public;
+
+end
+
+return HMAC;

lockbox/padding/ansix923.lua

@@ -0,0 +1,22 @@
+local ANSIX923Padding = function(blockSize, byteCount)
+
+    local paddingCount = blockSize - (byteCount % blockSize);
+    local bytesLeft = paddingCount;
+
+    local stream = function()
+        if bytesLeft > 1 then
+            bytesLeft = bytesLeft - 1;
+            return 0x00;
+        elseif bytesLeft > 0 then
+            bytesLeft = bytesLeft - 1;
+            return paddingCount;
+        else
+            return nil;
+        end
+    end
+
+    return stream;
+
+end
+
+return ANSIX923Padding;

lockbox/padding/isoiec7816.lua

@@ -0,0 +1,22 @@
+local ISOIEC7816Padding = function(blockSize, byteCount)
+
+    local paddingCount = blockSize - (byteCount % blockSize);
+    local bytesLeft = paddingCount;
+
+    local stream = function()
+        if bytesLeft == paddingCount then
+            bytesLeft = bytesLeft - 1;
+            return 0x80;
+        elseif bytesLeft > 0 then
+            bytesLeft = bytesLeft - 1;
+            return 0x00;
+        else
+            return nil;
+        end
+    end
+
+    return stream;
+
+end
+
+return ISOIEC7816Padding;

lockbox/padding/pkcs7.lua

@@ -0,0 +1,18 @@
+local PKCS7Padding = function(blockSize, byteCount)
+
+    local paddingCount = blockSize - ((byteCount -1) % blockSize) + 1;
+    local bytesLeft = paddingCount;
+
+    local stream = function()
+        if bytesLeft > 0 then
+            bytesLeft = bytesLeft - 1;
+            return paddingCount;
+        else
+            return nil;
+        end
+    end
+
+    return stream;
+end
+
+return PKCS7Padding;

lockbox/padding/zero.lua

@@ -0,0 +1,19 @@
+local ZeroPadding = function(blockSize, byteCount)
+
+    local paddingCount = blockSize - ((byteCount -1) % blockSize) + 1;
+    local bytesLeft = paddingCount;
+
+    local stream = function()
+        if bytesLeft > 0 then
+            bytesLeft = bytesLeft - 1;
+            return 0x00;
+        else
+            return nil;
+        end
+    end
+
+    return stream;
+
+end
+
+return ZeroPadding;

lockbox/util/array.lua

@@ -0,0 +1,211 @@
+
+local String = require("string");
+local Bit = require("lockbox.util.bit");
+local Queue = require("lockbox.util.queue");
+
+local XOR = Bit.bxor;
+
+local Array = {};
+
+Array.size = function(array)
+    return #array;
+end
+
+Array.fromString = function(string)
+    local bytes = {};
+
+    local i = 1;
+    local byte = String.byte(string, i);
+    while byte ~= nil do
+        bytes[i] = byte;
+        i = i + 1;
+        byte = String.byte(string, i);
+    end
+
+    return bytes;
+
+end
+
+Array.toString = function(bytes)
+    local chars = {};
+    local i = 1;
+
+    local byte = bytes[i];
+    while byte ~= nil do
+        chars[i] = String.char(byte);
+        i = i + 1;
+        byte = bytes[i];
+    end
+
+    return table.concat(chars, "");
+end
+
+Array.fromStream = function(stream)
+    local array = {};
+    local i = 1;
+
+    local byte = stream();
+    while byte ~= nil do
+        array[i] = byte;
+        i = i + 1;
+        byte = stream();
+    end
+
+    return array;
+end
+
+Array.readFromQueue = function(queue, size)
+    local array = {};
+
+    for i = 1, size do
+        array[i] = queue.pop();
+    end
+
+    return array;
+end
+
+Array.writeToQueue = function(queue, array)
+    local size = Array.size(array);
+
+    for i = 1, size do
+        queue.push(array[i]);
+    end
+end
+
+Array.toStream = function(array)
+    local queue = Queue();
+    local i = 1;
+
+    local byte = array[i];
+    while byte ~= nil do
+        queue.push(byte);
+        i = i + 1;
+        byte = array[i];
+    end
+
+    return queue.pop;
+end
+
+
+local fromHexTable = {};
+for i = 0, 255 do
+    fromHexTable[String.format("%02X", i)] = i;
+    fromHexTable[String.format("%02x", i)] = i;
+end
+
+Array.fromHex = function(hex)
+    local array = {};
+
+    for i = 1, String.len(hex) / 2 do
+        local h = String.sub(hex, i * 2 - 1, i * 2);
+        array[i] = fromHexTable[h];
+    end
+
+    return array;
+end
+
+
+local toHexTable = {};
+for i = 0, 255 do
+    toHexTable[i] = String.format("%02X", i);
+end
+
+Array.toHex = function(array)
+    local hex = {};
+    local i = 1;
+
+    local byte = array[i];
+    while byte ~= nil do
+        hex[i] = toHexTable[byte];
+        i = i + 1;
+        byte = array[i];
+    end
+
+    return table.concat(hex, "");
+
+end
+
+Array.concat = function(a, b)
+    local concat = {};
+    local out = 1;
+
+    local i = 1;
+    local byte = a[i];
+    while byte ~= nil do
+        concat[out] = byte;
+        i = i + 1;
+        out = out + 1;
+        byte = a[i];
+    end
+
+    i = 1;
+    byte = b[i];
+    while byte ~= nil do
+        concat[out] = byte;
+        i = i + 1;
+        out = out + 1;
+        byte = b[i];
+    end
+
+    return concat;
+end
+
+Array.truncate = function(a, newSize)
+    local x = {};
+
+    for i = 1, newSize do
+        x[i] = a[i];
+    end
+
+    return x;
+end
+
+Array.XOR = function(a, b)
+    local x = {};
+
+    for k, v in pairs(a) do
+        x[k] = XOR(v, b[k]);
+    end
+
+    return x;
+end
+
+Array.substitute = function(input, sbox)
+    local out = {};
+
+    for k, v in pairs(input) do
+        out[k] = sbox[v];
+    end
+
+    return out;
+end
+
+Array.permute = function(input, pbox)
+    local out = {};
+
+    for k, v in pairs(pbox) do
+        out[k] = input[v];
+    end
+
+    return out;
+end
+
+Array.copy = function(input)
+    local out = {};
+
+    for k, v in pairs(input) do
+        out[k] = v;
+    end
+    return out;
+end
+
+Array.slice = function(input, start, stop)
+    local out = {};
+
+    for i = start, stop do
+        out[i - start + 1] = input[i];
+    end
+    return out;
+end
+
+return Array;

lockbox/util/bit.lua

@@ -0,0 +1,25 @@
+local ok, e
+ok = nil
+if not ok then
+    ok, e = pcall(require, "bit") -- the LuaJIT one ?
+end
+if not ok then
+    ok, e = pcall(require, "bit32") -- Lua 5.2
+end
+if not ok then
+    ok, e = pcall(require, "bit.numberlua") -- for Lua 5.1, https://github.com/tst2005/lua-bit-numberlua/
+end
+if not ok then
+    error("no bitwise support found", 2)
+end
+assert(type(e) == "table", "invalid bit module")
+
+-- Workaround to support Lua 5.2 bit32 API with the LuaJIT bit one
+if e.rol and not e.lrotate then
+    e.lrotate = e.rol
+end
+if e.ror and not e.rrotate then
+    e.rrotate = e.ror
+end
+
+return e

lockbox/util/queue.lua

@@ -0,0 +1,47 @@
+local Queue = function()
+    local queue = {};
+    local tail = 0;
+    local head = 0;
+
+    local public = {};
+
+    public.push = function(obj)
+        queue[head] = obj;
+        head = head + 1;
+        return;
+    end
+
+    public.pop = function()
+        if tail < head
+        then
+            local obj = queue[tail];
+            queue[tail] = nil;
+            tail = tail + 1;
+            return obj;
+        else
+            return nil;
+        end
+    end
+
+    public.size = function()
+        return head - tail;
+    end
+
+    public.getHead = function()
+        return head;
+    end
+
+    public.getTail = function()
+        return tail;
+    end
+
+    public.reset = function()
+        queue = {};
+        head = 0;
+        tail = 0;
+    end
+
+    return public;
+end
+
+return Queue;

lockbox/util/stream.lua

@@ -0,0 +1,99 @@
+local Queue = require("lockbox.util.queue");
+local String = require("string");
+
+local Stream = {};
+
+
+Stream.fromString = function(string)
+    local i = 0;
+    return function()
+        i = i + 1;
+        return String.byte(string, i);
+    end
+end
+
+
+Stream.toString = function(stream)
+    local array = {};
+    local i = 1;
+
+    local byte = stream();
+    while byte ~= nil do
+        array[i] = String.char(byte);
+        i = i + 1;
+        byte = stream();
+    end
+
+    return table.concat(array);
+end
+
+
+Stream.fromArray = function(array)
+    local queue = Queue();
+    local i = 1;
+
+    local byte = array[i];
+    while byte ~= nil do
+        queue.push(byte);
+        i = i + 1;
+        byte = array[i];
+    end
+
+    return queue.pop;
+end
+
+
+Stream.toArray = function(stream)
+    local array = {};
+    local i = 1;
+
+    local byte = stream();
+    while byte ~= nil do
+        array[i] = byte;
+        i = i + 1;
+        byte = stream();
+    end
+
+    return array;
+end
+
+
+local fromHexTable = {};
+for i = 0, 255 do
+    fromHexTable[String.format("%02X", i)] = i;
+    fromHexTable[String.format("%02x", i)] = i;
+end
+
+Stream.fromHex = function(hex)
+    local queue = Queue();
+
+    for i = 1, String.len(hex) / 2 do
+        local h = String.sub(hex, i * 2 - 1, i * 2);
+        queue.push(fromHexTable[h]);
+    end
+
+    return queue.pop;
+end
+
+
+
+local toHexTable = {};
+for i = 0, 255 do
+    toHexTable[i] = String.format("%02X", i);
+end
+
+Stream.toHex = function(stream)
+    local hex = {};
+    local i = 1;
+
+    local byte = stream();
+    while byte ~= nil do
+        hex[i] = toHexTable[byte];
+        i = i + 1;
+        byte = stream();
+    end
+
+    return table.concat(hex);
+end
+
+return Stream;

pocket/startup.lua

@@ -3,3 +3,14 @@
 --
 
 require("/initenv").init_env()
+
+local util = require("scada-common.util")
+
+local POCKET_VERSION = "alpha-v0.0.0"
+
+local print = util.print
+local println = util.println
+local print_ts = util.print_ts
+local println_ts = util.println_ts
+
+println("Sorry, this isn't written yet :(")

reactor-plc/config.lua

@@ -3,11 +3,17 @@ local config = {}
 -- set to false to run in offline mode (safety regulation only)
 config.NETWORKED = true
 -- unique reactor ID
-config.REACTOR_ID  = 1
+config.REACTOR_ID = 1
+
 -- port to send packets TO server
 config.SERVER_PORT = 16000
 -- port to listen to incoming packets FROM server
 config.LISTEN_PORT = 14001
+-- max trusted modem message distance (0 to disable check)
+config.TRUSTED_RANGE = 0
+-- time in seconds (>= 2) before assuming a remote device is no longer active
+config.COMMS_TIMEOUT = 5
+
 -- log path
 config.LOG_PATH = "/log.txt"
 -- log mode

reactor-plc/startup.lua

@@ -4,22 +4,45 @@
 
 require("/initenv").init_env()
 
-local log = require("scada-common.log")
-local mqueue = require("scada-common.mqueue")
-local ppm = require("scada-common.ppm")
-local util = require("scada-common.util")
+local crash   = require("scada-common.crash")
+local log     = require("scada-common.log")
+local mqueue  = require("scada-common.mqueue")
+local ppm     = require("scada-common.ppm")
+local util    = require("scada-common.util")
 
-local config = require("reactor-plc.config")
-local plc = require("reactor-plc.plc")
+local config  = require("reactor-plc.config")
+local plc     = require("reactor-plc.plc")
 local threads = require("reactor-plc.threads")
 
-local R_PLC_VERSION = "alpha-v0.7.2"
+local R_PLC_VERSION = "v1.0.0"
 
 local print = util.print
 local println = util.println
 local print_ts = util.print_ts
 local println_ts = util.println_ts
 
+----------------------------------------
+-- config validation
+----------------------------------------
+
+local cfv = util.new_validator()
+
+cfv.assert_type_bool(config.NETWORKED)
+cfv.assert_type_int(config.REACTOR_ID)
+cfv.assert_port(config.SERVER_PORT)
+cfv.assert_port(config.LISTEN_PORT)
+cfv.assert_type_int(config.TRUSTED_RANGE)
+cfv.assert_type_num(config.COMMS_TIMEOUT)
+cfv.assert_min(config.COMMS_TIMEOUT, 2)
+cfv.assert_type_str(config.LOG_PATH)
+cfv.assert_type_int(config.LOG_MODE)
+
+assert(cfv.valid(), "bad config file: missing/invalid fields")
+
+----------------------------------------
+-- log init
+----------------------------------------
+
 log.init(config.LOG_PATH, config.LOG_MODE)
 
 log.info("========================================")
@@ -27,149 +50,175 @@ log.info("BOOTING reactor-plc.startup " .. R_PLC_VERSION)
 log.info("========================================")
 println(">> Reactor PLC " .. R_PLC_VERSION .. " <<")
 
--- mount connected devices
-ppm.mount_all()
+crash.set_env("plc", R_PLC_VERSION)
 
--- shared memory across threads
----@class plc_shared_memory
-local __shared_memory = {
-    -- networked setting
-    networked = config.NETWORKED,   ---@type boolean
+----------------------------------------
+-- main application
+----------------------------------------
 
-    -- PLC system state flags
-    ---@class plc_state
-    plc_state = {
-        init_ok = true,
-        shutdown = false,
-        degraded = false,
-        no_reactor = false,
-        no_modem = false
-    },
+local function main()
+    ----------------------------------------
+    -- startup
+    ----------------------------------------
 
-    -- control setpoints
-    ---@class setpoints
-    setpoints = {
-        burn_rate_en = false,
-        burn_rate = 0.0
-    },
+    -- mount connected devices
+    ppm.mount_all()
 
-    -- core PLC devices
-    plc_dev = {
-        reactor = ppm.get_fission_reactor(),
-        modem = ppm.get_wireless_modem()
-    },
+    -- shared memory across threads
+    ---@class plc_shared_memory
+    local __shared_memory = {
+        -- networked setting
+        networked = config.NETWORKED,   ---@type boolean
 
-    -- system objects
-    plc_sys = {
-        rps = nil,              ---@type rps
-        plc_comms = nil,        ---@type plc_comms
-        conn_watchdog = nil     ---@type watchdog
-    },
+        -- PLC system state flags
+        ---@class plc_state
+        plc_state = {
+            init_ok = true,
+            shutdown = false,
+            degraded = false,
+            reactor_formed = true,
+            no_reactor = false,
+            no_modem = false
+        },
 
-    -- message queues
-    q = {
-        mq_rps = mqueue.new(),
-        mq_comms_tx = mqueue.new(),
-        mq_comms_rx = mqueue.new()
+        -- control setpoints
+        ---@class setpoints
+        setpoints = {
+            burn_rate_en = false,
+            burn_rate = 0.0
+        },
+
+        -- core PLC devices
+        plc_dev = {
+            reactor = ppm.get_fission_reactor(),
+            modem = ppm.get_wireless_modem()
+        },
+
+        -- system objects
+        plc_sys = {
+            rps = nil,              ---@type rps
+            plc_comms = nil,        ---@type plc_comms
+            conn_watchdog = nil     ---@type watchdog
+        },
+
+        -- message queues
+        q = {
+            mq_rps = mqueue.new(),
+            mq_comms_tx = mqueue.new(),
+            mq_comms_rx = mqueue.new()
+        }
     }
-}
 
-local smem_dev = __shared_memory.plc_dev
-local smem_sys = __shared_memory.plc_sys
+    local smem_dev = __shared_memory.plc_dev
+    local smem_sys = __shared_memory.plc_sys
 
-local plc_state = __shared_memory.plc_state
+    local plc_state = __shared_memory.plc_state
 
--- we need a reactor and a modem
-if smem_dev.reactor == nil then
-    println("boot> fission reactor not found");
-    log.warning("no reactor on startup")
+    -- we need a reactor, can at least do some things even if it isn't formed though
+    if smem_dev.reactor == nil then
+        println("init> fission reactor not found");
+        log.warning("init> no reactor on startup")
 
-    plc_state.init_ok = false
-    plc_state.degraded = true
-    plc_state.no_reactor = true
-end
-if __shared_memory.networked and smem_dev.modem == nil then
-    println("boot> wireless modem not found")
-    log.warning("no wireless modem on startup")
+        plc_state.init_ok = false
+        plc_state.degraded = true
+        plc_state.no_reactor = true
+    elseif not smem_dev.reactor.isFormed() then
+        println("init> fission reactor not formed");
+        log.warning("init> reactor logic adapter present, but reactor is not formed")
 
-    if smem_dev.reactor ~= nil then
-        smem_dev.reactor.scram()
+        plc_state.degraded = true
+        plc_state.reactor_formed = false
     end
 
-    plc_state.init_ok = false
-    plc_state.degraded = true
-    plc_state.no_modem = true
-end
+    -- modem is required if networked
+    if __shared_memory.networked and smem_dev.modem == nil then
+        println("init> wireless modem not found")
+        log.warning("init> no wireless modem on startup")
 
--- PLC init
-local init = function ()
-    if plc_state.init_ok then
-        -- just booting up, no fission allowed (neutrons stay put thanks)
-        smem_dev.reactor.scram()
-
-        -- init reactor protection system
-        smem_sys.rps = plc.rps_init(smem_dev.reactor)
-        log.debug("init> rps init")
-
-        if __shared_memory.networked then
-            -- comms watchdog, 3 second timeout
-            smem_sys.conn_watchdog = util.new_watchdog(3)
-            log.debug("init> conn watchdog started")
-
-            -- start comms
-            smem_sys.plc_comms = plc.comms(config.REACTOR_ID, R_PLC_VERSION, smem_dev.modem, config.LISTEN_PORT, config.SERVER_PORT,
-                smem_dev.reactor, smem_sys.rps, smem_sys.conn_watchdog)
-            log.debug("init> comms init")
-        else
-            println("boot> starting in offline mode");
-            log.debug("init> running without networking")
+        -- scram reactor if present and enabled
+        if (smem_dev.reactor ~= nil) and plc_state.reactor_formed and smem_dev.reactor.getStatus() then
+            smem_dev.reactor.scram()
         end
 
----@diagnostic disable-next-line: undefined-field
-        os.queueEvent("clock_start")
+        plc_state.init_ok = false
+        plc_state.degraded = true
+        plc_state.no_modem = true
+    end
 
-        println("boot> completed");
-        log.debug("init> boot completed")
+    -- PLC init<br>
+    --- EVENT_CONSUMER: this function consumes events
+    local function init()
+        if plc_state.init_ok then
+            -- just booting up, no fission allowed (neutrons stay put thanks)
+            if plc_state.reactor_formed and smem_dev.reactor.getStatus() then
+                smem_dev.reactor.scram()
+            end
+
+            -- init reactor protection system
+            smem_sys.rps = plc.rps_init(smem_dev.reactor, plc_state.reactor_formed)
+            log.debug("init> rps init")
+
+            if __shared_memory.networked then
+                -- comms watchdog
+                smem_sys.conn_watchdog = util.new_watchdog(config.COMMS_TIMEOUT)
+                log.debug("init> conn watchdog started")
+
+                -- start comms
+                smem_sys.plc_comms = plc.comms(config.REACTOR_ID, R_PLC_VERSION, smem_dev.modem, config.LISTEN_PORT, config.SERVER_PORT,
+                                                config.TRUSTED_RANGE, smem_dev.reactor, smem_sys.rps, smem_sys.conn_watchdog)
+                log.debug("init> comms init")
+            else
+                println("init> starting in offline mode")
+                log.info("init> running without networking")
+            end
+
+            util.push_event("clock_start")
+
+            println("init> completed")
+            log.info("init> startup completed")
+        else
+            println("init> system in degraded state, awaiting devices...")
+            log.warning("init> started in a degraded state, awaiting peripheral connections...")
+        end
+    end
+
+    ----------------------------------------
+    -- start system
+    ----------------------------------------
+
+    -- initialize PLC
+    init()
+
+    -- init threads
+    local main_thread = threads.thread__main(__shared_memory, init)
+    local rps_thread  = threads.thread__rps(__shared_memory)
+
+    if __shared_memory.networked then
+        -- init comms threads
+        local comms_thread_tx = threads.thread__comms_tx(__shared_memory)
+        local comms_thread_rx = threads.thread__comms_rx(__shared_memory)
+
+        -- setpoint control only needed when networked
+        local sp_ctrl_thread = threads.thread__setpoint_control(__shared_memory)
+
+        -- run threads
+        parallel.waitForAll(main_thread.p_exec, rps_thread.p_exec, comms_thread_tx.p_exec, comms_thread_rx.p_exec, sp_ctrl_thread.p_exec)
+
+        if plc_state.init_ok then
+            -- send status one last time after RPS shutdown
+            smem_sys.plc_comms.send_status(plc_state.no_reactor, plc_state.reactor_formed)
+            smem_sys.plc_comms.send_rps_status()
+
+            -- close connection
+            smem_sys.plc_comms.close()
+        end
     else
-        println("boot> system in degraded state, awaiting devices...")
-        log.warning("init> booted in a degraded state, awaiting peripheral connections...")
+        -- run threads, excluding comms
+        parallel.waitForAll(main_thread.p_exec, rps_thread.p_exec)
     end
+
+    println_ts("exited")
+    log.info("exited")
 end
 
-----------------------------------------
--- start system
-----------------------------------------
-
--- initialize PLC
-init()
-
--- init threads
-local main_thread = threads.thread__main(__shared_memory, init)
-local rps_thread  = threads.thread__rps(__shared_memory)
-
-if __shared_memory.networked then
-    -- init comms threads
-    local comms_thread_tx = threads.thread__comms_tx(__shared_memory)
-    local comms_thread_rx = threads.thread__comms_rx(__shared_memory)
-
-    -- setpoint control only needed when networked
-    local sp_ctrl_thread = threads.thread__setpoint_control(__shared_memory)
-
-    -- run threads
-    parallel.waitForAll(main_thread.p_exec, rps_thread.p_exec, comms_thread_tx.p_exec, comms_thread_rx.p_exec, sp_ctrl_thread.p_exec)
-
-    if plc_state.init_ok then
-        -- send status one last time after RPS shutdown
-        smem_sys.plc_comms.send_status(plc_state.degraded)
-        smem_sys.plc_comms.send_rps_status()
-
-        -- close connection
-        smem_sys.plc_comms.close()
-    end
-else
-    -- run threads, excluding comms
-    parallel.waitForAll(main_thread.p_exec, rps_thread.p_exec)
-end
-
-println_ts("exited")
-log.info("exited")
+if not xpcall(main, crash.handler) then crash.exit() end

reactor-plc/threads.lua

@@ -1,7 +1,7 @@
-local log = require("scada-common.log")
+local log    = require("scada-common.log")
 local mqueue = require("scada-common.mqueue")
-local ppm = require("scada-common.ppm")
-local util = require("scada-common.util")
+local ppm    = require("scada-common.ppm")
+local util   = require("scada-common.util")
 
 local threads = {}
 
@@ -10,7 +10,7 @@ local println = util.println
 local print_ts = util.print_ts
 local println_ts = util.println_ts
 
-local MAIN_CLOCK    = 1   -- (1Hz, 20 ticks)
+local MAIN_CLOCK    = 0.5 -- (2Hz,   10 ticks)
 local RPS_SLEEP     = 250 -- (250ms, 5 ticks)
 local COMMS_SLEEP   = 150 -- (150ms, 3 ticks)
 local SP_CTRL_SLEEP = 250 -- (250ms, 5 ticks)
@@ -28,25 +28,27 @@ local MQ__COMM_CMD = {
 }
 
 -- main thread
+---@nodiscard
 ---@param smem plc_shared_memory
 ---@param init function
-threads.thread__main = function (smem, init)
-    local public = {}   ---@class thread
+function threads.thread__main(smem, init)
+    ---@class parallel_thread
+    local public = {}
 
     -- execute thread
-    public.exec = function ()
+    function public.exec()
         log.debug("main thread init, clock inactive")
 
         -- send status updates at 2Hz (every 10 server ticks) (every loop tick)
-        -- send link requests at 0.5Hz (every 40 server ticks) (every 4 loop ticks)
-        local LINK_TICKS = 4
+        -- send link requests at 0.5Hz (every 40 server ticks) (every 8 loop ticks)
+        local LINK_TICKS = 8
         local ticks_to_update = 0
         local loop_clock = util.new_clock(MAIN_CLOCK)
 
         -- load in from shared memory
-        local networked     = smem.networked
-        local plc_state     = smem.plc_state
-        local plc_dev       = smem.plc_dev
+        local networked = smem.networked
+        local plc_state = smem.plc_state
+        local plc_dev   = smem.plc_dev
 
         -- event loop
         while true do
@@ -55,8 +57,7 @@ threads.thread__main = function (smem, init)
             local plc_comms     = smem.plc_sys.plc_comms
             local conn_watchdog = smem.plc_sys.conn_watchdog
 
----@diagnostic disable-next-line: undefined-field
-            local event, param1, param2, param3, param4, param5 = os.pullEventRaw()
+            local event, param1, param2, param3, param4, param5 = util.pull_event()
 
             -- handle event
             if event == "timer" and loop_clock.is_clock(param1) then
@@ -79,6 +80,59 @@ threads.thread__main = function (smem, init)
                         end
                     end
                 end
+
+                -- are we now formed after waiting to be formed?
+                if (not plc_state.reactor_formed) and rps.is_formed() then
+                    -- push a connect event and unmount it from the PPM
+                    local iface = ppm.get_iface(plc_dev.reactor)
+                    if iface then
+                        log.info("unmounting and remounting unformed reactor")
+                        ppm.unmount(plc_dev.reactor)
+
+                        local type, device = ppm.mount(iface)
+
+                        if type == "fissionReactorLogicAdapter" and device ~= nil then
+                            -- reconnect reactor
+                            plc_dev.reactor = device
+
+                            -- we need to assume formed here as we cannot check in this main loop
+                            -- RPS will identify if it isn't and this will get set false later
+                            plc_state.reactor_formed = true
+
+                            println_ts("reactor reconnected.")
+                            log.info("reactor reconnected")
+
+                            -- SCRAM newly connected reactor
+                            smem.q.mq_rps.push_command(MQ__RPS_CMD.SCRAM)
+
+                            -- determine if we are still in a degraded state
+                            if not networked or not plc_state.no_modem then
+                                plc_state.degraded = false
+                            end
+
+                            rps.reconnect_reactor(plc_dev.reactor)
+                            if networked then
+                                plc_comms.reconnect_reactor(plc_dev.reactor)
+                            end
+
+                            -- reset RPS for newly connected reactor
+                            -- without this, is_formed will be out of date and cause it to think its no longer formed again
+                            rps.reset()
+                        else
+                            -- fully lost the reactor now :(
+                            println_ts("reactor lost (failed reconnect)!")
+                            log.error("reactor lost (failed reconnect)")
+
+                            plc_state.no_reactor = true
+                            plc_state.degraded = true
+                        end
+                    else
+                        log.error("failed to get interface of previously connected reactor", true)
+                    end
+                elseif not rps.is_formed() then
+                    -- reactor no longer formed
+                    plc_state.reactor_formed = false
+                end
             elseif event == "modem_message" and networked and plc_state.init_ok and not plc_state.no_modem then
                 -- got a packet
                 local packet = plc_comms.parse_packet(param1, param2, param3, param4, param5)
@@ -95,16 +149,18 @@ threads.thread__main = function (smem, init)
                 local type, device = ppm.handle_unmount(param1)
 
                 if type ~= nil and device ~= nil then
-                    if type == "fissionReactor" then
+                    if type == "fissionReactorLogicAdapter" then
                         println_ts("reactor disconnected!")
-                        log.error("reactor disconnected!")
+                        log.error("reactor logic adapter disconnected")
+
                         plc_state.no_reactor = true
                         plc_state.degraded = true
                     elseif networked and type == "modem" then
                         -- we only care if this is our wireless modem
                         if device == plc_dev.modem then
-                            println_ts("wireless modem disconnected!")
-                            log.error("comms modem disconnected!")
+                            println_ts("comms modem disconnected!")
+                            log.error("comms modem disconnected")
+
                             plc_state.no_modem = true
 
                             if plc_state.init_ok then
@@ -123,26 +179,35 @@ threads.thread__main = function (smem, init)
                 local type, device = ppm.mount(param1)
 
                 if type ~= nil and device ~= nil then
-                    if type == "fissionReactor" then
+                    if type == "fissionReactorLogicAdapter" then
                         -- reconnected reactor
                         plc_dev.reactor = device
 
-                        smem.q.mq_rps.push_command(MQ__RPS_CMD.SCRAM)
-
                         println_ts("reactor reconnected.")
                         log.info("reactor reconnected")
+
                         plc_state.no_reactor = false
 
+                        -- we need to assume formed here as we cannot check in this main loop
+                        -- RPS will identify if it isn't and this will get set false later
+                        plc_state.reactor_formed = true
+
+                        -- determine if we are still in a degraded state
+                        if (not networked or not plc_state.no_modem) and plc_state.reactor_formed then
+                            plc_state.degraded = false
+                        end
+
                         if plc_state.init_ok then
+                            smem.q.mq_rps.push_command(MQ__RPS_CMD.SCRAM)
+
                             rps.reconnect_reactor(plc_dev.reactor)
                             if networked then
                                 plc_comms.reconnect_reactor(plc_dev.reactor)
                             end
-                        end
 
-                        -- determine if we are still in a degraded state
-                        if not networked or not plc_state.no_modem then
-                            plc_state.degraded = false
+                            -- reset RPS for newly connected reactor
+                            -- without this, is_formed will be out of date and cause it to think its no longer formed again
+                            rps.reset()
                         end
                     elseif networked and type == "modem" then
                         if device.isWireless() then
@@ -189,13 +254,13 @@ threads.thread__main = function (smem, init)
     end
 
     -- execute the thread in a protected mode, retrying it on return if not shutting down
-    public.p_exec = function ()
+    function public.p_exec()
         local plc_state = smem.plc_state
 
         while not plc_state.shutdown do
             local status, result = pcall(public.exec)
             if status == false then
-                log.fatal(result)
+                log.fatal(util.strval(result))
             end
 
             -- if status is true, then we are probably exiting, so this won't matter
@@ -203,9 +268,7 @@ threads.thread__main = function (smem, init)
             -- this thread cannot be slept because it will miss events (namely "terminate" otherwise)
             if not plc_state.shutdown then
                 log.info("main thread restarting now...")
-
----@diagnostic disable-next-line: undefined-field
-                os.queueEvent("clock_start")
+                util.push_event("clock_start")
             end
         end
     end
@@ -214,12 +277,14 @@ threads.thread__main = function (smem, init)
 end
 
 -- RPS operation thread
+---@nodiscard
 ---@param smem plc_shared_memory
-threads.thread__rps = function (smem)
-    local public = {}   ---@class thread
+function threads.thread__rps(smem)
+    ---@class parallel_thread
+    local public = {}
 
     -- execute thread
-    public.exec = function ()
+    function public.exec()
         log.debug("rps thread start")
 
         -- load in from shared memory
@@ -235,10 +300,10 @@ threads.thread__rps = function (smem)
         -- thread loop
         while true do
             -- get plc_sys fields (may have been set late due to degraded boot)
-            local rps         = smem.plc_sys.rps
-            local plc_comms   = smem.plc_sys.plc_comms
+            local rps       = smem.plc_sys.rps
+            local plc_comms = smem.plc_sys.plc_comms
             -- get reactor, may have changed do to disconnect/reconnect
-            local reactor     = plc_dev.reactor
+            local reactor   = plc_dev.reactor
 
             -- RPS checks
             if plc_state.init_ok then
@@ -256,13 +321,13 @@ threads.thread__rps = function (smem)
                 -- if we tried to SCRAM but failed, keep trying
                 -- in that case, SCRAM won't be called until it reconnects (this is the expected use of this check)
 ---@diagnostic disable-next-line: need-check-nil
-                if not plc_state.no_reactor and rps.is_tripped() and reactor.getStatus() then
+                if (not plc_state.no_reactor) and rps.is_formed() and rps.is_tripped() and reactor.getStatus() then
                     rps.scram()
                 end
 
                 -- if we are in standalone mode, 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() end
+                if not networked then rps.reset(true) end
 
                 -- check safety (SCRAM occurs if tripped)
                 if not plc_state.no_reactor then
@@ -332,13 +397,13 @@ threads.thread__rps = function (smem)
     end
 
     -- execute the thread in a protected mode, retrying it on return if not shutting down
-    public.p_exec = function ()
+    function public.p_exec()
         local plc_state = smem.plc_state
 
         while not plc_state.shutdown do
             local status, result = pcall(public.exec)
             if status == false then
-                log.fatal(result)
+                log.fatal(util.strval(result))
             end
 
             if not plc_state.shutdown then
@@ -353,12 +418,14 @@ threads.thread__rps = function (smem)
 end
 
 -- communications sender thread
+---@nodiscard
 ---@param smem plc_shared_memory
-threads.thread__comms_tx = function (smem)
-    local public = {}   ---@class thread
+function threads.thread__comms_tx(smem)
+    ---@class parallel_thread
+    local public = {}
 
     -- execute thread
-    public.exec = function ()
+    function public.exec()
         log.debug("comms tx thread start")
 
         -- load in from shared memory
@@ -381,7 +448,7 @@ threads.thread__comms_tx = function (smem)
                         -- received a command
                         if msg.message == MQ__COMM_CMD.SEND_STATUS then
                             -- send PLC/RPS status
-                            plc_comms.send_status(plc_state.degraded)
+                            plc_comms.send_status(plc_state.no_reactor, plc_state.reactor_formed)
                             plc_comms.send_rps_status()
                         end
                     elseif msg.qtype == mqueue.TYPE.DATA then
@@ -407,13 +474,13 @@ threads.thread__comms_tx = function (smem)
     end
 
     -- execute the thread in a protected mode, retrying it on return if not shutting down
-    public.p_exec = function ()
+    function public.p_exec()
         local plc_state = smem.plc_state
 
         while not plc_state.shutdown do
             local status, result = pcall(public.exec)
             if status == false then
-                log.fatal(result)
+                log.fatal(util.strval(result))
             end
 
             if not plc_state.shutdown then
@@ -427,12 +494,14 @@ threads.thread__comms_tx = function (smem)
 end
 
 -- communications handler thread
+---@nodiscard
 ---@param smem plc_shared_memory
-threads.thread__comms_rx = function (smem)
-    local public = {}   ---@class thread
+function threads.thread__comms_rx(smem)
+    ---@class parallel_thread
+    local public = {}
 
     -- execute thread
-    public.exec = function ()
+    function public.exec()
         log.debug("comms rx thread start")
 
         -- load in from shared memory
@@ -461,7 +530,7 @@ threads.thread__comms_rx = function (smem)
                         -- received a packet
                         -- handle the packet (setpoints passed to update burn rate setpoint)
                         --                   (plc_state passed to check if degraded)
-                        plc_comms.handle_packet(msg.message, setpoints, plc_state)
+                        plc_comms.handle_packet(msg.message, plc_state, setpoints)
                     end
                 end
 
@@ -481,13 +550,13 @@ threads.thread__comms_rx = function (smem)
     end
 
     -- execute the thread in a protected mode, retrying it on return if not shutting down
-    public.p_exec = function ()
+    function public.p_exec()
         local plc_state = smem.plc_state
 
         while not plc_state.shutdown do
             local status, result = pcall(public.exec)
             if status == false then
-                log.fatal(result)
+                log.fatal(util.strval(result))
             end
 
             if not plc_state.shutdown then
@@ -500,13 +569,15 @@ threads.thread__comms_rx = function (smem)
     return public
 end
 
--- apply setpoints
+-- ramp control outputs to desired setpoints
+---@nodiscard
 ---@param smem plc_shared_memory
-threads.thread__setpoint_control = function (smem)
-    local public = {}   ---@class thread
+function threads.thread__setpoint_control(smem)
+    ---@class parallel_thread
+    local public = {}
 
     -- execute thread
-    public.exec = function ()
+    function public.exec()
         log.debug("setpoint control thread start")
 
         -- load in from shared memory
@@ -517,7 +588,7 @@ threads.thread__setpoint_control = function (smem)
         local last_update  = util.time()
         local running      = false
 
-        local last_sp_burn = 0.0
+        local last_burn_sp = 0.0
 
         -- do not use the actual elapsed time, it could spike
         -- we do not want to have big jumps as that is what we are trying to avoid in the first place
@@ -530,23 +601,25 @@ threads.thread__setpoint_control = function (smem)
             -- get reactor, may have changed do to disconnect/reconnect
             local reactor = plc_dev.reactor
 
-            if plc_state.init_ok and not plc_state.no_reactor then
+            if plc_state.init_ok and (not plc_state.no_reactor) then
                 -- check if we should start ramping
-                if setpoints.burn_rate_en and setpoints.burn_rate ~= last_sp_burn then
-                    if rps.is_active() then
-                        if math.abs(setpoints.burn_rate - last_sp_burn) <= 5 then
-                            -- update without ramp if <= 5 mB/t change
-                            log.debug("setting burn rate directly to " .. setpoints.burn_rate .. "mB/t")
+                if setpoints.burn_rate_en and (setpoints.burn_rate ~= last_burn_sp) then
+---@diagnostic disable-next-line: need-check-nil
+                    local cur_burn_rate = reactor.getBurnRate()
+
+                    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
+                        running = math.abs(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"))
+                        else
+                            log.debug(util.c("SPCTL: setting burn rate directly to ", setpoints.burn_rate, " mB/t"))
 ---@diagnostic disable-next-line: need-check-nil
                             reactor.setBurnRate(setpoints.burn_rate)
-                        else
-                            log.debug("starting burn rate ramp from " .. last_sp_burn .. "mB/t to " .. setpoints.burn_rate .. "mB/t")
-                            running = true
                         end
-
-                        last_sp_burn = setpoints.burn_rate
-                    else
-                        last_sp_burn = 0.0
                     end
                 end
 
@@ -562,34 +635,39 @@ threads.thread__setpoint_control = function (smem)
                             local current_burn_rate = reactor.getBurnRate()
 
                             -- we yielded, check enable again
-                            if setpoints.burn_rate_en and (current_burn_rate ~= ppm.ACCESS_FAULT) and (current_burn_rate ~= setpoints.burn_rate) then
+                            if setpoints.burn_rate_en and (type(current_burn_rate) == "number") and (current_burn_rate ~= setpoints.burn_rate) then
                                 -- calculate new burn rate
                                 local new_burn_rate = current_burn_rate
 
                                 if setpoints.burn_rate > current_burn_rate then
                                     -- need to ramp up
-                                    local new_burn_rate = current_burn_rate + (BURN_RATE_RAMP_mB_s * min_elapsed_s)
-                                    if new_burn_rate > setpoints.burn_rate then
-                                        new_burn_rate = setpoints.burn_rate
-                                    end
+                                    new_burn_rate = current_burn_rate + (BURN_RATE_RAMP_mB_s * min_elapsed_s)
+                                    if new_burn_rate > setpoints.burn_rate then new_burn_rate = setpoints.burn_rate end
                                 else
                                     -- need to ramp down
-                                    local new_burn_rate = current_burn_rate - (BURN_RATE_RAMP_mB_s * min_elapsed_s)
-                                    if new_burn_rate < setpoints.burn_rate then
-                                        new_burn_rate = setpoints.burn_rate
-                                    end
+                                    new_burn_rate = current_burn_rate - (BURN_RATE_RAMP_mB_s * min_elapsed_s)
+                                    if new_burn_rate < setpoints.burn_rate then new_burn_rate = setpoints.burn_rate end
                                 end
 
+                                running = running or (new_burn_rate ~= setpoints.burn_rate)
+
                                 -- set the burn rate
 ---@diagnostic disable-next-line: need-check-nil
                                 reactor.setBurnRate(new_burn_rate)
-
-                                running = running or (new_burn_rate ~= setpoints.burn_rate)
                             end
                         else
-                            last_sp_burn = 0.0
+                            log.debug("SPCTL: ramping aborted (reactor inactive)")
+                            setpoints.burn_rate_en = false
                         end
                     end
+                elseif setpoints.burn_rate_en then
+                    log.debug(util.c("SPCTL: ramping completed (setpoint of ", setpoints.burn_rate, " mB/t)"))
+                    setpoints.burn_rate_en = false
+                end
+
+                -- if ramping completed or was aborted, reset last burn setpoint so that if it is requested again it will be re-attempted
+                if not setpoints.burn_rate_en then
+                    last_burn_sp = 0
                 end
             end
 
@@ -605,13 +683,13 @@ threads.thread__setpoint_control = function (smem)
     end
 
     -- execute the thread in a protected mode, retrying it on return if not shutting down
-    public.p_exec = function ()
+    function public.p_exec()
         local plc_state = smem.plc_state
 
         while not plc_state.shutdown do
             local status, result = pcall(public.exec)
             if status == false then
-                log.fatal(result)
+                log.fatal(util.strval(result))
             end
 
             if not plc_state.shutdown then

rtu/config.lua

@@ -6,47 +6,58 @@ local config = {}
 config.SERVER_PORT = 16000
 -- port to listen to incoming packets FROM server
 config.LISTEN_PORT = 15001
+-- max trusted modem message distance (< 1 to disable check)
+config.TRUSTED_RANGE = 0
+-- time in seconds (>= 2) before assuming a remote device is no longer active
+config.COMMS_TIMEOUT = 5
+
 -- log path
 config.LOG_PATH = "/log.txt"
 -- log mode
 --  0 = APPEND (adds to existing file on start)
 --  1 = NEW (replaces existing file on start)
 config.LOG_MODE = 0
+
 -- RTU peripheral devices (named: side/network device name)
 config.RTU_DEVICES = {
     {
-        name = "boiler_1",
+        name = "boilerValve_0",
         index = 1,
         for_reactor = 1
     },
     {
-        name = "turbine_1",
+        name = "turbineValve_0",
         index = 1,
         for_reactor = 1
     }
 }
 -- RTU redstone interface definitions
 config.RTU_REDSTONE = {
-    {
-        for_reactor = 1,
-        io = {
-            {
-                channel = rsio.IO.WASTE_PO,
-                side = "top",
-                bundled_color = colors.blue
-            },
-            {
-                channel = rsio.IO.WASTE_PU,
-                side = "top",
-                bundled_color = colors.cyan
-            },
-            {
-                channel = rsio.IO.WASTE_AM,
-                side = "top",
-                bundled_color = colors.purple
-            }
-        }
-    }
+    -- {
+    --     for_reactor = 1,
+    --     io = {
+    --         {
+    --             port = rsio.IO.WASTE_PO,
+    --             side = "top",
+    --             bundled_color = colors.red
+    --         },
+    --         {
+    --             port = rsio.IO.WASTE_PU,
+    --             side = "top",
+    --             bundled_color = colors.orange
+    --         },
+    --         {
+    --             port = rsio.IO.WASTE_POPL,
+    --             side = "top",
+    --             bundled_color = colors.yellow
+    --         },
+    --         {
+    --             port = rsio.IO.WASTE_AM,
+    --             side = "top",
+    --             bundled_color = colors.lime
+    --         }
+    --     }
+    -- }
 }
 
 return config

rtu/dev/boiler_rtu.lua

@@ -1,51 +0,0 @@
-local rtu = require("rtu.rtu")
-
-local boiler_rtu = {}
-
--- create new boiler (mek 10.0) device
----@param boiler table
-boiler_rtu.new = function (boiler)
-    local self = {
-        rtu = rtu.init_unit(),
-        boiler = boiler
-    }
-
-    -- discrete inputs --
-    -- none
-
-    -- coils --
-    -- none
-
-    -- input registers --
-    -- build properties
-    self.rtu.connect_input_reg(self.boiler.getBoilCapacity)
-    self.rtu.connect_input_reg(self.boiler.getSteamCapacity)
-    self.rtu.connect_input_reg(self.boiler.getWaterCapacity)
-    self.rtu.connect_input_reg(self.boiler.getHeatedCoolantCapacity)
-    self.rtu.connect_input_reg(self.boiler.getCooledCoolantCapacity)
-    self.rtu.connect_input_reg(self.boiler.getSuperheaters)
-    self.rtu.connect_input_reg(self.boiler.getMaxBoilRate)
-    -- current state
-    self.rtu.connect_input_reg(self.boiler.getTemperature)
-    self.rtu.connect_input_reg(self.boiler.getBoilRate)
-    -- tanks
-    self.rtu.connect_input_reg(self.boiler.getSteam)
-    self.rtu.connect_input_reg(self.boiler.getSteamNeeded)
-    self.rtu.connect_input_reg(self.boiler.getSteamFilledPercentage)
-    self.rtu.connect_input_reg(self.boiler.getWater)
-    self.rtu.connect_input_reg(self.boiler.getWaterNeeded)
-    self.rtu.connect_input_reg(self.boiler.getWaterFilledPercentage)
-    self.rtu.connect_input_reg(self.boiler.getHeatedCoolant)
-    self.rtu.connect_input_reg(self.boiler.getHeatedCoolantNeeded)
-    self.rtu.connect_input_reg(self.boiler.getHeatedCoolantFilledPercentage)
-    self.rtu.connect_input_reg(self.boiler.getCooledCoolant)
-    self.rtu.connect_input_reg(self.boiler.getCooledCoolantNeeded)
-    self.rtu.connect_input_reg(self.boiler.getCooledCoolantFilledPercentage)
-
-    -- holding registers --
-    -- none
-
-    return self.rtu.interface()
-end
-
-return boiler_rtu

rtu/dev/boilerv_rtu.lua

@@ -3,56 +3,54 @@ local rtu = require("rtu.rtu")
 local boilerv_rtu = {}
 
 -- create new boiler (mek 10.1+) device
+---@nodiscard
 ---@param boiler table
-boilerv_rtu.new = function (boiler)
-    local self = {
-        rtu = rtu.init_unit(),
-        boiler = boiler
-    }
+function boilerv_rtu.new(boiler)
+    local unit = rtu.init_unit()
 
     -- discrete inputs --
-    self.rtu.connect_di(self.boiler.isFormed)
+    unit.connect_di(boiler.isFormed)
 
     -- coils --
     -- none
 
     -- input registers --
     -- multiblock properties
-    self.rtu.connect_input_reg(self.boiler.getLength)
-    self.rtu.connect_input_reg(self.boiler.getWidth)
-    self.rtu.connect_input_reg(self.boiler.getHeight)
-    self.rtu.connect_input_reg(self.boiler.getMinPos)
-    self.rtu.connect_input_reg(self.boiler.getMaxPos)
+    unit.connect_input_reg(boiler.getLength)
+    unit.connect_input_reg(boiler.getWidth)
+    unit.connect_input_reg(boiler.getHeight)
+    unit.connect_input_reg(boiler.getMinPos)
+    unit.connect_input_reg(boiler.getMaxPos)
     -- build properties
-    self.rtu.connect_input_reg(self.boiler.getBoilCapacity)
-    self.rtu.connect_input_reg(self.boiler.getSteamCapacity)
-    self.rtu.connect_input_reg(self.boiler.getWaterCapacity)
-    self.rtu.connect_input_reg(self.boiler.getHeatedCoolantCapacity)
-    self.rtu.connect_input_reg(self.boiler.getCooledCoolantCapacity)
-    self.rtu.connect_input_reg(self.boiler.getSuperheaters)
-    self.rtu.connect_input_reg(self.boiler.getMaxBoilRate)
-    self.rtu.connect_input_reg(self.boiler.getEnvironmentalLoss)
+    unit.connect_input_reg(boiler.getBoilCapacity)
+    unit.connect_input_reg(boiler.getSteamCapacity)
+    unit.connect_input_reg(boiler.getWaterCapacity)
+    unit.connect_input_reg(boiler.getHeatedCoolantCapacity)
+    unit.connect_input_reg(boiler.getCooledCoolantCapacity)
+    unit.connect_input_reg(boiler.getSuperheaters)
+    unit.connect_input_reg(boiler.getMaxBoilRate)
     -- current state
-    self.rtu.connect_input_reg(self.boiler.getTemperature)
-    self.rtu.connect_input_reg(self.boiler.getBoilRate)
+    unit.connect_input_reg(boiler.getTemperature)
+    unit.connect_input_reg(boiler.getBoilRate)
+    unit.connect_input_reg(boiler.getEnvironmentalLoss)
     -- tanks
-    self.rtu.connect_input_reg(self.boiler.getSteam)
-    self.rtu.connect_input_reg(self.boiler.getSteamNeeded)
-    self.rtu.connect_input_reg(self.boiler.getSteamFilledPercentage)
-    self.rtu.connect_input_reg(self.boiler.getWater)
-    self.rtu.connect_input_reg(self.boiler.getWaterNeeded)
-    self.rtu.connect_input_reg(self.boiler.getWaterFilledPercentage)
-    self.rtu.connect_input_reg(self.boiler.getHeatedCoolant)
-    self.rtu.connect_input_reg(self.boiler.getHeatedCoolantNeeded)
-    self.rtu.connect_input_reg(self.boiler.getHeatedCoolantFilledPercentage)
-    self.rtu.connect_input_reg(self.boiler.getCooledCoolant)
-    self.rtu.connect_input_reg(self.boiler.getCooledCoolantNeeded)
-    self.rtu.connect_input_reg(self.boiler.getCooledCoolantFilledPercentage)
+    unit.connect_input_reg(boiler.getSteam)
+    unit.connect_input_reg(boiler.getSteamNeeded)
+    unit.connect_input_reg(boiler.getSteamFilledPercentage)
+    unit.connect_input_reg(boiler.getWater)
+    unit.connect_input_reg(boiler.getWaterNeeded)
+    unit.connect_input_reg(boiler.getWaterFilledPercentage)
+    unit.connect_input_reg(boiler.getHeatedCoolant)
+    unit.connect_input_reg(boiler.getHeatedCoolantNeeded)
+    unit.connect_input_reg(boiler.getHeatedCoolantFilledPercentage)
+    unit.connect_input_reg(boiler.getCooledCoolant)
+    unit.connect_input_reg(boiler.getCooledCoolantNeeded)
+    unit.connect_input_reg(boiler.getCooledCoolantFilledPercentage)
 
     -- holding registers --
     -- none
 
-    return self.rtu.interface()
+    return unit.interface()
 end
 
 return boilerv_rtu

rtu/dev/energymachine_rtu.lua

@@ -1,39 +0,0 @@
-local rtu = require("rtu.rtu")
-
-local energymachine_rtu = {}
-
--- create new energy machine device
----@param machine table
-energymachine_rtu.new = function (machine)
-    local self = {
-        rtu = rtu.init_unit(),
-        machine = machine
-    }
-
-    ---@class rtu_device
-    local public = {}
-
-    -- get the RTU interface
-    public.rtu_interface = function () return self.rtu end
-
-    -- discrete inputs --
-    -- none
-
-    -- coils --
-    -- none
-
-    -- input registers --
-    -- build properties
-    self.rtu.connect_input_reg(self.machine.getTotalMaxEnergy)
-    -- containers
-    self.rtu.connect_input_reg(self.machine.getTotalEnergy)
-    self.rtu.connect_input_reg(self.machine.getTotalEnergyNeeded)
-    self.rtu.connect_input_reg(self.machine.getTotalEnergyFilledPercentage)
-
-    -- holding registers --
-    -- none
-
-    return public
-end
-
-return energymachine_rtu

rtu/dev/envd_rtu.lua

@@ -0,0 +1,27 @@
+local rtu = require("rtu.rtu")
+
+local envd_rtu = {}
+
+-- create new environment detector device
+---@nodiscard
+---@param envd table
+function envd_rtu.new(envd)
+    local unit = rtu.init_unit()
+
+    -- discrete inputs --
+    -- none
+
+    -- coils --
+    -- none
+
+    -- input registers --
+    unit.connect_input_reg(envd.getRadiation)
+    unit.connect_input_reg(envd.getRadiationRaw)
+
+    -- holding registers --
+    -- none
+
+    return unit.interface()
+end
+
+return envd_rtu

rtu/dev/imatrix_rtu.lua

@@ -3,43 +3,41 @@ local rtu = require("rtu.rtu")
 local imatrix_rtu = {}
 
 -- create new induction matrix (mek 10.1+) device
+---@nodiscard
 ---@param imatrix table
-imatrix_rtu.new = function (imatrix)
-    local self = {
-        rtu = rtu.init_unit(),
-        imatrix = imatrix
-    }
+function imatrix_rtu.new(imatrix)
+    local unit = rtu.init_unit()
 
     -- discrete inputs --
-    self.rtu.connect_di(self.boiler.isFormed)
+    unit.connect_di(imatrix.isFormed)
 
     -- coils --
     -- none
 
     -- input registers --
     -- multiblock properties
-    self.rtu.connect_input_reg(self.boiler.getLength)
-    self.rtu.connect_input_reg(self.boiler.getWidth)
-    self.rtu.connect_input_reg(self.boiler.getHeight)
-    self.rtu.connect_input_reg(self.boiler.getMinPos)
-    self.rtu.connect_input_reg(self.boiler.getMaxPos)
+    unit.connect_input_reg(imatrix.getLength)
+    unit.connect_input_reg(imatrix.getWidth)
+    unit.connect_input_reg(imatrix.getHeight)
+    unit.connect_input_reg(imatrix.getMinPos)
+    unit.connect_input_reg(imatrix.getMaxPos)
     -- build properties
-    self.rtu.connect_input_reg(self.imatrix.getMaxEnergy)
-    self.rtu.connect_input_reg(self.imatrix.getTransferCap)
-    self.rtu.connect_input_reg(self.imatrix.getInstalledCells)
-    self.rtu.connect_input_reg(self.imatrix.getInstalledProviders)
-    -- containers
-    self.rtu.connect_input_reg(self.imatrix.getEnergy)
-    self.rtu.connect_input_reg(self.imatrix.getEnergyNeeded)
-    self.rtu.connect_input_reg(self.imatrix.getEnergyFilledPercentage)
+    unit.connect_input_reg(imatrix.getMaxEnergy)
+    unit.connect_input_reg(imatrix.getTransferCap)
+    unit.connect_input_reg(imatrix.getInstalledCells)
+    unit.connect_input_reg(imatrix.getInstalledProviders)
     -- I/O rates
-    self.rtu.connect_input_reg(self.imatrix.getLastInput)
-    self.rtu.connect_input_reg(self.imatrix.getLastOutput)
+    unit.connect_input_reg(imatrix.getLastInput)
+    unit.connect_input_reg(imatrix.getLastOutput)
+    -- tanks
+    unit.connect_input_reg(imatrix.getEnergy)
+    unit.connect_input_reg(imatrix.getEnergyNeeded)
+    unit.connect_input_reg(imatrix.getEnergyFilledPercentage)
 
     -- holding registers --
     -- none
 
-    return self.rtu.interface()
+    return unit.interface()
 end
 
 return imatrix_rtu

rtu/dev/redstone_rtu.lua

@@ -1,23 +1,24 @@
-local rtu = require("rtu.rtu")
 local rsio = require("scada-common.rsio")
 
+local rtu  = require("rtu.rtu")
+
 local redstone_rtu = {}
 
+local IO_LVL = rsio.IO_LVL
+
 local digital_read = rsio.digital_read
 local digital_write = rsio.digital_write
-local digital_is_active = rsio.digital_is_active
 
 -- create new redstone device
-redstone_rtu.new = function ()
-    local self = {
-        rtu = rtu.init_unit()
-    }
+---@nodiscard
+function redstone_rtu.new()
+    local unit = rtu.init_unit()
 
     -- get RTU interface
-    local interface = self.rtu.interface()
+    local interface = unit.interface()
 
+    -- extends rtu_device; fields added manually to please Lua diagnostics
     ---@class rtu_rs_device
-    --- extends rtu_device; fields added manually to please Lua diagnostics
     local public = {
         io_count = interface.io_count,
         read_coil = interface.read_coil,
@@ -31,7 +32,7 @@ redstone_rtu.new = function ()
     -- link digital input
     ---@param side string
     ---@param color integer
-    public.link_di = function (side, color)
+    function public.link_di(side, color)
         local f_read = nil
 
         if color then
@@ -44,14 +45,13 @@ redstone_rtu.new = function ()
             end
         end
 
-        self.rtu.connect_di(f_read)
+        unit.connect_di(f_read)
     end
 
     -- link digital output
-    ---@param channel RS_IO
     ---@param side string
     ---@param color integer
-    public.link_do = function (channel, side, color)
+    function public.link_do(side, color)
         local f_read = nil
         local f_write = nil
 
@@ -61,15 +61,17 @@ redstone_rtu.new = function ()
             end
 
             f_write = function (level)
-                local output = rs.getBundledOutput(side)
+                if level ~= IO_LVL.FLOATING and level ~= IO_LVL.DISCONNECT then
+                    local output = rs.getBundledOutput(side)
 
-                if digital_write(channel, level) then
-                    output = colors.combine(output, color)
-                else
-                    output = colors.subtract(output, color)
+                    if digital_write(level) then
+                        output = colors.combine(output, color)
+                    else
+                        output = colors.subtract(output, color)
+                    end
+
+                    rs.setBundledOutput(side, output)
                 end
-
-                rs.setBundledOutput(side, output)
             end
         else
             f_read = function ()
@@ -77,17 +79,19 @@ redstone_rtu.new = function ()
             end
 
             f_write = function (level)
-                rs.setOutput(side, digital_is_active(channel, level))
+                if level ~= IO_LVL.FLOATING and level ~= IO_LVL.DISCONNECT then
+                    rs.setOutput(side, digital_write(level))
+                end
             end
         end
 
-        self.rtu.connect_coil(f_read, f_write)
+        unit.connect_coil(f_read, f_write)
     end
 
     -- link analog input
     ---@param side string
-    public.link_ai = function (side)
-        self.rtu.connect_input_reg(
+    function public.link_ai(side)
+        unit.connect_input_reg(
             function ()
                 return rs.getAnalogInput(side)
             end
@@ -96,8 +100,8 @@ redstone_rtu.new = function ()
 
     -- link analog output
     ---@param side string
-    public.link_ao = function (side)
-        self.rtu.connect_holding_reg(
+    function public.link_ao(side)
+        unit.connect_holding_reg(
             function ()
                 return rs.getAnalogOutput(side)
             end,

rtu/dev/sna_rtu.lua

@@ -0,0 +1,38 @@
+local rtu = require("rtu.rtu")
+
+local sna_rtu = {}
+
+-- create new solar neutron activator (SNA) device
+---@nodiscard
+---@param sna table
+function sna_rtu.new(sna)
+    local unit = rtu.init_unit()
+
+    -- discrete inputs --
+    -- none
+
+    -- coils --
+    -- none
+
+    -- input registers --
+    -- build properties
+    unit.connect_input_reg(sna.getInputCapacity)
+    unit.connect_input_reg(sna.getOutputCapacity)
+    -- current state
+    unit.connect_input_reg(sna.getProductionRate)
+    unit.connect_input_reg(sna.getPeakProductionRate)
+    -- tanks
+    unit.connect_input_reg(sna.getInput)
+    unit.connect_input_reg(sna.getInputNeeded)
+    unit.connect_input_reg(sna.getInputFilledPercentage)
+    unit.connect_input_reg(sna.getOutput)
+    unit.connect_input_reg(sna.getOutputNeeded)
+    unit.connect_input_reg(sna.getOutputFilledPercentage)
+
+    -- holding registers --
+    -- none
+
+    return unit.interface()
+end
+
+return sna_rtu

rtu/dev/sps_rtu.lua

@@ -0,0 +1,48 @@
+local rtu = require("rtu.rtu")
+
+local sps_rtu = {}
+
+-- create new super-critical phase shifter (SPS) device
+---@nodiscard
+---@param sps table
+function sps_rtu.new(sps)
+    local unit = rtu.init_unit()
+
+    -- discrete inputs --
+    unit.connect_di(sps.isFormed)
+
+    -- coils --
+    -- none
+
+    -- input registers --
+    -- multiblock properties
+    unit.connect_input_reg(sps.getLength)
+    unit.connect_input_reg(sps.getWidth)
+    unit.connect_input_reg(sps.getHeight)
+    unit.connect_input_reg(sps.getMinPos)
+    unit.connect_input_reg(sps.getMaxPos)
+    -- build properties
+    unit.connect_input_reg(sps.getCoils)
+    unit.connect_input_reg(sps.getInputCapacity)
+    unit.connect_input_reg(sps.getOutputCapacity)
+    unit.connect_input_reg(sps.getMaxEnergy)
+    -- current state
+    unit.connect_input_reg(sps.getProcessRate)
+    -- tanks
+    unit.connect_input_reg(sps.getInput)
+    unit.connect_input_reg(sps.getInputNeeded)
+    unit.connect_input_reg(sps.getInputFilledPercentage)
+    unit.connect_input_reg(sps.getOutput)
+    unit.connect_input_reg(sps.getOutputNeeded)
+    unit.connect_input_reg(sps.getOutputFilledPercentage)
+    unit.connect_input_reg(sps.getEnergy)
+    unit.connect_input_reg(sps.getEnergyNeeded)
+    unit.connect_input_reg(sps.getEnergyFilledPercentage)
+
+    -- holding registers --
+    -- none
+
+    return unit.interface()
+end
+
+return sps_rtu

rtu/dev/turbine_rtu.lua

@@ -1,46 +0,0 @@
-local rtu = require("rtu.rtu")
-
-local turbine_rtu = {}
-
--- create new turbine (mek 10.0) device
----@param turbine table
-turbine_rtu.new = function (turbine)
-    local self = {
-        rtu = rtu.init_unit(),
-        turbine = turbine
-    }
-
-    -- discrete inputs --
-    -- none
-
-    -- coils --
-    -- none
-
-    -- input registers --
-    -- build properties
-    self.rtu.connect_input_reg(self.turbine.getBlades)
-    self.rtu.connect_input_reg(self.turbine.getCoils)
-    self.rtu.connect_input_reg(self.turbine.getVents)
-    self.rtu.connect_input_reg(self.turbine.getDispersers)
-    self.rtu.connect_input_reg(self.turbine.getCondensers)
-    self.rtu.connect_input_reg(self.turbine.getSteamCapacity)
-    self.rtu.connect_input_reg(self.turbine.getMaxFlowRate)
-    self.rtu.connect_input_reg(self.turbine.getMaxProduction)
-    self.rtu.connect_input_reg(self.turbine.getMaxWaterOutput)
-    -- current state
-    self.rtu.connect_input_reg(self.turbine.getFlowRate)
-    self.rtu.connect_input_reg(self.turbine.getProductionRate)
-    self.rtu.connect_input_reg(self.turbine.getLastSteamInputRate)
-    self.rtu.connect_input_reg(self.turbine.getDumpingMode)
-    -- tanks
-    self.rtu.connect_input_reg(self.turbine.getSteam)
-    self.rtu.connect_input_reg(self.turbine.getSteamNeeded)
-    self.rtu.connect_input_reg(self.turbine.getSteamFilledPercentage)
-
-    -- holding registers --
-    -- none
-
-    return self.rtu.interface()
-end
-
-return turbine_rtu

rtu/dev/turbinev_rtu.lua

@@ -3,55 +3,53 @@ local rtu = require("rtu.rtu")
 local turbinev_rtu = {}
 
 -- create new turbine (mek 10.1+) device
+---@nodiscard
 ---@param turbine table
-turbinev_rtu.new = function (turbine)
-    local self = {
-        rtu = rtu.init_unit(),
-        turbine = turbine
-    }
+function turbinev_rtu.new(turbine)
+    local unit = rtu.init_unit()
 
     -- discrete inputs --
-    self.rtu.connect_di(self.boiler.isFormed)
+    unit.connect_di(turbine.isFormed)
 
     -- coils --
-    self.rtu.connect_coil(function () self.turbine.incrementDumpingMode() end, function () end)
-    self.rtu.connect_coil(function () self.turbine.decrementDumpingMode() end, function () end)
+    unit.connect_coil(function () turbine.incrementDumpingMode() end, function () end)
+    unit.connect_coil(function () turbine.decrementDumpingMode() end, function () end)
 
     -- input registers --
     -- multiblock properties
-    self.rtu.connect_input_reg(self.boiler.getLength)
-    self.rtu.connect_input_reg(self.boiler.getWidth)
-    self.rtu.connect_input_reg(self.boiler.getHeight)
-    self.rtu.connect_input_reg(self.boiler.getMinPos)
-    self.rtu.connect_input_reg(self.boiler.getMaxPos)
+    unit.connect_input_reg(turbine.getLength)
+    unit.connect_input_reg(turbine.getWidth)
+    unit.connect_input_reg(turbine.getHeight)
+    unit.connect_input_reg(turbine.getMinPos)
+    unit.connect_input_reg(turbine.getMaxPos)
     -- build properties
-    self.rtu.connect_input_reg(self.turbine.getBlades)
-    self.rtu.connect_input_reg(self.turbine.getCoils)
-    self.rtu.connect_input_reg(self.turbine.getVents)
-    self.rtu.connect_input_reg(self.turbine.getDispersers)
-    self.rtu.connect_input_reg(self.turbine.getCondensers)
-    self.rtu.connect_input_reg(self.turbine.getDumpingMode)
-    self.rtu.connect_input_reg(self.turbine.getSteamCapacity)
-    self.rtu.connect_input_reg(self.turbine.getMaxEnergy)
-    self.rtu.connect_input_reg(self.turbine.getMaxFlowRate)
-    self.rtu.connect_input_reg(self.turbine.getMaxWaterOutput)
-    self.rtu.connect_input_reg(self.turbine.getMaxProduction)
+    unit.connect_input_reg(turbine.getBlades)
+    unit.connect_input_reg(turbine.getCoils)
+    unit.connect_input_reg(turbine.getVents)
+    unit.connect_input_reg(turbine.getDispersers)
+    unit.connect_input_reg(turbine.getCondensers)
+    unit.connect_input_reg(turbine.getSteamCapacity)
+    unit.connect_input_reg(turbine.getMaxEnergy)
+    unit.connect_input_reg(turbine.getMaxFlowRate)
+    unit.connect_input_reg(turbine.getMaxProduction)
+    unit.connect_input_reg(turbine.getMaxWaterOutput)
     -- current state
-    self.rtu.connect_input_reg(self.turbine.getFlowRate)
-    self.rtu.connect_input_reg(self.turbine.getProductionRate)
-    self.rtu.connect_input_reg(self.turbine.getLastSteamInputRate)
+    unit.connect_input_reg(turbine.getFlowRate)
+    unit.connect_input_reg(turbine.getProductionRate)
+    unit.connect_input_reg(turbine.getLastSteamInputRate)
+    unit.connect_input_reg(turbine.getDumpingMode)
     -- tanks/containers
-    self.rtu.connect_input_reg(self.turbine.getSteam)
-    self.rtu.connect_input_reg(self.turbine.getSteamNeeded)
-    self.rtu.connect_input_reg(self.turbine.getSteamFilledPercentage)
-    self.rtu.connect_input_reg(self.turbine.getEnergy)
-    self.rtu.connect_input_reg(self.turbine.getEnergyNeeded)
-    self.rtu.connect_input_reg(self.turbine.getEnergyFilledPercentage)
+    unit.connect_input_reg(turbine.getSteam)
+    unit.connect_input_reg(turbine.getSteamNeeded)
+    unit.connect_input_reg(turbine.getSteamFilledPercentage)
+    unit.connect_input_reg(turbine.getEnergy)
+    unit.connect_input_reg(turbine.getEnergyNeeded)
+    unit.connect_input_reg(turbine.getEnergyFilledPercentage)
 
     -- holding registers --
-    self.rtu.connect_holding_reg(self.turbine.setDumpingMode, self.turbine.getDumpingMode)
+    unit.connect_holding_reg(turbine.getDumpingMode, turbine.setDumpingMode)
 
-    return self.rtu.interface()
+    return unit.interface()
 end
 
 return turbinev_rtu

rtu/modbus.lua

@@ -7,40 +7,36 @@ local MODBUS_FCODE = types.MODBUS_FCODE
 local MODBUS_EXCODE = types.MODBUS_EXCODE
 
 -- new modbus comms handler object
+---@nodiscard
 ---@param rtu_dev rtu_device|rtu_rs_device RTU device
 ---@param use_parallel_read boolean whether or not to use parallel calls when reading
-modbus.new = function (rtu_dev, use_parallel_read)
-    local self = {
-        rtu = rtu_dev,
-        use_parallel = use_parallel_read
-    }
-
-    ---@class modbus
-    local public = {}
-
+function modbus.new(rtu_dev, use_parallel_read)
     local insert = table.insert
 
+    -- read a span of coils (digital outputs)<br>
+    -- returns a table of readings or a MODBUS_EXCODE error code
+    ---@nodiscard
     ---@param c_addr_start integer
     ---@param count integer
-    ---@return boolean ok, table readings
-    local _1_read_coils = function (c_addr_start, count)
+    ---@return boolean ok, table|MODBUS_EXCODE readings
+    local function _1_read_coils(c_addr_start, count)
         local tasks = {}
-        local readings = {}
+        local readings = {} ---@type table|MODBUS_EXCODE
         local access_fault = false
-        local _, coils, _, _ = self.rtu.io_count()
+        local _, coils, _, _ = rtu_dev.io_count()
         local return_ok = ((c_addr_start + count) <= (coils + 1)) and (count > 0)
 
         if return_ok then
             for i = 1, count do
                 local addr = c_addr_start + i - 1
 
-                if self.use_parallel then
+                if use_parallel_read then
                     insert(tasks, function ()
-                        local reading, fault = self.rtu.read_coil(addr)
+                        local reading, fault = rtu_dev.read_coil(addr)
                         if fault then access_fault = true else readings[i] = reading end
                     end)
                 else
-                    readings[i], access_fault = self.rtu.read_coil(addr)
+                    readings[i], access_fault = rtu_dev.read_coil(addr)
 
                     if access_fault then
                         return_ok = false
@@ -51,13 +47,13 @@ modbus.new = function (rtu_dev, use_parallel_read)
             end
 
             -- run parallel tasks if configured
-            if self.use_parallel then
+            if use_parallel_read then
                 parallel.waitForAll(table.unpack(tasks))
+            end
 
-                if access_fault then
-                    return_ok = false
-                    readings = MODBUS_EXCODE.SERVER_DEVICE_FAIL
-                end
+            if access_fault or #readings ~= count then
+                return_ok = false
+                readings = MODBUS_EXCODE.SERVER_DEVICE_FAIL
             end
         else
             readings = MODBUS_EXCODE.ILLEGAL_DATA_ADDR
@@ -66,27 +62,30 @@ modbus.new = function (rtu_dev, use_parallel_read)
         return return_ok, readings
     end
 
+    -- read a span of discrete inputs (digital inputs)<br>
+    -- returns a table of readings or a MODBUS_EXCODE error code
+    ---@nodiscard
     ---@param di_addr_start integer
     ---@param count integer
-    ---@return boolean ok, table readings
-    local _2_read_discrete_inputs = function (di_addr_start, count)
+    ---@return boolean ok, table|MODBUS_EXCODE readings
+    local function _2_read_discrete_inputs(di_addr_start, count)
         local tasks = {}
-        local readings = {}
+        local readings = {} ---@type table|MODBUS_EXCODE
         local access_fault = false
-        local discrete_inputs, _, _, _ = self.rtu.io_count()
+        local discrete_inputs, _, _, _ = rtu_dev.io_count()
         local return_ok = ((di_addr_start + count) <= (discrete_inputs + 1)) and (count > 0)
 
         if return_ok then
             for i = 1, count do
                 local addr = di_addr_start + i - 1
 
-                if self.use_parallel then
+                if use_parallel_read then
                     insert(tasks, function ()
-                        local reading, fault = self.rtu.read_di(addr)
+                        local reading, fault = rtu_dev.read_di(addr)
                         if fault then access_fault = true else readings[i] = reading end
                     end)
                 else
-                    readings[i], access_fault = self.rtu.read_di(addr)
+                    readings[i], access_fault = rtu_dev.read_di(addr)
 
                     if access_fault then
                         return_ok = false
@@ -97,13 +96,13 @@ modbus.new = function (rtu_dev, use_parallel_read)
             end
 
             -- run parallel tasks if configured
-            if self.use_parallel then
+            if use_parallel_read then
                 parallel.waitForAll(table.unpack(tasks))
+            end
 
-                if access_fault then
-                    return_ok = false
-                    readings = MODBUS_EXCODE.SERVER_DEVICE_FAIL
-                end
+            if access_fault or #readings ~= count then
+                return_ok = false
+                readings = MODBUS_EXCODE.SERVER_DEVICE_FAIL
             end
         else
             readings = MODBUS_EXCODE.ILLEGAL_DATA_ADDR
@@ -112,27 +111,30 @@ modbus.new = function (rtu_dev, use_parallel_read)
         return return_ok, readings
     end
 
+    -- read a span of holding registers (analog outputs)<br>
+    -- returns a table of readings or a MODBUS_EXCODE error code
+    ---@nodiscard
     ---@param hr_addr_start integer
     ---@param count integer
-    ---@return boolean ok, table readings
-    local _3_read_multiple_holding_registers = function (hr_addr_start, count)
+    ---@return boolean ok, table|MODBUS_EXCODE readings
+    local function _3_read_multiple_holding_registers(hr_addr_start, count)
         local tasks = {}
-        local readings = {}
+        local readings = {} ---@type table|MODBUS_EXCODE
         local access_fault = false
-        local _, _, _, hold_regs = self.rtu.io_count()
+        local _, _, _, hold_regs = rtu_dev.io_count()
         local return_ok = ((hr_addr_start + count) <= (hold_regs + 1)) and (count > 0)
 
         if return_ok then
             for i = 1, count do
                 local addr = hr_addr_start + i - 1
 
-                if self.use_parallel then
+                if use_parallel_read then
                     insert(tasks, function ()
-                        local reading, fault = self.rtu.read_holding_reg(addr)
+                        local reading, fault = rtu_dev.read_holding_reg(addr)
                         if fault then access_fault = true else readings[i] = reading end
                     end)
                 else
-                    readings[i], access_fault = self.rtu.read_holding_reg(addr)
+                    readings[i], access_fault = rtu_dev.read_holding_reg(addr)
 
                     if access_fault then
                         return_ok = false
@@ -143,13 +145,13 @@ modbus.new = function (rtu_dev, use_parallel_read)
             end
 
             -- run parallel tasks if configured
-            if self.use_parallel then
+            if use_parallel_read then
                 parallel.waitForAll(table.unpack(tasks))
+            end
 
-                if access_fault then
-                    return_ok = false
-                    readings = MODBUS_EXCODE.SERVER_DEVICE_FAIL
-                end
+            if access_fault or #readings ~= count then
+                return_ok = false
+                readings = MODBUS_EXCODE.SERVER_DEVICE_FAIL
             end
         else
             readings = MODBUS_EXCODE.ILLEGAL_DATA_ADDR
@@ -158,27 +160,30 @@ modbus.new = function (rtu_dev, use_parallel_read)
         return return_ok, readings
     end
 
+    -- read a span of input registers (analog inputs)<br>
+    -- returns a table of readings or a MODBUS_EXCODE error code
+    ---@nodiscard
     ---@param ir_addr_start integer
     ---@param count integer
-    ---@return boolean ok, table readings
-    local _4_read_input_registers = function (ir_addr_start, count)
+    ---@return boolean ok, table|MODBUS_EXCODE readings
+    local function _4_read_input_registers(ir_addr_start, count)
         local tasks = {}
-        local readings = {}
+        local readings = {} ---@type table|MODBUS_EXCODE
         local access_fault = false
-        local _, _, input_regs, _ = self.rtu.io_count()
+        local _, _, input_regs, _ = rtu_dev.io_count()
         local return_ok = ((ir_addr_start + count) <= (input_regs + 1)) and (count > 0)
 
         if return_ok then
             for i = 1, count do
                 local addr = ir_addr_start + i - 1
 
-                if self.use_parallel then
+                if use_parallel_read then
                     insert(tasks, function ()
-                        local reading, fault = self.rtu.read_input_reg(addr)
+                        local reading, fault = rtu_dev.read_input_reg(addr)
                         if fault then access_fault = true else readings[i] = reading end
                     end)
                 else
-                    readings[i], access_fault = self.rtu.read_input_reg(addr)
+                    readings[i], access_fault = rtu_dev.read_input_reg(addr)
 
                     if access_fault then
                         return_ok = false
@@ -189,13 +194,13 @@ modbus.new = function (rtu_dev, use_parallel_read)
             end
 
             -- run parallel tasks if configured
-            if self.use_parallel then
+            if use_parallel_read then
                 parallel.waitForAll(table.unpack(tasks))
+            end
 
-                if access_fault then
-                    return_ok = false
-                    readings = MODBUS_EXCODE.SERVER_DEVICE_FAIL
-                end
+            if access_fault or #readings ~= count then
+                return_ok = false
+                readings = MODBUS_EXCODE.SERVER_DEVICE_FAIL
             end
         else
             readings = MODBUS_EXCODE.ILLEGAL_DATA_ADDR
@@ -204,16 +209,18 @@ modbus.new = function (rtu_dev, use_parallel_read)
         return return_ok, readings
     end
 
+    -- write a single coil (digital output)
+    ---@nodiscard
     ---@param c_addr integer
     ---@param value any
-    ---@return boolean ok, MODBUS_EXCODE|nil
-    local _5_write_single_coil = function (c_addr, value)
+    ---@return boolean ok, MODBUS_EXCODE
+    local function _5_write_single_coil(c_addr, value)
         local response = nil
-        local _, coils, _, _ = self.rtu.io_count()
+        local _, coils, _, _ = rtu_dev.io_count()
         local return_ok = c_addr <= coils
 
         if return_ok then
-            local access_fault = self.rtu.write_coil(c_addr, value)
+            local access_fault = rtu_dev.write_coil(c_addr, value)
 
             if access_fault then
                 return_ok = false
@@ -226,16 +233,18 @@ modbus.new = function (rtu_dev, use_parallel_read)
         return return_ok, response
     end
 
+    -- write a single holding register (analog output)
+    ---@nodiscard
     ---@param hr_addr integer
     ---@param value any
-    ---@return boolean ok, MODBUS_EXCODE|nil
-    local _6_write_single_holding_register = function (hr_addr, value)
+    ---@return boolean ok, MODBUS_EXCODE
+    local function _6_write_single_holding_register(hr_addr, value)
         local response = nil
-        local _, _, _, hold_regs = self.rtu.io_count()
+        local _, _, _, hold_regs = rtu_dev.io_count()
         local return_ok = hr_addr <= hold_regs
 
         if return_ok then
-            local access_fault = self.rtu.write_holding_reg(hr_addr, value)
+            local access_fault = rtu_dev.write_holding_reg(hr_addr, value)
 
             if access_fault then
                 return_ok = false
@@ -248,19 +257,21 @@ modbus.new = function (rtu_dev, use_parallel_read)
         return return_ok, response
     end
 
+    -- write multiple coils (digital outputs)
+    ---@nodiscard
     ---@param c_addr_start integer
     ---@param values any
-    ---@return boolean ok, MODBUS_EXCODE|nil
-    local _15_write_multiple_coils = function (c_addr_start, values)
+    ---@return boolean ok, MODBUS_EXCODE
+    local function _15_write_multiple_coils(c_addr_start, values)
         local response = nil
-        local _, coils, _, _ = self.rtu.io_count()
+        local _, coils, _, _ = rtu_dev.io_count()
         local count = #values
         local return_ok = ((c_addr_start + count) <= (coils + 1)) and (count > 0)
 
         if return_ok then
             for i = 1, count do
                 local addr = c_addr_start + i - 1
-                local access_fault = self.rtu.write_coil(addr, values[i])
+                local access_fault = rtu_dev.write_coil(addr, values[i])
 
                 if access_fault then
                     return_ok = false
@@ -275,19 +286,21 @@ modbus.new = function (rtu_dev, use_parallel_read)
         return return_ok, response
     end
 
+    -- write multiple holding registers (analog outputs)
+    ---@nodiscard
     ---@param hr_addr_start integer
     ---@param values any
-    ---@return boolean ok, MODBUS_EXCODE|nil
-    local _16_write_multiple_holding_registers = function (hr_addr_start, values)
+    ---@return boolean ok, MODBUS_EXCODE
+    local function _16_write_multiple_holding_registers(hr_addr_start, values)
         local response = nil
-        local _, _, _, hold_regs = self.rtu.io_count()
+        local _, _, _, hold_regs = rtu_dev.io_count()
         local count = #values
         local return_ok = ((hr_addr_start + count) <= (hold_regs + 1)) and (count > 0)
 
         if return_ok then
             for i = 1, count do
                 local addr = hr_addr_start + i - 1
-                local access_fault = self.rtu.write_holding_reg(addr, values[i])
+                local access_fault = rtu_dev.write_holding_reg(addr, values[i])
 
                 if access_fault then
                     return_ok = false
@@ -302,10 +315,14 @@ modbus.new = function (rtu_dev, use_parallel_read)
         return return_ok, response
     end
 
+    ---@class modbus
+    local public = {}
+
     -- validate a request without actually executing it
+    ---@nodiscard
     ---@param packet modbus_frame
     ---@return boolean return_code, modbus_packet reply
-    public.check_request = function (packet)
+    function public.check_request(packet)
         local return_code = true
         local response = { MODBUS_EXCODE.ACKNOWLEDGE }
 
@@ -332,10 +349,9 @@ modbus.new = function (rtu_dev, use_parallel_read)
 
         -- default is to echo back
         local func_code = packet.func_code
-        if not return_code then
-            -- echo back with error flag
-            func_code = bit.bor(packet.func_code, MODBUS_FCODE.ERROR_FLAG)
-        end
+
+        -- echo back with error flag, on success the "error" will be acknowledgement
+        func_code = bit.bor(packet.func_code, MODBUS_FCODE.ERROR_FLAG)
 
         -- create reply
         local reply = comms.modbus_packet()
@@ -345,13 +361,14 @@ modbus.new = function (rtu_dev, use_parallel_read)
     end
 
     -- handle a MODBUS TCP packet and generate a reply
+    ---@nodiscard
     ---@param packet modbus_frame
     ---@return boolean return_code, modbus_packet reply
-    public.handle_packet = function (packet)
+    function public.handle_packet(packet)
         local return_code = true
         local response = nil
 
-        if packet.length == 2 then
+        if packet.length >= 2 then
             -- handle  by function code
             if packet.func_code == MODBUS_FCODE.READ_COILS then
                 return_code, response = _1_read_coils(packet.data[1], packet.data[2])
@@ -366,9 +383,9 @@ modbus.new = function (rtu_dev, use_parallel_read)
             elseif packet.func_code == MODBUS_FCODE.WRITE_SINGLE_HOLD_REG then
                 return_code, response = _6_write_single_holding_register(packet.data[1], packet.data[2])
             elseif packet.func_code == MODBUS_FCODE.WRITE_MUL_COILS then
-                return_code, response = _15_write_multiple_coils(packet.data[1], packet.data[2])
+                return_code, response = _15_write_multiple_coils(packet.data[1], { table.unpack(packet.data, 2, packet.length) })
             elseif packet.func_code == MODBUS_FCODE.WRITE_MUL_HOLD_REGS then
-                return_code, response = _16_write_multiple_holding_registers(packet.data[1], packet.data[2])
+                return_code, response = _16_write_multiple_holding_registers(packet.data[1], { table.unpack(packet.data, 2, packet.length) })
             else
                 -- unknown function
                 return_code = false
@@ -377,6 +394,7 @@ modbus.new = function (rtu_dev, use_parallel_read)
         else
             -- invalid length
             return_code = false
+            response = MODBUS_EXCODE.NEG_ACKNOWLEDGE
         end
 
         -- default is to echo back
@@ -400,40 +418,46 @@ modbus.new = function (rtu_dev, use_parallel_read)
         return return_code, reply
     end
 
-    -- return a SERVER_DEVICE_BUSY error reply
-    ---@return modbus_packet reply
-    public.reply__srv_device_busy = function (packet)
-        -- reply back with error flag and exception code
-        local reply = comms.modbus_packet()
-        local fcode = bit.bor(packet.func_code, MODBUS_FCODE.ERROR_FLAG)
-        local data = { MODBUS_EXCODE.SERVER_DEVICE_BUSY }
-        reply.make(packet.txn_id, packet.unit_id, fcode, data)
-        return reply
-    end
-
-    -- return a NEG_ACKNOWLEDGE error reply
-    ---@return modbus_packet reply
-    public.reply__neg_ack = function (packet)
-        -- reply back with error flag and exception code
-        local reply = comms.modbus_packet()
-        local fcode = bit.bor(packet.func_code, MODBUS_FCODE.ERROR_FLAG)
-        local data = { MODBUS_EXCODE.NEG_ACKNOWLEDGE }
-        reply.make(packet.txn_id, packet.unit_id, fcode, data)
-        return reply
-    end
-
-    -- return a GATEWAY_PATH_UNAVAILABLE error reply
-    ---@return modbus_packet reply
-    public.reply__gw_unavailable = function (packet)
-        -- reply back with error flag and exception code
-        local reply = comms.modbus_packet()
-        local fcode = bit.bor(packet.func_code, MODBUS_FCODE.ERROR_FLAG)
-        local data = { MODBUS_EXCODE.GATEWAY_PATH_UNAVAILABLE }
-        reply.make(packet.txn_id, packet.unit_id, fcode, data)
-        return reply
-    end
-
     return public
 end
 
+-- return a SERVER_DEVICE_BUSY error reply
+---@nodiscard
+---@param packet modbus_frame MODBUS packet frame
+---@return modbus_packet reply
+function modbus.reply__srv_device_busy(packet)
+    -- reply back with error flag and exception code
+    local reply = comms.modbus_packet()
+    local fcode = bit.bor(packet.func_code, MODBUS_FCODE.ERROR_FLAG)
+    local data = { MODBUS_EXCODE.SERVER_DEVICE_BUSY }
+    reply.make(packet.txn_id, packet.unit_id, fcode, data)
+    return reply
+end
+
+-- return a NEG_ACKNOWLEDGE error reply
+---@nodiscard
+---@param packet modbus_frame MODBUS packet frame
+---@return modbus_packet reply
+function modbus.reply__neg_ack(packet)
+    -- reply back with error flag and exception code
+    local reply = comms.modbus_packet()
+    local fcode = bit.bor(packet.func_code, MODBUS_FCODE.ERROR_FLAG)
+    local data = { MODBUS_EXCODE.NEG_ACKNOWLEDGE }
+    reply.make(packet.txn_id, packet.unit_id, fcode, data)
+    return reply
+end
+
+-- return a GATEWAY_PATH_UNAVAILABLE error reply
+---@nodiscard
+---@param packet modbus_frame MODBUS packet frame
+---@return modbus_packet reply
+function modbus.reply__gw_unavailable(packet)
+    -- reply back with error flag and exception code
+    local reply = comms.modbus_packet()
+    local fcode = bit.bor(packet.func_code, MODBUS_FCODE.ERROR_FLAG)
+    local data = { MODBUS_EXCODE.GATEWAY_PATH_UNAVAILABLE }
+    reply.make(packet.txn_id, packet.unit_id, fcode, data)
+    return reply
+end
+
 return modbus

rtu/rtu.lua

@@ -1,26 +1,27 @@
-local comms = require("scada-common.comms")
-local ppm = require("scada-common.ppm")
-local log = require("scada-common.log")
-local types = require("scada-common.types")
-local util = require("scada-common.util")
+local comms  = require("scada-common.comms")
+local ppm    = require("scada-common.ppm")
+local log    = require("scada-common.log")
+local types  = require("scada-common.types")
+local util   = require("scada-common.util")
 
 local modbus = require("rtu.modbus")
 
 local rtu = {}
 
-local rtu_t = types.rtu_t
-
-local PROTOCOLS = comms.PROTOCOLS
-local SCADA_MGMT_TYPES = comms.SCADA_MGMT_TYPES
-local RTU_UNIT_TYPES = comms.RTU_UNIT_TYPES
+local PROTOCOL = comms.PROTOCOL
+local DEVICE_TYPE = comms.DEVICE_TYPE
+local ESTABLISH_ACK = comms.ESTABLISH_ACK
+local SCADA_MGMT_TYPE = comms.SCADA_MGMT_TYPE
+local RTU_UNIT_TYPE = types.RTU_UNIT_TYPE
 
 local print = util.print
 local println = util.println
 local print_ts = util.print_ts
 local println_ts = util.println_ts
 
--- create a new RTU
-rtu.init_unit = function ()
+-- create a new RTU unit
+---@nodiscard
+function rtu.init_unit()
     local self = {
         discrete_inputs = {},
         coils = {},
@@ -38,13 +39,13 @@ rtu.init_unit = function ()
     local protected = {}
 
     -- refresh IO count
-    local _count_io = function ()
+    local function _count_io()
         self.io_count_cache = { #self.discrete_inputs, #self.coils, #self.input_regs, #self.holding_regs }
     end
 
     -- return IO count
     ---@return integer discrete_inputs, integer coils, integer input_regs, integer holding_regs
-    public.io_count = function ()
+    function public.io_count()
         return self.io_count_cache[1], self.io_count_cache[2], self.io_count_cache[3], self.io_count_cache[4]
     end
 
@@ -53,7 +54,7 @@ rtu.init_unit = function ()
     -- connect discrete input
     ---@param f function
     ---@return integer count count of discrete inputs
-    protected.connect_di = function (f)
+    function protected.connect_di(f)
         insert(self.discrete_inputs, { read = f })
         _count_io()
         return #self.discrete_inputs
@@ -62,7 +63,7 @@ rtu.init_unit = function ()
     -- read discrete input
     ---@param di_addr integer
     ---@return any value, boolean access_fault
-    public.read_di = function (di_addr)
+    function public.read_di(di_addr)
         ppm.clear_fault()
         local value = self.discrete_inputs[di_addr].read()
         return value, ppm.is_faulted()
@@ -74,7 +75,7 @@ rtu.init_unit = function ()
     ---@param f_read function
     ---@param f_write function
     ---@return integer count count of coils
-    protected.connect_coil = function (f_read, f_write)
+    function protected.connect_coil(f_read, f_write)
         insert(self.coils, { read = f_read, write = f_write })
         _count_io()
         return #self.coils
@@ -83,7 +84,7 @@ rtu.init_unit = function ()
     -- read coil
     ---@param coil_addr integer
     ---@return any value, boolean access_fault
-    public.read_coil = function (coil_addr)
+    function public.read_coil(coil_addr)
         ppm.clear_fault()
         local value = self.coils[coil_addr].read()
         return value, ppm.is_faulted()
@@ -93,7 +94,7 @@ rtu.init_unit = function ()
     ---@param coil_addr integer
     ---@param value any
     ---@return boolean access_fault
-    public.write_coil = function (coil_addr, value)
+    function public.write_coil(coil_addr, value)
         ppm.clear_fault()
         self.coils[coil_addr].write(value)
         return ppm.is_faulted()
@@ -104,7 +105,7 @@ rtu.init_unit = function ()
     -- connect input register
     ---@param f function
     ---@return integer count count of input registers
-    protected.connect_input_reg = function (f)
+    function protected.connect_input_reg(f)
         insert(self.input_regs, { read = f })
         _count_io()
         return #self.input_regs
@@ -113,7 +114,7 @@ rtu.init_unit = function ()
     -- read input register
     ---@param reg_addr integer
     ---@return any value, boolean access_fault
-    public.read_input_reg = function (reg_addr)
+    function public.read_input_reg(reg_addr)
         ppm.clear_fault()
         local value = self.input_regs[reg_addr].read()
         return value, ppm.is_faulted()
@@ -125,7 +126,7 @@ rtu.init_unit = function ()
     ---@param f_read function
     ---@param f_write function
     ---@return integer count count of holding registers
-    protected.connect_holding_reg = function (f_read, f_write)
+    function protected.connect_holding_reg(f_read, f_write)
         insert(self.holding_regs, { read = f_read, write = f_write })
         _count_io()
         return #self.holding_regs
@@ -134,7 +135,7 @@ rtu.init_unit = function ()
     -- read holding register
     ---@param reg_addr integer
     ---@return any value, boolean access_fault
-    public.read_holding_reg = function (reg_addr)
+    function public.read_holding_reg(reg_addr)
         ppm.clear_fault()
         local value = self.holding_regs[reg_addr].read()
         return value, ppm.is_faulted()
@@ -144,7 +145,7 @@ rtu.init_unit = function ()
     ---@param reg_addr integer
     ---@param value any
     ---@return boolean access_fault
-    public.write_holding_reg = function (reg_addr, value)
+    function public.write_holding_reg(reg_addr, value)
         ppm.clear_fault()
         self.holding_regs[reg_addr].write(value)
         return ppm.is_faulted()
@@ -153,118 +154,75 @@ rtu.init_unit = function ()
     -- public RTU device access
 
     -- get the public interface to this RTU
-    protected.interface = function ()
-        return public
-    end
+    function protected.interface() return public end
 
     return protected
 end
 
 -- RTU Communications
----@param version string
----@param modem table
----@param local_port integer
----@param server_port integer
----@param conn_watchdog watchdog
-rtu.comms = function (version, modem, local_port, server_port, conn_watchdog)
+---@nodiscard
+---@param version string RTU version
+---@param modem table modem device
+---@param local_port integer local listening port
+---@param server_port integer remote server port
+---@param range integer trusted device connection range
+---@param conn_watchdog watchdog watchdog reference
+function rtu.comms(version, modem, local_port, server_port, range, conn_watchdog)
     local self = {
-        version = version,
         seq_num = 0,
         r_seq_num = nil,
         txn_id = 0,
-        modem = modem,
-        s_port = server_port,
-        l_port = local_port,
-        conn_watchdog = conn_watchdog
+        last_est_ack = ESTABLISH_ACK.ALLOW
     }
 
-    ---@class rtu_comms
-    local public = {}
-
     local insert = table.insert
 
-    -- open modem
-    if not self.modem.isOpen(self.l_port) then
-        self.modem.open(self.l_port)
-    end
+    comms.set_trusted_range(range)
 
     -- PRIVATE FUNCTIONS --
 
+    -- configure modem channels
+    local function _conf_channels()
+        modem.closeAll()
+        modem.open(local_port)
+    end
+
+    _conf_channels()
+
     -- send a scada management packet
-    ---@param msg_type SCADA_MGMT_TYPES
+    ---@param msg_type SCADA_MGMT_TYPE
     ---@param msg table
-    local _send = function (msg_type, msg)
+    local function _send(msg_type, msg)
         local s_pkt = comms.scada_packet()
         local m_pkt = comms.mgmt_packet()
 
         m_pkt.make(msg_type, msg)
-        s_pkt.make(self.seq_num, PROTOCOLS.SCADA_MGMT, m_pkt.raw_sendable())
+        s_pkt.make(self.seq_num, PROTOCOL.SCADA_MGMT, m_pkt.raw_sendable())
 
-        self.modem.transmit(self.s_port, self.l_port, s_pkt.raw_sendable())
+        modem.transmit(server_port, local_port, s_pkt.raw_sendable())
         self.seq_num = self.seq_num + 1
     end
 
     -- keep alive ack
     ---@param srv_time integer
-    local _send_keep_alive_ack = function (srv_time)
-        _send(SCADA_MGMT_TYPES.KEEP_ALIVE, { srv_time, util.time() })
+    local function _send_keep_alive_ack(srv_time)
+        _send(SCADA_MGMT_TYPE.KEEP_ALIVE, { srv_time, util.time() })
     end
 
-    -- PUBLIC FUNCTIONS --
-
-    -- send a MODBUS TCP packet
-    ---@param m_pkt modbus_packet
-    public.send_modbus = function (m_pkt)
-        local s_pkt = comms.scada_packet()
-        s_pkt.make(self.seq_num, PROTOCOLS.MODBUS_TCP, m_pkt.raw_sendable())
-        self.modem.transmit(self.s_port, self.l_port, s_pkt.raw_sendable())
-        self.seq_num = self.seq_num + 1
-    end
-
-    -- reconnect a newly connected modem
-    ---@param modem table
----@diagnostic disable-next-line: redefined-local
-    public.reconnect_modem = function (modem)
-        self.modem = modem
-
-        -- open modem
-        if not self.modem.isOpen(self.l_port) then
-            self.modem.open(self.l_port)
-        end
-    end
-
-    -- unlink from the server
-    ---@param rtu_state rtu_state
-    public.unlink = function (rtu_state)
-        rtu_state.linked = false
-        self.r_seq_num = nil
-    end
-
-    -- close the connection to the server
-    ---@param rtu_state rtu_state
-    public.close = function (rtu_state)
-        self.conn_watchdog.cancel()
-        public.unlink(rtu_state)
-        _send(SCADA_MGMT_TYPES.CLOSE, {})
-    end
-
-    -- send capability advertisement
+    -- generate device advertisement table
+    ---@nodiscard
     ---@param units table
-    public.send_advertisement = function (units)
-        local advertisement = { self.version }
+    ---@return table advertisement
+    local function _generate_advertisement(units)
+        local advertisement = {}
 
         for i = 1, #units do
-            local unit = units[i]   --@type rtu_unit_registry_entry
-            local type = comms.rtu_t_to_unit_type(unit.type)
+            local unit = units[i]   ---@type rtu_unit_registry_entry
 
-            if type ~= nil then
-                local advert = {
-                    type,
-                    unit.index,
-                    unit.reactor
-                }
+            if unit.type ~= nil then
+                local advert = { unit.type, unit.index, unit.reactor }
 
-                if type == RTU_UNIT_TYPES.REDSTONE then
+                if unit.type == RTU_UNIT_TYPE.REDSTONE then
                     insert(advert, unit.device)
                 end
 
@@ -272,17 +230,72 @@ rtu.comms = function (version, modem, local_port, server_port, conn_watchdog)
             end
         end
 
-        _send(SCADA_MGMT_TYPES.RTU_ADVERT, advertisement)
+        return advertisement
+    end
+
+    -- PUBLIC FUNCTIONS --
+
+    ---@class rtu_comms
+    local public = {}
+
+    -- send a MODBUS TCP packet
+    ---@param m_pkt modbus_packet
+    function public.send_modbus(m_pkt)
+        local s_pkt = comms.scada_packet()
+        s_pkt.make(self.seq_num, PROTOCOL.MODBUS_TCP, m_pkt.raw_sendable())
+        modem.transmit(server_port, local_port, s_pkt.raw_sendable())
+        self.seq_num = self.seq_num + 1
+    end
+
+    -- reconnect a newly connected modem
+    ---@param new_modem table
+    function public.reconnect_modem(new_modem)
+        modem = new_modem
+        _conf_channels()
+    end
+
+    -- unlink from the server
+    ---@param rtu_state rtu_state
+    function public.unlink(rtu_state)
+        rtu_state.linked = false
+        self.r_seq_num = nil
+    end
+
+    -- close the connection to the server
+    ---@param rtu_state rtu_state
+    function public.close(rtu_state)
+        conn_watchdog.cancel()
+        public.unlink(rtu_state)
+        _send(SCADA_MGMT_TYPE.CLOSE, {})
+    end
+
+    -- send establish request (includes advertisement)
+    ---@param units table
+    function public.send_establish(units)
+        _send(SCADA_MGMT_TYPE.ESTABLISH, { comms.version, version, DEVICE_TYPE.RTU, _generate_advertisement(units) })
+    end
+
+    -- send capability advertisement
+    ---@param units table
+    function public.send_advertisement(units)
+        _send(SCADA_MGMT_TYPE.RTU_ADVERT, _generate_advertisement(units))
+    end
+
+    -- notify that a peripheral was remounted
+    ---@param unit_index integer RTU unit ID
+    function public.send_remounted(unit_index)
+        _send(SCADA_MGMT_TYPE.RTU_DEV_REMOUNT, { unit_index })
     end
 
     -- parse a MODBUS/SCADA packet
+    ---@nodiscard
     ---@param side string
     ---@param sender integer
     ---@param reply_to integer
     ---@param message any
     ---@param distance integer
     ---@return modbus_frame|mgmt_frame|nil packet
-    public.parse_packet = function(side, sender, reply_to, message, distance)
+    function public.parse_packet(side, sender, reply_to, message, distance)
         local pkt = nil
         local s_pkt = comms.scada_packet()
 
@@ -291,13 +304,13 @@ rtu.comms = function (version, modem, local_port, server_port, conn_watchdog)
 
         if s_pkt.is_valid() then
             -- get as MODBUS TCP packet
-            if s_pkt.protocol() == PROTOCOLS.MODBUS_TCP then
+            if s_pkt.protocol() == PROTOCOL.MODBUS_TCP then
                 local m_pkt = comms.modbus_packet()
                 if m_pkt.decode(s_pkt) then
                     pkt = m_pkt.get()
                 end
             -- get as SCADA management packet
-            elseif s_pkt.protocol() == PROTOCOLS.SCADA_MGMT then
+            elseif s_pkt.protocol() == PROTOCOL.SCADA_MGMT then
                 local mgmt_pkt = comms.mgmt_packet()
                 if mgmt_pkt.decode(s_pkt) then
                     pkt = mgmt_pkt.get()
@@ -312,10 +325,10 @@ rtu.comms = function (version, modem, local_port, server_port, conn_watchdog)
 
     -- handle a MODBUS/SCADA packet
     ---@param packet modbus_frame|mgmt_frame
-    ---@param units table
+    ---@param units table RTU units
     ---@param rtu_state rtu_state
-    public.handle_packet = function(packet, units, rtu_state)
-        if packet ~= nil then
+    function public.handle_packet(packet, units, rtu_state)
+        if packet.scada_frame.local_port() == local_port then
             -- check sequence number
             if self.r_seq_num == nil then
                 self.r_seq_num = packet.scada_frame.seq_num()
@@ -327,84 +340,120 @@ rtu.comms = function (version, modem, local_port, server_port, conn_watchdog)
             end
 
             -- feed watchdog on valid sequence number
-            self.conn_watchdog.feed()
+            conn_watchdog.feed()
 
             local protocol = packet.scada_frame.protocol()
 
-            if protocol == PROTOCOLS.MODBUS_TCP then
-                local return_code = false
-                local reply = modbus.reply__neg_ack(packet)
+            if protocol == PROTOCOL.MODBUS_TCP then
+                ---@cast packet modbus_frame
+                if rtu_state.linked then
+                    local return_code = false
+                    local reply = modbus.reply__neg_ack(packet)
 
-                -- handle MODBUS instruction
-                if packet.unit_id <= #units then
-                    local unit = units[packet.unit_id]  ---@type rtu_unit_registry_entry
-                    local unit_dbg_tag = " (unit " .. packet.unit_id .. ")"
+                    -- handle MODBUS instruction
+                    if packet.unit_id <= #units then
+                        local unit = units[packet.unit_id]  ---@type rtu_unit_registry_entry
+                        local unit_dbg_tag = " (unit " .. packet.unit_id .. ")"
 
-                    if unit.name == "redstone_io" then
-                        -- immediately execute redstone RTU requests
-                        return_code, reply = unit.modbus_io.handle_packet(packet)
-                        if not return_code then
-                            log.warning("requested MODBUS operation failed" .. unit_dbg_tag)
+                        if unit.name == "redstone_io" then
+                            -- immediately execute redstone RTU requests
+                            return_code, reply = unit.modbus_io.handle_packet(packet)
+                            if not return_code then
+                                log.warning("requested MODBUS operation failed" .. unit_dbg_tag)
+                            end
+                        else
+                            -- check validity then pass off to unit comms thread
+                            return_code, reply = unit.modbus_io.check_request(packet)
+                            if return_code then
+                                -- check if there are more than 3 active transactions
+                                -- still queue the packet, but this may indicate a problem
+                                if unit.pkt_queue.length() > 3 then
+                                    reply = modbus.reply__srv_device_busy(packet)
+                                    log.debug("queueing new request with " .. unit.pkt_queue.length() ..
+                                        " transactions already in the queue" .. unit_dbg_tag)
+                                end
+
+                                -- always queue the command even if busy
+                                unit.pkt_queue.push_packet(packet)
+                            else
+                                log.warning("cannot perform requested MODBUS operation" .. unit_dbg_tag)
+                            end
                         end
                     else
-                        -- check validity then pass off to unit comms thread
-                        return_code, reply = unit.modbus_io.check_request(packet)
-                        if return_code then
-                            -- check if there are more than 3 active transactions
-                            -- still queue the packet, but this may indicate a problem
-                            if unit.pkt_queue.length() > 3 then
-                                reply = unit.modbus_io.reply__srv_device_busy(packet)
-                                log.debug("queueing new request with " .. unit.pkt_queue.length() ..
-                                    " transactions already in the queue" .. unit_dbg_tag)
+                        -- unit ID out of range?
+                        reply = modbus.reply__gw_unavailable(packet)
+                        log.error("received MODBUS packet for non-existent unit")
+                    end
+
+                    public.send_modbus(reply)
+                else
+                    log.debug("discarding MODBUS packet before linked")
+                end
+            elseif protocol == PROTOCOL.SCADA_MGMT then
+                ---@cast packet mgmt_frame
+                -- SCADA management packet
+                if packet.type == SCADA_MGMT_TYPE.ESTABLISH then
+                    if packet.length == 1 then
+                        local est_ack = packet.data[1]
+
+                        if est_ack == ESTABLISH_ACK.ALLOW then
+                            -- establish allowed
+                            rtu_state.linked = true
+                            self.r_seq_num = nil
+                            println_ts("supervisor connection established")
+                            log.info("supervisor connection established")
+                        else
+                            -- establish denied
+                            if est_ack ~= self.last_est_ack then
+                                if est_ack == ESTABLISH_ACK.BAD_VERSION then
+                                    -- version mismatch
+                                    println_ts("supervisor comms version mismatch (try updating), retrying...")
+                                    log.warning("supervisor connection denied due to comms version mismatch, retrying")
+                                else
+                                    println_ts("supervisor connection denied, retrying...")
+                                    log.warning("supervisor connection denied, retrying")
+                                end
                             end
 
-                            -- always queue the command even if busy
-                            unit.pkt_queue.push_packet(packet)
-                        else
-                            log.warning("cannot perform requested MODBUS operation" .. unit_dbg_tag)
-                        end
-                    end
-                else
-                    -- unit ID out of range?
-                    reply = modbus.reply__gw_unavailable(packet)
-                    log.error("received MODBUS packet for non-existent unit")
-                end
-
-                public.send_modbus(reply)
-            elseif protocol == PROTOCOLS.SCADA_MGMT then
-                -- SCADA management packet
-                if packet.type == SCADA_MGMT_TYPES.KEEP_ALIVE then
-                    -- keep alive request received, echo back
-                    if packet.length == 1 then
-                        local timestamp = packet.data[1]
-                        local trip_time = util.time() - timestamp
-
-                        if trip_time > 500 then
-                            log.warning("RTU KEEP_ALIVE trip time > 500ms (" .. trip_time .. "ms)")
+                            public.unlink(rtu_state)
                         end
 
-                        -- log.debug("RTU RTT = ".. trip_time .. "ms")
-
-                        _send_keep_alive_ack(timestamp)
+                        self.last_est_ack = est_ack
                     else
-                        log.debug("SCADA keep alive packet length mismatch")
+                        log.debug("SCADA_MGMT establish packet length mismatch")
+                    end
+                elseif rtu_state.linked then
+                    if packet.type == SCADA_MGMT_TYPE.KEEP_ALIVE then
+                        -- keep alive request received, echo back
+                        if packet.length == 1 and type(packet.data[1]) == "number" then
+                            local timestamp = packet.data[1]
+                            local trip_time = util.time() - timestamp
+
+                            if trip_time > 750 then
+                                log.warning("RTU KEEP_ALIVE trip time > 750ms (" .. trip_time .. "ms)")
+                            end
+
+                            -- log.debug("RTU RTT = " .. trip_time .. "ms")
+
+                            _send_keep_alive_ack(timestamp)
+                        else
+                            log.debug("SCADA_MGMT keep alive packet length/type mismatch")
+                        end
+                    elseif packet.type == SCADA_MGMT_TYPE.CLOSE then
+                        -- close connection
+                        conn_watchdog.cancel()
+                        public.unlink(rtu_state)
+                        println_ts("server connection closed by remote host")
+                        log.warning("server connection closed by remote host")
+                    elseif packet.type == SCADA_MGMT_TYPE.RTU_ADVERT then
+                        -- request for capabilities again
+                        public.send_advertisement(units)
+                    else
+                        -- not supported
+                        log.warning("received unsupported SCADA_MGMT message type " .. packet.type)
                     end
-                elseif packet.type == SCADA_MGMT_TYPES.CLOSE then
-                    -- close connection
-                    self.conn_watchdog.cancel()
-                    public.unlink(rtu_state)
-                    println_ts("server connection closed by remote host")
-                    log.warning("server connection closed by remote host")
-                elseif packet.type == SCADA_MGMT_TYPES.REMOTE_LINKED then
-                    -- acknowledgement
-                    rtu_state.linked = true
-                    self.r_seq_num = nil
-                elseif packet.type == SCADA_MGMT_TYPES.RTU_ADVERT then
-                    -- request for capabilities again
-                    public.send_advertisement(units)
                 else
-                    -- not supported
-                    log.warning("RTU got unexpected SCADA message type " .. packet.type)
+                    log.debug("discarding non-link SCADA_MGMT packet before linked")
                 end
             else
                 -- should be unreachable assuming packet is from parse_packet()

rtu/startup.lua

@@ -4,283 +4,449 @@
 
 require("/initenv").init_env()
 
-local log = require("scada-common.log")
-local mqueue = require("scada-common.mqueue")
-local ppm = require("scada-common.ppm")
-local rsio = require("scada-common.rsio")
-local types = require("scada-common.types")
-local util = require("scada-common.util")
+local crash        = require("scada-common.crash")
+local log          = require("scada-common.log")
+local mqueue       = require("scada-common.mqueue")
+local ppm          = require("scada-common.ppm")
+local rsio         = require("scada-common.rsio")
+local types        = require("scada-common.types")
+local util         = require("scada-common.util")
 
-local config = require("rtu.config")
-local modbus = require("rtu.modbus")
-local rtu = require("rtu.rtu")
-local threads = require("rtu.threads")
+local config       = require("rtu.config")
+local modbus       = require("rtu.modbus")
+local rtu          = require("rtu.rtu")
+local threads      = require("rtu.threads")
 
+local boilerv_rtu  = require("rtu.dev.boilerv_rtu")
+local envd_rtu     = require("rtu.dev.envd_rtu")
+local imatrix_rtu  = require("rtu.dev.imatrix_rtu")
 local redstone_rtu = require("rtu.dev.redstone_rtu")
-local boiler_rtu = require("rtu.dev.boiler_rtu")
-local boilerv_rtu = require("rtu.dev.boilerv_rtu")
-local energymachine_rtu = require("rtu.dev.energymachine_rtu")
-local imatrix_rtu = require("rtu.dev.imatrix_rtu")
-local turbine_rtu = require("rtu.dev.turbine_rtu")
+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 = "alpha-v0.7.1"
+local RTU_VERSION = "v0.13.0"
 
-local rtu_t = types.rtu_t
+local RTU_UNIT_TYPE = types.RTU_UNIT_TYPE
 
 local print = util.print
 local println = util.println
 local print_ts = util.print_ts
 local println_ts = util.println_ts
 
+----------------------------------------
+-- config validation
+----------------------------------------
+
+local cfv = util.new_validator()
+
+cfv.assert_port(config.SERVER_PORT)
+cfv.assert_port(config.LISTEN_PORT)
+cfv.assert_type_int(config.TRUSTED_RANGE)
+cfv.assert_type_num(config.COMMS_TIMEOUT)
+cfv.assert_min(config.COMMS_TIMEOUT, 2)
+cfv.assert_type_str(config.LOG_PATH)
+cfv.assert_type_int(config.LOG_MODE)
+cfv.assert_type_table(config.RTU_DEVICES)
+cfv.assert_type_table(config.RTU_REDSTONE)
+assert(cfv.valid(), "bad config file: missing/invalid fields")
+
+----------------------------------------
+-- log init
+----------------------------------------
+
 log.init(config.LOG_PATH, config.LOG_MODE)
 
 log.info("========================================")
 log.info("BOOTING rtu.startup " .. RTU_VERSION)
 log.info("========================================")
-println(">> RTU " .. RTU_VERSION .. " <<")
+println(">> RTU GATEWAY " .. RTU_VERSION .. " <<")
+
+crash.set_env("rtu", RTU_VERSION)
 
 ----------------------------------------
--- startup
+-- main application
 ----------------------------------------
 
--- mount connected devices
-ppm.mount_all()
+local function main()
+    ----------------------------------------
+    -- startup
+    ----------------------------------------
 
----@class rtu_shared_memory
-local __shared_memory = {
-    -- RTU system state flags
-    ---@class rtu_state
-    rtu_state = {
-        linked = false,
-        shutdown = false
-    },
+    -- mount connected devices
+    ppm.mount_all()
 
-    -- core RTU devices
-    rtu_dev = {
-        modem = ppm.get_wireless_modem()
-    },
+    ---@class rtu_shared_memory
+    local __shared_memory = {
+        -- RTU system state flags
+        ---@class rtu_state
+        rtu_state = {
+            linked = false,
+            shutdown = false
+        },
 
-    -- system objects
-    rtu_sys = {
-        rtu_comms = nil,        ---@type rtu_comms
-        conn_watchdog = nil,    ---@type watchdog
-        units = {}              ---@type table
-    },
+        -- core RTU devices
+        rtu_dev = {
+            modem = ppm.get_wireless_modem()
+        },
 
-    -- message queues
-    q = {
-        mq_comms = mqueue.new()
+        -- system objects
+        rtu_sys = {
+            rtu_comms = nil,        ---@type rtu_comms
+            conn_watchdog = nil,    ---@type watchdog
+            units = {}              ---@type table
+        },
+
+        -- message queues
+        q = {
+            mq_comms = mqueue.new()
+        }
     }
-}
 
-local smem_dev = __shared_memory.rtu_dev
-local smem_sys = __shared_memory.rtu_sys
+    local smem_dev = __shared_memory.rtu_dev
+    local smem_sys = __shared_memory.rtu_sys
 
--- get modem
-if smem_dev.modem == nil then
-    println("boot> wireless modem not found")
-    log.warning("no wireless modem on startup")
-    return
-end
-
-----------------------------------------
--- interpret config and init units
-----------------------------------------
-
-local units = __shared_memory.rtu_sys.units
-
-local rtu_redstone = config.RTU_REDSTONE
-local rtu_devices = config.RTU_DEVICES
-
--- redstone interfaces
-for entry_idx = 1, #rtu_redstone do
-    local rs_rtu = redstone_rtu.new()
-    local io_table = rtu_redstone[entry_idx].io
-    local io_reactor = rtu_redstone[entry_idx].for_reactor
-
-    local capabilities = {}
-
-    log.debug("init> starting redstone RTU I/O linking for reactor " .. io_reactor .. "...")
-
-    local continue = true
-
-    for i = 1, #units do
-        local unit = units[i]   ---@type rtu_unit_registry_entry
-        if unit.reactor == io_reactor and unit.type == rtu_t.redstone then
-            -- duplicate entry
-            log.warning("init> skipping definition block #" .. entry_idx .. " for reactor " .. io_reactor .. " with already defined redstone I/O")
-            continue = false
-            break
-        end
+    -- get modem
+    if smem_dev.modem == nil then
+        println("boot> wireless modem not found")
+        log.fatal("no wireless modem on startup")
+        return
     end
 
-    if continue then
-        for i = 1, #io_table do
-            local valid = false
-            local conf = io_table[i]
+    ----------------------------------------
+    -- interpret config and init units
+    ----------------------------------------
 
-            -- verify configuration
-            if rsio.is_valid_channel(conf.channel) and rsio.is_valid_side(conf.side) then
-                if conf.bundled_color then
-                    valid = rsio.is_color(conf.bundled_color)
-                else
-                    valid = true
-                end
+    local units = __shared_memory.rtu_sys.units
+
+    local rtu_redstone = config.RTU_REDSTONE
+    local rtu_devices = config.RTU_DEVICES
+
+    -- configure RTU gateway based on config file definitions
+    local function configure()
+        -- redstone interfaces
+        for entry_idx = 1, #rtu_redstone do
+            local rs_rtu = redstone_rtu.new()
+            local io_table = rtu_redstone[entry_idx].io             ---@type table
+            local io_reactor = rtu_redstone[entry_idx].for_reactor  ---@type integer
+
+            -- CHECK: reactor ID must be >= to 1
+            if (not util.is_int(io_reactor)) or (io_reactor < 0) then
+                local message = util.c("configure> redstone entry #", entry_idx, " : ", io_reactor, " isn't an integer >= 0")
+                println(message)
+                log.fatal(message)
+                return false
             end
 
-            if not valid then
-                local message = "init> invalid redstone definition at index " .. i .. " in definition block #" .. entry_idx ..
-                    " (for reactor " .. io_reactor .. ")"
-                println_ts(message)
-                log.warning(message)
-            else
-                -- link redstone in RTU
-                local mode = rsio.get_io_mode(conf.channel)
-                if mode == rsio.IO_MODE.DIGITAL_IN then
-                    -- can't have duplicate inputs
-                    if util.table_contains(capabilities, conf.channel) then
-                        log.warning("init> skipping duplicate input for channel " .. rsio.to_string(conf.channel) .. " on side " .. conf.side)
-                    else
-                        rs_rtu.link_di(conf.side, conf.bundled_color)
-                    end
-                elseif mode == rsio.IO_MODE.DIGITAL_OUT then
-                    rs_rtu.link_do(conf.channel, conf.side, conf.bundled_color)
-                elseif mode == rsio.IO_MODE.ANALOG_IN then
-                    -- can't have duplicate inputs
-                    if util.table_contains(capabilities, conf.channel) then
-                        log.warning("init> skipping duplicate input for channel " .. rsio.to_string(conf.channel) .. " on side " .. conf.side)
-                    else
-                        rs_rtu.link_ai(conf.side)
-                    end
-                elseif mode == rsio.IO_MODE.ANALOG_OUT then
-                    rs_rtu.link_ao(conf.side)
-                else
-                    -- should be unreachable code, we already validated channels
-                    log.error("init> fell through if chain attempting to identify IO mode", true)
+            -- CHECK: io table exists
+            if type(io_table) ~= "table" then
+                local message = util.c("configure> redstone entry #", entry_idx, " no IO table found")
+                println(message)
+                log.fatal(message)
+                return false
+            end
+
+            local capabilities = {}
+
+            log.debug(util.c("configure> starting redstone RTU I/O linking for reactor ", io_reactor, "..."))
+
+            local continue = true
+
+            -- CHECK: no duplicate entries
+            for i = 1, #units do
+                local unit = units[i]   ---@type rtu_unit_registry_entry
+                if unit.reactor == io_reactor and unit.type == RTU_UNIT_TYPE.REDSTONE then
+                    -- duplicate entry
+                    local message = util.c("configure> skipping definition block #", entry_idx, " for reactor ", io_reactor,
+                        " with already defined redstone I/O")
+                    println(message)
+                    log.warning(message)
+                    continue = false
                     break
                 end
+            end
 
-                table.insert(capabilities, conf.channel)
+            -- not a duplicate
+            if continue then
+                for i = 1, #io_table do
+                    local valid = false
+                    local conf = io_table[i]
 
-                log.debug("init> linked redstone " .. #capabilities .. ": " .. rsio.to_string(conf.channel) .. " (" .. conf.side ..
-                    ") for reactor " .. io_reactor)
+                    -- verify configuration
+                    if rsio.is_valid_port(conf.port) and rsio.is_valid_side(conf.side) then
+                        if conf.bundled_color then
+                            valid = rsio.is_color(conf.bundled_color)
+                        else
+                            valid = true
+                        end
+                    end
+
+                    if not valid then
+                        local message = util.c("configure> invalid redstone definition at index ", i, " in definition block #", entry_idx,
+                            " (for reactor ", io_reactor, ")")
+                        println(message)
+                        log.fatal(message)
+                        return false
+                    else
+                        -- link redstone in RTU
+                        local mode = rsio.get_io_mode(conf.port)
+                        if mode == rsio.IO_MODE.DIGITAL_IN then
+                            -- can't have duplicate inputs
+                            if util.table_contains(capabilities, conf.port) then
+                                local message = util.c("configure> skipping duplicate input for port ", rsio.to_string(conf.port), " on side ", conf.side)
+                                println(message)
+                                log.warning(message)
+                            else
+                                rs_rtu.link_di(conf.side, conf.bundled_color)
+                            end
+                        elseif mode == rsio.IO_MODE.DIGITAL_OUT then
+                            rs_rtu.link_do(conf.side, conf.bundled_color)
+                        elseif mode == rsio.IO_MODE.ANALOG_IN then
+                            -- can't have duplicate inputs
+                            if util.table_contains(capabilities, conf.port) then
+                                local message = util.c("configure> skipping duplicate input for port ", rsio.to_string(conf.port), " on side ", conf.side)
+                                println(message)
+                                log.warning(message)
+                            else
+                                rs_rtu.link_ai(conf.side)
+                            end
+                        elseif mode == rsio.IO_MODE.ANALOG_OUT then
+                            rs_rtu.link_ao(conf.side)
+                        else
+                            -- should be unreachable code, we already validated ports
+                            log.error("configure> fell through if chain attempting to identify IO mode", true)
+                            println("configure> encountered a software error, check logs")
+                            return false
+                        end
+
+                        table.insert(capabilities, conf.port)
+
+                        log.debug(util.c("configure> linked redstone ", #capabilities, ": ", rsio.to_string(conf.port),
+                            " (", conf.side, ") for reactor ", io_reactor))
+                    end
+                end
+
+                ---@class rtu_unit_registry_entry
+                local unit = {
+                    uid = 0,                        ---@type integer
+                    name = "redstone_io",           ---@type string
+                    type = RTU_UNIT_TYPE.REDSTONE,  ---@type RTU_UNIT_TYPE
+                    index = entry_idx,              ---@type integer
+                    reactor = io_reactor,           ---@type integer
+                    device = capabilities,          ---@type table use device field for redstone ports
+                    is_multiblock = false,          ---@type boolean
+                    formed = nil,                   ---@type boolean|nil
+                    rtu = rs_rtu,                   ---@type rtu_device|rtu_rs_device
+                    modbus_io = modbus.new(rs_rtu, false),
+                    pkt_queue = nil,                ---@type mqueue|nil
+                    thread = nil                    ---@type parallel_thread|nil
+                }
+
+                table.insert(units, unit)
+
+                local for_message = "facility"
+                if io_reactor > 0 then
+                    for_message = util.c("reactor ", io_reactor)
+                end
+
+                log.info(util.c("configure> initialized RTU unit #", #units, ": redstone_io (redstone) [1] for ", for_message))
+
+                unit.uid = #units
             end
         end
 
-        ---@class rtu_unit_registry_entry
-        local unit = {
-            name = "redstone_io",
-            type = rtu_t.redstone,
-            index = entry_idx,
-            reactor = io_reactor,
-            device = capabilities,  -- use device field for redstone channels
-            rtu = rs_rtu,
-            modbus_io = modbus.new(rs_rtu, false),
-            pkt_queue = nil,
-            thread = nil
-        }
+        -- mounted peripherals
+        for i = 1, #rtu_devices do
+            local name = rtu_devices[i].name
+            local index = rtu_devices[i].index
+            local for_reactor = rtu_devices[i].for_reactor
 
-        table.insert(units, unit)
+            -- CHECK: name is a string
+            if type(name) ~= "string" then
+                local message = util.c("configure> device entry #", i, ": device ", name, " isn't a string")
+                println(message)
+                log.fatal(message)
+                return false
+            end
 
-        log.debug("init> initialized RTU unit #" .. #units .. ": redstone_io (redstone) [1] for reactor " .. io_reactor)
-    end
-end
+            -- CHECK: index is an integer >= 1
+            if (not util.is_int(index)) or (index <= 0) then
+                local message = util.c("configure> device entry #", i, ": index ", index, " isn't an integer >= 1")
+                println(message)
+                log.fatal(message)
+                return false
+            end
 
--- mounted peripherals
-for i = 1, #rtu_devices do
-    local device = ppm.get_periph(rtu_devices[i].name)
+            -- CHECK: reactor is an integer >= 0
+            if (not util.is_int(for_reactor)) or (for_reactor < 0) then
+                local message = util.c("configure> device entry #", i, ": reactor ", for_reactor, " isn't an integer >= 0")
+                println(message)
+                log.fatal(message)
+                return false
+            end
 
-    if device == nil then
-        local message = "init> '" .. rtu_devices[i].name .. "' not found"
-        println_ts(message)
-        log.warning(message)
-    else
-        local type = ppm.get_type(rtu_devices[i].name)
-        local rtu_iface = nil   ---@type rtu_device
-        local rtu_type = ""
+            local device = ppm.get_periph(name)
 
-        if type == "boiler" then
-            -- boiler multiblock
-            rtu_type = rtu_t.boiler
-            rtu_iface = boiler_rtu.new(device)
-        elseif type == "boilerValve" then
-            -- boiler multiblock (10.1+)
-            rtu_type = rtu_t.boiler_valve
-            rtu_iface = boilerv_rtu.new(device)
-        elseif type == "turbine" then
-            -- turbine multiblock
-            rtu_type = rtu_t.turbine
-            rtu_iface = turbine_rtu.new(device)
-        elseif type == "turbineValve" then
-            -- turbine multiblock (10.1+)
-            rtu_type = rtu_t.turbine_valve
-            rtu_iface = turbinev_rtu.new(device)
-        elseif type == "mekanismMachine" then
-            -- assumed to be an induction matrix multiblock, pre Mekanism 10.1
-            -- also works with energy cubes
-            rtu_type = rtu_t.energy_machine
-            rtu_iface = energymachine_rtu.new(device)
-        elseif type == "inductionPort" then
-            -- induction matrix multiblock (10.1+)
-            rtu_type = rtu_t.induction_matrix
-            rtu_iface = imatrix_rtu.new(device)
-        else
-            local message = "init> device '" .. rtu_devices[i].name .. "' is not a known type (" .. type .. ")"
-            println_ts(message)
-            log.warning(message)
-        end
+            local type = nil            ---@type string|nil
+            local rtu_iface = nil       ---@type rtu_device
+            local rtu_type = nil        ---@type RTU_UNIT_TYPE
+            local is_multiblock = false
+            local formed = nil          ---@type boolean|nil
+
+            if device == nil then
+                local message = util.c("configure> '", name, "' not found, using placeholder")
+                println(message)
+                log.warning(message)
+
+                -- mount a virtual (placeholder) device
+                type, device = ppm.mount_virtual()
+            else
+                type = ppm.get_type(name)
+            end
+
+            if type == "boilerValve" then
+                -- boiler multiblock
+                rtu_type = RTU_UNIT_TYPE.BOILER_VALVE
+                rtu_iface = boilerv_rtu.new(device)
+                is_multiblock = true
+                formed = device.isFormed()
+
+                if formed == ppm.UNDEFINED_FIELD or formed == ppm.ACCESS_FAULT then
+                    println_ts(util.c("configure> failed to check if  '", name, "' is formed"))
+                    log.fatal(util.c("configure> failed to check if  '", name, "' is a formed boiler multiblock"))
+                    return false
+                end
+            elseif type == "turbineValve" then
+                -- turbine multiblock
+                rtu_type = RTU_UNIT_TYPE.TURBINE_VALVE
+                rtu_iface = turbinev_rtu.new(device)
+                is_multiblock = true
+                formed = device.isFormed()
+
+                if formed == ppm.UNDEFINED_FIELD or formed == ppm.ACCESS_FAULT then
+                    println_ts(util.c("configure> failed to check if  '", name, "' is formed"))
+                    log.fatal(util.c("configure> failed to check if  '", name, "' is a formed turbine multiblock"))
+                    return false
+                end
+            elseif type == "inductionPort" then
+                -- induction matrix multiblock
+                rtu_type = RTU_UNIT_TYPE.IMATRIX
+                rtu_iface = imatrix_rtu.new(device)
+                is_multiblock = true
+                formed = device.isFormed()
+
+                if formed == ppm.UNDEFINED_FIELD or formed == ppm.ACCESS_FAULT then
+                    println_ts(util.c("configure> failed to check if  '", name, "' is formed"))
+                    log.fatal(util.c("configure> failed to check if  '", name, "' is a formed induction matrix multiblock"))
+                    return false
+                end
+            elseif type == "spsPort" then
+                -- SPS multiblock
+                rtu_type = RTU_UNIT_TYPE.SPS
+                rtu_iface = sps_rtu.new(device)
+                is_multiblock = true
+                formed = device.isFormed()
+
+                if formed == ppm.UNDEFINED_FIELD or formed == ppm.ACCESS_FAULT then
+                    println_ts(util.c("configure> failed to check if  '", name, "' is formed"))
+                    log.fatal(util.c("configure> failed to check if  '", name, "' is a formed SPS multiblock"))
+                    return false
+                end
+            elseif type == "solarNeutronActivator" then
+                -- SNA
+                rtu_type = RTU_UNIT_TYPE.SNA
+                rtu_iface = sna_rtu.new(device)
+            elseif type == "environmentDetector" then
+                -- advanced peripherals environment detector
+                rtu_type = RTU_UNIT_TYPE.ENV_DETECTOR
+                rtu_iface = envd_rtu.new(device)
+            elseif type == ppm.VIRTUAL_DEVICE_TYPE then
+                -- placeholder device
+                rtu_type = RTU_UNIT_TYPE.VIRTUAL
+                rtu_iface = rtu.init_unit().interface()
+            else
+                local message = util.c("configure> device '", name, "' is not a known type (", type, ")")
+                println_ts(message)
+                log.fatal(message)
+                return false
+            end
 
-        if rtu_iface ~= nil then
             ---@class rtu_unit_registry_entry
             local rtu_unit = {
-                name = rtu_devices[i].name,
-                type = rtu_type,
-                index = rtu_devices[i].index,
-                reactor = rtu_devices[i].for_reactor,
-                device = device,
-                rtu = rtu_iface,
+                uid = 0,                                ---@type integer
+                name = name,                            ---@type string
+                type = rtu_type,                        ---@type RTU_UNIT_TYPE
+                index = index,                          ---@type integer
+                reactor = for_reactor,                  ---@type integer
+                device = device,                        ---@type table
+                is_multiblock = is_multiblock,          ---@type boolean
+                formed = formed,                        ---@type boolean|nil
+                rtu = rtu_iface,                        ---@type rtu_device|rtu_rs_device
                 modbus_io = modbus.new(rtu_iface, true),
-                pkt_queue = mqueue.new(),
-                thread = nil
+                pkt_queue = mqueue.new(),               ---@type mqueue|nil
+                thread = nil                            ---@type parallel_thread|nil
             }
 
             rtu_unit.thread = threads.thread__unit_comms(__shared_memory, rtu_unit)
 
             table.insert(units, rtu_unit)
 
-            log.debug("init> initialized RTU unit #" .. #units .. ": " .. rtu_devices[i].name .. " (" .. rtu_type .. ") [" ..
-                rtu_devices[i].index .. "] for reactor " .. rtu_devices[i].for_reactor)
+            if is_multiblock and not formed then
+                log.info(util.c("configure> device '", name, "' is not formed"))
+            end
+
+            local for_message = "facility"
+            if for_reactor > 0 then
+                for_message = util.c("reactor ", for_reactor)
+            end
+
+            log.info(util.c("configure> initialized RTU unit #", #units, ": ", name, " (", types.rtu_type_to_string(rtu_type), ") [", index, "] for ", for_message))
+
+            rtu_unit.uid = #units
         end
+
+        -- we made it through all that trusting-user-to-write-a-config-file chaos
+        return true
     end
+
+    ----------------------------------------
+    -- start system
+    ----------------------------------------
+
+    log.debug("boot> running configure()")
+
+    if configure() then
+        -- start connection watchdog
+        smem_sys.conn_watchdog = util.new_watchdog(config.COMMS_TIMEOUT)
+        log.debug("startup> conn watchdog started")
+
+        -- setup comms
+        smem_sys.rtu_comms = rtu.comms(RTU_VERSION, smem_dev.modem, config.LISTEN_PORT, config.SERVER_PORT,
+                                        config.TRUSTED_RANGE, smem_sys.conn_watchdog)
+        log.debug("startup> comms init")
+
+        -- init threads
+        local main_thread  = threads.thread__main(__shared_memory)
+        local comms_thread = threads.thread__comms(__shared_memory)
+
+        -- assemble thread list
+        local _threads = { main_thread.p_exec, comms_thread.p_exec }
+        for i = 1, #units do
+            if units[i].thread ~= nil then
+                table.insert(_threads, units[i].thread.p_exec)
+            end
+        end
+
+        log.info("startup> completed")
+
+        -- run threads
+        parallel.waitForAll(table.unpack(_threads))
+    else
+        println("configuration failed, exiting...")
+    end
+
+    println_ts("exited")
+    log.info("exited")
 end
 
-----------------------------------------
--- start system
-----------------------------------------
-
--- start connection watchdog
-smem_sys.conn_watchdog = util.new_watchdog(5)
-log.debug("boot> conn watchdog started")
-
--- setup comms
-smem_sys.rtu_comms = rtu.comms(RTU_VERSION, smem_dev.modem, config.LISTEN_PORT, config.SERVER_PORT, smem_sys.conn_watchdog)
-log.debug("boot> comms init")
-
--- init threads
-local main_thread  = threads.thread__main(__shared_memory)
-local comms_thread = threads.thread__comms(__shared_memory)
-
--- assemble thread list
-local _threads = { main_thread.p_exec, comms_thread.p_exec }
-for i = 1, #units do
-    if units[i].thread ~= nil then
-        table.insert(_threads, units[i].thread.p_exec)
-    end
-end
-
--- run threads
-parallel.waitForAll(table.unpack(_threads))
-
-println_ts("exited")
-log.info("exited")
+if not xpcall(main, crash.handler) then crash.exit() end

rtu/threads.lua

@@ -1,21 +1,21 @@
-local log = require("scada-common.log")
-local mqueue = require("scada-common.mqueue")
-local ppm = require("scada-common.ppm")
-local types = require("scada-common.types")
-local util = require("scada-common.util")
+local log          = require("scada-common.log")
+local mqueue       = require("scada-common.mqueue")
+local ppm          = require("scada-common.ppm")
+local types        = require("scada-common.types")
+local util         = require("scada-common.util")
 
-local boiler_rtu = require("rtu.dev.boiler_rtu")
-local boilerv_rtu = require("rtu.dev.boilerv_rtu")
-local energymachine_rtu = require("rtu.dev.energymachine_rtu")
-local imatrix_rtu = require("rtu.dev.imatrix_rtu")
-local turbine_rtu = require("rtu.dev.turbine_rtu")
+local boilerv_rtu  = require("rtu.dev.boilerv_rtu")
+local envd_rtu     = require("rtu.dev.envd_rtu")
+local imatrix_rtu  = require("rtu.dev.imatrix_rtu")
+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 modbus = require("rtu.modbus")
+local modbus       = require("rtu.modbus")
 
 local threads = {}
 
-local rtu_t = types.rtu_t
+local RTU_UNIT_TYPE = types.RTU_UNIT_TYPE
 
 local print = util.print
 local println = util.println
@@ -26,12 +26,14 @@ local MAIN_CLOCK  = 2   -- (2Hz, 40 ticks)
 local COMMS_SLEEP = 100 -- (100ms, 2 ticks)
 
 -- main thread
+---@nodiscard
 ---@param smem rtu_shared_memory
-threads.thread__main = function (smem)
-    local public = {}   ---@class thread
+function threads.thread__main(smem)
+    ---@class parallel_thread
+    local public = {}
 
     -- execute thread
-    public.exec = function ()
+    function public.exec()
         log.debug("main thread start")
 
         -- main loop clock
@@ -44,22 +46,24 @@ threads.thread__main = function (smem)
         local conn_watchdog = smem.rtu_sys.conn_watchdog
         local units         = smem.rtu_sys.units
 
+        -- start unlinked (in case of restart)
+        rtu_comms.unlink(rtu_state)
+
         -- start clock
         loop_clock.start()
 
         -- event loop
         while true do
----@diagnostic disable-next-line: undefined-field
-            local event, param1, param2, param3, param4, param5 = os.pullEventRaw()
+            local event, param1, param2, param3, param4, param5 = util.pull_event()
 
             if event == "timer" and loop_clock.is_clock(param1) then
                 -- start next clock timer
                 loop_clock.start()
 
-                -- period tick, if we are not linked send advertisement
+                -- period tick, if we are not linked send establish request
                 if not rtu_state.linked then
                     -- advertise units
-                    rtu_comms.send_advertisement(units)
+                    rtu_comms.send_establish(units)
                 end
             elseif event == "modem_message" then
                 -- got a packet
@@ -91,7 +95,10 @@ threads.thread__main = function (smem)
                                 -- we are going to let the PPM prevent crashes
                                 -- return fault flags/codes to MODBUS queries
                                 local unit = units[i]
-                                println_ts("lost the " .. unit.type .. " on interface " .. unit.name)
+                                local type_name = types.rtu_type_to_string(unit.type)
+                                println_ts(util.c("lost the ", type_name, " on interface ", unit.name))
+                                log.warning(util.c("lost the ", type_name, " unit peripheral on interface ", unit.name))
+                                break
                             end
                         end
                     end
@@ -108,9 +115,9 @@ threads.thread__main = function (smem)
                             rtu_comms.reconnect_modem(rtu_dev.modem)
 
                             println_ts("wireless modem reconnected.")
-                            log.info("comms modem reconnected.")
+                            log.info("comms modem reconnected")
                         else
-                            log.info("wired modem reconnected.")
+                            log.info("wired modem reconnected")
                         end
                     else
                         -- relink lost peripheral to correct unit entry
@@ -118,27 +125,79 @@ threads.thread__main = function (smem)
                             local unit = units[i]   ---@type rtu_unit_registry_entry
 
                             -- find disconnected device to reconnect
+                            -- note: cannot check isFormed as that would yield this coroutine and consume events
                             if unit.name == param1 then
+                                local resend_advert = false
+
                                 -- found, re-link
                                 unit.device = device
 
-                                if unit.type == rtu_t.boiler then
-                                    unit.rtu = boiler_rtu.new(device)
-                                elseif unit.type == rtu_t.boiler_valve then
+                                if unit.type == RTU_UNIT_TYPE.VIRTUAL then
+                                    resend_advert = true
+                                    if type == "boilerValve" then
+                                        -- boiler multiblock
+                                        unit.type = RTU_UNIT_TYPE.BOILER_VALVE
+                                    elseif type == "turbineValve" then
+                                        -- turbine multiblock
+                                        unit.type = RTU_UNIT_TYPE.TURBINE_VALVE
+                                    elseif type == "inductionPort" then
+                                        -- induction matrix multiblock
+                                        unit.type = RTU_UNIT_TYPE.IMATRIX
+                                    elseif type == "spsPort" then
+                                        -- SPS multiblock
+                                        unit.type = RTU_UNIT_TYPE.SPS
+                                    elseif type == "solarNeutronActivator" then
+                                        -- SNA
+                                        unit.type = RTU_UNIT_TYPE.SNA
+                                    elseif type == "environmentDetector" then
+                                        -- advanced peripherals environment detector
+                                        unit.type = RTU_UNIT_TYPE.ENV_DETECTOR
+                                    else
+                                        resend_advert = false
+                                        log.error(util.c("virtual device '", unit.name, "' cannot init to an unknown type (", type, ")"))
+                                    end
+                                end
+
+                                if unit.type == RTU_UNIT_TYPE.BOILER_VALVE then
                                     unit.rtu = boilerv_rtu.new(device)
-                                elseif unit.type == rtu_t.turbine then
-                                    unit.rtu = turbine_rtu.new(device)
-                                elseif unit.type == rtu_t.turbine_valve then
+                                     -- if not formed, indexing the multiblock functions would have resulted in a PPM fault
+                                    unit.formed = util.trinary(device.__p_is_faulted(), false, nil)
+                                elseif unit.type == RTU_UNIT_TYPE.TURBINE_VALVE then
                                     unit.rtu = turbinev_rtu.new(device)
-                                elseif unit.type == rtu_t.energy_machine then
-                                    unit.rtu = energymachine_rtu.new(device)
-                                elseif unit.type == rtu_t.induction_matrix then
+                                     -- if not formed, indexing the multiblock functions would have resulted in a PPM fault
+                                    unit.formed = util.trinary(device.__p_is_faulted(), false, nil)
+                                elseif unit.type == RTU_UNIT_TYPE.IMATRIX then
                                     unit.rtu = imatrix_rtu.new(device)
+                                     -- if not formed, indexing the multiblock functions would have resulted in a PPM fault
+                                    unit.formed = util.trinary(device.__p_is_faulted(), false, nil)
+                                elseif unit.type == RTU_UNIT_TYPE.SPS then
+                                    unit.rtu = sps_rtu.new(device)
+                                     -- if not formed, indexing the multiblock functions would have resulted in a PPM fault
+                                    unit.formed = util.trinary(device.__p_is_faulted(), false, nil)
+                                elseif unit.type == RTU_UNIT_TYPE.SNA then
+                                    unit.rtu = sna_rtu.new(device)
+                                elseif unit.type == RTU_UNIT_TYPE.ENV_DETECTOR then
+                                    unit.rtu = envd_rtu.new(device)
+                                else
+                                    log.error(util.c("failed to identify reconnected RTU unit type (", unit.name, ")"), true)
+                                end
+
+                                if unit.is_multiblock and (unit.formed == false) then
+                                    log.info(util.c("assuming ", unit.name, " is not formed due to PPM faults while initializing"))
                                 end
 
                                 unit.modbus_io = modbus.new(unit.rtu, true)
 
-                                println_ts("reconnected the " .. unit.type .. " on interface " .. unit.name)
+                                local type_name = types.rtu_type_to_string(unit.type)
+                                local message = util.c("reconnected the ", type_name, " on interface ", unit.name)
+                                println_ts(message)
+                                log.info(message)
+
+                                if resend_advert then
+                                    rtu_comms.send_advertisement(units)
+                                else
+                                     rtu_comms.send_remounted(unit.uid)
+                                end
                             end
                         end
                     end
@@ -155,13 +214,13 @@ threads.thread__main = function (smem)
     end
 
     -- execute the thread in a protected mode, retrying it on return if not shutting down
-    public.p_exec = function ()
+    function public.p_exec()
         local rtu_state = smem.rtu_state
 
         while not rtu_state.shutdown do
             local status, result = pcall(public.exec)
             if status == false then
-                log.fatal(result)
+                log.fatal(util.strval(result))
             end
 
             if not rtu_state.shutdown then
@@ -175,22 +234,24 @@ threads.thread__main = function (smem)
 end
 
 -- communications handler thread
+---@nodiscard
 ---@param smem rtu_shared_memory
-threads.thread__comms = function (smem)
-    local public = {}   ---@class thread
+function threads.thread__comms(smem)
+    ---@class parallel_thread
+    local public = {}
 
     -- execute thread
-    public.exec = function ()
+    function public.exec()
         log.debug("comms thread start")
 
         -- load in from shared memory
-        local rtu_state     = smem.rtu_state
-        local rtu_comms     = smem.rtu_sys.rtu_comms
-        local units         = smem.rtu_sys.units
+        local rtu_state   = smem.rtu_state
+        local rtu_comms   = smem.rtu_sys.rtu_comms
+        local units       = smem.rtu_sys.units
 
-        local comms_queue   = smem.q.mq_comms
+        local comms_queue = smem.q.mq_comms
 
-        local last_update   = util.time()
+        local last_update = util.time()
 
         -- thread loop
         while true do
@@ -227,13 +288,13 @@ threads.thread__comms = function (smem)
     end
 
     -- execute the thread in a protected mode, retrying it on return if not shutting down
-    public.p_exec = function ()
+    function public.p_exec()
         local rtu_state = smem.rtu_state
 
         while not rtu_state.shutdown do
             local status, result = pcall(public.exec)
             if status == false then
-                log.fatal(result)
+                log.fatal(util.strval(result))
             end
 
             if not rtu_state.shutdown then
@@ -247,14 +308,16 @@ threads.thread__comms = function (smem)
 end
 
 -- per-unit communications handler thread
+---@nodiscard
 ---@param smem rtu_shared_memory
 ---@param unit rtu_unit_registry_entry
-threads.thread__unit_comms = function (smem, unit)
-    local public = {}   ---@class thread
+function threads.thread__unit_comms(smem, unit)
+    ---@class parallel_thread
+    local public = {}
 
     -- execute thread
-    public.exec = function ()
-        log.debug("rtu unit thread start -> " .. unit.name .. "(" .. unit.type .. ")")
+    function public.exec()
+        log.debug(util.c("rtu unit thread start -> ", types.rtu_type_to_string(unit.type), "(", unit.name, ")"))
 
         -- load in from shared memory
         local rtu_state    = smem.rtu_state
@@ -263,6 +326,16 @@ threads.thread__unit_comms = function (smem, unit)
 
         local last_update  = util.time()
 
+        local last_f_check = 0
+
+        local detail_name  = util.c(types.rtu_type_to_string(unit.type), " (", unit.name, ") [", unit.index, "] for reactor ", unit.reactor)
+        local short_name   = util.c(types.rtu_type_to_string(unit.type), " (", unit.name, ")")
+
+        if packet_queue == nil then
+            log.error("rtu unit thread created without a message queue, exiting...", true)
+            return
+        end
+
         -- thread loop
         while true do
             -- check for messages in the message queue
@@ -285,9 +358,71 @@ threads.thread__unit_comms = function (smem, unit)
                 util.nop()
             end
 
+            -- check if multiblock is still formed if this is a multiblock
+            if unit.is_multiblock and (util.time_ms() - last_f_check > 250) then
+                local is_formed = unit.device.isFormed()
+
+                last_f_check = util.time_ms()
+
+                if unit.formed == nil then unit.formed = is_formed end
+
+                if (not unit.formed) and is_formed then
+                    -- newly re-formed
+                    local iface = ppm.get_iface(unit.device)
+                    if iface then
+                        log.info(util.c("unmounting and remounting reformed RTU unit ", detail_name))
+
+                        ppm.unmount(unit.device)
+
+                        local type, device = ppm.mount(iface)
+
+                        if device ~= nil then
+                            if type == "boilerValve" and unit.type == RTU_UNIT_TYPE.BOILER_VALVE then
+                                -- boiler multiblock
+                                unit.device = device
+                                unit.rtu = boilerv_rtu.new(device)
+                                unit.formed = device.isFormed()
+                                unit.modbus_io = modbus.new(unit.rtu, true)
+                            elseif type == "turbineValve" and unit.type == RTU_UNIT_TYPE.TURBINE_VALVE then
+                                -- turbine multiblock
+                                unit.device = device
+                                unit.rtu = turbinev_rtu.new(device)
+                                unit.formed = device.isFormed()
+                                unit.modbus_io = modbus.new(unit.rtu, true)
+                            elseif type == "inductionPort" and unit.type == RTU_UNIT_TYPE.IMATRIX then
+                                -- induction matrix multiblock
+                                unit.device = device
+                                unit.rtu = imatrix_rtu.new(device)
+                                unit.formed = device.isFormed()
+                                unit.modbus_io = modbus.new(unit.rtu, true)
+                            elseif type == "spsPort" and unit.type == RTU_UNIT_TYPE.SPS then
+                                -- SPS multiblock
+                                unit.device = device
+                                unit.rtu = sps_rtu.new(device)
+                                unit.formed = device.isFormed()
+                                unit.modbus_io = modbus.new(unit.rtu, true)
+                            else
+                                log.error("illegal remount of non-multiblock RTU attempted for " .. short_name, true)
+                            end
+
+                            rtu_comms.send_remounted(unit.uid)
+                        else
+                            -- fully lost the peripheral now :(
+                            log.error(util.c(unit.name, " lost (failed reconnect)"))
+                        end
+
+                        log.info(util.c("reconnected the ", unit.type, " on interface ", unit.name))
+                    else
+                        log.error("failed to get interface of previously connected RTU unit " .. detail_name, true)
+                    end
+                end
+
+                unit.formed = is_formed
+            end
+
             -- check for termination request
             if rtu_state.shutdown then
-                log.info("rtu unit thread exiting -> " .. unit.name .. "(" .. unit.type .. ")")
+                log.info("rtu unit thread exiting -> " .. short_name)
                 break
             end
 
@@ -297,17 +432,17 @@ threads.thread__unit_comms = function (smem, unit)
     end
 
     -- execute the thread in a protected mode, retrying it on return if not shutting down
-    public.p_exec = function ()
+    function public.p_exec()
         local rtu_state = smem.rtu_state
 
         while not rtu_state.shutdown do
             local status, result = pcall(public.exec)
             if status == false then
-                log.fatal(result)
+                log.fatal(util.strval(result))
             end
 
             if not rtu_state.shutdown then
-                log.info("rtu unit thread " .. unit.name .. "(" .. unit.type .. ") restarting in 5 seconds...")
+                log.info(util.c("rtu unit thread ", types.rtu_type_to_string(unit.type), "(", unit.name, " restarting in 5 seconds..."))
                 util.psleep(5)
             end
         end