prinThor 0.0.3

The highly reliable but not necessarily functional 3D Printer firmware
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

use embassy_time::{Duration, Instant};
use crate::hwa;

pub struct Timings {
    // Segment reference time
    t_segment: Instant,
    // Micro-segment reference time
    t_u_segment: Instant,
    // Time to prepare a segment
    t_segment_preparation: Duration,
    t_segment_execution: Duration,
    // Aggregated computation for every micro-segment
    t_u_segment_computation_agg: Duration,
    // Aggregated stepping time for every micro-segment
    t_u_segment_stepping_agg: Duration,
    // Aggregated remaining time for every micro-segment
    t_u_segment_remaining_agg: Duration,
    // Min computation for every micro-segment
    t_u_segment_computation_min: Duration,
    // Min stepping time for every micro-segment
    t_u_segment_stepping_min: Duration,
    // Min remaining time for every micro-segment
    t_u_segment_remaining_min: Duration,
    // Max computation for every micro-segment
    t_u_segment_computation_max: Duration,
    // Max stepping time for every micro-segment
    t_u_segment_stepping_max: Duration,
    // Max remaining time for every micro-segment
    t_u_segment_remaining_max: Duration,
    t_segment_remaining: Duration,
}

impl Timings {
    pub fn new() -> Self {
        Self {
            t_segment: Instant::now(),
            t_u_segment: Instant::now(),
            t_segment_preparation: Duration::from_ticks(0),
            t_segment_execution: Duration::from_ticks(0),
            t_u_segment_computation_agg: Duration::from_ticks(0),
            t_u_segment_stepping_agg: Duration::from_ticks(0),
            t_u_segment_remaining_agg: Duration::from_ticks(0),
            t_u_segment_computation_min: Duration::from_ticks(999999999),
            t_u_segment_stepping_min: Duration::from_ticks(999999999),
            t_u_segment_remaining_min: Duration::from_ticks(999999999),
            t_u_segment_computation_max: Duration::from_ticks(0),
            t_u_segment_stepping_max: Duration::from_ticks(0),
            t_u_segment_remaining_max: Duration::from_ticks(0),
            t_segment_remaining: Duration::from_ticks(0),
        }
    }
    pub fn u_reset(&mut self) {
        self.t_u_segment = Instant::now();
    }

    pub fn set_prep(&mut self) {
        self.t_segment_preparation = self.t_segment.elapsed();
    }

    pub fn add_u_comp(&mut self) {
        let elapsed = self.t_u_segment.elapsed();
        self.t_u_segment_computation_min = self.t_u_segment_computation_min.min(elapsed);
        self.t_u_segment_computation_max = self.t_u_segment_computation_max.max(elapsed);
        self.t_u_segment_computation_agg += elapsed;
        self.u_reset();
    }

    pub fn add_u_stepping(&mut self) {
        let elapsed = self.t_u_segment.elapsed();
        self.t_u_segment_stepping_min = self.t_u_segment_stepping_min.min(elapsed);
        self.t_u_segment_stepping_max = self.t_u_segment_stepping_max.max(elapsed);
        self.t_u_segment_stepping_agg += elapsed;
        self.u_reset();
    }

    pub fn add_u_remaining(&mut self) {
        let elapsed = self.t_u_segment.elapsed();
        self.t_u_segment_remaining_min = self.t_u_segment_remaining_min.min(elapsed);
        self.t_u_segment_remaining_max = self.t_u_segment_remaining_max.max(elapsed);
        self.t_u_segment_remaining_agg += elapsed;
        self.u_reset();
    }

    pub fn set_execution(&mut self) {
        self.t_segment_execution = self.t_segment.elapsed();
    }

    pub fn set_remaining(&mut self) {
        self.t_segment_remaining = self.t_segment.elapsed() - self.t_segment_execution;
    }

    pub fn report(&self) {
        hwa::debug!("Segment timings: {} + {} + {} = {}",
            self.t_segment_preparation.as_micros(),
            self.t_segment_execution.as_micros(),
            self.t_segment_remaining.as_micros(),
            (self.t_segment_preparation + self.t_segment_execution + self.t_segment_remaining).as_micros()
        );
        hwa::debug!("\tMicro-segment timings: {} + {} + {} = {}",
            self.t_u_segment_computation_agg.as_micros(),
            self.t_u_segment_stepping_agg.as_micros(),
            self.t_u_segment_remaining_agg.as_micros(),
            (self.t_u_segment_computation_agg + self.t_u_segment_stepping_agg + self.t_u_segment_remaining_agg).as_micros()
        );
        hwa::debug!("\tMicro-segment ranges: [{} .. {}] + [{} .. {}] + [{} .. {}] = [{} .. {}]",
            self.t_u_segment_computation_min.as_micros(),
            self.t_u_segment_computation_max.as_micros(),
            self.t_u_segment_stepping_min.as_micros(),
            self.t_u_segment_stepping_max.as_micros(),
            self.t_u_segment_remaining_min.as_micros(),
            self.t_u_segment_remaining_max.as_micros(),
            (self.t_u_segment_computation_min + self.t_u_segment_stepping_min + self.t_u_segment_remaining_min).as_micros(),
            (self.t_u_segment_computation_max + self.t_u_segment_stepping_max + self.t_u_segment_remaining_max).as_micros(),
        );
    }
}