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,334 @@
+// Active SECS/GEM host: connects to equipment and walks the full GEM core
+// demo. After establishing communication and going online, the host configures
+// dynamic event reporting (define report -> link CEID -> enable), triggers a
+// host command that fires the linked CEID, exercises alarm enable + alarm
+// triggering, fetches the recipe list and a single recipe body, sends a
+// terminal display, and finally requests OFFLINE and separates.
+
+#include <asio.hpp>
+#include <chrono>
+#include <cstdint>
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <system_error>
+#include <vector>
+
+#include "secsgem/endpoint.hpp"
+#include "secsgem/gem/messages.hpp"
+#include "secsgem/secs2/codec.hpp"
+#include "secsgem/secs2/message.hpp"
+
+using namespace secsgem;
+namespace s2 = secsgem::secs2;
+namespace gem = secsgem::gem;
+
+namespace {
+
+std::string arg(int argc, char** argv, const std::string& key, const std::string& def) {
+  for (int i = 1; i + 1 < argc; ++i)
+    if (key == argv[i]) return argv[i + 1];
+  return def;
+}
+
+constexpr const char* kHostMdln = "GEMHOST";
+constexpr const char* kHostRev = "0.1.0";
+
+// Demo report / event subscription ids the host will install.
+constexpr uint32_t kDataIdReports = 7;
+constexpr uint32_t kRptidStatus   = 1000;
+constexpr uint32_t kCeidProcessStarted = 300;
+constexpr uint32_t kCeidAlarmSetEvent  = 200;
+constexpr uint32_t kAlarmChiller       = 1;
+
+struct Sequence : std::enable_shared_from_this<Sequence> {
+  using Step = std::function<void(std::function<void()>)>;
+  std::vector<Step> steps;
+  std::size_t i = 0;
+
+  void run() {
+    if (i >= steps.size()) return;
+    auto self = shared_from_this();
+    steps[i]([self] {
+      ++self->i;
+      self->run();
+    });
+  }
+};
+
+}  // namespace
+
+int main(int argc, char** argv) {
+  Client::Config cfg;
+  cfg.host = arg(argc, argv, "--host", "127.0.0.1");
+  cfg.port = static_cast<uint16_t>(std::stoi(arg(argc, argv, "--port", "5000")));
+  cfg.device_id = static_cast<uint16_t>(std::stoi(arg(argc, argv, "--device", "0")));
+  cfg.timers.linktest = std::chrono::milliseconds(0);
+
+  asio::io_context io;
+  Client client(io, cfg);
+
+  auto logfn = [](const std::string& m) { std::cout << "[host]  " << m << std::endl; };
+  client.on_log(logfn);
+
+  client.on_connection([&io, logfn](std::shared_ptr<Connection> conn) {
+    // Inbound primaries from the equipment.
+    conn->set_message_handler(
+        [logfn](const s2::Message& msg) -> std::optional<s2::Message> {
+          // S10F3: terminal display from equipment.
+          if (msg.stream == 10 && msg.function == 3) {
+            auto td = gem::parse_terminal_display(msg);
+            if (td) logfn("TERMINAL[" + std::to_string(td->tid) + "] " + td->text);
+            return gem::s10f4_terminal_display_ack(gem::TerminalAck::Accepted);
+          }
+          // S6F11: event report from equipment.
+          if (msg.stream == 6 && msg.function == 11) {
+            auto er = gem::parse_s6f11(msg);
+            if (er) {
+              logfn("EVENT CEID=" + std::to_string(er->ceid) + " (" +
+                    std::to_string(er->reports.size()) + " reports)");
+              for (const auto& r : er->reports) {
+                std::string s = "  RPTID " + std::to_string(r.rptid) + ":";
+                for (const auto& v : r.values) s += " " + s2::to_sml(v);
+                logfn(s);
+              }
+            }
+            return gem::s6f12_event_report_ack(gem::EventReportAck::Accept);
+          }
+          // S5F1: alarm send from equipment.
+          if (msg.stream == 5 && msg.function == 1) {
+            auto a = gem::parse_s5f1(msg);
+            if (a) {
+              logfn(std::string("ALARM ") + (a->is_set() ? "SET" : "CLR") +
+                    " ALID=" + std::to_string(a->alid) +
+                    " cat=" + std::to_string(a->category()) + " \"" + a->altx + "\"");
+            }
+            return gem::s5f2_alarm_ack(gem::AlarmAck::Accept);
+          }
+          if (msg.reply_expected) return s2::Message(msg.stream, 0, false);
+          return std::nullopt;
+        });
+
+    auto seq = std::make_shared<Sequence>();
+    auto svids = std::make_shared<std::vector<uint32_t>>();
+    auto pacing = std::make_shared<asio::steady_timer>(io);
+
+    auto fail = [conn, logfn](const char* where, std::error_code ec) {
+      logfn(std::string(where) + " failed: " + ec.message());
+      conn->close(std::string(where) + " failed");
+    };
+
+    auto pause_then = [pacing](std::chrono::milliseconds dt, std::function<void()> cb) {
+      pacing->expires_after(dt);
+      pacing->async_wait([cb = std::move(cb)](std::error_code ec) {
+        if (!ec) cb();
+      });
+    };
+
+    // 1. Establish communications.
+    seq->steps.push_back([conn, logfn, fail](auto next) {
+      conn->send_request(gem::s1f13_establish_comms(kHostMdln, kHostRev),
+                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
+                           if (ec) { fail("S1F13", ec); return; }
+                           logfn("S1F14 reply: " + reply.sml());
+                           next();
+                         });
+    });
+
+    // 2. Request ONLINE.
+    seq->steps.push_back([conn, logfn, fail](auto next) {
+      conn->send_request(gem::s1f17_request_online(),
+                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
+                           if (ec) { fail("S1F17", ec); return; }
+                           auto a = gem::ack_byte(reply);
+                           logfn("S1F18 ONLACK=" + (a ? std::to_string(*a) : "?"));
+                           next();
+                         });
+    });
+
+    // 3. Discover SVIDs.
+    seq->steps.push_back([conn, logfn, fail, svids](auto next) {
+      conn->send_request(gem::s1f11_status_namelist_request({}),
+                         [logfn, fail, svids, next](std::error_code ec, const s2::Message& reply) {
+                           if (ec) { fail("S1F11", ec); return; }
+                           auto parsed = gem::parse_s1f12(reply);
+                           if (parsed) {
+                             for (const auto& sn : *parsed) {
+                               svids->push_back(sn.id);
+                               logfn("  SVID " + std::to_string(sn.id) + " " + sn.name);
+                             }
+                           }
+                           next();
+                         });
+    });
+
+    // 4. Read SVID values.
+    seq->steps.push_back([conn, logfn, fail, svids](auto next) {
+      conn->send_request(gem::s1f3_selected_status_request(*svids),
+                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
+                           if (ec) { fail("S1F3", ec); return; }
+                           logfn("S1F4 values: " + reply.sml());
+                           next();
+                         });
+    });
+
+    // 5. EC namelist.
+    seq->steps.push_back([conn, logfn, fail](auto next) {
+      conn->send_request(gem::s2f29_ec_namelist_request({}),
+                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
+                           if (ec) { fail("S2F29", ec); return; }
+                           logfn("S2F30 namelist: " + reply.sml());
+                           next();
+                         });
+    });
+
+    // 6. Define a report covering all SVIDs.
+    seq->steps.push_back([conn, logfn, fail, svids](auto next) {
+      conn->send_request(gem::s2f33_define_report(kDataIdReports, {{kRptidStatus, *svids}}),
+                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
+                           if (ec) { fail("S2F33", ec); return; }
+                           auto a = gem::ack_byte(reply);
+                           logfn("S2F34 DRACK=" + (a ? std::to_string(*a) : "?"));
+                           next();
+                         });
+    });
+
+    // 7. Link CEIDs to the report.
+    seq->steps.push_back([conn, logfn, fail](auto next) {
+      conn->send_request(
+          gem::s2f35_link_event_report(kDataIdReports,
+                                       {{kCeidProcessStarted, {kRptidStatus}},
+                                        {kCeidAlarmSetEvent, {kRptidStatus}}}),
+          [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
+            if (ec) { fail("S2F35", ec); return; }
+            auto a = gem::ack_byte(reply);
+            logfn("S2F36 LRACK=" + (a ? std::to_string(*a) : "?"));
+            next();
+          });
+    });
+
+    // 8. Enable the linked CEIDs.
+    seq->steps.push_back([conn, logfn, fail](auto next) {
+      conn->send_request(
+          gem::s2f37_enable_event(true, {kCeidProcessStarted, kCeidAlarmSetEvent}),
+          [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
+            if (ec) { fail("S2F37", ec); return; }
+            auto a = gem::ack_byte(reply);
+            logfn("S2F38 ERACK=" + (a ? std::to_string(*a) : "?"));
+            next();
+          });
+    });
+
+    // 9. Host command START -> equipment fires CEID kCeidProcessStarted.
+    seq->steps.push_back([conn, logfn, fail, pause_then](auto next) {
+      std::vector<gem::EquipmentDataModel::CommandParam> params = {
+          {"LOTID", s2::Item::ascii("LOT-42")},
+          {"PPID",  s2::Item::ascii("RECIPE-A")},
+      };
+      conn->send_request(gem::s2f41_host_command("START", params),
+                         [logfn, fail, pause_then, next](std::error_code ec, const s2::Message& reply) {
+                           if (ec) { fail("S2F41/START", ec); return; }
+                           auto r = gem::parse_s2f42(reply);
+                           logfn("S2F42 HCACK=" +
+                                 (r ? std::to_string(static_cast<int>(r->hcack)) : "?"));
+                           pause_then(std::chrono::milliseconds(300), next);
+                         });
+    });
+
+    // 10. List alarm directory.
+    seq->steps.push_back([conn, logfn, fail](auto next) {
+      conn->send_request(gem::s5f5_list_alarms_request({}),
+                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
+                           if (ec) { fail("S5F5", ec); return; }
+                           logfn("S5F6 alarms: " + reply.sml());
+                           next();
+                         });
+    });
+
+    // 11. Enable alarm 1 (so the equipment is allowed to send S5F1 for it).
+    seq->steps.push_back([conn, logfn, fail](auto next) {
+      conn->send_request(gem::s5f3_enable_alarm(true, kAlarmChiller),
+                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
+                           if (ec) { fail("S5F3", ec); return; }
+                           auto a = gem::ack_byte(reply);
+                           logfn("S5F4 ACKC5=" + (a ? std::to_string(*a) : "?"));
+                           next();
+                         });
+    });
+
+    // 12. Host command FAULT -> equipment sets alarm 1 and emits S5F1 + S6F11.
+    seq->steps.push_back([conn, logfn, fail, pause_then](auto next) {
+      conn->send_request(gem::s2f41_host_command("FAULT"),
+                         [logfn, fail, pause_then, next](std::error_code ec, const s2::Message& reply) {
+                           if (ec) { fail("S2F41/FAULT", ec); return; }
+                           auto r = gem::parse_s2f42(reply);
+                           logfn("S2F42 HCACK=" +
+                                 (r ? std::to_string(static_cast<int>(r->hcack)) : "?"));
+                           pause_then(std::chrono::milliseconds(300), next);
+                         });
+    });
+
+    // 13. List recipes.
+    seq->steps.push_back([conn, logfn, fail](auto next) {
+      conn->send_request(gem::s7f19_current_eppd_request(),
+                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
+                           if (ec) { fail("S7F19", ec); return; }
+                           auto list = gem::parse_s7f20(reply);
+                           if (list) {
+                             logfn("S7F20: " + std::to_string(list->size()) + " recipes");
+                             for (const auto& p : *list) logfn("  PPID " + p);
+                           }
+                           next();
+                         });
+    });
+
+    // 14. Fetch a single recipe body.
+    seq->steps.push_back([conn, logfn, fail](auto next) {
+      conn->send_request(gem::s7f5_process_program_request("RECIPE-A"),
+                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
+                           if (ec) { fail("S7F5", ec); return; }
+                           auto pp = gem::parse_s7f6(reply);
+                           if (pp)
+                             logfn("S7F6 PPID=" + pp->ppid + " body=" +
+                                   std::to_string(pp->ppbody.size()) + " bytes");
+                           next();
+                         });
+    });
+
+    // 15. Send a terminal display to the equipment.
+    seq->steps.push_back([conn, logfn, fail](auto next) {
+      conn->send_request(gem::s10f1_terminal_display_single(0, "Hello equipment!"),
+                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
+                           if (ec) { fail("S10F1", ec); return; }
+                           auto a = gem::ack_byte(reply);
+                           logfn("S10F2 ACKC10=" + (a ? std::to_string(*a) : "?"));
+                           next();
+                         });
+    });
+
+    // 16. Request OFFLINE.
+    seq->steps.push_back([conn, logfn, fail](auto next) {
+      conn->send_request(gem::s1f15_request_offline(),
+                         [logfn, fail, next](std::error_code ec, const s2::Message& reply) {
+                           if (ec) { fail("S1F15", ec); return; }
+                           auto a = gem::ack_byte(reply);
+                           logfn("S1F16 OFLACK=" + (a ? std::to_string(*a) : "?"));
+                           next();
+                         });
+    });
+
+    // 17. Separate.
+    seq->steps.push_back([conn, logfn](auto) {
+      logfn("flow complete; separating");
+      conn->separate();
+    });
+
+    conn->set_selected_handler([seq]() { seq->run(); });
+  });
+
+  client.start();
+  io.run();
+  std::cout << "[host]  exiting" << std::endl;
+  return 0;
+}