raphael/secs-gem
Public Access
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
711ee1b40f7859e4f984383d4220dacb8bfa1a41
secs-gem/apps/secs_client.cpp
T
raphael 711ee1b40f #4 Split EquipmentDataModel into focused stores 
The god-class is gone.  Each capability is now its own focused store:
StatusVariableStore, DataVariableStore, EquipmentConstantStore (with EAC
range validation), EventReportSubscriptions, AlarmRegistry, RecipeStore,
Clock, HostCommandRegistry.  Each is independently testable.

EquipmentDataModel becomes a small composite that holds one of each store
as a public member, plus three convenience methods (vid_value, vid_exists,
compose_reports_for) that span SVIDs+DVIDs and inject the right callbacks
into the EventReportSubscriptions.

New under include/secsgem/gem/store/:

  status_variables.hpp   StatusVariable, StatusVariableStore,
                         DataVariable, DataVariableStore
  equipment_constants.hpp EquipmentConstant, EquipmentConstantStore,
                          EquipmentAck. set_value() now validates
                          numeric values against min_str/max_str and
                          returns EAC=4 on out-of-range — closes the
                          COMPLIANCE.md gap about EC range validation.
  event_reports.hpp      CollectionEvent, Report, ReportData,
                         EventReportSubscriptions + DefineReportAck,
                         LinkEventAck, EnableEventAck. The store is
                         pure data; VidLookup / VidExists callbacks
                         are injected at define / emit time so the
                         service doesn't back-reference the SVID
                         store.
  alarms.hpp             Alarm, AlarmAck, AlarmRegistry.
                         Encapsulates the (enabled, active) sets and
                         ALCD byte computation.
  recipes.hpp            ProcessProgramAck, RecipeStore.
  clock.hpp              TimeAck, Clock. set_time_string applies an
                         offset so subsequent reads reflect the host
                         time without mutating system clock.
  host_commands.hpp      HostCmdAck, CommandParameter,
                         HostCommandRegistry with Spec/Result types.

include/secsgem/gem/data_model.hpp shrinks to a 50-line composite:

  struct EquipmentDataModel {
    StatusVariableStore       svids;
    DataVariableStore         dvids;
    EquipmentConstantStore    ecids;
    EventReportSubscriptions  events;
    AlarmRegistry             alarms;
    RecipeStore               recipes;
    Clock                     clock;
    HostCommandRegistry       commands;
    /* + vid_value, vid_exists, compose_reports_for sugar */
  };

src/gem/data_model.cpp is gone — every store is inline header-only.

include/secsgem/gem/messages_helpers.hpp picks up EventReportAck and
TerminalAck (S6F12 / S10F2-F4 ack enums that aren't tied to any one
store).

Call-site updates:

  apps/secs_server.cpp   model->status_variable(id) -> model->svids.get(id),
                         model->equipment_constant(id) -> model->ecids.get(id),
                         model->alarm_set(id) -> model->alarms.set_active(id),
                         model->dispatch_command(...) -> model->commands.dispatch(...),
                         and similar across every handler.  Plus
                         model->current_time_string() -> model->clock....

  src/config/loader.cpp  model.add_status_variable(sv) -> model.svids.add(sv),
                         and similar.  HostCommandRegistry::Spec replaces
                         EquipmentDataModel::CommandSpec.

  apps/secs_client.cpp   std::vector<EquipmentDataModel::CommandParam> ->
                         std::vector<CommandParameter>.

  tests/test_data_model.cpp  Rewritten around the individual stores;
                         each gets its own TEST_CASE block.  Adds three
                         new cases covering EC range validation (in
                         range / out of range / non-numeric skipped).

  tests/test_loader.cpp  m.has_event(100) -> m.events.has_event(100),
                         etc.

Verified:

  - Tests: 69 cases / 370 assertions pass (was 67 / 384; -14 stale
    composite-API assertions + 16 new store-level assertions covering
    EC range validation and the per-store add/get/list/delete paths).
  - Demo: byte-identical behaviour across the full 17-step flow.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
2026-06-02 09:51:54 +02:00

335 lines
14 KiB
C++
Raw Blame History

// 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_s10f3(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->alcd & 0x80) ? "SET" : "CLR") +
" ALID=" + std::to_string(a->alid) +
" cat=" + std::to_string(a->alcd & 0x7F) + " \"" + 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::CommandParameter> 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(gem::kAlarmEnableByte, 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;
}
Reference in New Issue View Git Blame Copy Permalink