carbon_client_ffi.hpp

Go to the documentation of this file.

// Copyright (c) 2024-2025 Voyant Photonics, Inc.
// All rights reserved.
 
#pragma once
 
#include <cstdarg>
#include <cstdint>
#include <cstdlib>
#include <ostream>
#include <new>
#include <voyant_types_ffi.hpp>

enum class StreamTransport : uint8_t {
  Unicast,
  Multicast,
};

struct CarbonClientHandleC;

struct CarbonConfigC;

struct SdlCommandParams {
  uint8_t req_state;
  float hfov_deg;
  float hfov_center_deg;
  float frame_rate_fps;
  float ramp_bandwidth_ghz;
  uint8_t ramp_length;
};
 
extern "C" {

CarbonClientHandleC *carbon_client_new(const CarbonConfigC *config);

bool carbon_client_start(CarbonClientHandleC *handle);

void carbon_client_stop(CarbonClientHandleC *handle);

bool carbon_client_is_running(const CarbonClientHandleC *handle);

bool carbon_client_try_receive_frame(CarbonClientHandleC *handle);

VoyantFrameMeta carbon_client_frame_meta(const CarbonClientHandleC *handle);

int64_t carbon_client_frame_points(const CarbonClientHandleC *handle,
                                   PointDataV1 *dest,
                                   uintptr_t capacity);

bool carbon_client_get_sensor_state(const CarbonClientHandleC *handle, SensorState *out);

bool carbon_client_get_time_sync_state(const CarbonClientHandleC *handle, TimeSyncState *out);

uint8_t sensor_state_to_sdl_command(const SensorState *state, SdlCommandParams *out);

uint8_t carbon_client_send_sdl(CarbonClientHandleC *handle, const SdlCommandParams *params);

uint8_t carbon_client_poll_sdl(CarbonClientHandleC *handle);

uint8_t carbon_client_send_sdl_blocking(CarbonClientHandleC *handle,
                                        const SdlCommandParams *params);

bool carbon_client_wait_for_heartbeat(CarbonClientHandleC *handle);

bool carbon_client_ensure_idle_for_calibration(CarbonClientHandleC *handle);

bool carbon_client_apply_default_background_noise(CarbonClientHandleC *handle);

bool carbon_client_refine_background_noise(CarbonClientHandleC *handle,
                                           uint32_t iterations);

bool carbon_client_start_diagnostic_capture(CarbonClientHandleC *handle,
                                            const char *path,
                                            bool overwrite);

void carbon_client_stop_diagnostic_capture(CarbonClientHandleC *handle);

bool carbon_client_is_diagnostic_capturing(const CarbonClientHandleC *handle);

uintptr_t carbon_client_diagnostic_capture_error(const CarbonClientHandleC *handle,
                                                 char *buf,
                                                 uintptr_t capacity);

void carbon_client_free(CarbonClientHandleC *handle);

CarbonConfigC *carbon_config_new();

CarbonConfigC *carbon_config_from_json(const char *path);

void carbon_config_free(CarbonConfigC *cfg);

void carbon_config_set_bind_addr(CarbonConfigC *cfg, const char *v);

void carbon_config_set_group_addr(CarbonConfigC *cfg, const char *v);

void carbon_config_set_interface_addr(CarbonConfigC *cfg,
                                      const char *v);

void carbon_config_set_observer_only(CarbonConfigC *cfg, bool v);

void carbon_config_set_stream_transport(CarbonConfigC *cfg, StreamTransport v);

void carbon_config_set_use_msg_timestamp(CarbonConfigC *cfg, bool v);

void carbon_config_set_batch_size(CarbonConfigC *cfg, uintptr_t v);

void carbon_config_set_recv_buffer_size(CarbonConfigC *cfg, uintptr_t v);

void carbon_config_set_receiver_channel_capacity(CarbonConfigC *cfg, uintptr_t v);

void carbon_config_set_vel_corr_factor(CarbonConfigC *cfg, float v);

void carbon_config_set_bandwidth_hz(CarbonConfigC *cfg, float v);

void carbon_config_set_elevation_fov_deg(CarbonConfigC *cfg, float v);

void carbon_config_set_peak_combine_twin_only(CarbonConfigC *cfg, bool v);

void carbon_config_set_peak_combine_cluster_min_size(CarbonConfigC *cfg, uintptr_t v);

void carbon_config_set_peak_combine_beat_thresh_hz(CarbonConfigC *cfg, float v);

void carbon_config_set_peak_combine_beat_outlier_removal(CarbonConfigC *cfg, bool v);

void carbon_config_set_peak_combine_snr_pre_threshold_enabled(CarbonConfigC *cfg, bool v);

void carbon_config_set_peak_combine_snr_pre_threshold_max_db(CarbonConfigC *cfg, float v);

void carbon_config_set_peak_combine_snr_pre_threshold_min_db(CarbonConfigC *cfg, float v);

void carbon_config_set_peak_combine_snr_pre_threshold_slope_db_per_hz(CarbonConfigC *cfg, float v);

void carbon_config_set_rd_outlier_range_thresh_min_m(CarbonConfigC *cfg, float v);

void carbon_config_set_rd_outlier_range_thresh_max_m(CarbonConfigC *cfg, float v);

void carbon_config_set_rd_outlier_doppler_thresh_min_mps(CarbonConfigC *cfg, float v);

void carbon_config_set_rd_outlier_doppler_thresh_max_mps(CarbonConfigC *cfg, float v);

void carbon_config_set_rd_outlier_ref_range_m(CarbonConfigC *cfg, float v);

void carbon_config_set_diagnostic_mode(CarbonConfigC *cfg, bool v);

void carbon_config_set_range_min(CarbonConfigC *cfg, float v);

void carbon_config_set_range_max(CarbonConfigC *cfg, float v);

void carbon_config_set_doppler_min(CarbonConfigC *cfg, float v);

void carbon_config_set_doppler_max(CarbonConfigC *cfg, float v);

void carbon_config_set_azimuth_deg_min(CarbonConfigC *cfg, float v);

void carbon_config_set_azimuth_deg_max(CarbonConfigC *cfg, float v);

void carbon_config_set_elevation_deg_min(CarbonConfigC *cfg, float v);

void carbon_config_set_elevation_deg_max(CarbonConfigC *cfg, float v);

void carbon_config_set_spatial_filter_enabled(CarbonConfigC *cfg, bool v);

void carbon_config_set_spatial_min_valid_neighbors(CarbonConfigC *cfg, uint8_t v);

void carbon_config_set_spatial_point_cluster_size(CarbonConfigC *cfg, uint8_t v);

void carbon_config_set_spatial_support_threshold(CarbonConfigC *cfg,
                                                 float v);

void carbon_config_set_eval_mode(CarbonConfigC *cfg, bool v);

void carbon_config_set_report_dir(CarbonConfigC *cfg, const char *v);

void carbon_config_set_fpga_target_addr(CarbonConfigC *cfg, const char *v);

void carbon_config_set_sdl_timeout_sec(CarbonConfigC *cfg, float v);

void carbon_config_set_sdl_max_retries(CarbonConfigC *cfg, uint8_t v);
 
}  // extern "C"