Config.hpp

Go to the documentation of this file.

#pragma once
 
// Centralized, typed view of config.toml, parsed once via toml++ (see Config.cpp).
//
// Every C++ binary used to re-open and hand-scan config.toml with its own copy-pasted parser; this
// module is the single source of truth. Each field carries the historical call-site default so a
// missing key reproduces the old behavior exactly. Only sections that C++ actually consumes are
// modeled — [sim_pt_targets], [gui.*], [pressure_limits.*], [adc], [discovery] are TS/Python-only.
//
// NOTE: distinct from the unrelated legacy global `class Config` in lib/include/Config.h.
 
#include <cstdint>
#include <map>
#include <string>
#include <vector>
 
#include "config/LoadActiveBoards.hpp"  // ActiveBoardKind, PtInterface, PtBoardConfig, BoardChannels
#include "config/T7Config.hpp"          // T7Board
#include "time/BoardClockSync.hpp"      // fsw::time::TimeSyncConfig
 
namespace fsw {
namespace config {
 
struct NetworkConfig {
    std::string bind_ip = "0.0.0.0";    // [network].bind_ip
    uint16_t sensor_port = 5006;        // [network].sensor_port
    uint16_t actuator_cmd_port = 5005;  // [network].actuator_cmd_port
};
 
struct DatabaseConfig {
    std::string host = "127.0.0.1";  // [database].host
    uint16_t port = 2240;            // [database].port
};
 
struct ServerHeartbeatConfig {    // [server_heartbeat]
    uint32_t interval_ms = 1000;  // daq_bridge default (file usually supplies)
    uint16_t broadcast_port = 5005;
    std::string broadcast_ip = "255.255.255.255";
    bool send_from_daq_bridge = true;  // synthesized: false when [heartbeat_service].enabled
};
 
struct HeartbeatServiceConfig {  // [heartbeat_service]
    bool enabled = false;
    uint32_t interval_ms = 1000;  // clamped >=100 at use site
    std::string broadcast_ip = "192.168.2.255";
    uint16_t broadcast_port = 5005;
    std::string elodin_host = "127.0.0.1";
    uint16_t elodin_port = 2240;
};
 
struct LogsConfig {
    uint16_t backend_udp_port = 8092;  // [logs].backend_udp_port
};
 
struct ControllerServiceConfig {  // [controller_service]
    uint16_t port = 9999;
    std::string host = "127.0.0.1";
    uint32_t fire_duration_ms = 6000;
    uint32_t fire_extended_ms = 10000;
    /**
     * Who drives the valves during the burn. Default false keeps the historical split, where the
     * sequencer hands PWM roles to controller_service and tells it when the gate opens.
     *
     * true means the sequencer owns them outright: it never sends FIRE_START, and the controller
     * refuses to run its PWM gate at all. A rig with no PWM press valves wants this — otherwise
     * the controller looks for roles it cannot find and, historically, fell back to hardcoded
     * channel numbers that belonged to entirely different valves.
     */
    bool sequencer_owns_valves = false;
};
 
struct ControllerConfig {  // [controller]
    // Which actuators the controller drives is NOT stated here — it is the 4th element of the
    // [actuator_roles] entry (see ActuatorRole::controller_role), so the assignment lives with
    // the actuator and the sequencer's fire-state handoff reads the same fact.
    double pwm_frequency_hz = 10.0;
    uint32_t pwm_duration_ms = 10000;
    double controller_loop_hz = 10.0;
    double P_copv_min_pa = 0.0;
    double fallback_fuel_duty_cycle = 0.0;
    double fallback_ox_duty_cycle = 0.0;
    std::string lut_path;
    std::string thrust_curve_path;
};
 
struct ActuatorServiceConfig {  // [actuator_service]
    uint16_t port = 9998;
    std::string bind_address = "0.0.0.0";
};
 
struct CalibrationConfig {  // [calibration.tc/.rtd/.lc]
    double tc_adc_ref_voltage = 2.5;
    double rtd_adc_ref_voltage = 2.5;
    double rtd_excitation_ua = 1000.0;
    double rtd_r0_ohm = 1000.0;
    double lc_sensitivity_mv_per_v = 2.0;
    double lc_pga_gain = 32.0;
    double lc_full_scale_value = 300.0;
    // Per-type coefficient sources from the TOML (previously ignored; the service used to hardcode
    // these). json_dir = newest-*.json dir of per-channel coeffs; csv_path = first of
    // [calibration.*] csv_paths. Empty string keeps the historical hardcoded default at the call
    // site.
    std::string tc_json_dir, tc_csv_path;
    std::string rtd_json_dir, rtd_csv_path;
    std::string lc_json_dir, lc_csv_path;
};
 
struct FireConfig {     // [fire]
    std::string state;  // "" when absent; consumers guard on empty and keep their own default
    std::string expiry_target;
    uint32_t duration_ms = 6000;
    uint32_t extended_ms = 10000;
    /**
     * The valve the burn is timed around, if the fire state staggers its actuators.
     *
     * Same meaning as [flow].gate_actuator, and it matters MORE here. A fire column that opens an
     * upstream valve first and the main a second later, with the window measured from the
     * transition, burns for (duration - stagger) — and if the stagger equals the duration it does
     * not burn at all while still commanding an ignition sequence. Naming the gate makes
     * duration_ms mean "this valve is open for that long", which is what a burn time is.
     */
    std::string gate_actuator;
};
 
/**
 * [flow] — the characterization hold: open a valve for an exact interval, then close it.
 *
 * Mirrors [fire], with one deliberate difference. [fire] names its state by string, which is the
 * coupling that let a rename strand the rig mid-burn; [flow] never does. WHICH state this is comes
 * from the `is_flow` flag on a [[states]] entry, so the operator can rename it, delete it, or move
 * the flag to another state without touching anything here.
 */
struct FlowConfig {             // [flow]
    std::string return_target;  // where the hold expires to; "" disables the flow hold
    uint32_t duration_ms = 0;   // default window when the client supplies none
    uint32_t max_ms = 0;        // ceiling on a client-supplied window; 0 falls back to duration_ms
    /**
     * The actuator the hold is timed around — the one whose opening actually starts the flow.
     *
     * A staggered state does not open everything at once: a pressure-regulated feed may crack an
     * upstream valve first and only then the main, using the per-actuator delays in
     * state_machine_actuator_delays.csv. The requested duration is what the operator wants THIS
     * valve open for, so the sequencer holds for (its delay + the requested duration). Empty means
     * no stagger and the hold is measured from the transition.
     */
    std::string gate_actuator;
};
 
struct StateMachinePaths {  // [state_machine]
    std::string transitions_csv = "config/state_transitions.csv";
    std::string actuator_csv = "config/state_machine_actuators.csv";
    std::string actuator_delay_csv = "config/state_machine_actuator_delays.csv";
};
 
struct StateDef {  // one per [[states]]
    int id = -1;
    std::string name;
    bool is_abort = false;
    bool is_boot = false;
    /** Marks the state the characterization hold drives. A flag rather than a name in [flow], so
     *  renaming the state cannot break it. First one wins, as with is_boot. */
    bool is_flow = false;
 
    // ── Dynamic states ────────────────────────────────────────────────────────────────────────
    //
    // A state with a script runs it on entry: the CSV column is applied first, putting every valve
    // in a defined position, and the script then layers on top.
    //
    // There is deliberately NO `is_dynamic` flag. A non-empty script_file is what makes a state
    // dynamic, for the reason [fire] demonstrates the other way: when a flag and the data it
    // describes are separate, they can disagree, and the disagreement is silent.
 
    /** Script filename inside the profile's scripts/ directory, e.g. "copv_press.script".
     *
     *  A bare filename, never a path — it arrives from operator-editable config and the backend
     *  writes files at this name, so it must match ^[A-Za-z0-9_-]+\.script$ with no separators and
     *  no "..". Empty means this state is not dynamic.
     *
     *  The script lives beside config.toml rather than inside it because writeConfig() is a full
     *  TOML re-stringify that destroys every comment and all layout on each save. Out of the TOML,
     *  a script survives a config save byte-for-byte and diffs cleanly. */
    std::string script_file;
 
    /** Wall-clock ceiling for the whole script, in milliseconds. Mandatory for a dynamic state:
     *  an unbounded script has no safe degraded mode, so config that omits it leaves the state not
     *  enterable rather than enterable-and-unbounded. */
    uint32_t script_timeout_ms = 0;
 
    /** Where the state lands when the script runs off its end without calling transition_to.
     *  Mandatory. Unreachable when every path ends in an explicit transition_to, and required
     *  anyway — it is the backstop for the path the author did not think about. */
    std::string script_return_target;
 
    /** Where the state lands when script_timeout_ms expires. Mandatory, and deliberately NOT
     *  defaulted to script_return_target: a runaway may want somewhere more conservative than a
     *  clean finish, and a safety landing that appears by default is the kind that is wrong
     *  silently. */
    std::string script_timeout_target;
};
 
// [actuator_roles] value ["NC"|"NO", channel, board_id, controller_role?]
//
// The optional 4th element assigns the actuator to controller_service: "pwm_fuel" or "pwm_ox".
// It is the single statement of which hardware the controller drives — the sequencer stops
// commanding an assigned actuator in the fire state (so there is one writer during a burn), and
// the controller resolves its PWM outputs from the same entries.
//
// It is a separate slot from `kind` deliberately. `kind` used to carry a third value "PWM" for
// this, but it is also where NC/NO polarity lives, so an actuator could not be both PWM-driven
// and normally open — and since the shipped configs needed NC/NO, nothing was ever marked "PWM"
// and the fire-state handoff never engaged on a real rig.
struct ActuatorRole {
    std::string kind = "NC";  // raw first element; polarity only (NC/NO)
    bool is_no = false;       // kind == "NO"; always false on a ball valve board
    bool ball_valve = false;  // its board_id names a [boards.*] with type = "BALL_VALVE"
    int channel = 0;
    int board_id = 0;
    std::string controller_role;  // "pwm_fuel" | "pwm_ox"; empty = sequencer-owned
};
 
// One [boards.*] section. Superset of every reader's keys so a single parse serves all binaries.
struct BoardConfig {
    std::string section;  // e.g. "boards.pt_board" (order/diagnostics)
    std::string type;     // "PT"/"TC"/"RTD"/"LC"/"ACTUATOR"/"ENCODER"/"BALL_VALVE" (raw, unquoted)
    std::string ip;
    int board_id = -1;  // board_id, with legacy "id" fallback
    bool enabled = true;
    int num_actuators = 0;
    uint16_t send_port = 5005;
    uint16_t listen_port = 5005;
    int enable_serial_printing = 0;  // tolerate bool-or-int; clamped 0..3
    int voltage_reference = 0;
    bool necessary_for_abort = false;
    bool designated_survivor = false;
    /** Connector ids this board samples — the ONLY statement of which channels exist.
     *
     *  These are identifiers, not a range: {1, 3, 5, 7} is ordinary, and getAdcChannel()
     *  maps each id to hardware, so an id above the count is normal. It goes on the wire
     *  verbatim as SensorConfigPacket's `N x uint8_t sensor_id`, and the packet's
     *  `num_sensors` byte is simply N — the firmware reads it as `active_count` and loops
     *  over the ids (see LC_Hotfire collect_chunk_impl).
     *
     *  There used to be a separate config-only `num_sensors` that meant "expand to 1..N
     *  when this list is empty". Nothing on the wire or in firmware carried that meaning,
     *  and having both let a board declare {1, 2, 6} beside num_sensors = 4, which no
     *  layer defined. Empty now means no channels, which is what it reads like. */
    std::vector<int> active_connectors;
 
    // PT-specific (feeds pt_boards()):
    std::string pt_type;  // "" if absent
    double adc_ref_voltage = 2.5;
    bool has_hp_pt_keys = false;  // hp_pt_connectors or hp_pt_full_scale_psi present (legacy infer)
    double hp_pt_full_scale_psi = 5000.0;
    double hp_pt_sense_resistor_ohms = 120.0;
 
    /** Elodin slot: board_id % 10, with 0 mapping to 10. */
    uint8_t slot() const {
        int m = board_id % 10;
        return static_cast<uint8_t>(m == 0 ? 10 : m);
    }
};
 
/** The whole parsed config.toml, restricted to what C++ consumes. */
struct Config {
    NetworkConfig network;
    DatabaseConfig database;
    ServerHeartbeatConfig server_heartbeat;
    HeartbeatServiceConfig heartbeat_service;
    LogsConfig logs;
    fsw::time::TimeSyncConfig time_sync;
    uint32_t config_broadcast_interval_ms = 1000;  // [config_broadcast_service].interval_ms
    std::vector<BoardConfig> boards;               // parse order preserved
    // [boards.*] with type = "T7" (LabJack, read by t7_bridge only). They also appear in `boards`
    // with type "T7", which every other reader skips as an unknown type. A board named in any
    // t7_errors entry must not be streamed; t7_bridge refuses to start while the list is non-empty.
    std::vector<T7Board> t7_boards;
    std::vector<std::string> t7_errors;
    std::map<std::string, ActuatorRole> actuator_roles;
    FireConfig fire;
    FlowConfig flow;
    ControllerServiceConfig controller_service;
    ControllerConfig controller;
    ActuatorServiceConfig actuator_service;
    CalibrationConfig calibration;
    StateMachinePaths state_machine;
    std::vector<StateDef> states;
    // section name -> {role name -> channel}, e.g. "sensor_roles_pt_board" -> {"Fuel Upstream": 1}.
    std::map<std::string, std::map<std::string, int>> sensor_roles;
    std::map<std::string, double> abort_pts;  // [abort_pts]
    // section name -> {role name -> "cubic"|"robust"|"physics"|"blend"} for a PT board, or
    // "linear"|"cubic"|"physics" for an LC board (linear is the LC default), e.g.
    // "calibration_model_pt_board" -> {"Ox Upstream": "robust"}. Per-sensor streaming model.
    std::map<std::string, std::map<std::string, std::string>> calibration_models;
    // Per-sensor physics-mode parameters, role-keyed, parallel to calibration_models:
    // [calibration_full_scale_<board>] role->PSI (PT) or role->kg (LC) and
    // [calibration_sense_resistor_<board>] role->Ω (PT 4-20 mA only).
    std::map<std::string, std::map<std::string, double>> calibration_full_scale;
    std::map<std::string, std::map<std::string, double>> calibration_sense_resistor;
    // LC-only physics params, role-keyed, parallel to calibration_full_scale:
    // [calibration_sensitivity_<board>] role->mV/V and [calibration_pga_<board>] role->gain.
    std::map<std::string, std::map<std::string, double>> calibration_sensitivity;
    std::map<std::string, std::map<std::string, double>> calibration_pga_gain;
 
    /** [sensor_roles_<board>] with a legacy [sensor_roles] fallback. */
    const std::map<std::string, int>* sensor_roles_for(const std::string& board_key) const;
 
    /** [calibration_model_<board>] role->model map, or nullptr when absent/empty. */
    const std::map<std::string, std::string>* calibration_model_for(
        const std::string& section_key) const;
 
    /** [calibration_full_scale_<board>] role->PSI map, or nullptr when absent/empty. */
    const std::map<std::string, double>* full_scale_for(const std::string& section_key) const;
 
    /** [calibration_sense_resistor_<board>] role->Ω map, or nullptr when absent/empty. */
    const std::map<std::string, double>* sense_resistor_for(const std::string& section_key) const;
 
    /** [calibration_sensitivity_<board>] role->mV/V map, or nullptr when absent/empty. */
    const std::map<std::string, double>* sensitivity_for(const std::string& section_key) const;
 
    /** [calibration_pga_<board>] role->gain map, or nullptr when absent/empty. */
    const std::map<std::string, double>* pga_gain_for(const std::string& section_key) const;
};
 
/** Parse config.toml. Invalid environmental identities throw std::invalid_argument;
 * other read/parse errors log and return a default-constructed Config. */
Config load(const std::string& path);
 
/** Parse config from an in-memory TOML string (SequencerService / ActuatorCommander hold it so). */
Config load_from_string(const std::string& text);
 
/**
 * Derive the active-board table (enabled boards -> Elodin BoardChannels), with the same
 * slot-collision validation the old load_active_boards() logged. Free-function form used by
 * daq_bridge/calibration/sequencer.
 */
std::map<ActiveBoardKind, std::vector<elodin::BoardChannels>> active_boards(const Config& cfg);
 
/** [boards.*].type string -> kind; anything unrecognised is UNKNOWN. */
ActiveBoardKind kind_of(const std::string& type_str);
 
/** Derive PT board 4-20 mA parameters keyed by Elodin slot (mirrors old load_pt_boards()). */
std::map<uint8_t, PtBoardConfig> pt_boards(const Config& cfg);
 
}  // namespace config
}  // namespace fsw