PD0Messages.hpp

Go to the documentation of this file.

#ifndef DVL_TELEDYNE_PD0MESSAGES_HPP
#define DVL_TELEDYNE_PD0MESSAGES_HPP

#include <stdint.h>
#include <base/Time.hpp>
#include <base/Eigen.hpp>
#include <vector>

namespace dvl_teledyne
{
    struct Sensors
    {
        bool calculates_speed_of_sound;
        bool depth;
        bool yaw;
        bool pitch;
        bool roll;
        bool salinity;
        bool temperature;
    };

    struct DeviceInfo
    {
        uint8_t fw_version;
        uint8_t fw_revision;
        uint64_t cpu_board_serno;
        uint16_t system_configuration;
        uint8_t  beam_count;

        /* Set of sensors available on the device */
        Sensors available_sensors;
    };

    struct AcquisitionConfiguration
    {
        Sensors  used_sensors;

        uint8_t  lag_duration;
        uint8_t  cell_count;
        uint8_t  profiling_mode;
        uint8_t  low_correlation_threshold;
        uint8_t  code_repetition_count;
        uint16_t pings_per_ensemble;
        float    cell_length;
        float    blank_after_transmit_distance;
        float    water_layer_min_ping_threshold;
        float    water_layer_velocity_threshold;
        base::Time time_between_ping_groups;
        float yaw_alignment;
        float yaw_bias;
        float first_cell_distance;
        float transmit_pulse_length;
        uint8_t  water_layer_start;
        uint8_t  water_layer_end;
        uint8_t  false_target_threshold;
        bool  low_latency_trigger;
        float transmit_lag_distance;
        bool  narrow_bandwidth_mode;
        uint8_t  base_frequency_index;
    };

    enum COORDINATE_SYSTEMS
    {
        BEAM, INSTRUMENT, SHIP, EARTH
    };

    struct OutputConfiguration
    {
        COORDINATE_SYSTEMS coordinate_system;
        bool use_attitude;
        bool use_3beam_solution;
        bool use_bin_mapping;
    };

    struct Status
    {
        uint32_t seq;
        base::Time time;

        base::Quaterniond orientation;
        float stddev_orientation[3];

        float depth;
        float speed_of_sound;
        float salinity;
        float temperature;
        float pressure;
        float pressure_variance;

        uint8_t adc_channels[8];

        base::Time min_preping_wait;

        uint16_t self_test_result;
        uint32_t status_word;
    };

    struct CellReading
    {
        float velocity[4];
        float correlation[4];
        float intensity[4];
        float quality[4];
    };

    struct CellReadings
    {
        base::Time time;
        std::vector<CellReading> readings;
    };

    struct BottomTrackingConfiguration
    {
        uint16_t ping_per_ensemble;
        uint16_t delay_before_reacquiring;
        float    correlation_threshold;
        float    evaluation_threshold;
        float    good_ping_threshold;
        uint8_t  mode;
        float  max_velocity_error;

        float max_tracking_depth;

        uint8_t  gain;
    };

    struct BottomTracking
    {
        base::Time time;

        float range[4];
        float velocity[4];
        float correlation[4];
        float evaluation[4];
        float good_ping_ratio[4];

        float rssi[4];
    };
}

#endif