fugit 0.5.0

Time library for embedded targets with ease-of-use and performance first.
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! Type aliases for common uses

use crate::kind::{Monotonic, Wrapping};
use crate::Duration;
use crate::Instant;
use crate::Rate;

/// Alias for picosecond duration
pub type PicosDuration<T> = Duration<T, 1, 1_000_000_000_000>;

/// Alias for picosecond duration (`u32` backing storage)
pub type PicosDurationU32 = Duration<u32, 1, 1_000_000_000_000>;

/// Alias for picosecond duration (`u64` backing storage)
pub type PicosDurationU64 = Duration<u64, 1, 1_000_000_000_000>;

/// Alias for nanosecond duration
pub type NanosDuration<T> = Duration<T, 1, 1_000_000_000>;

/// Alias for nanosecond duration (`u32` backing storage)
pub type NanosDurationU32 = Duration<u32, 1, 1_000_000_000>;

/// Alias for nanosecond duration (`u64` backing storage)
pub type NanosDurationU64 = Duration<u64, 1, 1_000_000_000>;

/// Alias for microsecond duration
pub type MicrosDuration<T> = Duration<T, 1, 1_000_000>;

/// Alias for microsecond duration (`u32` backing storage)
pub type MicrosDurationU32 = Duration<u32, 1, 1_000_000>;

/// Alias for microsecond duration (`u64` backing storage)
pub type MicrosDurationU64 = Duration<u64, 1, 1_000_000>;

/// Alias for millisecond duration
pub type MillisDuration<T> = Duration<T, 1, 1_000>;

/// Alias for millisecond duration (`u32` backing storage)
pub type MillisDurationU32 = Duration<u32, 1, 1_000>;

/// Alias for millisecond duration (`u64` backing storage)
pub type MillisDurationU64 = Duration<u64, 1, 1_000>;

/// Alias for second duration
pub type SecsDuration<T> = Duration<T, 1, 1>;

/// Alias for second duration (`u32` backing storage)
pub type SecsDurationU32 = Duration<u32, 1, 1>;

/// Alias for second duration (`u64` backing storage)
pub type SecsDurationU64 = Duration<u64, 1, 1>;

/// Alias for minutes duration
pub type MinutesDuration<T> = Duration<T, 60, 1>;

/// Alias for minutes duration (`u32` backing storage)
pub type MinutesDurationU32 = Duration<u32, 60, 1>;

/// Alias for minutes duration (`u64` backing storage)
pub type MinutesDurationU64 = Duration<u64, 60, 1>;

/// Alias for hours duration
pub type HoursDuration<T> = Duration<T, 3_600, 1>;

/// Alias for hours duration (`u32` backing storage)
pub type HoursDurationU32 = Duration<u32, 3_600, 1>;

/// Alias for hours duration (`u64` backing storage)
pub type HoursDurationU64 = Duration<u64, 3_600, 1>;

/// Alias for durations that come from timers with a specific frequency
pub type TimerDuration<T, const FREQ_HZ: u64> = Duration<T, 1, FREQ_HZ>;

/// Alias for durations that come from timers with a specific frequency (`u32` backing storage)
pub type TimerDurationU32<const FREQ_HZ: u64> = Duration<u32, 1, FREQ_HZ>;

/// Alias for durations that come from timers with a specific frequency (`u64` backing storage)
pub type TimerDurationU64<const FREQ_HZ: u64> = Duration<u64, 1, FREQ_HZ>;

// -------------------------------

/// Alias for instants on a monotonic timeline
pub type MonotonicInstant<T, const NOM: u64, const DENOM: u64> = Instant<T, NOM, DENOM, Monotonic>;

/// Alias for monotonic instants that come from timers with a specific frequency
pub type MonotonicTimerInstant<T, const FREQ_HZ: u64> = Instant<T, 1, FREQ_HZ, Monotonic>;

/// Alias for monotonic instants that come from timers with a specific frequency (`u32` backing
/// storage)
pub type MonotonicTimerInstantU32<const FREQ_HZ: u64> = Instant<u32, 1, FREQ_HZ, Monotonic>;

/// Alias for monotonic instants that come from timers with a specific frequency (`u64` backing
/// storage)
pub type MonotonicTimerInstantU64<const FREQ_HZ: u64> = Instant<u64, 1, FREQ_HZ, Monotonic>;

// -------------------------------

/// Alias for instants on a wrapping counter
pub type WrappingInstant<T, const NOM: u64, const DENOM: u64> = Instant<T, NOM, DENOM, Wrapping>;

/// Alias for wrapping instants that come from timers with a specific frequency
pub type WrappingTimerInstant<T, const FREQ_HZ: u64> = Instant<T, 1, FREQ_HZ, Wrapping>;

/// Alias for wrapping instants that come from timers with a specific frequency (`u32` backing
/// storage)
pub type WrappingTimerInstantU32<const FREQ_HZ: u64> = Instant<u32, 1, FREQ_HZ, Wrapping>;

/// Alias for wrapping instants that come from timers with a specific frequency (`u64` backing
/// storage)
pub type WrappingTimerInstantU64<const FREQ_HZ: u64> = Instant<u64, 1, FREQ_HZ, Wrapping>;

// -------------------------------

/// Alias for hertz rate
pub type Hertz<T> = Rate<T, 1, 1>;

/// Alias for hertz rate (`u32` backing storage)
pub type HertzU32 = Rate<u32, 1, 1>;

/// Alias for hertz rate (`u64` backing storage)
pub type HertzU64 = Rate<u64, 1, 1>;

/// Alias for kilohertz rate
pub type Kilohertz<T> = Rate<T, 1_000, 1>;

/// Alias for kilohertz rate (`u32` backing storage)
pub type KilohertzU32 = Rate<u32, 1_000, 1>;

/// Alias for kilohertz rate (`u64` backing storage)
pub type KilohertzU64 = Rate<u64, 1_000, 1>;

/// Alias for megahertz rate
pub type Megahertz<T> = Rate<T, 1_000_000, 1>;

/// Alias for megahertz rate (`u32` backing storage)
pub type MegahertzU32 = Rate<u32, 1_000_000, 1>;

/// Alias for megahertz rate (`u64` backing storage)
pub type MegahertzU64 = Rate<u64, 1_000_000, 1>;

/// Alias for gigahertz rate
pub type Gigahertz<T> = Rate<T, 1_000_000_000, 1>;

/// Alias for gigahertz rate (`u32` backing storage)
pub type GigahertzU32 = Rate<u32, 1_000_000_000, 1>;

/// Alias for gigahertz rate (`u64` backing storage)
pub type GigahertzU64 = Rate<u64, 1_000_000_000, 1>;

/// Alias for rate that come from timers with a specific frequency
pub type TimerRate<T, const FREQ_HZ: u64> = Rate<T, FREQ_HZ, 1>;

/// Alias for rate that come from timers with a specific frequency (`u32` backing storage)
pub type TimerRateU32<const FREQ_HZ: u64> = Rate<u32, FREQ_HZ, 1>;

/// Alias for rate that come from timers with a specific frequency (`u64` backing storage)
pub type TimerRateU64<const FREQ_HZ: u64> = Rate<u64, FREQ_HZ, 1>;