cc-mek-scada/rtu/startup.lua

--
-- RTU: Remote Terminal Unit
--

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 config = require("rtu.config")
local modbus = require("rtu.modbus")
local rtu = require("rtu.rtu")
local threads = require("rtu.threads")

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 turbinev_rtu = require("rtu.dev.turbinev_rtu")

local RTU_VERSION = "alpha-v0.7.1"

local rtu_t = types.rtu_t

local print = util.print
local println = util.println
local print_ts = util.print_ts
local println_ts = util.println_ts

log.init(config.LOG_PATH, config.LOG_MODE)

log.info("========================================")
log.info("BOOTING rtu.startup " .. RTU_VERSION)
log.info("========================================")
println(">> RTU " .. RTU_VERSION .. " <<")

----------------------------------------
-- startup
----------------------------------------

-- mount connected devices
ppm.mount_all()

---@class rtu_shared_memory
local __shared_memory = {
    -- RTU system state flags
    ---@class rtu_state
    rtu_state = {
        linked = false,
        shutdown = false
    },

    -- core RTU devices
    rtu_dev = {
        modem = ppm.get_wireless_modem()
    },

    -- 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

-- 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
    end

    if continue then
        for i = 1, #io_table do
            local valid = false
            local conf = io_table[i]

            -- 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
            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)
                    break
                end

                table.insert(capabilities, conf.channel)

                log.debug("init> linked redstone " .. #capabilities .. ": " .. rsio.to_string(conf.channel) .. " (" .. conf.side ..
                    ") for reactor " .. io_reactor)
            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
        }

        table.insert(units, unit)

        log.debug("init> initialized RTU unit #" .. #units .. ": redstone_io (redstone) [1] for reactor " .. io_reactor)
    end
end

-- mounted peripherals
for i = 1, #rtu_devices do
    local device = ppm.get_periph(rtu_devices[i].name)

    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 = ""

        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

        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,
                modbus_io = modbus.new(rtu_iface, true),
                pkt_queue = mqueue.new(),
                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)
        end
    end
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")