motor-driver-hal 0.1.3

motor-driver using embedded-hal for linux
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

/// Error types that can occur during motor driver operations.
/// 
/// This enum represents all possible error conditions that can arise when
/// using motor driver implementations. Errors are categorized by their source
/// and can help diagnose hardware or configuration issues.
/// 
/// # Example
/// 
/// ```rust
/// use motor_driver_hal::MotorDriverError;
/// 
/// match motor.set_speed(1500) {
///     Ok(()) => println!("Speed set successfully"),
///     Err(MotorDriverError::InvalidSpeed) => println!("Speed value too high"),
///     Err(MotorDriverError::NotInitialized) => println!("Driver not initialized"),
///     Err(e) => println!("Other error: {}", e),
/// }
/// ```
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum MotorDriverError {
    /// GPIO pin control operation failed.
    /// 
    /// This error occurs when setting GPIO pin states (high/low) fails,
    /// typically due to hardware issues or incorrect pin configuration.
    GpioError,
    
    /// PWM channel operation failed.
    /// 
    /// This error occurs when PWM duty cycle setting fails, which can
    /// happen due to invalid duty cycle values or PWM hardware issues.
    PwmError,
    
    /// Invalid speed value provided.
    /// 
    /// This error occurs when the speed value exceeds the configured
    /// maximum duty cycle or is otherwise invalid for the motor configuration.
    InvalidSpeed,
    
    /// Invalid configuration detected.
    /// 
    /// This error occurs when the motor driver configuration is incomplete
    /// or contains conflicting settings that prevent proper operation.
    InvalidConfiguration,
    
    /// Motor driver has not been initialized.
    /// 
    /// This error occurs when attempting to perform operations before
    /// calling the `initialize()` method.
    NotInitialized,
    
    /// Hardware fault detected.
    /// 
    /// This error indicates a general hardware fault that prevents normal
    /// operation, such as encoder reading failures or unsupported operations.
    HardwareFault,
    
    /// Motor current consumption exceeds safe limits.
    /// 
    /// This error occurs when the motor draws more current than the
    /// configured safe operating limits.
    OverCurrent,
    
    /// Motor driver temperature exceeds safe operating limits.
    /// 
    /// This error occurs when the motor driver's temperature sensor
    /// detects overheating conditions.
    OverTemperature,
    
    /// Supply voltage is below minimum operating requirements.
    /// 
    /// This error occurs when the motor driver's supply voltage
    /// drops below the minimum required for safe operation.
    UnderVoltage,
    
    /// Supply voltage exceeds maximum operating limits.
    /// 
    /// This error occurs when the motor driver's supply voltage
    /// exceeds the maximum safe operating voltage.
    OverVoltage,
    
    /// Communication with motor driver hardware failed.
    /// 
    /// This error occurs when communication protocols (I2C, SPI, UART)
    /// fail to communicate with smart motor drivers.
    CommunicationError,
}

impl core::fmt::Display for MotorDriverError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            MotorDriverError::GpioError => write!(f, "GPIO control error"),
            MotorDriverError::PwmError => write!(f, "PWM control error"),
            MotorDriverError::InvalidSpeed => write!(f, "Invalid speed value"),
            MotorDriverError::InvalidConfiguration => write!(f, "Invalid configuration"),
            MotorDriverError::NotInitialized => write!(f, "Driver not initialized"),
            MotorDriverError::HardwareFault => write!(f, "Hardware fault detected"),
            MotorDriverError::OverCurrent => write!(f, "Over current condition"),
            MotorDriverError::OverTemperature => write!(f, "Over temperature condition"),
            MotorDriverError::UnderVoltage => write!(f, "Under voltage condition"),
            MotorDriverError::OverVoltage => write!(f, "Over voltage condition"),
            MotorDriverError::CommunicationError => write!(f, "Communication error"),
        }
    }
}

#[cfg(feature = "std")]
impl std::error::Error for MotorDriverError {}