DatabaseConfig.hpp

Go to the documentation of this file.

#ifndef DAQ_DATABASE_CONFIG_HPP
#define DAQ_DATABASE_CONFIG_HPP
 
#include <cstdint>
#include <string>
#include <utility>
#include <vector>
 
#include "ElodinClient.hpp"
 
namespace fsw {
namespace elodin {
 
/**
 * @brief Per-board channel info for board-namespaced entity registration.
 *
 * board_id:     raw board ID from config (e.g. 21, 22, 12, 14)
 * board_number: Elodin / daq slot = (board_id % 10) with 0 → 10 (e.g. id 12→2, id 10→10)
 * channels:     local connector IDs (1-10) that are active on this board
 */
struct BoardChannels {
    uint8_t board_id;
    uint8_t board_number;           // board_id % 10
    std::vector<uint8_t> channels;  // local channels (1-10)
};
 
/**
 * @brief Elodin table ids (hi, lo) for the RAW sensor VTables the given boards publish.
 *
 * The (type_hi, (board_number-1)*0x20 + channel) encoding is defined by
 * DatabaseConfig::register_tables(), so it lives here beside it rather than being re-derived by
 * every subscriber. Built from the boards actually in config — the version this replaced guessed
 * boards 1-8 x channels 1-10 and subscribed to 480 tables whether they existed or not.
 */
std::vector<std::pair<uint8_t, uint8_t>> raw_sensor_tables(
    const std::vector<BoardChannels>& pt_boards, const std::vector<BoardChannels>& act_boards,
    const std::vector<BoardChannels>& tc_boards, const std::vector<BoardChannels>& rtd_boards,
    const std::vector<BoardChannels>& lc_boards, const std::vector<BoardChannels>& enc_boards);
 
/**
 * @brief Elodin table ids for the CALIBRATED VTables, matching register_calibrated_tables()
 *        (same encoding as above with a +0x10 channel offset, and ACT at 0x31 rather than 0x30).
 */
std::vector<std::pair<uint8_t, uint8_t>> calibrated_sensor_tables(
    const std::vector<BoardChannels>& pt_boards, const std::vector<BoardChannels>& tc_boards,
    const std::vector<BoardChannels>& rtd_boards, const std::vector<BoardChannels>& lc_boards,
    const std::vector<BoardChannels>& enc_boards, const std::vector<BoardChannels>& act_boards);
 
/**
 * Ball valve boards (BALL_VALVE) have their own type_hi bytes, so a valve never shares a key with
 * an ACTUATOR board on the same board_id % 10 slot (board 71 and actuator board 11 are both slot
 * 1): 0x33 raw position counts   BV<n>.CH<m>          raw_adc_counts 0x34 calibrated position
 * BV<n>_Cal.CH<m>      position_pct, raw_adc, cal_status 0x35 commanded state BV_CMD.B<n>.CH<m>
 * actuator_state (0 closed, 1 open) Low bytes follow the other boards: raw/cmd (n-1)*0x20 + m,
 * calibrated (n-1)*0x20 + 0x10 + m.
 */
constexpr uint8_t kBallValveRawHi = 0x33;
constexpr uint8_t kBallValveCalHi = 0x34;
constexpr uint8_t kBallValveCmdHi = 0x35;
 
std::vector<std::pair<uint8_t, uint8_t>> ball_valve_raw_tables(
    const std::vector<BoardChannels>& bv_boards);
std::vector<std::pair<uint8_t, uint8_t>> ball_valve_calibrated_tables(
    const std::vector<BoardChannels>& bv_boards);
std::vector<std::pair<uint8_t, uint8_t>> ball_valve_cmd_tables(
    const std::vector<BoardChannels>& bv_boards);
 
/** Non-sensor tables, named rather than spelled as literals at each use site. */
constexpr std::pair<uint8_t, uint8_t> kTableSequencerState{0x50, 0x00};
constexpr std::pair<uint8_t, uint8_t> kTableControllerState{0x43, 0x00};
constexpr std::pair<uint8_t, uint8_t> kTableCalibrationCommand{0x46, 0x00};
 
/**
 * @brief Register sensor table schemas with Elodin database.
 *
 * All VTables use board-namespaced entity names (e.g. PT1.CH1, TC1.CH5,
 * ACT2.CH3).  Role names (e.g. "Fuel Upstream") are metadata only — the
 * frontend maps channel → display name from config.toml at render time.
 *
 * Two separate entry points:
 *   - register_tables()            → RAW VTables only  (called by daq_bridge)
 *   - register_calibrated_tables() → CALIBRATED VTables (called by calibration_service)
 */
class DatabaseConfig {
public:
    static bool register_environmental_tables(ElodinClient& client,
                                              const std::vector<BoardChannels>& boards);
 
    /**
     * @brief Register RAW sensor / actuator VTables.
     *
     * Each vector lists boards with their local channels.
     * Entity names: PT<board_number>.CH<n>, ACT<board_number>.CH<n>, etc.
     */
    static bool register_tables(ElodinClient& client, const std::vector<BoardChannels>& pt_boards,
                                const std::vector<BoardChannels>& act_boards,
                                const std::vector<BoardChannels>& tc_boards,
                                const std::vector<BoardChannels>& rtd_boards,
                                const std::vector<BoardChannels>& lc_boards,
                                const std::vector<BoardChannels>& enc_boards);
 
    /**
     * @brief Register CALIBRATED VTables.
     *
     * Entity names: PT<board_number>_Cal.CH<n>, TC<board_number>_Cal.CH<n>, etc.
     */
    static bool register_calibrated_tables(ElodinClient& client,
                                           const std::vector<BoardChannels>& pt_boards,
                                           const std::vector<BoardChannels>& tc_boards,
                                           const std::vector<BoardChannels>& rtd_boards,
                                           const std::vector<BoardChannels>& lc_boards,
                                           const std::vector<BoardChannels>& enc_boards,
                                           const std::vector<BoardChannels>& act_boards);
 
    /**
     * @brief Register BOARD_HEARTBEAT VTables for specific board IDs.
     */
    static bool register_heartbeat_tables(ElodinClient& client,
                                          const std::vector<uint8_t>& board_ids);
 
    /**
     * @brief Register SELF_TEST VTables for specific board IDs.
     */
    static bool register_self_test_tables(ElodinClient& client,
                                          const std::vector<uint8_t>& board_ids);
 
    /**
     * @brief Register one LabJack T7's RAW VTables (t7_bridge).
     *
     * Per AIN: table {0x26, (slot-1)*0x20 + ain}, entity T7<slot>.AIN<ain>, fields timestamp_ns,
     * channel_id, volts (f32), sample_ts_ms, status — T7RawMessage. With `cjc`, also the
     * cold-junction table {0x26, (slot-1)*0x20 + 0x0F}, entity T7<slot>.CJC, field
     * temperature_c (f32) in the same layout.
     */
    static bool register_t7_raw_tables(ElodinClient& client, uint8_t slot,
                                       const std::vector<uint8_t>& ains, bool cjc);
 
    /**
     * @brief Register one LabJack T7's CALIBRATED VTables (calibration_service).
     *
     * Per input: table {0x26, (slot-1)*0x20 + 0x10 + ain}, entity T7<slot>_Cal.AIN<ain>, fields
     * timestamp_ns, channel_id, <cal_field> (f32: pressure_psi / temperature_c / force_kg),
     * raw_uv (i32: the reading in µV, the "ADC code" calibration works in), cal_status — the
     * ESP32 calibrated layout.
     */
    struct T7Table {
        uint8_t ain;
        std::string cal_field;
    };
    static bool register_t7_calibrated_tables(ElodinClient& client, uint8_t slot,
                                              const std::vector<T7Table>& tables);
 
    /** @brief Register ball valve RAW position VTables [0x33] (daq_bridge). */
    static bool register_ball_valve_tables(ElodinClient& client,
                                           const std::vector<BoardChannels>& bv_boards);
 
    /** @brief Register ball valve CALIBRATED position VTables [0x34] (calibration_service). */
    static bool register_ball_valve_calibrated_tables(ElodinClient& client,
                                                      const std::vector<BoardChannels>& bv_boards);
 
    /** @brief Register ball valve commanded-state VTables [0x35] (sequencer_service). */
    static bool register_ball_valve_cmd_tables(ElodinClient& client,
                                               const std::vector<BoardChannels>& bv_boards);
 
    /** @brief Register sequencer/controller and ACT_CMD tables */
    static bool register_non_sensor_tables(ElodinClient& client,
                                           const std::vector<BoardChannels>& act_boards = {});
};
 
}  // namespace elodin
}  // namespace fsw
 
#endif  // DAQ_DATABASE_CONFIG_HPP