Initial commit: C++20 SECS-II / HSMS / GEM client + server
A fully containerised SECS/GEM toolchain. Single docker compose project,
no host build tools. 63 unit-test cases / 278 assertions, two demo
executables, end-to-end two-container demo exercising every implemented
capability.
Architecture (bottom-up):
secs2/ E5 SECS-II codec
Item variant over L/A/B/BOOLEAN/I1-8/U1-8/F4/F8
encode/decode big-endian, 1/2/3-byte length encoding
Message SxFy + W-bit + optional root item
to_sml human-readable text rendering
hsms/ E37 HSMS transport (TCP)
Header 10-byte header + SType enum (Data/Select/Deselect/
Linktest/Reject/Separate)
Frame 4-byte length prefix + payload encode/decode
Connection async Asio TCP, NOT-SELECTED -> SELECTED state machine,
T3/T5/T6/T7/T8 timers, system-bytes reply correlation,
graceful close-after-flush separation
endpoint active Client (connect with T5 retry) and passive Server
(accept loop) wrappers over Connection
gem/ E30 GEM logic
ControlStateMachine 5-state E30 control model with operator
actions, host requests, SEMI-mandated ack
codes (OnlineAck, OfflineAck, CommAck), and
a state-change handler
EquipmentDataModel in-memory dictionary: SVIDs, DVIDs, ECIDs
(with EAC), CEIDs, report defs, CEID->report
links, enabled-events set, alarm table
(ALCD, enabled, active), process programs,
host command registry, clock (16-char
YYYYMMDDhhmmsscc with offset)
messages.hpp builders + parsers for every SxFy below
GEM message coverage (full list):
S1F1/F2 Are You There / On Line Data
S1F3/F4 Selected Equipment Status Request / Data
S1F11/F12 Status Variable Namelist Request / Data
S1F13/F14 Establish Communications (+ CommAck)
S1F15/F16 Request OFFLINE (+ OfflineAck)
S1F17/F18 Request ONLINE (+ OnlineAck)
S2F13/F14 Equipment Constant Request / Data
S2F15/F16 EC Send + EquipmentAck (Accept/UnknownEcid/Busy/OutOfRange)
S2F17/F18 Date and Time Request / Data
S2F29/F30 Equipment Constant Namelist Request / Data
S2F31/F32 Date and Time Set Request / TimeAck
S2F33/F34 Define Report + DefineReportAck (5 enum values)
S2F35/F36 Link Event Report + LinkEventAck
S2F37/F38 Enable / Disable Event Report + EnableEventAck
S2F41/F42 Host Command + HostCmdAck (7 values) + per-param CPACKs
S5F1/F2 Alarm Report Send + AlarmAck (ALCD bit-7 set/cleared
+ lower-7 category)
S5F3/F4 Enable/Disable Alarm Send + AlarmAck
S5F5/F6 List Alarms Request / Data (active alarms tagged in ALCD)
S6F11/F12 Event Report Send (equipment-initiated CEID emission
with full report data) + EventReportAck
S7F3/F4 Process Program Send + ProcessProgramAck (7 values)
S7F5/F6 Process Program Request / Data
S7F19/F20 Current EPPD List Request / Data
S10F1/F2 Terminal Display Single (host->equipment) + TerminalAck
S10F3/F4 Terminal Display Single (equipment->host)
Demo apps:
apps/secs_server.cpp passive equipment. Populates the data model
with 3 SVIDs (ControlState, Clock,
EventsEnabled), 2 ECIDs, 3 CEIDs
(ControlStateChanged, AlarmSetEvent,
ProcessStarted), 2 alarms (Chiller Temp High
cat 4, Door Open cat 1), 2 recipes
(RECIPE-A, RECIPE-B), and 4 host commands
(START, STOP, PAUSE, FAULT). Emits S6F11 on
every control state transition + on START;
emits S5F1 + the AlarmSetEvent CEID on FAULT.
Pushes an S10F3 welcome message when the host
comes online.
apps/secs_client.cpp active host. Walks 17 steps: Establish ->
Online -> S1F11 SVID namelist -> S1F3 read ->
S2F29 EC namelist -> S2F13 read ->
S2F17 clock -> S2F33/S2F35/S2F37 dynamic
event subscription -> S2F41 START
(-> receives S6F11) -> S5F5 alarm list ->
S5F3 enable alarm 1 -> S2F41 FAULT
(-> receives S5F1 + S6F11) -> S7F19/S7F5
recipe list + body -> S10F1 terminal ->
S1F15 Offline -> Separate. Handles inbound
S6F11, S5F1, S10F3 primaries.
Testing:
tests/test_secs2.cpp codec round-trip for every format,
byte-layout assertions for known values,
truncation/trailing-byte rejection,
nested list round-trip, SML rendering
tests/test_hsms.cpp header byte layout, data + control
header round-trip, full frame round-
trip with length prefix, short-payload
rejection
tests/test_control_state.cpp every (state, event) pair in the E30
control state machine, including
AlreadyOnline / NotAccept rejections
and idempotent offline-while-offline
tests/test_data_model.cpp SVID/ECID/Alarm/Recipe CRUD, clock
format + parse, host command registry,
full event-report pipeline (define ->
link -> enable -> compose) with
every error path (InvalidVid,
UnknownCeid, UnknownRptid), alarm
set/clear with ALCD bit-7 semantics
tests/test_messages.cpp round-trip + byte-layout for every
builder/parser pair, including S6F11
event reports with mixed item types
Toolchain:
Dockerfile Ubuntu 24.04, g++-13, CMake, Ninja, libasio-dev
docker-compose.yml builder / tests / server / client services,
source bind-mounted, build artifacts in a
named volume so the host tree stays clean
CMakeLists.txt C++20, -Wall -Wextra -Wpedantic, standalone
Asio (ASIO_STANDALONE), doctest via FetchContent
Documentation:
README.md architecture, quick start, demo log
COMPLIANCE.md honest per-capability E5/E30/E37 audit with
spec section refs. Calls out what's implemented,
what's partial (Reject.req, Alarms missing F7/F8,
EC range validation, PP without verify, terminal
single-line only), and what's intentionally not
yet implemented (spooling, S9 error stream,
Documentation S1F19/F20+F21/F22, limits monitoring,
trace data collection, multi-block, material
movement). Does NOT claim "100% GEM-compliant" and
lists the work required to honestly make that claim.
This is Layer 0 + the start of Layer 1 from implementation_plan.md.
The transition-table-driven "spec-as-data" architecture (Layer 1
proper) is not yet implemented; the current code uses imperative
state machines that are structurally ready to be refactored onto
tables.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,225 @@
|
||||
#include "secsgem/secs2/codec.hpp"
|
||||
|
||||
#include <bit>
|
||||
#include <cstdio>
|
||||
#include <type_traits>
|
||||
|
||||
namespace secsgem::secs2 {
|
||||
namespace {
|
||||
|
||||
template <typename T>
|
||||
void put_scalar_be(std::vector<uint8_t>& out, T value) {
|
||||
if constexpr (std::is_same_v<T, float>) {
|
||||
uint32_t bits = std::bit_cast<uint32_t>(value);
|
||||
for (int i = 3; i >= 0; --i) out.push_back(static_cast<uint8_t>(bits >> (8 * i)));
|
||||
} else if constexpr (std::is_same_v<T, double>) {
|
||||
uint64_t bits = std::bit_cast<uint64_t>(value);
|
||||
for (int i = 7; i >= 0; --i) out.push_back(static_cast<uint8_t>(bits >> (8 * i)));
|
||||
} else {
|
||||
using U = std::make_unsigned_t<T>;
|
||||
U u = static_cast<U>(value);
|
||||
for (int i = static_cast<int>(sizeof(T)) - 1; i >= 0; --i)
|
||||
out.push_back(static_cast<uint8_t>(u >> (8 * i)));
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
T get_scalar_be(const uint8_t* p) {
|
||||
if constexpr (std::is_same_v<T, float>) {
|
||||
uint32_t bits = 0;
|
||||
for (int i = 0; i < 4; ++i) bits = (bits << 8) | p[i];
|
||||
return std::bit_cast<float>(bits);
|
||||
} else if constexpr (std::is_same_v<T, double>) {
|
||||
uint64_t bits = 0;
|
||||
for (int i = 0; i < 8; ++i) bits = (bits << 8) | p[i];
|
||||
return std::bit_cast<double>(bits);
|
||||
} else {
|
||||
using U = std::make_unsigned_t<T>;
|
||||
U u = 0;
|
||||
for (std::size_t i = 0; i < sizeof(T); ++i) u = static_cast<U>((u << 8) | p[i]);
|
||||
return static_cast<T>(u);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
std::vector<T> read_array(const uint8_t* p, std::size_t bytes) {
|
||||
if (bytes % sizeof(T) != 0)
|
||||
throw CodecError("item byte length is not a multiple of the element size");
|
||||
const std::size_t n = bytes / sizeof(T);
|
||||
std::vector<T> out;
|
||||
out.reserve(n);
|
||||
for (std::size_t i = 0; i < n; ++i) out.push_back(get_scalar_be<T>(p + i * sizeof(T)));
|
||||
return out;
|
||||
}
|
||||
|
||||
void write_header(std::vector<uint8_t>& out, Format fmt, std::size_t length) {
|
||||
std::size_t nlen;
|
||||
if (length <= 0xFF) nlen = 1;
|
||||
else if (length <= 0xFFFF) nlen = 2;
|
||||
else if (length <= 0xFFFFFF) nlen = 3;
|
||||
else throw CodecError("item length exceeds 3-byte maximum");
|
||||
|
||||
out.push_back(static_cast<uint8_t>((static_cast<uint8_t>(fmt) << 2) | nlen));
|
||||
for (std::size_t i = 0; i < nlen; ++i) {
|
||||
const std::size_t shift = 8 * (nlen - 1 - i);
|
||||
out.push_back(static_cast<uint8_t>((length >> shift) & 0xFF));
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
void encode_into(const Item& item, std::vector<uint8_t>& out) {
|
||||
const Format fmt = item.format();
|
||||
|
||||
if (fmt == Format::List) {
|
||||
const auto& children = item.as_list();
|
||||
write_header(out, fmt, children.size());
|
||||
for (const auto& child : children) encode_into(child, out);
|
||||
return;
|
||||
}
|
||||
|
||||
std::visit(
|
||||
[&](const auto& v) {
|
||||
using V = std::decay_t<decltype(v)>;
|
||||
if constexpr (std::is_same_v<V, Item::List>) {
|
||||
// unreachable: lists handled above
|
||||
} else if constexpr (std::is_same_v<V, std::string>) {
|
||||
write_header(out, fmt, v.size());
|
||||
out.insert(out.end(), v.begin(), v.end());
|
||||
} else {
|
||||
using Elem = typename V::value_type;
|
||||
write_header(out, fmt, v.size() * sizeof(Elem));
|
||||
for (auto e : v) put_scalar_be(out, e);
|
||||
}
|
||||
},
|
||||
item.storage());
|
||||
}
|
||||
|
||||
std::vector<uint8_t> encode(const Item& item) {
|
||||
std::vector<uint8_t> out;
|
||||
encode_into(item, out);
|
||||
return out;
|
||||
}
|
||||
|
||||
Item decode_at(const uint8_t* data, std::size_t len, std::size_t& pos) {
|
||||
if (pos >= len) throw CodecError("unexpected end of input reading format byte");
|
||||
|
||||
const uint8_t format_byte = data[pos++];
|
||||
const uint8_t nlen = format_byte & 0x03;
|
||||
const Format fmt = static_cast<Format>((format_byte >> 2) & 0x3F);
|
||||
|
||||
if (nlen == 0) throw CodecError("invalid item: zero length bytes");
|
||||
if (pos + nlen > len) throw CodecError("unexpected end of input reading length bytes");
|
||||
|
||||
std::size_t length = 0;
|
||||
for (uint8_t i = 0; i < nlen; ++i) length = (length << 8) | data[pos++];
|
||||
|
||||
if (fmt == Format::List) {
|
||||
Item::List items;
|
||||
items.reserve(length);
|
||||
for (std::size_t i = 0; i < length; ++i) items.push_back(decode_at(data, len, pos));
|
||||
return Item::list(std::move(items));
|
||||
}
|
||||
|
||||
if (pos + length > len) throw CodecError("unexpected end of input reading item data");
|
||||
const uint8_t* p = data + pos;
|
||||
pos += length;
|
||||
|
||||
switch (fmt) {
|
||||
case Format::ASCII:
|
||||
return Item::ascii(std::string(reinterpret_cast<const char*>(p), length));
|
||||
case Format::Binary:
|
||||
return Item::binary(std::vector<uint8_t>(p, p + length));
|
||||
case Format::Boolean:
|
||||
return Item::boolean(std::vector<uint8_t>(p, p + length));
|
||||
case Format::U1:
|
||||
return Item::u1(std::vector<uint8_t>(p, p + length));
|
||||
case Format::I1:
|
||||
return Item::i1(read_array<int8_t>(p, length));
|
||||
case Format::U2:
|
||||
return Item::u2(read_array<uint16_t>(p, length));
|
||||
case Format::I2:
|
||||
return Item::i2(read_array<int16_t>(p, length));
|
||||
case Format::U4:
|
||||
return Item::u4(read_array<uint32_t>(p, length));
|
||||
case Format::I4:
|
||||
return Item::i4(read_array<int32_t>(p, length));
|
||||
case Format::F4:
|
||||
return Item::f4(read_array<float>(p, length));
|
||||
case Format::U8:
|
||||
return Item::u8(read_array<uint64_t>(p, length));
|
||||
case Format::I8:
|
||||
return Item::i8(read_array<int64_t>(p, length));
|
||||
case Format::F8:
|
||||
return Item::f8(read_array<double>(p, length));
|
||||
case Format::List:
|
||||
break; // handled above
|
||||
}
|
||||
throw CodecError("unknown SECS-II format code");
|
||||
}
|
||||
|
||||
Item decode(const std::vector<uint8_t>& bytes) {
|
||||
std::size_t pos = 0;
|
||||
Item item = decode_at(bytes.data(), bytes.size(), pos);
|
||||
if (pos != bytes.size()) throw CodecError("trailing bytes after decoded item");
|
||||
return item;
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
void sml_into(const Item& item, std::string& out) {
|
||||
const Format fmt = item.format();
|
||||
out += '<';
|
||||
out += format_name(fmt);
|
||||
|
||||
if (fmt == Format::List) {
|
||||
out += " [" + std::to_string(item.size()) + "]";
|
||||
for (const auto& child : item.as_list()) {
|
||||
out += ' ';
|
||||
sml_into(child, out);
|
||||
}
|
||||
out += " >";
|
||||
return;
|
||||
}
|
||||
|
||||
std::visit(
|
||||
[&](const auto& v) {
|
||||
using V = std::decay_t<decltype(v)>;
|
||||
if constexpr (std::is_same_v<V, Item::List>) {
|
||||
// unreachable
|
||||
} else if constexpr (std::is_same_v<V, std::string>) {
|
||||
out += " \"" + v + "\"";
|
||||
} else {
|
||||
using Elem = typename V::value_type;
|
||||
for (auto e : v) {
|
||||
out += ' ';
|
||||
if constexpr (std::is_same_v<Elem, uint8_t>) {
|
||||
if (fmt == Format::Boolean) {
|
||||
out += (e ? "T" : "F");
|
||||
} else {
|
||||
char buf[5];
|
||||
std::snprintf(buf, sizeof(buf), "0x%02X", e);
|
||||
out += buf;
|
||||
}
|
||||
} else if constexpr (std::is_floating_point_v<Elem>) {
|
||||
out += std::to_string(e);
|
||||
} else {
|
||||
out += std::to_string(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
item.storage());
|
||||
|
||||
out += " >";
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
std::string to_sml(const Item& item) {
|
||||
std::string out;
|
||||
sml_into(item, out);
|
||||
return out;
|
||||
}
|
||||
|
||||
} // namespace secsgem::secs2
|
||||
Reference in New Issue
Block a user