raphael
813e011409
tests / build-and-test (push) Failing after 32s
Adds the GEM "Documentation" Fundamental capability: the equipment now
self-reports which GEM capabilities it supports, and the host can
discover the DVID namelist with the same shape used for SVIDs.
Catalog (data/messages.yaml -> generated messages.hpp)
S1F19 W header-only Get GEM Compliance Request
S1F20 <L,3 <A SOFTREV>
<A EQPTYP>
<L,a <L,2 <U1 CCODE> <A CDESC>>>>
Get GEM Compliance Data
S1F21 W <L,n <U4 VID>> DVID Namelist Request (n=0 = all)
S1F22 <L,n <L,3 <U4 VID>
<A VNAME>
<A UNITS>>> DVID Namelist Data
Codegen emits CapabilityEntry and GemCompliance structs. S1F22 reuses
S1F12's StatusName struct (same wire shape; dedup avoids redefinition).
Equipment data dictionary (data/equipment.yaml)
device: Adds `equipment_type: "EQUIPMENT"`
for the S1F20 EQPTYP field.
capabilities: New section. List of
- {code, name} (CCODE, CDESC) pairs honestly
reflecting what the codebase
implements: 1, 2, 3, 5, 6, 7, 8,
9, 11, 12, 14 (partial), 15.
dvids: New section, same schema as
svids:. Demo populates two:
- WaferCounter (U4, units wafer)
- ChamberPressure (F4, units Torr)
Loader (src/config/loader.cpp + include/secsgem/config/loader.hpp)
EquipmentDescriptor gains equipment_type and capabilities (vector of
(uint8_t, string) pairs). load_equipment now reads `capabilities:`
into the descriptor and `dvids:` into model.dvids.
Server (apps/secs_server.cpp)
router.on(1, 19) returns S1F20 with desc.software_rev,
desc.equipment_type, and desc.capabilities converted to
vector<CapabilityEntry>.
router.on(1, 21) returns S1F22 built from model.dvids.all().
Client (apps/secs_client.cpp)
Two new demo steps after Request Online and before SVID discovery:
S1F19 -> S1F20: logs SOFTREV, EQPTYP, and every (CCODE, CDESC)
the equipment claims.
S1F21 -> S1F22: logs each DVID with units.
Tests
tests/test_messages.cpp Round-trip S1F19/F20 with a 3-entry
capability list; round-trip S1F22 with two
DVIDs.
tests/test_loader.cpp Asserts equipment_type, the capabilities
list contains CCODE 14 (Spooling), and the
two DVIDs land in model.dvids.
COMPLIANCE.md
"Documentation" Fundamental moves from ⬜ to ✅.
S1F19/F20 + S1F21/F22 rows in the coverage matrix flip to ✅.
The "what would it take" list drops the documentation-messages bullet.
Verified
- Tests: 77 cases / 444 assertions pass.
- Demo: client logs the full capability list received from the
equipment, including CCODE 14 "Spooling (partial; S2F43/F44 +
S6F23/F24)" — the equipment honestly reports its partial
implementation rather than overclaiming.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
424 lines
19 KiB
C++
424 lines
19 KiB
C++
// 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();
|
|
});
|
|
});
|
|
|
|
// 2a. Ask the equipment to self-report its GEM compliance.
|
|
seq->steps.push_back([conn, logfn, fail](auto next) {
|
|
conn->send_request(gem::s1f19_get_gem_compliance_request(),
|
|
[logfn, fail, next](std::error_code ec, const s2::Message& reply) {
|
|
if (ec) { fail("S1F19", ec); return; }
|
|
auto parsed = gem::parse_s1f20(reply);
|
|
if (parsed) {
|
|
logfn("S1F20 SOFTREV=" + parsed->softrev +
|
|
" TYPE=" + parsed->equipment_type +
|
|
" (" + std::to_string(parsed->capabilities.size()) +
|
|
" capabilities)");
|
|
for (const auto& c : parsed->capabilities) {
|
|
logfn(" CCODE " + std::to_string(c.ccode) + " " + c.cdesc);
|
|
}
|
|
}
|
|
next();
|
|
});
|
|
});
|
|
|
|
// 2b. Discover DVIDs.
|
|
seq->steps.push_back([conn, logfn, fail](auto next) {
|
|
conn->send_request(gem::s1f21_data_variable_namelist_request({}),
|
|
[logfn, fail, next](std::error_code ec, const s2::Message& reply) {
|
|
if (ec) { fail("S1F21", ec); return; }
|
|
auto parsed = gem::parse_s1f22(reply);
|
|
if (parsed) {
|
|
logfn("S1F22 (" + std::to_string(parsed->size()) + " DVIDs)");
|
|
for (const auto& dn : *parsed) {
|
|
logfn(" DVID " + std::to_string(dn.id) + " " + dn.name +
|
|
(dn.units.empty() ? "" : " [" + dn.units + "]"));
|
|
}
|
|
}
|
|
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);
|
|
});
|
|
});
|
|
|
|
// 13a. Force the equipment into spool mode (test-only RCMD; stands in
|
|
// for "the host link has gone down" in the real protocol).
|
|
seq->steps.push_back([conn, logfn, fail](auto next) {
|
|
conn->send_request(gem::s2f41_host_command("SPOOL_ON", {}),
|
|
[logfn, fail, next](std::error_code ec, const s2::Message& reply) {
|
|
if (ec) { fail("S2F41/SPOOL_ON", ec); return; }
|
|
auto r = gem::parse_s2f42(reply);
|
|
logfn("S2F42 HCACK=" +
|
|
(r ? std::to_string(static_cast<int>(r->hcack)) : "?"));
|
|
next();
|
|
});
|
|
});
|
|
|
|
// 13b. Trigger a START while spooling — the CEID 300 emission should
|
|
// land in the equipment's spool, not arrive live.
|
|
seq->steps.push_back([conn, logfn, fail, pause_then](auto next) {
|
|
conn->send_request(gem::s2f41_host_command("START", {}),
|
|
[logfn, fail, pause_then, next](std::error_code ec,
|
|
const s2::Message& reply) {
|
|
if (ec) { fail("S2F41/START(spool)", ec); return; }
|
|
auto r = gem::parse_s2f42(reply);
|
|
logfn("S2F42 HCACK=" +
|
|
(r ? std::to_string(static_cast<int>(r->hcack)) : "?") +
|
|
" (CEID 300 should be spooled, not delivered live)");
|
|
pause_then(std::chrono::milliseconds(150), next);
|
|
});
|
|
});
|
|
|
|
// 13c. Drop the spool flag back to off.
|
|
seq->steps.push_back([conn, logfn, fail](auto next) {
|
|
conn->send_request(gem::s2f41_host_command("SPOOL_OFF", {}),
|
|
[logfn, fail, next](std::error_code ec, const s2::Message& reply) {
|
|
if (ec) { fail("S2F41/SPOOL_OFF", ec); return; }
|
|
auto r = gem::parse_s2f42(reply);
|
|
logfn("S2F42 HCACK=" +
|
|
(r ? std::to_string(static_cast<int>(r->hcack)) : "?"));
|
|
next();
|
|
});
|
|
});
|
|
|
|
// 13d. Ask the equipment to transmit the spooled queue.
|
|
seq->steps.push_back([conn, logfn, fail, pause_then](auto next) {
|
|
conn->send_request(gem::s6f23_request_spool_data(gem::SpoolRequestCode::Transmit),
|
|
[logfn, fail, pause_then, next](std::error_code ec,
|
|
const s2::Message& reply) {
|
|
if (ec) { fail("S6F23", ec); return; }
|
|
auto a = gem::ack_byte(reply);
|
|
logfn("S6F24 RSDA=" + (a ? std::to_string(*a) : "?") +
|
|
" (expect spooled S6F11 to arrive next)");
|
|
pause_then(std::chrono::milliseconds(300), next);
|
|
});
|
|
});
|
|
|
|
// 14. 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;
|
|
}
|