deimos 0.16.2

Control-loop and data pipeline for the Deimos data acquisition system
Documentation 
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

use std::time::{Duration, Instant};

use crate::peripheral::Peripheral;
use deimos_shared::{peripherals::PeripheralId, states::OperatingMetrics};

use crate::socket::SocketAddr;

/// Peripheral control metrics
#[derive(Default, Clone, Copy, Debug)]
pub(crate) struct PeripheralMetrics {
    /// Last set of peripheral-side comm metrics
    pub operating_metrics: OperatingMetrics,

    /// Time at which the last in-order packet from this peripheral
    /// was received by the controller
    pub last_received_time_ns: i64,

    /// Latest packet arrival timing delta from target time
    pub raw_timing_delta_ns: f64,

    /// Filtered packet arrival timing delta from target time
    pub filtered_timing_delta_ns: f64,

    /// Requested change in peripheral's sampling period
    pub requested_period_delta_ns: f64,

    /// Requested change in peripheral's sampling phase
    pub requested_phase_delta_ns: f64,

    /// How many cycles has it been since we heard from this peripheral?
    pub loss_of_contact_counter: f64,

    /// How many packets behind is the peripheral?
    pub cycle_lag_count: f64,
}

pub(crate) enum ConnState {
    Binding {
        binding_timeout: Instant,
        reconnect_deadline: Option<Instant>,
    },
    Configuring {
        configuring_timeout: Instant,
        reconnect_deadline: Option<Instant>,
    },
    Operating(),
    Disconnected {
        deadline: Option<Instant>,
    },
}

/// Peripheral-specific metrics, readings, channel names, etc
pub(crate) struct PeripheralState {
    /// Ethernet address
    pub addr: SocketAddr,

    /// Device unique ID
    #[allow(dead_code)]
    pub id: PeripheralId,

    /// Device name
    pub name: String,

    //
    // Values updated live during operation
    //
    /// Has this peripheral received and acknowledged its pre-operation
    /// configuration frame yet?
    pub acknowledged_configuration: bool,

    /// Connection state tracking binding/configuring/operating timeouts.
    pub conn_state: ConnState,

    /// Timing and comm metrics
    pub metrics: PeripheralMetrics,

    /// Has this peripheral produced at least one in-order operating packet?
    pub has_received_packet: bool,

    //
    // Baked values not intended to change after init
    //
    /// Output channel names including peripheral name
    pub metric_full_names: Vec<String>,
}

impl PeripheralState {
    #[allow(clippy::borrowed_box)] // Fixing this with trait objects requires using Any
    pub fn new(
        name: &String,
        addr: SocketAddr,
        p: &Box<dyn Peripheral>,
        ctx: &crate::controller::context::ControllerCtx,
    ) -> Self {
        // Metric names are pretty manual
        let mut mnames = Vec::new();
        for orig in [
            "cycle_time_ns",
            "cycle_time_margin_ns",
            "raw_timing_delta_ns",
            "filtered_timing_delta_ns",
            "requested_period_delta_ns",
            "requested_phase_delta_ns",
            "loss_of_contact_counter",
            "cycle_lag_count",
        ]
        .iter()
        {
            mnames.push(format!("{name}.metrics.{orig}"))
        }

        let metrics = PeripheralMetrics::default();
        let acknowledged_configuration = false;
        let conn_state = ConnState::Binding {
            binding_timeout: Instant::now() + Duration::from_millis(ctx.binding_timeout_ms as u64),
            reconnect_deadline: None,
        };
        let id = p.id();

        Self {
            addr,
            id,
            name: name.to_owned(),
            acknowledged_configuration,
            conn_state,
            metrics,
            has_received_packet: false,
            metric_full_names: mnames,
        }
    }

    pub fn write_metric_values(&self, out: &mut [f64]) {
        out[0] = self.metrics.operating_metrics.cycle_time_ns as f64;
        out[1] = self.metrics.operating_metrics.cycle_time_margin_ns as f64;
        out[2] = self.metrics.raw_timing_delta_ns;
        out[3] = self.metrics.filtered_timing_delta_ns;
        out[4] = self.metrics.requested_period_delta_ns;
        out[5] = self.metrics.requested_phase_delta_ns;
        out[6] = self.metrics.loss_of_contact_counter;
        out[7] = self.metrics.cycle_lag_count;
    }
}