raphael
0090791968
Host commands were declarative-only: dispatch() returned the YAML-defined HCACK plus side effects, and ignored the command parameters entirely (the param list was a commented-out argument). Equipment could acknowledge a command but never run anything in response — the pvd_tool example worked around this by hard-coding behaviour in a C++ router handler. Add set_handler(rcmd, fn): a registered handler receives the live CPNAME/ CPVAL parameters and returns the HCACK, overriding the declarative default. Live on S2F41/F21/F49 via the shared dispatch(). No handler => byte-for-byte the previous declarative behaviour. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
90 lines
3.0 KiB
C++
90 lines
3.0 KiB
C++
#pragma once
|
|
|
|
#include <cstdint>
|
|
#include <functional>
|
|
#include <map>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "secsgem/secs2/item.hpp"
|
|
|
|
namespace secsgem::gem {
|
|
|
|
namespace s2 = secsgem::secs2;
|
|
|
|
enum class HostCmdAck : uint8_t {
|
|
Accept = 0,
|
|
InvalidCommand = 1,
|
|
CannotDoNow = 2,
|
|
ParameterInvalid = 3,
|
|
AcceptedWillFinishLater = 4,
|
|
Rejected = 5,
|
|
InvalidObject = 6,
|
|
};
|
|
|
|
// One <CPNAME, CPVAL> entry on S2F41. The messages catalog declares this
|
|
// struct external_struct: true so the codegen references it rather than
|
|
// redefining it.
|
|
struct CommandParameter {
|
|
std::string name;
|
|
s2::Item value;
|
|
};
|
|
|
|
class HostCommandRegistry {
|
|
public:
|
|
// Declarative effect, loaded from YAML.
|
|
struct Spec {
|
|
HostCmdAck ack = HostCmdAck::Accept;
|
|
std::optional<uint32_t> emit_ceid;
|
|
std::optional<uint32_t> set_alarm;
|
|
std::optional<bool> force_spool; // toggles the SpoolStore's flag
|
|
};
|
|
|
|
struct Result {
|
|
HostCmdAck ack = HostCmdAck::InvalidCommand;
|
|
std::optional<uint32_t> emit_ceid;
|
|
std::optional<uint32_t> set_alarm;
|
|
std::optional<bool> force_spool;
|
|
};
|
|
|
|
// Behaviour hook: vendor code that actually *does* something when the host
|
|
// sends a command (run a recipe, move hardware, validate the parameters).
|
|
// The handler receives the live <CPNAME, CPVAL> parameter list and returns
|
|
// the HCACK to send back; returning anything other than Accept suppresses
|
|
// the Spec's declarative side effects, since the router only applies
|
|
// emit_ceid / set_alarm / force_spool on Accept. Without a handler a
|
|
// command stays purely declarative (the YAML Spec's static ack), which is
|
|
// the pre-existing behaviour.
|
|
using Handler = std::function<HostCmdAck(
|
|
const std::string& rcmd, const std::vector<CommandParameter>& params)>;
|
|
|
|
void register_command(std::string rcmd, Spec spec) {
|
|
by_rcmd_.insert_or_assign(std::move(rcmd), std::move(spec));
|
|
}
|
|
// Attach behaviour to an already-registered command. Independent of
|
|
// register_command so the data dictionary (YAML) and the behaviour
|
|
// (application code) can be wired separately.
|
|
void set_handler(std::string rcmd, Handler h) {
|
|
handlers_.insert_or_assign(std::move(rcmd), std::move(h));
|
|
}
|
|
bool has(const std::string& rcmd) const { return by_rcmd_.count(rcmd) > 0; }
|
|
bool has_handler(const std::string& rcmd) const { return handlers_.count(rcmd) > 0; }
|
|
Result dispatch(const std::string& rcmd,
|
|
const std::vector<CommandParameter>& params) const {
|
|
auto it = by_rcmd_.find(rcmd);
|
|
if (it == by_rcmd_.end()) return {HostCmdAck::InvalidCommand, std::nullopt, std::nullopt, std::nullopt};
|
|
HostCmdAck ack = it->second.ack;
|
|
if (auto hit = handlers_.find(rcmd); hit != handlers_.end() && hit->second)
|
|
ack = hit->second(rcmd, params); // vendor behaviour decides the outcome
|
|
return {ack, it->second.emit_ceid, it->second.set_alarm, it->second.force_spool};
|
|
}
|
|
|
|
private:
|
|
std::map<std::string, Spec> by_rcmd_;
|
|
std::map<std::string, Handler> handlers_;
|
|
};
|
|
|
|
} // namespace secsgem::gem
|