raphael
6ff3104591
Fleshes out the host-side message surface so the demo client app no
longer has to inline message construction. Senders added (each is a
one-line wrapper over the codegen builders + Connection::send_request):
Remote command: S2F41/F42, S2F49/F50
Alarm management: S5F3/F4 enable, S5F5/F6 list, S5F7/F8 list-enabled,
S5F13/F14 recover, S5F17/F18 recover-abort
Process programs: S7F3/F4 send, S7F5/F6 request, S7F19/F20 EPPD
Spool: S6F23/F24
Terminal: S10F1/F2 single, S10F5/F6 multi
E40 Process Jobs: S16F11/F12 create, S16F5/F6 command, S16F13/F14 dequeue
E94 Control Jobs: S14F9/F10 create, S14F11/F12 delete, S16F27/F28 command
CommandParameter is reused from store/host_commands.hpp rather than
inventing a parallel ParamPair — host and equipment talk in the same
struct now.
Closes the outbound side of the host-mode menu. The remaining piece
is an integration test that drives this against the equipment server
end-to-end (B4).
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
187 lines
8.6 KiB
C++
187 lines
8.6 KiB
C++
#pragma once
|
|
|
|
#include <array>
|
|
#include <cstdint>
|
|
#include <functional>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <system_error>
|
|
#include <vector>
|
|
|
|
#include "secsgem/gem/store/event_reports.hpp"
|
|
#include "secsgem/gem/store/host_commands.hpp" // CommandParameter
|
|
#include "secsgem/gem/store/spool.hpp" // SpoolRequestCode
|
|
#include "secsgem/hsms/connection.hpp"
|
|
#include "secsgem/secs2/item.hpp"
|
|
#include "secsgem/secs2/message.hpp"
|
|
|
|
// GEM host-side message handler. Wraps an HSMS Connection (Active mode)
|
|
// and provides:
|
|
//
|
|
// - Inbound dispatch with sensible automatic acks for the messages a
|
|
// host is expected to accept passively (S5F1 alarms, S6F11 event
|
|
// reports, S9F* errors, S10F1 terminal text). Each gets a
|
|
// user-settable observer callback.
|
|
//
|
|
// - High-level workflow shortcuts: establish_communication() (S1F13)
|
|
// and go_remote() (S1F17) are the standard GEM host startup pair.
|
|
//
|
|
// - Convenience senders for the GEM/E40/E94 message surface
|
|
// (see host_handler_senders.hpp for the full menu in B2/B3).
|
|
//
|
|
// Mirrors secsgem-py's `GemHostHandler` in `gem/hosthandler.py`. Equipment-
|
|
// side behaviour lives in the existing server app; pulling it into a
|
|
// matching `EquipmentHandler` class is a separate refactor.
|
|
namespace secsgem::gem {
|
|
|
|
class HostHandler : public std::enable_shared_from_this<HostHandler> {
|
|
public:
|
|
using ReplyHandler = std::function<void(std::error_code, const secs2::Message&)>;
|
|
using EventHandler = std::function<void(uint32_t dataid, uint32_t ceid,
|
|
const std::vector<ReportData>& reports)>;
|
|
using AlarmHandler = std::function<void(uint32_t alid, uint8_t alcd,
|
|
const std::string& altx)>;
|
|
using TerminalHandler = std::function<void(uint32_t tid, const std::string& text)>;
|
|
using S9Handler = std::function<void(uint8_t function,
|
|
const std::array<uint8_t, 10>& mhead)>;
|
|
using LogHandler = std::function<void(const std::string&)>;
|
|
|
|
explicit HostHandler(std::shared_ptr<hsms::Connection> conn);
|
|
|
|
// Inbound observers. Each is optional; if unset, the message is acked
|
|
// (where required) and otherwise ignored.
|
|
void set_event_handler(EventHandler h) { on_event_ = std::move(h); }
|
|
void set_alarm_handler(AlarmHandler h) { on_alarm_ = std::move(h); }
|
|
void set_terminal_handler(TerminalHandler h) { on_terminal_ = std::move(h); }
|
|
void set_s9_handler(S9Handler h) { on_s9_ = std::move(h); }
|
|
void set_log_handler(LogHandler h) { on_log_ = std::move(h); }
|
|
|
|
// Wire the inbound message handler into the underlying Connection.
|
|
// Call once before Connection::start() so the dispatch table is live
|
|
// when the first inbound primary arrives.
|
|
void install();
|
|
|
|
// ---- Workflow shortcuts ------------------------------------------------
|
|
|
|
// S1F13/F14 Establish Communication. Resolves `cb` with the equipment's
|
|
// S1F14 reply (or a timeout / error).
|
|
void establish_communication(ReplyHandler cb);
|
|
|
|
// S1F17/F18 Request Online. Equipment may reply Accepted / NotAllowed /
|
|
// AlreadyOnline; the raw S1F18 message is forwarded to `cb`.
|
|
void go_remote(ReplyHandler cb);
|
|
|
|
// S1F15/F16 Request Offline. Counterpart to go_remote().
|
|
void go_offline(ReplyHandler cb);
|
|
|
|
// ---- Status + subscription senders (B2) -------------------------------
|
|
|
|
// S1F3/F4 Selected Status Data: empty `svids` requests every SVID.
|
|
void send_selected_status(const std::vector<uint32_t>& svids, ReplyHandler cb);
|
|
|
|
// S1F11/F12 Status Variable Namelist: empty `svids` requests every name.
|
|
void send_status_namelist(const std::vector<uint32_t>& svids, ReplyHandler cb);
|
|
|
|
// S2F33/F34 Define Report. `reports[i] = {rptid, [vids]}`; an empty
|
|
// rptid list per request resets that report (per E30 §6.11).
|
|
void send_define_reports(
|
|
uint32_t dataid,
|
|
const std::vector<std::pair<uint32_t, std::vector<uint32_t>>>& reports,
|
|
ReplyHandler cb);
|
|
|
|
// S2F35/F36 Link Event Reports. `links[i] = {ceid, [rptids]}`.
|
|
void send_link_event_reports(
|
|
uint32_t dataid,
|
|
const std::vector<std::pair<uint32_t, std::vector<uint32_t>>>& links,
|
|
ReplyHandler cb);
|
|
|
|
// S2F37/F38 Enable/Disable Events. Empty `ceids` = all.
|
|
void send_enable_events(bool enable, const std::vector<uint32_t>& ceids,
|
|
ReplyHandler cb);
|
|
|
|
// ---- Remote command senders (B3) --------------------------------------
|
|
|
|
// S2F41/F42 Host Command. `params` reuses CommandParameter from
|
|
// host_commands.hpp so host- and equipment-side code share the type.
|
|
void send_remote_command(const std::string& rcmd,
|
|
const std::vector<CommandParameter>& params,
|
|
ReplyHandler cb);
|
|
|
|
// S2F49/F50 Enhanced Host Command (OBJSPEC-scoped + per-CP CPACK/CEPACK).
|
|
void send_enhanced_remote_command(uint32_t dataid, const std::string& objspec,
|
|
const std::string& rcmd,
|
|
const std::vector<CommandParameter>& params,
|
|
ReplyHandler cb);
|
|
|
|
// ---- Alarm management (B3) --------------------------------------------
|
|
|
|
// S5F3/F4 Enable/Disable Alarm. Spec uses ALED bit-7 to encode enable.
|
|
void send_enable_alarm(uint32_t alid, bool enable, ReplyHandler cb);
|
|
void send_list_alarms(const std::vector<uint32_t>& alids, ReplyHandler cb); // S5F5/F6
|
|
void send_list_enabled_alarms(ReplyHandler cb); // S5F7/F8
|
|
|
|
// S5F13/F14 Exception Recover Request. Asks the equipment to perform
|
|
// the named recovery action against the previously-posted EXID.
|
|
void send_exception_recover(uint32_t exid, const std::string& exrecvra,
|
|
ReplyHandler cb);
|
|
void send_exception_recover_abort(uint32_t exid, ReplyHandler cb); // S5F17/F18
|
|
|
|
// ---- Process program transfer (B3) ------------------------------------
|
|
|
|
void send_request_eppd(ReplyHandler cb); // S7F19/F20
|
|
void send_pp_data(const std::string& ppid, const std::string& body,
|
|
ReplyHandler cb); // S7F3/F4
|
|
void send_request_pp(const std::string& ppid, ReplyHandler cb); // S7F5/F6
|
|
|
|
// ---- Spool (B3) -------------------------------------------------------
|
|
|
|
void send_request_spool(SpoolRequestCode code, ReplyHandler cb); // S6F23/F24
|
|
|
|
// ---- Terminal (B3) ----------------------------------------------------
|
|
|
|
void send_terminal_display(uint32_t tid, const std::string& text,
|
|
ReplyHandler cb); // S10F1/F2
|
|
void send_terminal_display_multi(uint32_t tid,
|
|
const std::vector<std::string>& lines,
|
|
ReplyHandler cb); // S10F5/F6
|
|
|
|
// ---- E40 Process Jobs (B3) --------------------------------------------
|
|
|
|
void send_create_process_job(const std::string& prjobid, const std::string& ppid,
|
|
const std::vector<std::string>& mtrloutspec,
|
|
ReplyHandler cb); // S16F11/F12
|
|
void send_pr_job_command(const std::string& prjobid, const std::string& prcmd,
|
|
ReplyHandler cb); // S16F5/F6
|
|
void send_pr_job_dequeue(const std::string& prjobid, ReplyHandler cb); // S16F13/F14
|
|
|
|
// ---- E94 Control Jobs (B3) --------------------------------------------
|
|
|
|
void send_create_control_job(const std::string& ctljobid,
|
|
const std::vector<std::string>& prjobids,
|
|
ReplyHandler cb); // S14F9/F10
|
|
void send_delete_control_job(const std::string& ctljobid, ReplyHandler cb); // S14F11/F12
|
|
void send_cj_command(const std::string& ctljobid, const std::string& ctljobcmd,
|
|
ReplyHandler cb); // S16F27/F28
|
|
|
|
// ---- Low-level: forward a primary verbatim ----------------------------
|
|
void send_request(secs2::Message msg, ReplyHandler cb);
|
|
|
|
// Access to the underlying connection (sample apps and tests need it).
|
|
hsms::Connection& connection() { return *conn_; }
|
|
|
|
protected:
|
|
// Single inbound dispatch entry point — installed on Connection.
|
|
std::optional<secs2::Message> handle_inbound(const secs2::Message& msg);
|
|
|
|
void log(const std::string& msg);
|
|
|
|
std::shared_ptr<hsms::Connection> conn_;
|
|
EventHandler on_event_;
|
|
AlarmHandler on_alarm_;
|
|
TerminalHandler on_terminal_;
|
|
S9Handler on_s9_;
|
|
LogHandler on_log_;
|
|
};
|
|
|
|
} // namespace secsgem::gem
|