sensor_state_display.hpp

Go to the documentation of this file.

// Copyright (c) 2024-2025 Voyant Photonics, Inc.
// All rights reserved.
 
#pragma once
 
#include <iomanip>
#include <ostream>
#include <voyant_types_ffi.hpp>
 
inline std::ostream& operator<<(std::ostream& os, const DspFrameStartToggle& v)
{
    switch (v)
    {
        case DspFrameStartToggle::CW:
            return os << "CW";
        case DspFrameStartToggle::CCW:
            return os << "CCW";
        default:
            return os << "DspFrameStartToggle(" << static_cast<int>(v) << ")";
    }
}
 
inline std::ostream& operator<<(std::ostream& os, const SdlRampLength& v)
{
    switch (v)
    {
        case SdlRampLength::Unknown:
            return os << "Unknown";
        case SdlRampLength::V8_192us:
            return os << "V8_192us";
        case SdlRampLength::V16_384us:
            return os << "V16_384us";
        default:
            return os << "SdlRampLength(" << static_cast<int>(v) << ")";
    }
}
 
inline std::ostream& operator<<(std::ostream& os, const SdlState& v)
{
    switch (v)
    {
        case SdlState::Unknown:
            return os << "Unknown";
        case SdlState::ErrorFault:
            return os << "ErrorFault";
        case SdlState::Boot:
            return os << "Boot";
        case SdlState::Initialization:
            return os << "Initialization";
        case SdlState::Standby:
            return os << "Standby";
        case SdlState::WarmUp:
            return os << "WarmUp";
        case SdlState::Idle:
            return os << "Idle";
        case SdlState::PointCloud:
            return os << "PointCloud";
        case SdlState::CoolDown:
            return os << "CoolDown";
        case SdlState::DebugCalibration:
            return os << "DebugCalibration";
        case SdlState::Reserved:
            return os << "Reserved";
        case SdlState::ReservedV11:
            return os << "ReservedV11";
        case SdlState::ReservedV12:
            return os << "ReservedV12";
        case SdlState::ReservedV13:
            return os << "ReservedV13";
        case SdlState::ReservedV14:
            return os << "ReservedV14";
        case SdlState::FirmwareUpdate:
            return os << "FirmwareUpdate";
        default:
            return os << "SdlState(" << static_cast<int>(v) << ")";
    }
}
 
inline std::ostream& operator<<(std::ostream& os, const SdlStatus& v)
{
    switch (v)
    {
        case SdlStatus::Unknown:
            return os << "Unknown";
        case SdlStatus::Idle:
            return os << "Idle";
        case SdlStatus::Pending:
            return os << "Pending";
        case SdlStatus::Applied:
            return os << "Applied";
        case SdlStatus::BadFovCenterCombo:
            return os << "BadFovCenterCombo";
        case SdlStatus::InvalidParameter:
            return os << "InvalidParameter";
        case SdlStatus::InvalidStateTransition:
            return os << "InvalidStateTransition";
        case SdlStatus::MissingCalibration:
            return os << "MissingCalibration";
        case SdlStatus::UnableToCalibrate:
            return os << "UnableToCalibrate";
        case SdlStatus::ParseError:
            return os << "ParseError";
        case SdlStatus::ApplicationError:
            return os << "ApplicationError";
        case SdlStatus::FovFpsError:
            return os << "FovFpsError";
        case SdlStatus::CommandBuildFailed:
            return os << "CommandBuildFailed";
        case SdlStatus::PreviousCommandPending:
            return os << "PreviousCommandPending";
        case SdlStatus::SendFailed:
            return os << "SendFailed";
        case SdlStatus::Timeout:
            return os << "Timeout";
        case SdlStatus::MaxRetriesExceeded:
            return os << "MaxRetriesExceeded";
        case SdlStatus::StreamReset:
            return os << "StreamReset";
        case SdlStatus::MessageReadyForMcu:
            return os << "MessageReadyForMcu";
        case SdlStatus::ValidMessageParsed:
            return os << "ValidMessageParsed";
        default:
            return os << "SdlStatus(" << static_cast<int>(v) << ")";
    }
}
 
inline std::ostream& operator<<(std::ostream& os, const ProductId& v)
{
    switch (v)
    {
        case ProductId::Unknown:
            return os << "Unknown";
        case ProductId::Lark:
            return os << "Lark";
        case ProductId::Meadowlark:
            return os << "Meadowlark";
        case ProductId::CarbonBenchtop:
            return os << "Carbon Benchtop";
        case ProductId::Carbon30:
            return os << "Carbon 30";
        case ProductId::VivadoSimulator:
            return os << "Vivado Simulator";
        case ProductId::VerilatorSimulator:
            return os << "Verilator Simulator";
        case ProductId::XceliumSimulator:
            return os << "Xcelium Simulator";
        case ProductId::IsaacSim:
            return os << "Isaac Sim";
        case ProductId::SoftwareSimulator:
            return os << "Software Simulator";
        default:
            return os << "ProductId(" << static_cast<int>(v) << ")";
    }
}
 
inline std::ostream& operator<<(std::ostream& os, const SdlDeviceState& s)
{
    return os << "SdlDeviceState{"
              << " state=" << s.device_state << " status=" << s.sdl_status << " fps=" << s.frame_rate_fps
              << " hfov=" << s.hfov_deg << "deg"
              << " hfov_center=" << s.hfov_center_deg << "deg"
              << " bw=" << s.ramp_bandwidth_ghz << "GHz"
              << " ramp_length=" << s.ramp_length << " }";
}
 
inline std::ostream& operator<<(std::ostream& os, const HealthState& h)
{
    std::ios_base::fmtflags flags(os.flags());
    os << std::fixed << std::setprecision(1) << "HealthState{"
       << " fpga=" << h.fpga_temp_c << "C"
       << " clarity=" << h.clarity_board_temp_c << "C"
       << " carat=" << h.carat_board_temp_c << "C"
       << " pic=" << h.pic_temp_c << "C"
       << " soa=" << h.soa_temp_c << "C"
       << " adc=" << h.adc_temp_c << "C" << std::hex << " error=" << h.error_word << " hw_health=" << h.hardware_health
       << " pwr=" << static_cast<int>(h.power_health) << std::dec << " lo_pwr=" << h.lo_power_mon << " }";
    os.flags(flags);
    return os;
}
 
inline std::ostream& operator<<(std::ostream& os, const CounterState& c)
{
    return os << "CounterState{"
              << " frames=" << c.total_frame_count << " ramps=" << c.total_ramp_count
              << " drops=" << c.total_drops_count << " any_drops=" << (c.any_drops_sticky != 0 ? "true" : "false")
              << " mcu_cycles=" << c.mcu_cycles_counter << " }";
}
 
inline std::ostream& operator<<(std::ostream& os, const DeviceInfo& d)
{
    return os << "DeviceInfo{"
              << " serial=" << d.serial_number << " product=" << d.product_id << " fpga=v"
              << static_cast<int>(d.fpga_version_major) << "." << static_cast<int>(d.fpga_version_minor) << "."
              << static_cast<int>(d.fpga_version_patch) << " mcu=v" << static_cast<int>(d.mcu_version_major) << "."
              << static_cast<int>(d.mcu_version_minor) << "." << static_cast<int>(d.mcu_version_patch) << " }";
}
 
inline std::ostream& operator<<(std::ostream& os, const CalibrationState& c)
{
    std::ios_base::fmtflags flags(os.flags());
    os << std::fixed << "CalibrationState{"
       << " encoder_az_offset=" << c.encoder_azimuth_offset << std::setprecision(6)
       << " doppler_bias=" << c.doppler_calibration_mirror_bias << "m/s"
       << " doppler_offset=" << c.doppler_calibration_mirror_offset << "m" << std::setprecision(0)
       << " chirp_bw=" << c.chirp_bandwidth_hz << "Hz" << std::setprecision(4) << " datum=(" << c.datum_delta_x_m << ","
       << c.datum_delta_y_m << "," << c.datum_delta_z_m << ")m"
       << " }";
    os.flags(flags);
    return os;
}
 
inline std::ostream& operator<<(std::ostream& os, const DspHeaderState& d)
{
    std::ios_base::fmtflags flags(os.flags());
    os << "DspHeaderState{"
       << " ts=" << d.timestamp_seconds << "." << std::setw(9) << std::setfill('0') << d.timestamp_nanoseconds
       << std::setfill(' ') << " toggle=" << d.frame_start_toggle << " }";
    os.flags(flags);
    return os;
}
 
inline std::ostream& operator<<(std::ostream& os, const SensorState& s)
{
    return os << "SensorState{\n"
              << "  " << s.device << "\n"
              << "  " << s.sdl << "\n"
              << "  " << s.health << "\n"
              << "  " << s.counters << "\n"
              << "  " << s.calibration << "\n"
              << "  " << s.dsp_header << "\n"
              << "  peaks_per_frame=" << s.peaks_per_frame << " last_heartbeat_frame=" << s.last_heartbeat_frame << "\n}";
}
 
inline std::ostream& operator<<(std::ostream& os, const SyncQuality& q)
{
    switch (q)
    {
        case SyncQuality::Unsynced:
            return os << "Unsynced";
        case SyncQuality::Poor:
            return os << "Poor";
        case SyncQuality::Fair:
            return os << "Fair";
        case SyncQuality::Good:
            return os << "Good";
        case SyncQuality::Excellent:
            return os << "Excellent";
        default:
            return os << "SyncQuality(" << static_cast<int>(q) << ")";
    }
}
 
inline std::ostream& operator<<(std::ostream& os, const HostState& h)
{
    return os << "HostState{"
              << " state_age_frames=" << h.state_age_frames << " dropped_ramps=" << h.dropped_ramps
              << " sync_valid=" << (h.sync_valid ? "true" : "false") << " sync_offset_ns=" << h.sync_offset_ns
              << " sync_jitter_ns=" << h.sync_jitter_ns << " sync_round_trip_ns=" << h.sync_round_trip_ns << " }";
}
 
inline std::ostream& operator<<(std::ostream& os, const TimeSyncState& t)
{
    std::ios_base::fmtflags flags = os.flags();
    std::streamsize         prec  = os.precision();
    // Offsets are nanoseconds on the wire; show microseconds for readability.
    os << "TimeSyncState{ quality=" << t.quality << " valid=" << (t.valid != 0) << std::fixed << std::setprecision(1)
       << " offset=" << static_cast<double>(t.offset_ns) / 1000.0 << "us"
       << " round_trip=" << static_cast<double>(t.round_trip_ns) / 1000.0 << "us"
       << " jitter=" << static_cast<double>(t.jitter_ns) / 1000.0 << "us"
       << " samples=" << t.sample_count << " age_ms=" << t.age_ms << " }";
    os.flags(flags);
    os.precision(prec);
    return os;
}