cc-mek-scada/rtu/rtu.lua

local audio   = require("scada-common.audio")
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 databus = require("rtu.databus")
local modbus  = require("rtu.modbus")

local rtu = {}

local PROTOCOL = comms.PROTOCOL
local DEVICE_TYPE = comms.DEVICE_TYPE
local ESTABLISH_ACK = comms.ESTABLISH_ACK
local MGMT_TYPE = comms.MGMT_TYPE
local RTU_UNIT_TYPE = types.RTU_UNIT_TYPE

---@type rtu_config
local config = {}

rtu.config = config

-- load the RTU configuration
function rtu.load_config()
    if not settings.load("/rtu.settings") then return false end

    config.Peripherals = settings.get("Peripherals")
    config.Redstone = settings.get("Redstone")

    config.SpeakerVolume = settings.get("SpeakerVolume")

    config.SVR_Channel = settings.get("SVR_Channel")
    config.RTU_Channel = settings.get("RTU_Channel")
    config.ConnTimeout = settings.get("ConnTimeout")
    config.TrustedRange = settings.get("TrustedRange")
    config.AuthKey = settings.get("AuthKey")

    config.LogMode = settings.get("LogMode")
    config.LogPath = settings.get("LogPath")
    config.LogDebug = settings.get("LogDebug")

    config.FrontPanelTheme = settings.get("FrontPanelTheme")
    config.ColorMode = settings.get("ColorMode")

    local cfv = util.new_validator()

    cfv.assert_type_num(config.SpeakerVolume)
    cfv.assert_range(config.SpeakerVolume, 0, 3)

    cfv.assert_channel(config.SVR_Channel)
    cfv.assert_channel(config.RTU_Channel)
    cfv.assert_type_num(config.ConnTimeout)
    cfv.assert_min(config.ConnTimeout, 2)
    cfv.assert_type_num(config.TrustedRange)
    cfv.assert_min(config.TrustedRange, 0)
    cfv.assert_type_str(config.AuthKey)

    if type(config.AuthKey) == "string" then
        local len = string.len(config.AuthKey)
        cfv.assert_eq(len == 0 or len >= 8, true)
    end

    cfv.assert_type_int(config.LogMode)
    cfv.assert_range(config.LogMode, 0, 1)
    cfv.assert_type_str(config.LogPath)
    cfv.assert_type_bool(config.LogDebug)

    cfv.assert_type_int(config.FrontPanelTheme)
    cfv.assert_range(config.FrontPanelTheme, 1, 2)
    cfv.assert_type_int(config.ColorMode)
    cfv.assert_range(config.ColorMode, 1, 4)

    cfv.assert_type_table(config.Peripherals)
    cfv.assert_type_table(config.Redstone)

    return cfv.valid()
end

-- create a new RTU unit<br>
-- if this is for a PPM peripheral, auto fault clearing MUST stay enabled once access begins
---@nodiscard
---@param device table|nil peripheral device, if applicable
function rtu.init_unit(device)
    local self = {
        discrete_inputs = {},
        coils = {},
        input_regs = {},
        holding_regs = {},
        io_count_cache = { 0, 0, 0, 0 }
    }

    local insert = table.insert

    ---@class rtu_device
    local public = {}

    ---@class rtu
    local protected = {}

    -- function to check if the peripheral (if exists) is faulted
    local function _is_faulted() return false end
    if device then _is_faulted = device.__p_is_faulted end

    -- refresh IO count
    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
    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

    -- discrete inputs: single bit read-only

    -- connect discrete input
    ---@param f function
    ---@return integer count count of discrete inputs
    function protected.connect_di(f)
        insert(self.discrete_inputs, { read = f })
        _count_io()
        return #self.discrete_inputs
    end

    -- read discrete input
    ---@param di_addr integer
    ---@return any value, boolean access_fault
    function public.read_di(di_addr)
        local value = self.discrete_inputs[di_addr].read()
        return value, _is_faulted()
    end

    -- coils: single bit read-write

    -- connect coil
    ---@param f_read function
    ---@param f_write function
    ---@return integer count count of coils
    function protected.connect_coil(f_read, f_write)
        insert(self.coils, { read = f_read, write = f_write })
        _count_io()
        return #self.coils
    end

    -- read coil
    ---@param coil_addr integer
    ---@return any value, boolean access_fault
    function public.read_coil(coil_addr)
        local value = self.coils[coil_addr].read()
        return value, _is_faulted()
    end

    -- write coil
    ---@param coil_addr integer
    ---@param value any
    ---@return boolean access_fault
    function public.write_coil(coil_addr, value)
        self.coils[coil_addr].write(value)
        return _is_faulted()
    end

    -- input registers: multi-bit read-only

    -- connect input register
    ---@param f function
    ---@return integer count count of input registers
    function protected.connect_input_reg(f)
        insert(self.input_regs, { read = f })
        _count_io()
        return #self.input_regs
    end

    -- read input register
    ---@param reg_addr integer
    ---@return any value, boolean access_fault
    function public.read_input_reg(reg_addr)
        local value = self.input_regs[reg_addr].read()
        return value, _is_faulted()
    end

    -- holding registers: multi-bit read-write

    -- connect holding register
    ---@param f_read function
    ---@param f_write function
    ---@return integer count count of holding registers
    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
    end

    -- read holding register
    ---@param reg_addr integer
    ---@return any value, boolean access_fault
    function public.read_holding_reg(reg_addr)
        local value = self.holding_regs[reg_addr].read()
        return value, _is_faulted()
    end

    -- write holding register
    ---@param reg_addr integer
    ---@param value any
    ---@return boolean access_fault
    function public.write_holding_reg(reg_addr, value)
        self.holding_regs[reg_addr].write(value)
        return _is_faulted()
    end

    -- public RTU device access

    -- get the public interface to this RTU
    function protected.interface() return public end

    return protected
end

-- create an alarm speaker sounder
---@param speaker table device peripheral
function rtu.init_sounder(speaker)
    ---@class rtu_speaker_sounder
    local spkr_ctl = {
        speaker = speaker,
        name = ppm.get_iface(speaker),
        playing = false,
        stream = audio.new_stream(),
        play = function () end,
        stop = function () end,
        continue = function () end
    }

    -- continue audio stream if playing
    function spkr_ctl.continue()
        if spkr_ctl.playing then
            if spkr_ctl.speaker ~= nil and spkr_ctl.stream.has_next_block() then
                local success = spkr_ctl.speaker.playAudio(spkr_ctl.stream.get_next_block(), config.SpeakerVolume)
                if not success then log.error(util.c("rtu_sounder(", spkr_ctl.name, "): error playing audio")) end
            end
        end
    end

    -- start audio stream playback
    function spkr_ctl.play()
        if not spkr_ctl.playing then
            spkr_ctl.playing = true
            return spkr_ctl.continue()
        end
    end

    -- stop audio stream playback
    function spkr_ctl.stop()
        spkr_ctl.playing = false
        spkr_ctl.speaker.stop()
        spkr_ctl.stream.stop()
    end

    return spkr_ctl
end

-- RTU Communications
---@nodiscard
---@param version string RTU version
---@param nic nic network interface device
---@param conn_watchdog watchdog watchdog reference
function rtu.comms(version, nic, conn_watchdog)
    local self = {
        sv_addr = comms.BROADCAST,
        seq_num = 0,
        r_seq_num = nil,
        txn_id = 0,
        last_est_ack = ESTABLISH_ACK.ALLOW
    }

    local insert = table.insert

    comms.set_trusted_range(config.TrustedRange)

    -- PRIVATE FUNCTIONS --

    -- configure modem channels
    nic.closeAll()
    nic.open(config.RTU_Channel)

    -- send a scada management packet
    ---@param msg_type MGMT_TYPE
    ---@param msg table
    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.sv_addr, self.seq_num, PROTOCOL.SCADA_MGMT, m_pkt.raw_sendable())

        nic.transmit(config.SVR_Channel, config.RTU_Channel, s_pkt)
        self.seq_num = self.seq_num + 1
    end

    -- keep alive ack
    ---@param srv_time integer
    local function _send_keep_alive_ack(srv_time)
        _send(MGMT_TYPE.KEEP_ALIVE, { srv_time, util.time() })
    end

    -- generate device advertisement table
    ---@nodiscard
    ---@param units table
    ---@return table advertisement
    local function _generate_advertisement(units)
        local advertisement = {}

        for i = 1, #units do
            local unit = units[i]   ---@type rtu_unit_registry_entry

            if unit.type ~= nil then
                local advert = { unit.type, unit.index, unit.reactor }

                if unit.type == RTU_UNIT_TYPE.REDSTONE then
                    insert(advert, unit.device)
                end

                insert(advertisement, advert)
            end
        end

        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.sv_addr, self.seq_num, PROTOCOL.MODBUS_TCP, m_pkt.raw_sendable())
        nic.transmit(config.SVR_Channel, config.RTU_Channel, s_pkt)
        self.seq_num = self.seq_num + 1
    end

    -- unlink from the server
    ---@param rtu_state rtu_state
    function public.unlink(rtu_state)
        rtu_state.linked = false
        self.sv_addr = comms.BROADCAST
        self.r_seq_num = nil
        databus.tx_link_state(types.PANEL_LINK_STATE.DISCONNECTED)
    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(MGMT_TYPE.CLOSE, {})
    end

    -- send establish request (includes advertisement)
    ---@param units table
    function public.send_establish(units)
        _send(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(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(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
    function public.parse_packet(side, sender, reply_to, message, distance)
        local s_pkt = nic.receive(side, sender, reply_to, message, distance)
        local pkt = nil

        if s_pkt then
            -- get as MODBUS TCP packet
            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() == PROTOCOL.SCADA_MGMT then
                local mgmt_pkt = comms.mgmt_packet()
                if mgmt_pkt.decode(s_pkt) then
                    pkt = mgmt_pkt.get()
                end
            else
                log.debug("illegal packet type " .. s_pkt.protocol(), true)
            end
        end

        return pkt
    end

    -- handle a MODBUS/SCADA packet
    ---@param packet modbus_frame|mgmt_frame
    ---@param units table RTU units
    ---@param rtu_state rtu_state
    ---@param sounders table speaker alarm sounders
    function public.handle_packet(packet, units, rtu_state, sounders)
        -- print a log message to the terminal as long as the UI isn't running
        local function println_ts(message) if not rtu_state.fp_ok then util.println_ts(message) end end

        local protocol = packet.scada_frame.protocol()
        local l_chan   = packet.scada_frame.local_channel()
        local src_addr = packet.scada_frame.src_addr()

        if l_chan == config.RTU_Channel then
            -- check sequence number
            if self.r_seq_num == nil then
                self.r_seq_num = packet.scada_frame.seq_num()
            elseif rtu_state.linked and ((self.r_seq_num + 1) ~= packet.scada_frame.seq_num()) then
                log.warning("sequence out-of-order: last = " .. self.r_seq_num .. ", new = " .. packet.scada_frame.seq_num())
                return
            elseif rtu_state.linked and (src_addr ~= self.sv_addr) then
                log.debug("received packet from unknown computer " .. src_addr .. " while linked (expected " .. self.sv_addr ..
                            "); channel in use by another system?")
                return
            else
                self.r_seq_num = packet.scada_frame.seq_num()
            end

            -- feed watchdog on valid sequence number
            conn_watchdog.feed()

            -- handle packet
            if protocol == PROTOCOL.MODBUS_TCP then
                ---@cast packet modbus_frame
                if rtu_state.linked then
                    local return_code   ---@type boolean
                    local reply         ---@type modbus_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 .. ")"

                        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
                        -- unit ID out of range?
                        reply = modbus.reply__gw_unavailable(packet)
                        log.debug("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 rtu_state.linked then
                    if packet.type == 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 == 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 == MGMT_TYPE.RTU_ADVERT then
                        -- request for capabilities again
                        public.send_advertisement(units)
                    elseif packet.type == MGMT_TYPE.RTU_TONE_ALARM then
                        -- alarm tone update from supervisor
                        if (packet.length == 1) and type(packet.data[1] == "table") and (#packet.data[1] == 8) then
                            local states = packet.data[1]

                            for i = 1, #sounders do
                                local s = sounders[i]   ---@type rtu_speaker_sounder

                                -- set tone states
                                for id = 1, #states do s.stream.set_active(id, states[id] == true) end
                            end
                        end
                    else
                        -- not supported
                        log.debug("received unsupported SCADA_MGMT message type " .. packet.type)
                    end
                elseif packet.type == 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.sv_addr = packet.scada_frame.src_addr()
                            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

                            public.unlink(rtu_state)
                        end

                        self.last_est_ack = est_ack

                        -- report link state
                        databus.tx_link_state(est_ack + 1)
                    else
                        log.debug("SCADA_MGMT establish packet length mismatch")
                    end
                else
                    log.debug("discarding non-link SCADA_MGMT packet before linked")
                end
            else
                -- should be unreachable assuming packet is from parse_packet()
                log.error("illegal packet type " .. protocol, true)
            end
        else
            log.debug("received packet on unconfigured channel " .. l_chan, true)
        end
    end

    return public
end

return rtu