1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Useful enums for Ouster sensors.

use crate::common::*;

/// The mode includes number of vertical scans in one revolution and rotation frequency (Hz).
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub enum LidarMode {
    #[serde(rename = "512x10")]
    Mode512x10,
    #[serde(rename = "512x20")]
    Mode512x20,
    #[serde(rename = "1024x10")]
    Mode1024x10,
    #[serde(rename = "1024x20")]
    Mode1024x20,
    #[serde(rename = "2048x10")]
    Mode2048x10,
}

impl LidarMode {
    pub fn columns_per_revolution(&self) -> u16 {
        use LidarMode::*;
        match self {
            Mode512x10 | Mode512x20 => 512,
            Mode1024x10 | Mode1024x20 => 1024,
            Mode2048x10 => 2048,
        }
    }
}

impl Display for LidarMode {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        use LidarMode::*;
        let text = match self {
            Mode512x10 => "512x10",
            Mode512x20 => "512x20",
            Mode1024x10 => "1024x10",
            Mode1024x20 => "1024x20",
            Mode2048x10 => "2048x10",
        };
        write!(formatter, "{}", text)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub enum MultipurposeIoMode {
    #[serde(rename = "OUTPUT_FROM_INTERNAL_OSC")]
    OutputFromInternalOsc,
    #[serde(rename = "OUTPUT_FROM_SYNC_PULSE_IN")]
    OutputFromSyncPulseIn,
    #[serde(rename = "OUTPUT_FROM_PTP_1588")]
    OutputFromPtp1588,
    #[serde(rename = "OFF")]
    Off,
}

impl Display for MultipurposeIoMode {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        use MultipurposeIoMode::*;
        let text = match self {
            OutputFromInternalOsc => "OUTPUT_FROM_INTERNAL_OSC",
            OutputFromSyncPulseIn => "OUTPUT_FROM_SYNC_PULSE_IN",
            OutputFromPtp1588 => "OUTPUT_FROM_PTP1588",
            Off => "OFF",
        };
        write!(formatter, "{}", text)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub enum TimestampMode {
    #[serde(rename = "TIME_FROM_INTERNAL_OSC")]
    TimeFromInternalOsc,
    #[serde(rename = "TIME_FROM_PTP_1588")]
    TimeFromPtp1588,
    #[serde(rename = "TIME_FROM_SYNC_PULSE_IN")]
    TimeFromSyncPulseIn,
}

impl Display for TimestampMode {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        use TimestampMode::*;
        let text = match self {
            TimeFromInternalOsc => "TIME_FROM_INTERNAL_OSC",
            TimeFromPtp1588 => "TIME_FROM_PTP1588",
            TimeFromSyncPulseIn => "TIME_FROM_SYNC_PULSE_IN",
        };
        write!(formatter, "{}", text)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub enum Polarity {
    #[serde(rename = "ACTIVE_HIGH")]
    ActiveHigh,
    #[serde(rename = "ACTIVE_LOW")]
    ActiveLow,
}

impl Display for Polarity {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        use Polarity::*;
        let text = match self {
            ActiveHigh => "ACTIVE_HIGH",
            ActiveLow => "ACTIVE_LOW",
        };
        write!(formatter, "{}", text)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub enum OnOffMode {
    #[serde(rename = "ON")]
    On,
    #[serde(rename = "OFF")]
    Off,
}

impl Display for OnOffMode {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        use OnOffMode::*;
        let text = match self {
            On => "ON",
            Off => "OFF",
        };
        write!(formatter, "{}", text)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub enum NmeaBaudRate {
    #[serde(rename = "BAUD_9600")]
    Baud9600,
    #[serde(rename = "BAUD_115200")]
    Baud115200,
}

impl Display for NmeaBaudRate {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        use NmeaBaudRate::*;
        let text = match self {
            Baud9600 => "BAUD_9600",
            Baud115200 => "BAUD_115200",
        };
        write!(formatter, "{}", text)
    }
}