stepper-motion 0.1.1

Configuration-driven stepper motor motion control with embedded-hal 1.0 support
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

//! System configuration - root configuration structure.

use heapless::{FnvIndexMap, String};
use serde::Deserialize;

use super::motor::MotorConfig;
use super::trajectory::{TrajectoryConfig, WaypointTrajectory};

/// Root configuration structure from TOML.
#[derive(Debug, Clone, Deserialize)]
pub struct SystemConfig {
    /// Named motor configurations.
    pub motors: FnvIndexMap<String<32>, MotorConfig, 8>,

    /// Named trajectory configurations.
    #[serde(default)]
    pub trajectories: FnvIndexMap<String<32>, TrajectoryConfig, 64>,

    /// Named waypoint trajectories (sequences).
    #[serde(default)]
    pub sequences: FnvIndexMap<String<32>, WaypointTrajectory, 16>,
}

impl SystemConfig {
    /// Get a motor configuration by name.
    pub fn motor(&self, name: &str) -> Option<&MotorConfig> {
        self.motors
            .iter()
            .find(|(k, _)| k.as_str() == name)
            .map(|(_, v)| v)
    }

    /// Get a trajectory configuration by name.
    pub fn trajectory(&self, name: &str) -> Option<&TrajectoryConfig> {
        self.trajectories
            .iter()
            .find(|(k, _)| k.as_str() == name)
            .map(|(_, v)| v)
    }

    /// Get a waypoint trajectory by name.
    pub fn sequence(&self, name: &str) -> Option<&WaypointTrajectory> {
        self.sequences
            .iter()
            .find(|(k, _)| k.as_str() == name)
            .map(|(_, v)| v)
    }

    /// List all motor names.
    pub fn motor_names(&self) -> impl Iterator<Item = &str> {
        self.motors.keys().map(|s| s.as_str())
    }

    /// List all trajectory names.
    pub fn trajectory_names(&self) -> impl Iterator<Item = &str> {
        self.trajectories.keys().map(|s| s.as_str())
    }

    /// List all sequence names.
    pub fn sequence_names(&self) -> impl Iterator<Item = &str> {
        self.sequences.keys().map(|s| s.as_str())
    }
}

impl Default for SystemConfig {
    fn default() -> Self {
        Self {
            motors: FnvIndexMap::new(),
            trajectories: FnvIndexMap::new(),
            sequences: FnvIndexMap::new(),
        }
    }
}