embedded_aim_motor/motor/
parameters.rs

1use super::Motor;
2use crate::{AlarmCode, Direction, Error, Result};
3use embassy_time::Duration;
4
5impl<I: embedded_io_async::Read + embedded_io_async::Write> Motor<I> {
6    pub async fn modbus_enabled(&mut self) -> Result<bool> {
7        self.read_one_word_parameter(0x00, |v| match v {
8            0 => Ok(false),
9            1 => Ok(true),
10            _ => Err(Error::UnexpectedResponseData),
11        })
12        .await
13    }
14
15    pub async fn set_modbus_enabled(&mut self, value: bool) -> Result<()> {
16        self.write_one_word_parameter(0x00, value, |v| match v {
17            false => Ok(0),
18            true => Ok(1),
19        })
20        .await
21    }
22
23    pub async fn drive_enabled(&mut self) -> Result<bool> {
24        self.read_one_word_parameter(0x01, |v| match v {
25            0 => Ok(false),
26            1 => Ok(true),
27            _ => Err(Error::UnexpectedResponseData),
28        })
29        .await
30    }
31
32    pub async fn set_drive_enabled(&mut self, value: bool) -> Result<()> {
33        self.write_one_word_parameter(0x01, value, |v| match v {
34            false => Ok(0),
35            true => Ok(1),
36        })
37        .await
38    }
39
40    /// Gets the target speed in RPM
41    ///
42    /// In speed mode, this is the target speed.
43    /// In position mode, this is the maximum speed.
44    pub async fn target_rpm(&mut self) -> Result<u16> {
45        self.read_one_word_parameter(0x02, Ok).await
46    }
47
48    /// Sets the target speed in RPM
49    ///
50    /// 0-3000 RPM.
51    /// In speed mode, this is the target speed.
52    /// In position mode, this is the maximum speed.
53    pub async fn set_target_rpm(&mut self, value: u16) -> Result<()> {
54        self.write_one_word_parameter(0x02, value, Ok).await
55    }
56
57    pub async fn acceleration(&mut self) -> Result<u16> {
58        self.read_one_word_parameter(0x03, Ok).await
59    }
60
61    pub async fn set_acceleration(&mut self, value: u16) -> Result<()> {
62        self.write_one_word_parameter(0x03, value, Ok).await
63    }
64
65    pub async fn weak_magnetic_angle(&mut self) -> Result<u16> {
66        self.read_one_word_parameter(0x04, Ok).await
67    }
68
69    pub async fn set_weak_magnetic_angle(&mut self, value: u16) -> Result<()> {
70        self.write_one_word_parameter(0x04, value, Ok).await
71    }
72
73    pub async fn speed_kp(&mut self) -> Result<u16> {
74        self.read_one_word_parameter(0x05, Ok).await
75    }
76
77    pub async fn set_speed_kp(&mut self, value: u16) -> Result<()> {
78        self.write_one_word_parameter(0x05, value, Ok).await
79    }
80
81    pub async fn speed_i_time(&mut self) -> Result<Duration> {
82        self.read_one_word_parameter(0x06, |v| Ok(Duration::from_millis(v.into())))
83            .await
84    }
85
86    pub async fn set_speed_i_time(&mut self, value: Duration) -> Result<()> {
87        self.write_one_word_parameter(0x06, value, |v| Ok(v.as_millis() as u16))
88            .await
89    }
90
91    pub async fn position_kp(&mut self) -> Result<u16> {
92        self.read_one_word_parameter(0x07, Ok).await
93    }
94
95    pub async fn set_position_kp(&mut self, value: u16) -> Result<()> {
96        self.write_one_word_parameter(0x07, value, Ok).await
97    }
98
99    pub async fn speed_feed(&mut self) -> Result<f32> {
100        self.read_one_word_parameter(0x08, |v| Ok(v as f32 / 327.))
101            .await
102    }
103
104    pub async fn set_speed_feed(&mut self, value: f32) -> Result<()> {
105        self.write_one_word_parameter(0x08, value, |v| Ok((v * 327.) as u16))
106            .await
107    }
108
109    pub async fn dir_polarity(&mut self) -> Result<Direction> {
110        self.read_one_word_parameter(0x09, |v| match v {
111            0 => Ok(Direction::CounterClockwise),
112            1 => Ok(Direction::Clockwise),
113            _ => Err(Error::UnexpectedResponseData),
114        })
115        .await
116    }
117
118    pub async fn set_dir_polarity(&mut self, value: Direction) -> Result<()> {
119        self.write_one_word_parameter(0x09, value, |v| match v {
120            Direction::CounterClockwise => Ok(0),
121            Direction::Clockwise => Ok(1),
122        })
123        .await
124    }
125
126    pub async fn electronic_gear_numerator(&mut self) -> Result<u16> {
127        self.read_one_word_parameter(0x0A, Ok).await
128    }
129
130    /// Set numerator of electronic gear ratio
131    ///
132    /// 0-65535
133    /// 0 enables special functions
134    pub async fn set_electronic_gear_numerator(&mut self, value: u16) -> Result<()> {
135        self.write_one_word_parameter(0x0A, value, Ok).await
136    }
137
138    pub async fn electronic_gear_denominator(&mut self) -> Result<u16> {
139        self.read_one_word_parameter(0x0B, Ok).await
140    }
141
142    /// Set denominator of electronic gear ratio
143    ///
144    /// 1-65535
145    pub async fn set_electronic_gear_denominator(&mut self, value: u16) -> Result<()> {
146        self.write_one_word_parameter(0x0B, value, Ok).await
147    }
148
149    pub async fn target_position(&mut self) -> Result<u32> {
150        self.read_two_word_parameter(0x0C, |msb, lsb| {
151            let msb = msb.to_be_bytes();
152            let lsb = lsb.to_be_bytes();
153            Ok(u32::from_be_bytes([lsb[0], lsb[1], msb[0], msb[1]]))
154        })
155        .await
156    }
157
158    pub async fn set_target_position(&mut self, value: u32) -> Result<()> {
159        self.write_two_word_parameter(0x0C, value, |v| {
160            let data = v.to_be_bytes();
161            let msb = u16::from_be_bytes([data[0], data[1]]);
162            let lsb = u16::from_be_bytes([data[2], data[3]]);
163            Ok([lsb, msb])
164        })
165        .await
166    }
167
168    pub async fn alarm_code(&mut self) -> Result<Option<AlarmCode>> {
169        self.read_one_word_parameter(0x0E, |v| match v {
170            0 => Ok(None),
171            0x10 => Ok(Some(AlarmCode::PowerFailure)),
172            0x12 => Ok(Some(AlarmCode::Overflow)),
173            0x14 => Ok(Some(AlarmCode::Block)),
174            0x15 => Ok(Some(AlarmCode::Overpressure)),
175            _ => Err(Error::UnexpectedResponseData),
176        })
177        .await
178    }
179
180    pub async fn current(&mut self) -> Result<f32> {
181        self.read_one_word_parameter(0x0F, |v| Ok(v as f32 / 2000.))
182            .await
183    }
184
185    pub async fn speed(&mut self) -> Result<f32> {
186        self.read_one_word_parameter(0x10, |v| Ok(v as f32 / 10.))
187            .await
188    }
189
190    pub async fn voltage(&mut self) -> Result<f32> {
191        self.read_one_word_parameter(0x11, |v| Ok(v as f32 / 327.))
192            .await
193    }
194
195    pub async fn temperature(&mut self) -> Result<u16> {
196        self.read_one_word_parameter(0x12, Ok).await
197    }
198
199    pub async fn pwm(&mut self) -> Result<u16> {
200        self.read_one_word_parameter(0x13, Ok).await
201    }
202
203    pub async fn parameter_save_flag(&mut self) -> Result<bool> {
204        self.read_one_word_parameter(0x14, |v| match v {
205            0 => Ok(false),
206            1 => Ok(true),
207            _ => Err(Error::UnexpectedResponseData),
208        })
209        .await
210    }
211
212    pub async fn set_parameter_save_flag(&mut self, value: bool) -> Result<()> {
213        self.write_one_word_parameter(0x14, value, |v| match v {
214            false => Ok(0),
215            true => Ok(1),
216        })
217        .await
218    }
219
220    pub async fn device_address(&mut self) -> Result<u16> {
221        self.read_one_word_parameter(0x15, Ok).await
222    }
223
224    pub async fn absolute_position(&mut self) -> Result<u32> {
225        self.read_two_word_parameter(0x16, |msb, lsb| {
226            let msb = msb.to_be_bytes();
227            let lsb = lsb.to_be_bytes();
228            Ok(u32::from_be_bytes([lsb[0], lsb[1], msb[0], msb[1]]))
229        })
230        .await
231    }
232
233    pub async fn set_absolute_position(&mut self, value: u32) -> Result<()> {
234        self.write_two_word_parameter(0x16, value, |v| {
235            let data = v.to_be_bytes();
236            let msb = u16::from_be_bytes([data[0], data[1]]);
237            let lsb = u16::from_be_bytes([data[2], data[3]]);
238            Ok([lsb, msb])
239        })
240        .await
241    }
242
243    pub async fn still_maximum_allowed_current(&mut self) -> Result<u16> {
244        self.read_one_word_parameter(0x18, Ok).await
245    }
246
247    pub async fn set_still_maximum_allowed_current(&mut self, value: u16) -> Result<()> {
248        self.write_one_word_parameter(0x18, value, Ok).await
249    }
250
251    pub async fn specific_function(&mut self) -> Result<u16> {
252        self.read_one_word_parameter(0x19, Ok).await
253    }
254
255    pub async fn set_specific_function(&mut self, value: u16) -> Result<()> {
256        self.write_one_word_parameter(0x19, value, Ok).await
257    }
258}
embedded_aim_motor/motor/parameters.rs

embedded_aim_motor/motor/
parameters.rs
