GitHub/cc-scada
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

work on PLC comms

Browse Source
This commit is contained in:
Mikayla Fischler
2022-01-22 14:26:25 -05:00
parent c6722c4cbe
commit ffca88845b
3 changed files with 277 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

235
scada-common/comms.lua
View File

@@ -5,16 +5,47 @@ PROTOCOLS = {
COORD_DATA = 3 -- data packets for coordinators to/from supervisory controller
}
RPLC_TYPES = {
KEEP_ALIVE = 0, -- keep alive packets
LINK_REQ = 1, -- linking requests
STATUS = 2, -- reactor/system status
MEK_STRUCT = 3, -- mekanism build structure
RS_IO_CONNS = 4, -- redstone I/O connections
RS_IO_SET = 5, -- set redstone outputs
RS_IO_GET = 6, -- get redstone inputs
MEK_SCRAM = 7, -- SCRAM reactor
MEK_ENABLE = 8, -- enable reactor
MEK_BURN_RATE = 9, -- set burn rate
ISS_ALARM = 10, -- ISS alarm broadcast
ISS_GET = 11, -- get ISS status
ISS_CLEAR = 12 -- clear ISS trip (if in bad state, will trip immideatly)
}
RPLC_LINKING = {
ALLOW = 0,
DENY = 1,
COLLISION = 2
}
-- generic SCADA packet object
function scada_packet()
local self = {
modem_msg_in = nil,
raw = nil
valid = false,
seq_id = nil,
protocol = nil,
length = nil
length = nil,
raw = nil
}
local make = function (seq_id, protocol, payload)
self.valid = true
self.seq_id = seq_id
self.protocol = protocol
self.length = #payload
self.raw = { self.seq_id, self.protocol, self.length, payload }
end
local receive = function (side, sender, reply_to, message, distance)
self.modem_msg_in = {
iface = side,
@@ -30,9 +61,10 @@ function scada_packet()
-- malformed
return false
else
self.seq_id = self.raw[0]
self.protocol = self.raw[1]
self.length = self.raw[2]
self.valid = true
self.seq_id = self.raw[1]
self.protocol = self.raw[2]
self.length = self.raw[3]
end
end
@@ -48,6 +80,14 @@ function scada_packet()
return self.length
end
local data = function (packet)
local subset = nil
if self.valid then
subset = { table.unpack(self.raw, 4, 3 + self.length) }
end
return subset
end
local raw = function (packet)
return self.raw
end
@@ -56,7 +96,24 @@ function scada_packet()
return self.modem_msg_in
end
local as_rplc = function ()
local pkt = nil
if self.valid and self.protocol == PROTOCOLS.RPLC then
local body = data()
if #body > 2 then
pkt = {
id = body[1],
type = body[2],
length = #body - 2,
body = { table.unpack(body, 3, 2 + #body) }
}
end
end
return pkt
end
return {
make = make,
receive = receive,
seq_id = seq_id,
protocol = protocol,
@@ -83,65 +140,77 @@ end
-- reactor PLC communications
function rplc_comms(id, modem, local_port, server_port, reactor)
local self = {
_id = id,
_modem = modem,
_server = server_port,
_local = local_port,
_reactor = reactor,
_status_cache = nil
id = id,
seq_id = 0,
modem = modem,
s_port = server_port,
l_port = local_port,
reactor = reactor,
status_cache = nil
}
-- PRIVATE FUNCTIONS --
local _send = function (msg)
self._modem.transmit(self._server, self._local, msg)
local packet = scada_packet()
packet.make(self.seq_id, PROTOCOLS.RPLC, msg)
self.modem.transmit(self.s_port, self.l_port, packet.raw())
self.seq_id = self.seq_id + 1
end
-- variable reactor status information, excluding heating rate
local _reactor_status = function ()
return {
status = self._reactor.getStatus(),
burn_rate = self._reactor.getBurnRate(),
act_burn_r = self._reactor.getActualBurnRate(),
temp = self._reactor.getTemperature(),
damage = self._reactor.getDamagePercent(),
boil_eff = self._reactor.getBoilEfficiency(),
env_loss = self._reactor.getEnvironmentalLoss(),
status = self.reactor.getStatus(),
burn_rate = self.reactor.getBurnRate(),
act_burn_r = self.reactor.getActualBurnRate(),
temp = self.reactor.getTemperature(),
damage = self.reactor.getDamagePercent(),
boil_eff = self.reactor.getBoilEfficiency(),
env_loss = self.reactor.getEnvironmentalLoss(),
fuel = self._reactor.getFuel(),
fuel_need = self._reactor.getFuelNeeded(),
fuel_fill = self._reactor.getFuelFilledPercentage(),
waste = self._reactor.getWaste(),
waste_need = self._reactor.getWasteNeeded(),
waste_fill = self._reactor.getWasteFilledPercentage(),
cool_type = self._reactor.getCoolant()['name'],
cool_amnt = self._reactor.getCoolant()['amount'],
cool_need = self._reactor.getCoolantNeeded(),
cool_fill = self._reactor.getCoolantFilledPercentage(),
hcool_type = self._reactor.getHeatedCoolant()['name'],
hcool_amnt = self._reactor.getHeatedCoolant()['amount'],
hcool_need = self._reactor.getHeatedCoolantNeeded(),
hcool_fill = self._reactor.getHeatedCoolantFilledPercentage()
fuel = self.reactor.getFuel(),
fuel_need = self.reactor.getFuelNeeded(),
fuel_fill = self.reactor.getFuelFilledPercentage(),
waste = self.reactor.getWaste(),
waste_need = self.reactor.getWasteNeeded(),
waste_fill = self.reactor.getWasteFilledPercentage(),
cool_type = self.reactor.getCoolant()['name'],
cool_amnt = self.reactor.getCoolant()['amount'],
cool_need = self.reactor.getCoolantNeeded(),
cool_fill = self.reactor.getCoolantFilledPercentage(),
hcool_type = self.reactor.getHeatedCoolant()['name'],
hcool_amnt = self.reactor.getHeatedCoolant()['amount'],
hcool_need = self.reactor.getHeatedCoolantNeeded(),
hcool_fill = self.reactor.getHeatedCoolantFilledPercentage()
}
end
local _status_changed = function ()
local status = self._reactor_status()
local _update_status_cache = function ()
local status = _reactor_status()
local changed = false
for key, value in pairs() do
if value ~= _status_cache[key] then
for key, value in pairs(status) do
if value ~= self.status_cache[key] then
changed = true
break
end
end
if changed then
self.status_cache = status
end
return changed
end
-- attempt to establish link with
-- PUBLIC FUNCTIONS --
-- attempt to establish link with supervisor
local send_link_req = function ()
local linking_data = {
id = self._id,
type = "link_req"
id = self.id,
type = RPLC_TYPES.LINK_REQ
}
_send(linking_data)
@@ -151,19 +220,19 @@ function rplc_comms(id, modem, local_port, server_port, reactor)
-- server will cache these
local send_struct = function ()
local mek_data = {
heat_cap = self._reactor.getHeatCapacity(),
fuel_asm = self._reactor.getFuelAssemblies(),
fuel_sa = self._reactor.getFuelSurfaceArea(),
fuel_cap = self._reactor.getFuelCapacity(),
waste_cap = self._reactor.getWasteCapacity(),
cool_cap = self._reactor.getCoolantCapacity(),
hcool_cap = self._reactor.getHeatedCoolantCapacity(),
max_burn = self._reactor.getMaxBurnRate()
heat_cap = self.reactor.getHeatCapacity(),
fuel_asm = self.reactor.getFuelAssemblies(),
fuel_sa = self.reactor.getFuelSurfaceArea(),
fuel_cap = self.reactor.getFuelCapacity(),
waste_cap = self.reactor.getWasteCapacity(),
cool_cap = self.reactor.getCoolantCapacity(),
hcool_cap = self.reactor.getHeatedCoolantCapacity(),
max_burn = self.reactor.getMaxBurnRate()
}
local struct_packet = {
id = self._id,
type = "struct_data",
id = self.id,
type = RPLC_TYPES.MEK_STRUCT,
mek_data = mek_data
}
@@ -171,49 +240,63 @@ function rplc_comms(id, modem, local_port, server_port, reactor)
end
-- send live status information
local send_status = function ()
local mek_data = self._reactor_status()
-- control_state: acknowledged control state from supervisor
-- overridden: if ISS force disabled reactor
local send_status = function (control_state, overridden)
local mek_data = nil
local sys_data = {
timestamp = os.time(),
control_state = false,
overridden = false,
faults = {},
waste_production = "antimatter" -- "plutonium", "polonium", "antimatter"
}
end
local send_keep_alive = function ()
-- heating rate is volatile, so it is skipped in status
-- send it with keep alive packets
local mek_data = {
heating_rate = self._reactor.getHeatingRate()
}
-- basic keep alive packet to server
local keep_alive_packet = {
id = self._id,
type = "keep_alive",
if _update_status_cache() then
mek_data = self.status_cache
end
local sys_status = {
id = self.id,
type = RPLC_TYPES.STATUS,
timestamp = os.time(),
control_state = control_state,
overridden = overridden,
heating_rate = self.reactor.getHeatingRate(),
mek_data = mek_data
}
_send(keep_alive_packet)
_send(sys_status)
end
local send_rs_io_conns = function ()
end
local handle_link = function (packet)
if packet.type == "link_response" then
return packet.accepted
if packet.type == RPLC_TYPES.LINK_REQ then
return packet.data[1] == RPLC_LINKING.ALLOW
else
return nil
end
end
local handle_packet = function (packet)
if packet.type == RPLC_TYPES.KEEP_ALIVE then
-- keep alive request received, nothing to do except feed watchdog
elseif packet.type == RPLC_TYPES.MEK_STRUCT then
-- request for physical structure
send_struct()
elseif packet.type == RPLC_TYPES.RS_IO_CONNS then
-- request for redstone connections
send_rs_io_conns()
elseif packet.type == RPLC_TYPES.RS_IO_GET then
elseif packet.type == RPLC_TYPES.RS_IO_SET then
elseif packet.type == RPLC_TYPES.MEK_SCRAM then
elseif packet.type == RPLC_TYPES.MEK_ENABLE then
elseif packet.type == RPLC_TYPES.MEK_BURN_RATE then
elseif packet.type == RPLC_TYPES.ISS_GET then
elseif packet.type == RPLC_TYPES.ISS_CLEAR then
end
end
return {
send_link_req = send_link_req,
send_struct = send_struct,
send_status = send_status,
send_keep_alive = send_keep_alive,
send_rs_io_conns = send_rs_io_conns,
handle_link = handle_link
}
end