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,30 @@
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "secsgem/secs2/item.hpp"
|
||||
|
||||
namespace secsgem::secs2 {
|
||||
|
||||
class CodecError : public std::runtime_error {
|
||||
public:
|
||||
using std::runtime_error::runtime_error;
|
||||
};
|
||||
|
||||
// Encode a single item (with all nested children) to its SECS-II byte form.
|
||||
std::vector<uint8_t> encode(const Item& item);
|
||||
void encode_into(const Item& item, std::vector<uint8_t>& out);
|
||||
|
||||
// Decode exactly one item starting at `pos`, advancing `pos` past it.
|
||||
Item decode_at(const uint8_t* data, std::size_t len, std::size_t& pos);
|
||||
|
||||
// Decode one item that occupies the entire buffer; throws on trailing bytes.
|
||||
Item decode(const std::vector<uint8_t>& bytes);
|
||||
|
||||
// Human-readable SML (SECS Message Language) rendering, single line.
|
||||
std::string to_sml(const Item& item);
|
||||
|
||||
} // namespace secsgem::secs2
|
||||
@@ -0,0 +1,119 @@
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <variant>
|
||||
#include <vector>
|
||||
|
||||
namespace secsgem::secs2 {
|
||||
|
||||
// SECS-II data item format codes (the 6-bit value, before being shifted left
|
||||
// two bits to make the format byte). Values are the canonical octal codes from
|
||||
// SEMI E5.
|
||||
enum class Format : uint8_t {
|
||||
List = 000, // 0
|
||||
Binary = 010, // 8
|
||||
Boolean = 011, // 9
|
||||
ASCII = 020, // 16
|
||||
I8 = 030, // 24
|
||||
I1 = 031, // 25
|
||||
I2 = 032, // 26
|
||||
I4 = 034, // 28
|
||||
F8 = 040, // 32
|
||||
F4 = 044, // 36
|
||||
U8 = 050, // 40
|
||||
U1 = 051, // 41
|
||||
U2 = 052, // 42
|
||||
U4 = 054, // 44
|
||||
};
|
||||
|
||||
const char* format_name(Format f);
|
||||
|
||||
// Number of bytes one element of the given format occupies on the wire.
|
||||
// Lists are special (their length is an element count, not a byte count) and
|
||||
// return 0 here.
|
||||
std::size_t element_size(Format f);
|
||||
|
||||
// A SECS-II data item: a typed, possibly nested value. Lists hold child items;
|
||||
// every other format holds a homogeneous array of scalars (a single scalar is
|
||||
// just an array of length one). The active variant alternative is kept in sync
|
||||
// with `format_`; several formats (Binary, Boolean, U1) share the same C++
|
||||
// storage type and are disambiguated by `format_`.
|
||||
class Item {
|
||||
public:
|
||||
using List = std::vector<Item>;
|
||||
using Storage = std::variant<
|
||||
List, // List
|
||||
std::string, // ASCII
|
||||
std::vector<uint8_t>, // Binary, Boolean, U1
|
||||
std::vector<int8_t>, // I1
|
||||
std::vector<int16_t>, // I2
|
||||
std::vector<int32_t>, // I4
|
||||
std::vector<int64_t>, // I8
|
||||
std::vector<uint16_t>, // U2
|
||||
std::vector<uint32_t>, // U4
|
||||
std::vector<uint64_t>, // U8
|
||||
std::vector<float>, // F4
|
||||
std::vector<double>>; // F8
|
||||
|
||||
Item() : format_(Format::List), data_(List{}) {}
|
||||
|
||||
Format format() const { return format_; }
|
||||
bool is_list() const { return format_ == Format::List; }
|
||||
|
||||
// Number of elements: child count for lists, character count for ASCII,
|
||||
// array length for numeric/binary formats.
|
||||
std::size_t size() const;
|
||||
|
||||
// --- Factory functions -------------------------------------------------
|
||||
static Item list(List items) { return Item(Format::List, std::move(items)); }
|
||||
static Item ascii(std::string s) { return Item(Format::ASCII, std::move(s)); }
|
||||
static Item binary(std::vector<uint8_t> b) { return Item(Format::Binary, std::move(b)); }
|
||||
static Item boolean(std::vector<uint8_t> b) { return Item(Format::Boolean, std::move(b)); }
|
||||
static Item boolean(bool b) { return Item(Format::Boolean, std::vector<uint8_t>{static_cast<uint8_t>(b ? 1 : 0)}); }
|
||||
|
||||
static Item u1(std::vector<uint8_t> v) { return Item(Format::U1, std::move(v)); }
|
||||
static Item u2(std::vector<uint16_t> v) { return Item(Format::U2, std::move(v)); }
|
||||
static Item u4(std::vector<uint32_t> v) { return Item(Format::U4, std::move(v)); }
|
||||
static Item u8(std::vector<uint64_t> v) { return Item(Format::U8, std::move(v)); }
|
||||
static Item i1(std::vector<int8_t> v) { return Item(Format::I1, std::move(v)); }
|
||||
static Item i2(std::vector<int16_t> v) { return Item(Format::I2, std::move(v)); }
|
||||
static Item i4(std::vector<int32_t> v) { return Item(Format::I4, std::move(v)); }
|
||||
static Item i8(std::vector<int64_t> v) { return Item(Format::I8, std::move(v)); }
|
||||
static Item f4(std::vector<float> v) { return Item(Format::F4, std::move(v)); }
|
||||
static Item f8(std::vector<double> v) { return Item(Format::F8, std::move(v)); }
|
||||
|
||||
// Scalar convenience overloads.
|
||||
static Item u1(uint8_t v) { return u1(std::vector<uint8_t>{v}); }
|
||||
static Item u2(uint16_t v) { return u2(std::vector<uint16_t>{v}); }
|
||||
static Item u4(uint32_t v) { return u4(std::vector<uint32_t>{v}); }
|
||||
static Item u8(uint64_t v) { return u8(std::vector<uint64_t>{v}); }
|
||||
static Item i1(int8_t v) { return i1(std::vector<int8_t>{v}); }
|
||||
static Item i2(int16_t v) { return i2(std::vector<int16_t>{v}); }
|
||||
static Item i4(int32_t v) { return i4(std::vector<int32_t>{v}); }
|
||||
static Item i8(int64_t v) { return i8(std::vector<int64_t>{v}); }
|
||||
static Item f4(float v) { return f4(std::vector<float>{v}); }
|
||||
static Item f8(double v) { return f8(std::vector<double>{v}); }
|
||||
|
||||
// Construct directly from a format and matching storage (used by the decoder).
|
||||
static Item raw(Format f, Storage s) { return Item(f, std::move(s)); }
|
||||
|
||||
// --- Typed accessors (throw std::bad_variant_access on mismatch) --------
|
||||
const List& as_list() const { return std::get<List>(data_); }
|
||||
List& as_list() { return std::get<List>(data_); }
|
||||
const std::string& as_ascii() const { return std::get<std::string>(data_); }
|
||||
const std::vector<uint8_t>& as_bytes() const { return std::get<std::vector<uint8_t>>(data_); }
|
||||
|
||||
const Storage& storage() const { return data_; }
|
||||
|
||||
bool operator==(const Item&) const = default;
|
||||
|
||||
private:
|
||||
Item(Format f, Storage s) : format_(f), data_(std::move(s)) {}
|
||||
|
||||
Format format_;
|
||||
Storage data_;
|
||||
};
|
||||
|
||||
} // namespace secsgem::secs2
|
||||
@@ -0,0 +1,37 @@
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "secsgem/secs2/item.hpp"
|
||||
|
||||
namespace secsgem::secs2 {
|
||||
|
||||
// A logical SECS-II message: stream/function, the W-bit (reply expected), and
|
||||
// an optional root data item as the body. The transport (HSMS) header carries
|
||||
// stream/function/W on the wire; the body bytes are the encoded root item.
|
||||
struct Message {
|
||||
uint8_t stream = 0;
|
||||
uint8_t function = 0;
|
||||
bool reply_expected = false; // W-bit
|
||||
std::optional<Item> body;
|
||||
|
||||
Message() = default;
|
||||
Message(uint8_t s, uint8_t f, bool w, std::optional<Item> b = std::nullopt)
|
||||
: stream(s), function(f), reply_expected(w), body(std::move(b)) {}
|
||||
|
||||
// Encode the body item to bytes (empty if there is no body).
|
||||
std::vector<uint8_t> encode_body() const;
|
||||
|
||||
// Build a Message from stream/function/W and raw body bytes (empty -> no body).
|
||||
static Message from_body(uint8_t stream, uint8_t function, bool reply_expected,
|
||||
const std::vector<uint8_t>& body_bytes);
|
||||
|
||||
// e.g. S1F2 W
|
||||
// <L [2] <A "MDLN"> <A "1.0"> >
|
||||
std::string sml() const;
|
||||
};
|
||||
|
||||
} // namespace secsgem::secs2
|
||||
Reference in New Issue
Block a user