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>
2026-06-02 00:21:10 +02:00
commit 96b02f8b50
36 changed files with 5210 additions and 0 deletions
@@ -0,0 +1,99 @@
+#include <doctest/doctest.h>
+
+#include "secsgem/secs2/codec.hpp"
+#include "secsgem/secs2/item.hpp"
+#include "secsgem/secs2/message.hpp"
+
+using namespace secsgem::secs2;
+
+TEST_CASE("encode known byte layouts") {
+  CHECK(encode(Item::ascii("ABC")) ==
+        std::vector<uint8_t>{0x41, 0x03, 'A', 'B', 'C'});
+  CHECK(encode(Item::u1(uint8_t{255})) ==
+        std::vector<uint8_t>{0xA5, 0x01, 0xFF});
+  CHECK(encode(Item::u4(uint32_t{0x01020304})) ==
+        std::vector<uint8_t>{0xB1, 0x04, 0x01, 0x02, 0x03, 0x04});
+  CHECK(encode(Item::boolean(true)) ==
+        std::vector<uint8_t>{0x25, 0x01, 0x01});
+  CHECK(encode(Item::binary({0xDE, 0xAD})) ==
+        std::vector<uint8_t>{0x21, 0x02, 0xDE, 0xAD});
+
+  // L [2] <A "MD"> <U2 258>
+  CHECK(encode(Item::list({Item::ascii("MD"), Item::u2(uint16_t{258})})) ==
+        std::vector<uint8_t>{0x01, 0x02, 0x41, 0x02, 'M', 'D', 0xA9, 0x02, 0x01, 0x02});
+}
+
+TEST_CASE("round-trip scalar items") {
+  auto rt = [](const Item& i) { return decode(encode(i)); };
+
+  CHECK(rt(Item::ascii("hello world")) == Item::ascii("hello world"));
+  CHECK(rt(Item::ascii("")) == Item::ascii(""));
+  CHECK(rt(Item::u1(uint8_t{0})) == Item::u1(uint8_t{0}));
+  CHECK(rt(Item::u2(uint16_t{0xBEEF})) == Item::u2(uint16_t{0xBEEF}));
+  CHECK(rt(Item::u4(uint32_t{0xDEADBEEF})) == Item::u4(uint32_t{0xDEADBEEF}));
+  CHECK(rt(Item::u8(uint64_t{0x0102030405060708ULL})) == Item::u8(uint64_t{0x0102030405060708ULL}));
+  CHECK(rt(Item::i1(int8_t{-5})) == Item::i1(int8_t{-5}));
+  CHECK(rt(Item::i2(int16_t{-1234})) == Item::i2(int16_t{-1234}));
+  CHECK(rt(Item::i4(int32_t{-123456})) == Item::i4(int32_t{-123456}));
+  CHECK(rt(Item::i8(int64_t{-9000000000LL})) == Item::i8(int64_t{-9000000000LL}));
+  CHECK(rt(Item::binary({1, 2, 3, 255, 0})) == Item::binary({1, 2, 3, 255, 0}));
+  CHECK(rt(Item::boolean({1, 0, 1})) == Item::boolean({1, 0, 1}));
+}
+
+TEST_CASE("round-trip floating point preserves bit pattern") {
+  CHECK(decode(encode(Item::f4(3.14159f))) == Item::f4(3.14159f));
+  CHECK(decode(encode(Item::f8(2.718281828459045))) == Item::f8(2.718281828459045));
+  CHECK(decode(encode(Item::f4({1.0f, -2.5f, 0.0f}))) == Item::f4({1.0f, -2.5f, 0.0f}));
+}
+
+TEST_CASE("round-trip nested lists") {
+  Item nested = Item::list({
+      Item::ascii("EQUIP-01"),
+      Item::list({Item::u4(uint32_t{12}), Item::u4(uint32_t{34})}),
+      Item::list({}),  // empty list
+      Item::binary({0xFF}),
+  });
+  CHECK(decode(encode(nested)) == nested);
+}
+
+TEST_CASE("multi-element numeric arrays") {
+  auto v = Item::u2({1, 2, 3, 4, 5});
+  CHECK(v.size() == 5);
+  CHECK(decode(encode(v)) == v);
+}
+
+TEST_CASE("decode rejects truncated input") {
+  CHECK_THROWS_AS(decode(std::vector<uint8_t>{0x41, 0x03, 'A'}), CodecError);  // ascii len 3, 1 byte
+  CHECK_THROWS_AS(decode(std::vector<uint8_t>{0x41}), CodecError);             // missing length byte
+  CHECK_THROWS_AS(decode(std::vector<uint8_t>{}), CodecError);                 // empty
+}
+
+TEST_CASE("decode rejects trailing bytes") {
+  CHECK_THROWS_AS(decode(std::vector<uint8_t>{0xA5, 0x01, 0xFF, 0x00}), CodecError);
+}
+
+TEST_CASE("message body round-trip") {
+  Item body = Item::list({Item::ascii("MDLN-1"), Item::ascii("1.0.0")});
+  Message m(1, 2, false, body);
+
+  auto bytes = m.encode_body();
+  Message decoded = Message::from_body(1, 2, false, bytes);
+
+  REQUIRE(decoded.body.has_value());
+  CHECK(*decoded.body == body);
+  CHECK(decoded.stream == 1);
+  CHECK(decoded.function == 2);
+}
+
+TEST_CASE("empty message body") {
+  Message m(1, 1, true);  // S1F1 W, header-only
+  CHECK(m.encode_body().empty());
+
+  Message decoded = Message::from_body(1, 1, true, {});
+  CHECK_FALSE(decoded.body.has_value());
+}
+
+TEST_CASE("SML rendering") {
+  Item body = Item::list({Item::ascii("MDLN"), Item::u4(uint32_t{42})});
+  CHECK(to_sml(body) == "<L [2] <A \"MDLN\" > <U4 42 > >");
+}