DatabaseConfig.cpp

Go to the documentation of this file.

#include "elodin/DatabaseConfig.hpp"
 
#include <algorithm>
#include <iostream>
#include <string>
 
#include "db.hpp"  // utl/db.hpp — VTable builder, Msg, postcard encoding
 
using namespace vtable;
using namespace vtable::builder;
 
namespace fsw {
namespace elodin {
 
// ── Helper: encode a db.hpp message and send via ElodinClient ──────────────
template <typename T>
static bool send_msg(ElodinClient& client, T msg) {
    auto buf = Msg(msg).encode_vec();
    if (buf.empty()) {
        std::cerr << "[DatabaseConfig] Failed to encode message" << std::endl;
        return false;
    }
    return client.send_msg({0, 0}, buf);  // packet_id unused — already in buf
}
 
bool DatabaseConfig::register_environmental_tables(ElodinClient& client,
                                                   const std::vector<BoardChannels>& boards) {
    bool ok = true;
    for (const auto& board : boards) {
        if (board.board_id == 0 ||
            std::find(board.channels.begin(), board.channels.end(), 1) == board.channels.end())
            continue;
        const std::string entity = "ENV" + std::to_string(board.board_id);
        const std::string prefix = entity + ".";
        auto vt = builder::vtable({
            raw_field(0, 8, schema(PrimType::U64(), {}, component(prefix + "timestamp_ns"))),
            raw_field(8, 4, schema(PrimType::F32(), {}, component(prefix + "temperature_c"))),
            raw_field(12, 4, schema(PrimType::U32(), {}, component(prefix + "pressure_pa"))),
            raw_field(16, 4, schema(PrimType::F32(), {}, component(prefix + "humidity_rh"))),
            raw_field(20, 4, schema(PrimType::U32(), {}, component(prefix + "sample_ts_ms"))),
        });
        if (!send_msg(client, VTableMsg{.id = {0x25, board.board_id}, .vtable = vt})) {
            ok = false;
            continue;
        }
        for (const char* field :
             {"timestamp_ns", "temperature_c", "pressure_pa", "humidity_rh", "sample_ts_ms"})
            ok = send_msg(client, set_component_name(prefix + field)) && ok;
        ok = send_msg(client, set_entity_name((0x25u << 8) | board.board_id, entity)) && ok;
    }
    return ok;
}
 
// ── Helper: register one raw-sensor VTable for a single channel ────────────
// All raw sensor messages share the same 21-byte layout:
//   u64 timestamp_ns | u8 channel_id | u8[3] pad | u32 raw_adc | u32 sample_ts | u8 status
static bool register_raw_sensor_vtable(
    ElodinClient& client,
    uint8_t type_hi,     // high byte of packet_id (0x20=PT, 0x21=TC, 0x22=RTD, 0x23=LC, 0x30=ACT)
    uint8_t channel_id,  // low byte of packet_id (1-based channel)
    uint64_t entity_id,  // unique entity id for set_entity_name
    const std::string& entity_name,    // human-readable name
    const std::string& adc_field_name  // "raw_adc_counts" or "raw_resistance_counts"
) {
    std::string prefix = entity_name + ".";
 
    auto vt = builder::vtable({
        raw_field(0, 8, schema(PrimType::U64(), {}, component(prefix + "timestamp_ns"))),
        raw_field(8, 1, schema(PrimType::U8(), {}, component(prefix + "channel_id"))),
        // 3 bytes padding at offset 9 — skip
        raw_field(12, 4, schema(PrimType::U32(), {}, component(prefix + adc_field_name))),
        raw_field(16, 4, schema(PrimType::U32(), {}, component(prefix + "sample_ts_ms"))),
        raw_field(20, 1, schema(PrimType::U8(), {}, component(prefix + "status"))),
    });
 
    if (!send_msg(client, VTableMsg{.id = {type_hi, channel_id}, .vtable = vt})) {
        std::cerr << "[DatabaseConfig] ❌ VTable failed: " << entity_name << std::endl;
        return false;
    }
 
    // Name the per-field components
    send_msg(client, set_component_name(prefix + "timestamp_ns"));
    send_msg(client, set_component_name(prefix + "channel_id"));
    send_msg(client, set_component_name(prefix + adc_field_name));
    send_msg(client, set_component_name(prefix + "sample_ts_ms"));
    send_msg(client, set_component_name(prefix + "status"));
 
    // Name the entity
    send_msg(client, set_entity_name(entity_id, entity_name));
 
    return true;
}
 
// ── Helper: register one calibrated-sensor VTable for a single channel ─────
// All calibrated messages share the same 21-byte layout:
//   u64 timestamp_ns | u8 channel_id | u8[3] pad | f32 calibrated_value | u32 raw_counts | u8
//   cal_status
static bool register_calibrated_vtable(
    ElodinClient& client,
    uint8_t type_hi,  // high byte (0x20=PT, 0x21=TC, 0x22=RTD, 0x23=LC)
    uint8_t pkt_lo,   // full low byte for packet ID (already includes board offset + 0x10)
    uint64_t entity_id, const std::string& entity_name,
    const std::string& cal_field_name,  // "pressure_psi", "temperature_c", "force_lbf"
    const std::string& raw_field_name   // "raw_adc", "raw_resistance"
) {
    std::string prefix = entity_name + ".";
 
    auto vt = builder::vtable({
        raw_field(0, 8, schema(PrimType::U64(), {}, component(prefix + "timestamp_ns"))),
        raw_field(8, 1, schema(PrimType::U8(), {}, component(prefix + "channel_id"))),
        // 3 bytes padding at offset 9 — skip
        raw_field(12, 4, schema(PrimType::F32(), {}, component(prefix + cal_field_name))),
        raw_field(16, 4, schema(PrimType::U32(), {}, component(prefix + raw_field_name))),
        raw_field(20, 1, schema(PrimType::U8(), {}, component(prefix + "cal_status"))),
    });
 
    if (!send_msg(client, VTableMsg{.id = {type_hi, pkt_lo}, .vtable = vt})) {
        std::cerr << "[DatabaseConfig] ❌ Calibrated VTable failed: " << entity_name << std::endl;
        return false;
    }
 
    send_msg(client, set_component_name(prefix + "timestamp_ns"));
    send_msg(client, set_component_name(prefix + "channel_id"));
    send_msg(client, set_component_name(prefix + cal_field_name));
    send_msg(client, set_component_name(prefix + raw_field_name));
    send_msg(client, set_component_name(prefix + "cal_status"));
    send_msg(client, set_entity_name(entity_id, entity_name));
 
    return true;
}
 
// ── Helper: register actuator state VTable (0=closed, 1=open) ───────────────
// Layout: u64 timestamp_ns | u8 channel_id | u8 actuator_state (10 bytes)
static bool register_actuator_state_vtable(ElodinClient& client, uint8_t type_hi,
                                           uint8_t channel_id, uint64_t entity_id,
                                           const std::string& entity_name) {
    std::string prefix = entity_name + ".";
 
    auto vt = builder::vtable({
        raw_field(0, 8, schema(PrimType::U64(), {}, component(prefix + "timestamp_ns"))),
        raw_field(8, 1, schema(PrimType::U8(), {}, component(prefix + "channel_id"))),
        raw_field(9, 1, schema(PrimType::U8(), {}, component(prefix + "actuator_state"))),
    });
 
    if (!send_msg(client, VTableMsg{.id = {type_hi, channel_id}, .vtable = vt})) {
        std::cerr << "[DatabaseConfig] ❌ Actuator state VTable failed: " << entity_name
                  << std::endl;
        return false;
    }
 
    send_msg(client, set_component_name(prefix + "timestamp_ns"));
    send_msg(client, set_component_name(prefix + "channel_id"));
    send_msg(client, set_component_name(prefix + "actuator_state"));
    send_msg(client, set_entity_name(entity_id, entity_name));
 
    return true;
}
 
// ════════════════════════════════════════════════════════════════════════════
// PUBLIC API — RAW VTables only (for daq_bridge)
// ════════════════════════════════════════════════════════════════════════════
 
namespace {
/** Append (type_hi, (board_number-1)*0x20 + offset + ch) for every active channel. */
void appendTables(std::vector<std::pair<uint8_t, uint8_t>>& out,
                  const std::vector<BoardChannels>& boards, uint8_t type_hi, uint8_t offset) {
    for (const auto& board : boards)
        for (uint8_t ch : board.channels)
            out.push_back(
                {type_hi, static_cast<uint8_t>((board.board_number - 1) * 0x20 + offset + ch)});
}
}  // namespace
 
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) {
    std::vector<std::pair<uint8_t, uint8_t>> t;
    appendTables(t, pt_boards, 0x20, 0x00);
    appendTables(t, act_boards, 0x30, 0x00);
    appendTables(t, tc_boards, 0x21, 0x00);
    appendTables(t, rtd_boards, 0x22, 0x00);
    appendTables(t, lc_boards, 0x23, 0x00);
    appendTables(t, enc_boards, 0x24, 0x00);
    return t;
}
 
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) {
    std::vector<std::pair<uint8_t, uint8_t>> t;
    appendTables(t, pt_boards, 0x20, 0x10);
    appendTables(t, tc_boards, 0x21, 0x10);
    appendTables(t, rtd_boards, 0x22, 0x10);
    appendTables(t, lc_boards, 0x23, 0x10);
    appendTables(t, enc_boards, 0x24, 0x10);
    appendTables(t, act_boards, 0x31, 0x10);
    return t;
}
 
namespace {
// One T7 VTable: 21 bytes, u64 @0 | u8 @8 | pad | 4-byte value @12 | 4 bytes @16 | u8 @20.
bool register_t7_vtable(ElodinClient& client, uint8_t lo, const std::string& entity,
                        const char* value_field, const char* u32_field, PrimType u32_type,
                        const char* status_field) {
    const std::string prefix = entity + ".";
    auto vt = builder::vtable({
        raw_field(0, 8, schema(PrimType::U64(), {}, component(prefix + "timestamp_ns"))),
        raw_field(8, 1, schema(PrimType::U8(), {}, component(prefix + "channel_id"))),
        raw_field(12, 4, schema(PrimType::F32(), {}, component(prefix + value_field))),
        raw_field(16, 4, schema(u32_type, {}, component(prefix + u32_field))),
        raw_field(20, 1, schema(PrimType::U8(), {}, component(prefix + status_field))),
    });
    if (!send_msg(client, VTableMsg{.id = {0x26, lo}, .vtable = vt})) {
        std::cerr << "[DatabaseConfig] T7 VTable failed: " << entity << std::endl;
        return false;
    }
    bool ok = true;
    for (const char* field : {"timestamp_ns", "channel_id", value_field, u32_field, status_field})
        ok = send_msg(client, set_component_name(prefix + field)) && ok;
    return send_msg(client, set_entity_name((static_cast<uint64_t>(0x26) << 8) | lo, entity)) && ok;
}
}  // namespace
 
bool DatabaseConfig::register_t7_raw_tables(ElodinClient& client, uint8_t slot,
                                            const std::vector<uint8_t>& ains, bool cjc) {
    bool ok = true;
    const uint8_t base = static_cast<uint8_t>((slot - 1) * 0x20);
    const std::string n = std::to_string(slot);
    for (uint8_t ain : ains)
        ok = register_t7_vtable(client, static_cast<uint8_t>(base + ain),
                                "T7" + n + ".AIN" + std::to_string(ain), "volts", "sample_ts_ms",
                                PrimType::U32(), "status") &&
             ok;
    if (cjc)
        ok = register_t7_vtable(client, static_cast<uint8_t>(base + 0x0F), "T7" + n + ".CJC",
                                "temperature_c", "sample_ts_ms", PrimType::U32(), "status") &&
             ok;
    return ok;
}
 
bool DatabaseConfig::register_t7_calibrated_tables(ElodinClient& client, uint8_t slot,
                                                   const std::vector<T7Table>& tables) {
    bool ok = true;
    const uint8_t base = static_cast<uint8_t>((slot - 1) * 0x20 + 0x10);
    const std::string n = std::to_string(slot);
    for (const auto& t : tables)
        ok = register_t7_vtable(client, static_cast<uint8_t>(base + t.ain),
                                "T7" + n + "_Cal.AIN" + std::to_string(t.ain), t.cal_field.c_str(),
                                "raw_uv", PrimType::I32(), "cal_status") &&
             ok;
    return ok;
}
 
bool DatabaseConfig::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) {
    std::cout << "[DatabaseConfig] Registering RAW VTables (board-namespaced)..." << std::endl;
    int registered = 0;
    int pt_count = 0, act_count = 0, tc_count = 0, rtd_count = 0, lc_count = 0, enc_count = 0;
 
    for (const auto& board : pt_boards) {
        for (uint8_t ch : board.channels) {
            std::string entity =
                "PT" + std::to_string(board.board_number) + ".CH" + std::to_string(ch);
            uint8_t lo = static_cast<uint8_t>((board.board_number - 1) * 0x20 + ch);
            uint64_t entity_id = (static_cast<uint64_t>(0x20) << 8) | lo;
            if (register_raw_sensor_vtable(client, 0x20, lo, entity_id, entity, "raw_adc_counts")) {
                registered++;
                pt_count++;
            }
        }
    }
 
    for (const auto& board : act_boards) {
        for (uint8_t ch : board.channels) {
            std::string entity =
                "ACT" + std::to_string(board.board_number) + ".CH" + std::to_string(ch);
            uint8_t lo = static_cast<uint8_t>((board.board_number - 1) * 0x20 + ch);
            uint64_t entity_id = (static_cast<uint64_t>(0x30) << 8) | lo;
            if (register_raw_sensor_vtable(client, 0x30, lo, entity_id, entity, "raw_adc_counts")) {
                registered++;
                act_count++;
            }
        }
    }
 
    for (const auto& board : tc_boards) {
        for (uint8_t ch : board.channels) {
            std::string entity =
                "TC" + std::to_string(board.board_number) + ".CH" + std::to_string(ch);
            uint8_t lo = static_cast<uint8_t>((board.board_number - 1) * 0x20 + ch);
            uint64_t entity_id = (static_cast<uint64_t>(0x21) << 8) | lo;
            if (register_raw_sensor_vtable(client, 0x21, lo, entity_id, entity, "raw_adc_counts")) {
                registered++;
                tc_count++;
            }
        }
    }
 
    for (const auto& board : rtd_boards) {
        for (uint8_t ch : board.channels) {
            std::string entity =
                "RTD" + std::to_string(board.board_number) + ".CH" + std::to_string(ch);
            uint8_t lo = static_cast<uint8_t>((board.board_number - 1) * 0x20 + ch);
            uint64_t entity_id = (static_cast<uint64_t>(0x22) << 8) | lo;
            if (register_raw_sensor_vtable(client, 0x22, lo, entity_id, entity,
                                           "raw_resistance_counts")) {
                registered++;
                rtd_count++;
            }
        }
    }
 
    for (const auto& board : lc_boards) {
        for (uint8_t ch : board.channels) {
            std::string entity =
                "LC" + std::to_string(board.board_number) + ".CH" + std::to_string(ch);
            uint8_t lo = static_cast<uint8_t>((board.board_number - 1) * 0x20 + ch);
            uint64_t entity_id = (static_cast<uint64_t>(0x23) << 8) | lo;
            if (register_raw_sensor_vtable(client, 0x23, lo, entity_id, entity, "raw_adc_counts")) {
                registered++;
                lc_count++;
            }
        }
    }
 
    for (const auto& board : enc_boards) {
        for (uint8_t ch : board.channels) {
            std::string entity =
                "ENC" + std::to_string(board.board_number) + ".CH" + std::to_string(ch);
            uint8_t lo = static_cast<uint8_t>((board.board_number - 1) * 0x20 + ch);
            uint64_t entity_id = (static_cast<uint64_t>(0x24) << 8) | lo;
            if (register_raw_sensor_vtable(client, 0x24, lo, entity_id, entity, "raw_angle")) {
                registered++;
                enc_count++;
            }
        }
    }
 
    std::cout << "[DatabaseConfig] ✅ Registered " << registered << " RAW VTables (" << pt_count
              << " PT, " << act_count << " ACT, " << tc_count << " TC, " << rtd_count << " RTD, "
              << lc_count << " LC, " << enc_count << " ENC)" << std::endl;
    return registered > 0;
}
 
// ════════════════════════════════════════════════════════════════════════════
// PUBLIC API — CALIBRATED VTables only (for calibration_service)
// ════════════════════════════════════════════════════════════════════════════
 
bool DatabaseConfig::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) {
    std::cout << "[DatabaseConfig] Registering CALIBRATED VTables..." << std::endl;
    int registered = 0;
 
    for (const auto& board : pt_boards) {
        for (uint8_t ch : board.channels) {
            std::string entity =
                "PT" + std::to_string(board.board_number) + "_Cal.CH" + std::to_string(ch);
            uint8_t lo = static_cast<uint8_t>((board.board_number - 1) * 0x20 + 0x10 + ch);
            uint64_t entity_id = (static_cast<uint64_t>(0x20) << 8) | lo;
            if (register_calibrated_vtable(client, 0x20, lo, entity_id, entity, "pressure_psi",
                                           "raw_adc"))
                registered++;
        }
    }
 
    for (const auto& board : tc_boards) {
        for (uint8_t ch : board.channels) {
            std::string entity =
                "TC" + std::to_string(board.board_number) + "_Cal.CH" + std::to_string(ch);
            uint8_t lo = static_cast<uint8_t>((board.board_number - 1) * 0x20 + 0x10 + ch);
            uint64_t entity_id = (static_cast<uint64_t>(0x21) << 8) | lo;
            if (register_calibrated_vtable(client, 0x21, lo, entity_id, entity, "temperature_c",
                                           "raw_adc"))
                registered++;
        }
    }
 
    for (const auto& board : rtd_boards) {
        for (uint8_t ch : board.channels) {
            std::string entity =
                "RTD" + std::to_string(board.board_number) + "_Cal.CH" + std::to_string(ch);
            uint8_t lo = static_cast<uint8_t>((board.board_number - 1) * 0x20 + 0x10 + ch);
            uint64_t entity_id = (static_cast<uint64_t>(0x22) << 8) | lo;
            if (register_calibrated_vtable(client, 0x22, lo, entity_id, entity, "temperature_c",
                                           "raw_resistance"))
                registered++;
        }
    }
 
    for (const auto& board : lc_boards) {
        for (uint8_t ch : board.channels) {
            std::string entity =
                "LC" + std::to_string(board.board_number) + "_Cal.CH" + std::to_string(ch);
            uint8_t lo = static_cast<uint8_t>((board.board_number - 1) * 0x20 + 0x10 + ch);
            uint64_t entity_id = (static_cast<uint64_t>(0x23) << 8) | lo;
            if (register_calibrated_vtable(client, 0x23, lo, entity_id, entity, "force_kg",
                                           "raw_adc"))
                registered++;
        }
    }
 
    for (const auto& board : enc_boards) {
        for (uint8_t ch : board.channels) {
            std::string entity =
                "ENC" + std::to_string(board.board_number) + "_Cal.CH" + std::to_string(ch);
            uint8_t lo = static_cast<uint8_t>((board.board_number - 1) * 0x20 + 0x10 + ch);
            uint64_t entity_id = (static_cast<uint64_t>(0x24) << 8) | lo;
            if (register_calibrated_vtable(client, 0x24, lo, entity_id, entity, "position_deg",
                                           "raw_adc"))
                registered++;
        }
    }
 
    // Actuators use 0x31 for calibrated (separate type byte to avoid collision with raw 0x30)
    for (const auto& board : act_boards) {
        for (uint8_t ch : board.channels) {
            std::string entity =
                "ACT" + std::to_string(board.board_number) + "_Cal.CH" + std::to_string(ch);
            uint8_t lo = static_cast<uint8_t>((board.board_number - 1) * 0x20 + 0x10 + ch);
            uint64_t entity_id = (static_cast<uint64_t>(0x31) << 8) | lo;
            if (register_calibrated_vtable(client, 0x31, lo, entity_id, entity, "current_a",
                                           "raw_adc"))
                registered++;
        }
    }
 
    std::cout << "[DatabaseConfig] ✅ Registered " << registered << " CALIBRATED VTables"
              << std::endl;
    return registered > 0;
}
 
// ════════════════════════════════════════════════════════════════════════════
// PUBLIC API — BOARD HEARTBEAT VTables
// ════════════════════════════════════════════════════════════════════════════
 
bool DatabaseConfig::register_heartbeat_tables(ElodinClient& client,
                                               const std::vector<uint8_t>& board_ids) {
    std::cout << "[DatabaseConfig] Registering BOARD_HEARTBEAT VTables (" << board_ids.size()
              << " boards)..." << std::endl;
    int registered = 0;
 
    // Board heartbeat layout (16 bytes, no padding required):
    //   u64 timestamp_ns (0,8) | u8 board_id (8) | u8 board_type (9)
    //   u8 engine_state (10)   | u8 board_state (11) | u32 packet_ts_ms (12,4)
    for (uint8_t board_id : board_ids) {
        std::string entity = "BOARD.HB_" + std::to_string(board_id);
        std::string prefix = entity + ".";
 
        auto vt = builder::vtable({
            raw_field(0, 8, schema(PrimType::U64(), {}, component(prefix + "timestamp_ns"))),
            raw_field(8, 1, schema(PrimType::U8(), {}, component(prefix + "board_id"))),
            raw_field(9, 1, schema(PrimType::U8(), {}, component(prefix + "board_type"))),
            raw_field(10, 1, schema(PrimType::U8(), {}, component(prefix + "engine_state"))),
            raw_field(11, 1, schema(PrimType::U8(), {}, component(prefix + "board_state"))),
            raw_field(12, 4, schema(PrimType::U32(), {}, component(prefix + "packet_ts_ms"))),
        });
 
        uint64_t entity_id = 0x1000 + board_id;
        if (!send_msg(client, VTableMsg{.id = {0x10, board_id}, .vtable = vt})) {
            std::cerr << "[DatabaseConfig] ❌ Heartbeat VTable failed: " << entity << std::endl;
            continue;
        }
 
        send_msg(client, set_component_name(prefix + "timestamp_ns"));
        send_msg(client, set_component_name(prefix + "board_id"));
        send_msg(client, set_component_name(prefix + "board_type"));
        send_msg(client, set_component_name(prefix + "engine_state"));
        send_msg(client, set_component_name(prefix + "board_state"));
        send_msg(client, set_component_name(prefix + "packet_ts_ms"));
        send_msg(client, set_entity_name(entity_id, entity));
        registered++;
    }
 
    std::cout << "[DatabaseConfig] ✅ Registered " << registered << " HEARTBEAT VTables"
              << std::endl;
    return registered > 0;
}
 
// Per-sensor self-test VTables: [0x60 + sensor_id, board_id].
// Each sensor result gets its own VTable so Elodin VTableStream delivers every
// result individually (a shared table only delivers the last-written row).
static constexpr uint8_t SELF_TEST_HIGH_BASE = 0x60;
static constexpr uint8_t SELF_TEST_MAX_SENSOR = 15;
 
static bool register_self_test_vtable(ElodinClient& client, uint8_t board_id, uint8_t sensor_id) {
    std::string entity = "SELF_TEST.BOARD_" + std::to_string(board_id);
    std::string prefix = entity + ".s" + std::to_string(sensor_id) + ".";
 
    auto vt = builder::vtable({
        raw_field(0, 8, schema(PrimType::U64(), {}, component(prefix + "timestamp_ns"))),
        raw_field(8, 1, schema(PrimType::U8(), {}, component(prefix + "sensor_id"))),
        raw_field(9, 1, schema(PrimType::U8(), {}, component(prefix + "result"))),
    });
 
    uint8_t high = SELF_TEST_HIGH_BASE + sensor_id;
    uint64_t entity_id = (static_cast<uint64_t>(high) << 8) | board_id;
    if (!send_msg(client, VTableMsg{.id = {high, board_id}, .vtable = vt}))
        return false;
 
    send_msg(client, set_component_name(prefix + "timestamp_ns"));
    send_msg(client, set_component_name(prefix + "sensor_id"));
    send_msg(client, set_component_name(prefix + "result"));
    send_msg(client, set_entity_name(entity_id, entity));
    return true;
}
 
bool DatabaseConfig::register_self_test_tables(ElodinClient& client,
                                               const std::vector<uint8_t>& board_ids) {
    std::cout << "[DatabaseConfig] Registering SELF_TEST VTables (" << board_ids.size()
              << " boards, sensors 0-" << (int)SELF_TEST_MAX_SENSOR << ")..." << std::endl;
    int registered = 0;
    for (uint8_t board_id : board_ids) {
        for (uint8_t s = 0; s <= SELF_TEST_MAX_SENSOR; ++s) {
            if (register_self_test_vtable(client, board_id, s))
                registered++;
        }
    }
    std::cout << "[DatabaseConfig] ✅ Registered " << registered << " SELF_TEST VTables"
              << std::endl;
    return registered > 0;
}
 
// ── Helper: register Sequencer tables ──────────────
static bool register_sequencer_vtable(ElodinClient& client) {
    // SequencerState: u64@0 + u8@8 + 3-byte hole + u32@12 + u8@16 = 17 bytes (u32 4-aligned like
    // sensor rows)
    auto vt1 = builder::vtable({
        raw_field(0, 8, schema(PrimType::U64(), {}, component("SEQUENCER.state.timestamp_ns"))),
        raw_field(8, 1, schema(PrimType::U8(), {}, component("SEQUENCER.state.current_state"))),
        raw_field(12, 4, schema(PrimType::U32(), {}, component("SEQUENCER.state.allowed_bitmask"))),
        raw_field(16, 1, schema(PrimType::U8(), {}, component("SEQUENCER.state.debug_mode"))),
    });
    if (!send_msg(client, VTableMsg{.id = {0x50, 0x00}, .vtable = vt1}))
        return false;
    send_msg(client, set_component_name("SEQUENCER.state.timestamp_ns"));
    send_msg(client, set_component_name("SEQUENCER.state.current_state"));
    send_msg(client, set_component_name("SEQUENCER.state.allowed_bitmask"));
    send_msg(client, set_component_name("SEQUENCER.state.debug_mode"));
    send_msg(client, set_entity_name(0x5000, "SEQUENCER.state"));
 
    // StateTransition: U64+U8+U8+U8 (11 bytes)
    auto vt2 = builder::vtable({
        raw_field(0, 8, schema(PrimType::U64(), {}, component("CONTROLLER.state.timestamp_ns"))),
        raw_field(8, 1, schema(PrimType::U8(), {}, component("CONTROLLER.state.from_state"))),
        raw_field(9, 1, schema(PrimType::U8(), {}, component("CONTROLLER.state.to_state"))),
        raw_field(10, 1, schema(PrimType::U8(), {}, component("CONTROLLER.state.reason"))),
    });
    if (!send_msg(client, VTableMsg{.id = {0x43, 0x00}, .vtable = vt2}))
        return false;
    send_msg(client, set_component_name("CONTROLLER.state.timestamp_ns"));
    send_msg(client, set_component_name("CONTROLLER.state.from_state"));
    send_msg(client, set_component_name("CONTROLLER.state.to_state"));
    send_msg(client, set_component_name("CONTROLLER.state.reason"));
    send_msg(client, set_entity_name(0x4300, "CONTROLLER.state"));
 
    return true;
}
 
static bool register_calibration_command_vtable(ElodinClient& client) {
    // CalibrationCommand: u64 timestamp_ns | u8 type | u8 pad | u16 sensor_id (LE) | f32 reference.
    // sensor_id is the uid board_id*100+connector (e.g. board 21 conn 5 = 2105) — a full u16, so it
    // sits at the even offset 10 (2-byte aligned). It used to be declared u8 at offset 9; Elodin
    // zeroes any byte no field covers, so the high byte was dropped and every capture to a board
    // with id >= 3 (uid > 255) landed on uid & 0xFF (e.g. 2105 -> 57). The backend writer and the
    // service parser use this same layout.
    auto vt = builder::vtable({
        raw_field(0, 8, schema(PrimType::U64(), {}, component("CALIBRATION.command.timestamp_ns"))),
        raw_field(8, 1, schema(PrimType::U8(), {}, component("CALIBRATION.command.type"))),
        raw_field(10, 2, schema(PrimType::U16(), {}, component("CALIBRATION.command.sensor_id"))),
        raw_field(12, 4,
                  schema(PrimType::F32(), {}, component("CALIBRATION.command.reference_value"))),
    });
    if (!send_msg(client, VTableMsg{.id = {0x46, 0x00}, .vtable = vt}))
        return false;
    send_msg(client, set_component_name("CALIBRATION.command.timestamp_ns"));
    send_msg(client, set_component_name("CALIBRATION.command.type"));
    send_msg(client, set_component_name("CALIBRATION.command.sensor_id"));
    send_msg(client, set_component_name("CALIBRATION.command.reference_value"));
    send_msg(client, set_entity_name(0x4600, "CALIBRATION.command"));
    return true;
}
 
// ════════════════════════════════════════════════════════════════════════════
// PUBLIC API — ball valve boards (0x33 raw, 0x34 calibrated, 0x35 commanded)
// ════════════════════════════════════════════════════════════════════════════
 
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>> t;
    appendTables(t, bv_boards, kBallValveRawHi, 0x00);
    return t;
}
 
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>> t;
    appendTables(t, bv_boards, kBallValveCalHi, 0x10);
    return t;
}
 
std::vector<std::pair<uint8_t, uint8_t>> ball_valve_cmd_tables(
    const std::vector<BoardChannels>& bv_boards) {
    std::vector<std::pair<uint8_t, uint8_t>> t;
    appendTables(t, bv_boards, kBallValveCmdHi, 0x00);
    return t;
}
 
bool DatabaseConfig::register_ball_valve_tables(ElodinClient& client,
                                                const std::vector<BoardChannels>& bv_boards) {
    bool ok = true;
    for (const auto& board : bv_boards)
        for (uint8_t ch : board.channels) {
            std::string entity =
                "BV" + std::to_string(board.board_number) + ".CH" + std::to_string(ch);
            uint8_t lo = static_cast<uint8_t>((board.board_number - 1) * 0x20 + ch);
            uint64_t entity_id = (static_cast<uint64_t>(kBallValveRawHi) << 8) | lo;
            ok = register_raw_sensor_vtable(client, kBallValveRawHi, lo, entity_id, entity,
                                            "raw_adc_counts") &&
                 ok;
        }
    return ok;
}
 
bool DatabaseConfig::register_ball_valve_calibrated_tables(
    ElodinClient& client, const std::vector<BoardChannels>& bv_boards) {
    bool ok = true;
    for (const auto& board : bv_boards)
        for (uint8_t ch : board.channels) {
            std::string entity =
                "BV" + std::to_string(board.board_number) + "_Cal.CH" + std::to_string(ch);
            uint8_t lo = static_cast<uint8_t>((board.board_number - 1) * 0x20 + 0x10 + ch);
            uint64_t entity_id = (static_cast<uint64_t>(kBallValveCalHi) << 8) | lo;
            ok = register_calibrated_vtable(client, kBallValveCalHi, lo, entity_id, entity,
                                            "position_pct", "raw_adc") &&
                 ok;
        }
    return ok;
}
 
bool DatabaseConfig::register_ball_valve_cmd_tables(ElodinClient& client,
                                                    const std::vector<BoardChannels>& bv_boards) {
    bool ok = true;
    for (const auto& board : bv_boards)
        for (uint8_t ch : board.channels) {
            uint8_t lo = static_cast<uint8_t>((board.board_number - 1) * 0x20 + ch);
            std::string entity =
                "BV_CMD.B" + std::to_string(board.board_number) + ".CH" + std::to_string(ch);
            uint64_t entity_id = (static_cast<uint64_t>(kBallValveCmdHi) << 8) | lo;
            ok = register_actuator_state_vtable(client, kBallValveCmdHi, lo, entity_id, entity) &&
                 ok;
        }
    return ok;
}
 
bool DatabaseConfig::register_non_sensor_tables(ElodinClient& client,
                                                const std::vector<BoardChannels>& act_boards) {
    bool ok = true;
    if (!register_sequencer_vtable(client))
        ok = false;
    if (!register_calibration_command_vtable(client))
        ok = false;
 
    // Register actuator commanded state VTables [0x32, (board_number-1)*0x20 + ch]
    int act_cmd_count = 0;
    if (!act_boards.empty()) {
        for (const auto& board : act_boards) {
            for (uint8_t ch : board.channels) {
                uint8_t lo = static_cast<uint8_t>((board.board_number - 1) * 0x20 + ch);
                std::string entity_name =
                    "ACT_CMD.B" + std::to_string(board.board_number) + ".CH" + std::to_string(ch);
                uint64_t entity_id = (static_cast<uint64_t>(0x32) << 8) | lo;
                if (register_actuator_state_vtable(client, 0x32, lo, entity_id, entity_name))
                    act_cmd_count++;
            }
        }
    } else {
        // Fallback: register for 4 boards x 10 channels when no board info available
        for (int bn = 1; bn <= 4; ++bn) {
            for (int ch = 1; ch <= 10; ++ch) {
                uint8_t lo = static_cast<uint8_t>((bn - 1) * 0x20 + ch);
                std::string entity_name =
                    "ACT_CMD.B" + std::to_string(bn) + ".CH" + std::to_string(ch);
                uint64_t entity_id = (static_cast<uint64_t>(0x32) << 8) | lo;
                if (register_actuator_state_vtable(client, 0x32, lo, entity_id, entity_name))
                    act_cmd_count++;
            }
        }
    }
    if (act_cmd_count > 0)
        std::cout << "[DatabaseConfig] ✅ Registered " << act_cmd_count
                  << " actuator commanded VTables [0x32]" << std::endl;
 
    if (ok) {
        std::cout << "[DatabaseConfig] ✅ Registered Sequencer/Controller VTables" << std::endl;
    }
    return ok;
}
 
}  // namespace elodin
}  // namespace fsw