1#[allow(unused_imports)]
15use crate::{
16 base58::Uid, byte_converter::*, device::*, error::TinkerforgeError, ip_connection::async_io::AsyncIpConnection,
17 low_level_traits::LowLevelRead,
18};
19#[allow(unused_imports)]
20use futures_core::Stream;
21#[allow(unused_imports)]
22use tokio_stream::StreamExt;
23pub enum StepperBrickFunction {
24 SetMaxVelocity,
25 GetMaxVelocity,
26 GetCurrentVelocity,
27 SetSpeedRamping,
28 GetSpeedRamping,
29 FullBrake,
30 SetCurrentPosition,
31 GetCurrentPosition,
32 SetTargetPosition,
33 GetTargetPosition,
34 SetSteps,
35 GetSteps,
36 GetRemainingSteps,
37 SetStepMode,
38 GetStepMode,
39 DriveForward,
40 DriveBackward,
41 Stop,
42 GetStackInputVoltage,
43 GetExternalInputVoltage,
44 GetCurrentConsumption,
45 SetMotorCurrent,
46 GetMotorCurrent,
47 Enable,
48 Disable,
49 IsEnabled,
50 SetDecay,
51 GetDecay,
52 SetMinimumVoltage,
53 GetMinimumVoltage,
54 SetSyncRect,
55 IsSyncRect,
56 SetTimeBase,
57 GetTimeBase,
58 GetAllData,
59 SetAllDataPeriod,
60 GetAllDataPeriod,
61 SetSpitfpBaudrateConfig,
62 GetSpitfpBaudrateConfig,
63 GetSendTimeoutCount,
64 SetSpitfpBaudrate,
65 GetSpitfpBaudrate,
66 GetSpitfpErrorCount,
67 EnableStatusLed,
68 DisableStatusLed,
69 IsStatusLedEnabled,
70 GetProtocol1BrickletName,
71 GetChipTemperature,
72 Reset,
73 WriteBrickletPlugin,
74 ReadBrickletPlugin,
75 GetIdentity,
76 CallbackUnderVoltage,
77 CallbackPositionReached,
78 CallbackAllData,
79 CallbackNewState,
80}
81impl From<StepperBrickFunction> for u8 {
82 fn from(fun: StepperBrickFunction) -> Self {
83 match fun {
84 StepperBrickFunction::SetMaxVelocity => 1,
85 StepperBrickFunction::GetMaxVelocity => 2,
86 StepperBrickFunction::GetCurrentVelocity => 3,
87 StepperBrickFunction::SetSpeedRamping => 4,
88 StepperBrickFunction::GetSpeedRamping => 5,
89 StepperBrickFunction::FullBrake => 6,
90 StepperBrickFunction::SetCurrentPosition => 7,
91 StepperBrickFunction::GetCurrentPosition => 8,
92 StepperBrickFunction::SetTargetPosition => 9,
93 StepperBrickFunction::GetTargetPosition => 10,
94 StepperBrickFunction::SetSteps => 11,
95 StepperBrickFunction::GetSteps => 12,
96 StepperBrickFunction::GetRemainingSteps => 13,
97 StepperBrickFunction::SetStepMode => 14,
98 StepperBrickFunction::GetStepMode => 15,
99 StepperBrickFunction::DriveForward => 16,
100 StepperBrickFunction::DriveBackward => 17,
101 StepperBrickFunction::Stop => 18,
102 StepperBrickFunction::GetStackInputVoltage => 19,
103 StepperBrickFunction::GetExternalInputVoltage => 20,
104 StepperBrickFunction::GetCurrentConsumption => 21,
105 StepperBrickFunction::SetMotorCurrent => 22,
106 StepperBrickFunction::GetMotorCurrent => 23,
107 StepperBrickFunction::Enable => 24,
108 StepperBrickFunction::Disable => 25,
109 StepperBrickFunction::IsEnabled => 26,
110 StepperBrickFunction::SetDecay => 27,
111 StepperBrickFunction::GetDecay => 28,
112 StepperBrickFunction::SetMinimumVoltage => 29,
113 StepperBrickFunction::GetMinimumVoltage => 30,
114 StepperBrickFunction::SetSyncRect => 33,
115 StepperBrickFunction::IsSyncRect => 34,
116 StepperBrickFunction::SetTimeBase => 35,
117 StepperBrickFunction::GetTimeBase => 36,
118 StepperBrickFunction::GetAllData => 37,
119 StepperBrickFunction::SetAllDataPeriod => 38,
120 StepperBrickFunction::GetAllDataPeriod => 39,
121 StepperBrickFunction::SetSpitfpBaudrateConfig => 231,
122 StepperBrickFunction::GetSpitfpBaudrateConfig => 232,
123 StepperBrickFunction::GetSendTimeoutCount => 233,
124 StepperBrickFunction::SetSpitfpBaudrate => 234,
125 StepperBrickFunction::GetSpitfpBaudrate => 235,
126 StepperBrickFunction::GetSpitfpErrorCount => 237,
127 StepperBrickFunction::EnableStatusLed => 238,
128 StepperBrickFunction::DisableStatusLed => 239,
129 StepperBrickFunction::IsStatusLedEnabled => 240,
130 StepperBrickFunction::GetProtocol1BrickletName => 241,
131 StepperBrickFunction::GetChipTemperature => 242,
132 StepperBrickFunction::Reset => 243,
133 StepperBrickFunction::WriteBrickletPlugin => 246,
134 StepperBrickFunction::ReadBrickletPlugin => 247,
135 StepperBrickFunction::GetIdentity => 255,
136 StepperBrickFunction::CallbackUnderVoltage => 31,
137 StepperBrickFunction::CallbackPositionReached => 32,
138 StepperBrickFunction::CallbackAllData => 40,
139 StepperBrickFunction::CallbackNewState => 41,
140 }
141 }
142}
143pub const STEPPER_BRICK_STEP_MODE_FULL_STEP: u8 = 1;
144pub const STEPPER_BRICK_STEP_MODE_HALF_STEP: u8 = 2;
145pub const STEPPER_BRICK_STEP_MODE_QUARTER_STEP: u8 = 4;
146pub const STEPPER_BRICK_STEP_MODE_EIGHTH_STEP: u8 = 8;
147pub const STEPPER_BRICK_STATE_STOP: u8 = 1;
148pub const STEPPER_BRICK_STATE_ACCELERATION: u8 = 2;
149pub const STEPPER_BRICK_STATE_RUN: u8 = 3;
150pub const STEPPER_BRICK_STATE_DEACCELERATION: u8 = 4;
151pub const STEPPER_BRICK_STATE_DIRECTION_CHANGE_TO_FORWARD: u8 = 5;
152pub const STEPPER_BRICK_STATE_DIRECTION_CHANGE_TO_BACKWARD: u8 = 6;
153pub const STEPPER_BRICK_COMMUNICATION_METHOD_NONE: u8 = 0;
154pub const STEPPER_BRICK_COMMUNICATION_METHOD_USB: u8 = 1;
155pub const STEPPER_BRICK_COMMUNICATION_METHOD_SPI_STACK: u8 = 2;
156pub const STEPPER_BRICK_COMMUNICATION_METHOD_CHIBI: u8 = 3;
157pub const STEPPER_BRICK_COMMUNICATION_METHOD_RS485: u8 = 4;
158pub const STEPPER_BRICK_COMMUNICATION_METHOD_WIFI: u8 = 5;
159pub const STEPPER_BRICK_COMMUNICATION_METHOD_ETHERNET: u8 = 6;
160pub const STEPPER_BRICK_COMMUNICATION_METHOD_WIFI_V2: u8 = 7;
161
162#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
163pub struct SpeedRamping {
164 pub acceleration: u16,
165 pub deacceleration: u16,
166}
167impl FromByteSlice for SpeedRamping {
168 fn bytes_expected() -> usize {
169 4
170 }
171 fn from_le_byte_slice(bytes: &[u8]) -> SpeedRamping {
172 SpeedRamping { acceleration: <u16>::from_le_byte_slice(&bytes[0..2]), deacceleration: <u16>::from_le_byte_slice(&bytes[2..4]) }
173 }
174}
175
176#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
177pub struct AllData {
178 pub current_velocity: u16,
179 pub current_position: i32,
180 pub remaining_steps: i32,
181 pub stack_voltage: u16,
182 pub external_voltage: u16,
183 pub current_consumption: u16,
184}
185impl FromByteSlice for AllData {
186 fn bytes_expected() -> usize {
187 16
188 }
189 fn from_le_byte_slice(bytes: &[u8]) -> AllData {
190 AllData {
191 current_velocity: <u16>::from_le_byte_slice(&bytes[0..2]),
192 current_position: <i32>::from_le_byte_slice(&bytes[2..6]),
193 remaining_steps: <i32>::from_le_byte_slice(&bytes[6..10]),
194 stack_voltage: <u16>::from_le_byte_slice(&bytes[10..12]),
195 external_voltage: <u16>::from_le_byte_slice(&bytes[12..14]),
196 current_consumption: <u16>::from_le_byte_slice(&bytes[14..16]),
197 }
198 }
199}
200
201#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
202pub struct AllDataEvent {
203 pub current_velocity: u16,
204 pub current_position: i32,
205 pub remaining_steps: i32,
206 pub stack_voltage: u16,
207 pub external_voltage: u16,
208 pub current_consumption: u16,
209}
210impl FromByteSlice for AllDataEvent {
211 fn bytes_expected() -> usize {
212 16
213 }
214 fn from_le_byte_slice(bytes: &[u8]) -> AllDataEvent {
215 AllDataEvent {
216 current_velocity: <u16>::from_le_byte_slice(&bytes[0..2]),
217 current_position: <i32>::from_le_byte_slice(&bytes[2..6]),
218 remaining_steps: <i32>::from_le_byte_slice(&bytes[6..10]),
219 stack_voltage: <u16>::from_le_byte_slice(&bytes[10..12]),
220 external_voltage: <u16>::from_le_byte_slice(&bytes[12..14]),
221 current_consumption: <u16>::from_le_byte_slice(&bytes[14..16]),
222 }
223 }
224}
225
226#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
227pub struct NewStateEvent {
228 pub state_new: u8,
229 pub state_previous: u8,
230}
231impl FromByteSlice for NewStateEvent {
232 fn bytes_expected() -> usize {
233 2
234 }
235 fn from_le_byte_slice(bytes: &[u8]) -> NewStateEvent {
236 NewStateEvent { state_new: <u8>::from_le_byte_slice(&bytes[0..1]), state_previous: <u8>::from_le_byte_slice(&bytes[1..2]) }
237 }
238}
239
240#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
241pub struct SpitfpBaudrateConfig {
242 pub enable_dynamic_baudrate: bool,
243 pub minimum_dynamic_baudrate: u32,
244}
245impl FromByteSlice for SpitfpBaudrateConfig {
246 fn bytes_expected() -> usize {
247 5
248 }
249 fn from_le_byte_slice(bytes: &[u8]) -> SpitfpBaudrateConfig {
250 SpitfpBaudrateConfig {
251 enable_dynamic_baudrate: <bool>::from_le_byte_slice(&bytes[0..1]),
252 minimum_dynamic_baudrate: <u32>::from_le_byte_slice(&bytes[1..5]),
253 }
254 }
255}
256
257#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
258pub struct SpitfpErrorCount {
259 pub error_count_ack_checksum: u32,
260 pub error_count_message_checksum: u32,
261 pub error_count_frame: u32,
262 pub error_count_overflow: u32,
263}
264impl FromByteSlice for SpitfpErrorCount {
265 fn bytes_expected() -> usize {
266 16
267 }
268 fn from_le_byte_slice(bytes: &[u8]) -> SpitfpErrorCount {
269 SpitfpErrorCount {
270 error_count_ack_checksum: <u32>::from_le_byte_slice(&bytes[0..4]),
271 error_count_message_checksum: <u32>::from_le_byte_slice(&bytes[4..8]),
272 error_count_frame: <u32>::from_le_byte_slice(&bytes[8..12]),
273 error_count_overflow: <u32>::from_le_byte_slice(&bytes[12..16]),
274 }
275 }
276}
277
278#[derive(Clone)]
279pub struct Protocol1BrickletName {
280 pub protocol_version: u8,
281 pub firmware_version: [u8; 3],
282 pub name: String,
283}
284impl FromByteSlice for Protocol1BrickletName {
285 fn bytes_expected() -> usize {
286 44
287 }
288 fn from_le_byte_slice(bytes: &[u8]) -> Protocol1BrickletName {
289 Protocol1BrickletName {
290 protocol_version: <u8>::from_le_byte_slice(&bytes[0..1]),
291 firmware_version: <[u8; 3]>::from_le_byte_slice(&bytes[1..4]),
292 name: <String>::from_le_byte_slice(&bytes[4..44]),
293 }
294 }
295}
296
297#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
298pub struct Identity {
299 pub uid: String,
300 pub connected_uid: String,
301 pub position: char,
302 pub hardware_version: [u8; 3],
303 pub firmware_version: [u8; 3],
304 pub device_identifier: u16,
305}
306impl FromByteSlice for Identity {
307 fn bytes_expected() -> usize {
308 25
309 }
310 fn from_le_byte_slice(bytes: &[u8]) -> Identity {
311 Identity {
312 uid: <String>::from_le_byte_slice(&bytes[0..8]),
313 connected_uid: <String>::from_le_byte_slice(&bytes[8..16]),
314 position: <char>::from_le_byte_slice(&bytes[16..17]),
315 hardware_version: <[u8; 3]>::from_le_byte_slice(&bytes[17..20]),
316 firmware_version: <[u8; 3]>::from_le_byte_slice(&bytes[20..23]),
317 device_identifier: <u16>::from_le_byte_slice(&bytes[23..25]),
318 }
319 }
320}
321
322#[derive(Clone)]
324pub struct StepperBrick {
325 device: Device,
326}
327impl StepperBrick {
328 pub const DEVICE_IDENTIFIER: u16 = 15;
329 pub const DEVICE_DISPLAY_NAME: &'static str = "Stepper Brick";
330 pub fn new(uid: Uid, connection: AsyncIpConnection) -> StepperBrick {
332 let mut result = StepperBrick { device: Device::new([2, 0, 10], uid, connection, Self::DEVICE_DISPLAY_NAME) };
333 result.device.response_expected[u8::from(StepperBrickFunction::SetMaxVelocity) as usize] = ResponseExpectedFlag::False;
334 result.device.response_expected[u8::from(StepperBrickFunction::GetMaxVelocity) as usize] = ResponseExpectedFlag::AlwaysTrue;
335 result.device.response_expected[u8::from(StepperBrickFunction::GetCurrentVelocity) as usize] = ResponseExpectedFlag::AlwaysTrue;
336 result.device.response_expected[u8::from(StepperBrickFunction::SetSpeedRamping) as usize] = ResponseExpectedFlag::False;
337 result.device.response_expected[u8::from(StepperBrickFunction::GetSpeedRamping) as usize] = ResponseExpectedFlag::AlwaysTrue;
338 result.device.response_expected[u8::from(StepperBrickFunction::FullBrake) as usize] = ResponseExpectedFlag::False;
339 result.device.response_expected[u8::from(StepperBrickFunction::SetCurrentPosition) as usize] = ResponseExpectedFlag::False;
340 result.device.response_expected[u8::from(StepperBrickFunction::GetCurrentPosition) as usize] = ResponseExpectedFlag::AlwaysTrue;
341 result.device.response_expected[u8::from(StepperBrickFunction::SetTargetPosition) as usize] = ResponseExpectedFlag::False;
342 result.device.response_expected[u8::from(StepperBrickFunction::GetTargetPosition) as usize] = ResponseExpectedFlag::AlwaysTrue;
343 result.device.response_expected[u8::from(StepperBrickFunction::SetSteps) as usize] = ResponseExpectedFlag::False;
344 result.device.response_expected[u8::from(StepperBrickFunction::GetSteps) as usize] = ResponseExpectedFlag::AlwaysTrue;
345 result.device.response_expected[u8::from(StepperBrickFunction::GetRemainingSteps) as usize] = ResponseExpectedFlag::AlwaysTrue;
346 result.device.response_expected[u8::from(StepperBrickFunction::SetStepMode) as usize] = ResponseExpectedFlag::False;
347 result.device.response_expected[u8::from(StepperBrickFunction::GetStepMode) as usize] = ResponseExpectedFlag::AlwaysTrue;
348 result.device.response_expected[u8::from(StepperBrickFunction::DriveForward) as usize] = ResponseExpectedFlag::False;
349 result.device.response_expected[u8::from(StepperBrickFunction::DriveBackward) as usize] = ResponseExpectedFlag::False;
350 result.device.response_expected[u8::from(StepperBrickFunction::Stop) as usize] = ResponseExpectedFlag::False;
351 result.device.response_expected[u8::from(StepperBrickFunction::GetStackInputVoltage) as usize] = ResponseExpectedFlag::AlwaysTrue;
352 result.device.response_expected[u8::from(StepperBrickFunction::GetExternalInputVoltage) as usize] =
353 ResponseExpectedFlag::AlwaysTrue;
354 result.device.response_expected[u8::from(StepperBrickFunction::GetCurrentConsumption) as usize] = ResponseExpectedFlag::AlwaysTrue;
355 result.device.response_expected[u8::from(StepperBrickFunction::SetMotorCurrent) as usize] = ResponseExpectedFlag::False;
356 result.device.response_expected[u8::from(StepperBrickFunction::GetMotorCurrent) as usize] = ResponseExpectedFlag::AlwaysTrue;
357 result.device.response_expected[u8::from(StepperBrickFunction::Enable) as usize] = ResponseExpectedFlag::False;
358 result.device.response_expected[u8::from(StepperBrickFunction::Disable) as usize] = ResponseExpectedFlag::False;
359 result.device.response_expected[u8::from(StepperBrickFunction::IsEnabled) as usize] = ResponseExpectedFlag::AlwaysTrue;
360 result.device.response_expected[u8::from(StepperBrickFunction::SetDecay) as usize] = ResponseExpectedFlag::False;
361 result.device.response_expected[u8::from(StepperBrickFunction::GetDecay) as usize] = ResponseExpectedFlag::AlwaysTrue;
362 result.device.response_expected[u8::from(StepperBrickFunction::SetMinimumVoltage) as usize] = ResponseExpectedFlag::True;
363 result.device.response_expected[u8::from(StepperBrickFunction::GetMinimumVoltage) as usize] = ResponseExpectedFlag::AlwaysTrue;
364 result.device.response_expected[u8::from(StepperBrickFunction::SetSyncRect) as usize] = ResponseExpectedFlag::False;
365 result.device.response_expected[u8::from(StepperBrickFunction::IsSyncRect) as usize] = ResponseExpectedFlag::AlwaysTrue;
366 result.device.response_expected[u8::from(StepperBrickFunction::SetTimeBase) as usize] = ResponseExpectedFlag::False;
367 result.device.response_expected[u8::from(StepperBrickFunction::GetTimeBase) as usize] = ResponseExpectedFlag::AlwaysTrue;
368 result.device.response_expected[u8::from(StepperBrickFunction::GetAllData) as usize] = ResponseExpectedFlag::AlwaysTrue;
369 result.device.response_expected[u8::from(StepperBrickFunction::SetAllDataPeriod) as usize] = ResponseExpectedFlag::True;
370 result.device.response_expected[u8::from(StepperBrickFunction::GetAllDataPeriod) as usize] = ResponseExpectedFlag::AlwaysTrue;
371 result.device.response_expected[u8::from(StepperBrickFunction::SetSpitfpBaudrateConfig) as usize] = ResponseExpectedFlag::False;
372 result.device.response_expected[u8::from(StepperBrickFunction::GetSpitfpBaudrateConfig) as usize] =
373 ResponseExpectedFlag::AlwaysTrue;
374 result.device.response_expected[u8::from(StepperBrickFunction::GetSendTimeoutCount) as usize] = ResponseExpectedFlag::AlwaysTrue;
375 result.device.response_expected[u8::from(StepperBrickFunction::SetSpitfpBaudrate) as usize] = ResponseExpectedFlag::False;
376 result.device.response_expected[u8::from(StepperBrickFunction::GetSpitfpBaudrate) as usize] = ResponseExpectedFlag::AlwaysTrue;
377 result.device.response_expected[u8::from(StepperBrickFunction::GetSpitfpErrorCount) as usize] = ResponseExpectedFlag::AlwaysTrue;
378 result.device.response_expected[u8::from(StepperBrickFunction::EnableStatusLed) as usize] = ResponseExpectedFlag::False;
379 result.device.response_expected[u8::from(StepperBrickFunction::DisableStatusLed) as usize] = ResponseExpectedFlag::False;
380 result.device.response_expected[u8::from(StepperBrickFunction::IsStatusLedEnabled) as usize] = ResponseExpectedFlag::AlwaysTrue;
381 result.device.response_expected[u8::from(StepperBrickFunction::GetProtocol1BrickletName) as usize] =
382 ResponseExpectedFlag::AlwaysTrue;
383 result.device.response_expected[u8::from(StepperBrickFunction::GetChipTemperature) as usize] = ResponseExpectedFlag::AlwaysTrue;
384 result.device.response_expected[u8::from(StepperBrickFunction::Reset) as usize] = ResponseExpectedFlag::False;
385 result.device.response_expected[u8::from(StepperBrickFunction::WriteBrickletPlugin) as usize] = ResponseExpectedFlag::False;
386 result.device.response_expected[u8::from(StepperBrickFunction::ReadBrickletPlugin) as usize] = ResponseExpectedFlag::AlwaysTrue;
387 result.device.response_expected[u8::from(StepperBrickFunction::GetIdentity) as usize] = ResponseExpectedFlag::AlwaysTrue;
388 result
389 }
390
391 pub fn get_response_expected(&mut self, fun: StepperBrickFunction) -> Result<bool, GetResponseExpectedError> {
406 self.device.get_response_expected(u8::from(fun))
407 }
408
409 pub fn set_response_expected(&mut self, fun: StepperBrickFunction, response_expected: bool) -> Result<(), SetResponseExpectedError> {
418 self.device.set_response_expected(u8::from(fun), response_expected)
419 }
420
421 pub fn set_response_expected_all(&mut self, response_expected: bool) {
423 self.device.set_response_expected_all(response_expected)
424 }
425
426 pub fn get_api_version(&self) -> [u8; 3] {
429 self.device.api_version
430 }
431
432 pub async fn get_under_voltage_callback_receiver(&mut self) -> impl Stream<Item = u16> {
437 self.device
438 .get_callback_receiver(u8::from(StepperBrickFunction::CallbackUnderVoltage))
439 .await
440 .map(|p| u16::from_le_byte_slice(p.body()))
441 }
442
443 pub async fn get_position_reached_callback_receiver(&mut self) -> impl Stream<Item = i32> {
452 self.device
453 .get_callback_receiver(u8::from(StepperBrickFunction::CallbackPositionReached))
454 .await
455 .map(|p| i32::from_le_byte_slice(p.body()))
456 }
457
458 pub async fn get_all_data_callback_receiver(&mut self) -> impl Stream<Item = AllDataEvent> {
463 self.device
464 .get_callback_receiver(u8::from(StepperBrickFunction::CallbackAllData))
465 .await
466 .map(|p| AllDataEvent::from_le_byte_slice(p.body()))
467 }
468
469 pub async fn get_new_state_callback_receiver(&mut self) -> impl Stream<Item = NewStateEvent> {
472 self.device
473 .get_callback_receiver(u8::from(StepperBrickFunction::CallbackNewState))
474 .await
475 .map(|p| NewStateEvent::from_le_byte_slice(p.body()))
476 }
477
478 pub async fn set_max_velocity(&mut self, velocity: u16) -> Result<(), TinkerforgeError> {
484 let mut payload = [0; 2];
485 velocity.write_to_slice(&mut payload[0..2]);
486
487 #[allow(unused_variables)]
488 let result = self.device.set(u8::from(StepperBrickFunction::SetMaxVelocity), &payload).await?;
489 Ok(())
490 }
491
492 pub async fn get_max_velocity(&mut self) -> Result<u16, TinkerforgeError> {
494 let payload = [0; 0];
495
496 #[allow(unused_variables)]
497 let result = self.device.get(u8::from(StepperBrickFunction::GetMaxVelocity), &payload).await?;
498 Ok(u16::from_le_byte_slice(result.body()))
499 }
500
501 pub async fn get_current_velocity(&mut self) -> Result<u16, TinkerforgeError> {
503 let payload = [0; 0];
504
505 #[allow(unused_variables)]
506 let result = self.device.get(u8::from(StepperBrickFunction::GetCurrentVelocity), &payload).await?;
507 Ok(u16::from_le_byte_slice(result.body()))
508 }
509
510 pub async fn set_speed_ramping(&mut self, acceleration: u16, deacceleration: u16) -> Result<(), TinkerforgeError> {
521 let mut payload = [0; 4];
522 acceleration.write_to_slice(&mut payload[0..2]);
523 deacceleration.write_to_slice(&mut payload[2..4]);
524
525 #[allow(unused_variables)]
526 let result = self.device.set(u8::from(StepperBrickFunction::SetSpeedRamping), &payload).await?;
527 Ok(())
528 }
529
530 pub async fn get_speed_ramping(&mut self) -> Result<SpeedRamping, TinkerforgeError> {
533 let payload = [0; 0];
534
535 #[allow(unused_variables)]
536 let result = self.device.get(u8::from(StepperBrickFunction::GetSpeedRamping), &payload).await?;
537 Ok(SpeedRamping::from_le_byte_slice(result.body()))
538 }
539
540 pub async fn full_brake(&mut self) -> Result<(), TinkerforgeError> {
549 let payload = [0; 0];
550
551 #[allow(unused_variables)]
552 let result = self.device.set(u8::from(StepperBrickFunction::FullBrake), &payload).await?;
553 Ok(())
554 }
555
556 pub async fn set_current_position(&mut self, position: i32) -> Result<(), TinkerforgeError> {
560 let mut payload = [0; 4];
561 position.write_to_slice(&mut payload[0..4]);
562
563 #[allow(unused_variables)]
564 let result = self.device.set(u8::from(StepperBrickFunction::SetCurrentPosition), &payload).await?;
565 Ok(())
566 }
567
568 pub async fn get_current_position(&mut self) -> Result<i32, TinkerforgeError> {
574 let payload = [0; 0];
575
576 #[allow(unused_variables)]
577 let result = self.device.get(u8::from(StepperBrickFunction::GetCurrentPosition), &payload).await?;
578 Ok(i32::from_le_byte_slice(result.body()))
579 }
580
581 pub async fn set_target_position(&mut self, position: i32) -> Result<(), TinkerforgeError> {
591 let mut payload = [0; 4];
592 position.write_to_slice(&mut payload[0..4]);
593
594 #[allow(unused_variables)]
595 let result = self.device.set(u8::from(StepperBrickFunction::SetTargetPosition), &payload).await?;
596 Ok(())
597 }
598
599 pub async fn get_target_position(&mut self) -> Result<i32, TinkerforgeError> {
601 let payload = [0; 0];
602
603 #[allow(unused_variables)]
604 let result = self.device.get(u8::from(StepperBrickFunction::GetTargetPosition), &payload).await?;
605 Ok(i32::from_le_byte_slice(result.body()))
606 }
607
608 pub async fn set_steps(&mut self, steps: i32) -> Result<(), TinkerforgeError> {
613 let mut payload = [0; 4];
614 steps.write_to_slice(&mut payload[0..4]);
615
616 #[allow(unused_variables)]
617 let result = self.device.set(u8::from(StepperBrickFunction::SetSteps), &payload).await?;
618 Ok(())
619 }
620
621 pub async fn get_steps(&mut self) -> Result<i32, TinkerforgeError> {
623 let payload = [0; 0];
624
625 #[allow(unused_variables)]
626 let result = self.device.get(u8::from(StepperBrickFunction::GetSteps), &payload).await?;
627 Ok(i32::from_le_byte_slice(result.body()))
628 }
629
630 pub async fn get_remaining_steps(&mut self) -> Result<i32, TinkerforgeError> {
635 let payload = [0; 0];
636
637 #[allow(unused_variables)]
638 let result = self.device.get(u8::from(StepperBrickFunction::GetRemainingSteps), &payload).await?;
639 Ok(i32::from_le_byte_slice(result.body()))
640 }
641
642 pub async fn set_step_mode(&mut self, mode: u8) -> Result<(), TinkerforgeError> {
658 let mut payload = [0; 1];
659 mode.write_to_slice(&mut payload[0..1]);
660
661 #[allow(unused_variables)]
662 let result = self.device.set(u8::from(StepperBrickFunction::SetStepMode), &payload).await?;
663 Ok(())
664 }
665
666 pub async fn get_step_mode(&mut self) -> Result<u8, TinkerforgeError> {
674 let payload = [0; 0];
675
676 #[allow(unused_variables)]
677 let result = self.device.get(u8::from(StepperBrickFunction::GetStepMode), &payload).await?;
678 Ok(u8::from_le_byte_slice(result.body()))
679 }
680
681 pub async fn drive_forward(&mut self) -> Result<(), TinkerforgeError> {
685 let payload = [0; 0];
686
687 #[allow(unused_variables)]
688 let result = self.device.set(u8::from(StepperBrickFunction::DriveForward), &payload).await?;
689 Ok(())
690 }
691
692 pub async fn drive_backward(&mut self) -> Result<(), TinkerforgeError> {
696 let payload = [0; 0];
697
698 #[allow(unused_variables)]
699 let result = self.device.set(u8::from(StepperBrickFunction::DriveBackward), &payload).await?;
700 Ok(())
701 }
702
703 pub async fn stop(&mut self) -> Result<(), TinkerforgeError> {
706 let payload = [0; 0];
707
708 #[allow(unused_variables)]
709 let result = self.device.set(u8::from(StepperBrickFunction::Stop), &payload).await?;
710 Ok(())
711 }
712
713 pub async fn get_stack_input_voltage(&mut self) -> Result<u16, TinkerforgeError> {
717 let payload = [0; 0];
718
719 #[allow(unused_variables)]
720 let result = self.device.get(u8::from(StepperBrickFunction::GetStackInputVoltage), &payload).await?;
721 Ok(u16::from_le_byte_slice(result.body()))
722 }
723
724 pub async fn get_external_input_voltage(&mut self) -> Result<u16, TinkerforgeError> {
737 let payload = [0; 0];
738
739 #[allow(unused_variables)]
740 let result = self.device.get(u8::from(StepperBrickFunction::GetExternalInputVoltage), &payload).await?;
741 Ok(u16::from_le_byte_slice(result.body()))
742 }
743
744 pub async fn get_current_consumption(&mut self) -> Result<u16, TinkerforgeError> {
746 let payload = [0; 0];
747
748 #[allow(unused_variables)]
749 let result = self.device.get(u8::from(StepperBrickFunction::GetCurrentConsumption), &payload).await?;
750 Ok(u16::from_le_byte_slice(result.body()))
751 }
752
753 pub async fn set_motor_current(&mut self, current: u16) -> Result<(), TinkerforgeError> {
759 let mut payload = [0; 2];
760 current.write_to_slice(&mut payload[0..2]);
761
762 #[allow(unused_variables)]
763 let result = self.device.set(u8::from(StepperBrickFunction::SetMotorCurrent), &payload).await?;
764 Ok(())
765 }
766
767 pub async fn get_motor_current(&mut self) -> Result<u16, TinkerforgeError> {
769 let payload = [0; 0];
770
771 #[allow(unused_variables)]
772 let result = self.device.get(u8::from(StepperBrickFunction::GetMotorCurrent), &payload).await?;
773 Ok(u16::from_le_byte_slice(result.body()))
774 }
775
776 pub async fn enable(&mut self) -> Result<(), TinkerforgeError> {
779 let payload = [0; 0];
780
781 #[allow(unused_variables)]
782 let result = self.device.set(u8::from(StepperBrickFunction::Enable), &payload).await?;
783 Ok(())
784 }
785
786 pub async fn disable(&mut self) -> Result<(), TinkerforgeError> {
797 let payload = [0; 0];
798
799 #[allow(unused_variables)]
800 let result = self.device.set(u8::from(StepperBrickFunction::Disable), &payload).await?;
801 Ok(())
802 }
803
804 pub async fn is_enabled(&mut self) -> Result<bool, TinkerforgeError> {
806 let payload = [0; 0];
807
808 #[allow(unused_variables)]
809 let result = self.device.get(u8::from(StepperBrickFunction::IsEnabled), &payload).await?;
810 Ok(bool::from_le_byte_slice(result.body()))
811 }
812
813 pub async fn set_decay(&mut self, decay: u16) -> Result<(), TinkerforgeError> {
839 let mut payload = [0; 2];
840 decay.write_to_slice(&mut payload[0..2]);
841
842 #[allow(unused_variables)]
843 let result = self.device.set(u8::from(StepperBrickFunction::SetDecay), &payload).await?;
844 Ok(())
845 }
846
847 pub async fn get_decay(&mut self) -> Result<u16, TinkerforgeError> {
849 let payload = [0; 0];
850
851 #[allow(unused_variables)]
852 let result = self.device.get(u8::from(StepperBrickFunction::GetDecay), &payload).await?;
853 Ok(u16::from_le_byte_slice(result.body()))
854 }
855
856 pub async fn set_minimum_voltage(&mut self, voltage: u16) -> Result<(), TinkerforgeError> {
862 let mut payload = [0; 2];
863 voltage.write_to_slice(&mut payload[0..2]);
864
865 #[allow(unused_variables)]
866 let result = self.device.set(u8::from(StepperBrickFunction::SetMinimumVoltage), &payload).await?;
867 Ok(())
868 }
869
870 pub async fn get_minimum_voltage(&mut self) -> Result<u16, TinkerforgeError> {
872 let payload = [0; 0];
873
874 #[allow(unused_variables)]
875 let result = self.device.get(u8::from(StepperBrickFunction::GetMinimumVoltage), &payload).await?;
876 Ok(u16::from_le_byte_slice(result.body()))
877 }
878
879 pub async fn set_sync_rect(&mut self, sync_rect: bool) -> Result<(), TinkerforgeError> {
894 let mut payload = [0; 1];
895 sync_rect.write_to_slice(&mut payload[0..1]);
896
897 #[allow(unused_variables)]
898 let result = self.device.set(u8::from(StepperBrickFunction::SetSyncRect), &payload).await?;
899 Ok(())
900 }
901
902 pub async fn is_sync_rect(&mut self) -> Result<bool, TinkerforgeError> {
904 let payload = [0; 0];
905
906 #[allow(unused_variables)]
907 let result = self.device.get(u8::from(StepperBrickFunction::IsSyncRect), &payload).await?;
908 Ok(bool::from_le_byte_slice(result.body()))
909 }
910
911 pub async fn set_time_base(&mut self, time_base: u32) -> Result<(), TinkerforgeError> {
917 let mut payload = [0; 4];
918 time_base.write_to_slice(&mut payload[0..4]);
919
920 #[allow(unused_variables)]
921 let result = self.device.set(u8::from(StepperBrickFunction::SetTimeBase), &payload).await?;
922 Ok(())
923 }
924
925 pub async fn get_time_base(&mut self) -> Result<u32, TinkerforgeError> {
927 let payload = [0; 0];
928
929 #[allow(unused_variables)]
930 let result = self.device.get(u8::from(StepperBrickFunction::GetTimeBase), &payload).await?;
931 Ok(u32::from_le_byte_slice(result.body()))
932 }
933
934 pub async fn get_all_data(&mut self) -> Result<AllData, TinkerforgeError> {
940 let payload = [0; 0];
941
942 #[allow(unused_variables)]
943 let result = self.device.get(u8::from(StepperBrickFunction::GetAllData), &payload).await?;
944 Ok(AllData::from_le_byte_slice(result.body()))
945 }
946
947 pub async fn set_all_data_period(&mut self, period: u32) -> Result<(), TinkerforgeError> {
950 let mut payload = [0; 4];
951 period.write_to_slice(&mut payload[0..4]);
952
953 #[allow(unused_variables)]
954 let result = self.device.set(u8::from(StepperBrickFunction::SetAllDataPeriod), &payload).await?;
955 Ok(())
956 }
957
958 pub async fn get_all_data_period(&mut self) -> Result<u32, TinkerforgeError> {
960 let payload = [0; 0];
961
962 #[allow(unused_variables)]
963 let result = self.device.get(u8::from(StepperBrickFunction::GetAllDataPeriod), &payload).await?;
964 Ok(u32::from_le_byte_slice(result.body()))
965 }
966
967 pub async fn set_spitfp_baudrate_config(
989 &mut self,
990 enable_dynamic_baudrate: bool,
991 minimum_dynamic_baudrate: u32,
992 ) -> Result<(), TinkerforgeError> {
993 let mut payload = [0; 5];
994 enable_dynamic_baudrate.write_to_slice(&mut payload[0..1]);
995 minimum_dynamic_baudrate.write_to_slice(&mut payload[1..5]);
996
997 #[allow(unused_variables)]
998 let result = self.device.set(u8::from(StepperBrickFunction::SetSpitfpBaudrateConfig), &payload).await?;
999 Ok(())
1000 }
1001
1002 pub async fn get_spitfp_baudrate_config(&mut self) -> Result<SpitfpBaudrateConfig, TinkerforgeError> {
1007 let payload = [0; 0];
1008
1009 #[allow(unused_variables)]
1010 let result = self.device.get(u8::from(StepperBrickFunction::GetSpitfpBaudrateConfig), &payload).await?;
1011 Ok(SpitfpBaudrateConfig::from_le_byte_slice(result.body()))
1012 }
1013
1014 pub async fn get_send_timeout_count(&mut self, communication_method: u8) -> Result<u32, TinkerforgeError> {
1034 let mut payload = [0; 1];
1035 communication_method.write_to_slice(&mut payload[0..1]);
1036
1037 #[allow(unused_variables)]
1038 let result = self.device.get(u8::from(StepperBrickFunction::GetSendTimeoutCount), &payload).await?;
1039 Ok(u32::from_le_byte_slice(result.body()))
1040 }
1041
1042 pub async fn set_spitfp_baudrate(&mut self, bricklet_port: char, baudrate: u32) -> Result<(), TinkerforgeError> {
1059 let mut payload = [0; 5];
1060 bricklet_port.write_to_slice(&mut payload[0..1]);
1061 baudrate.write_to_slice(&mut payload[1..5]);
1062
1063 #[allow(unused_variables)]
1064 let result = self.device.set(u8::from(StepperBrickFunction::SetSpitfpBaudrate), &payload).await?;
1065 Ok(())
1066 }
1067
1068 pub async fn get_spitfp_baudrate(&mut self, bricklet_port: char) -> Result<u32, TinkerforgeError> {
1073 let mut payload = [0; 1];
1074 bricklet_port.write_to_slice(&mut payload[0..1]);
1075
1076 #[allow(unused_variables)]
1077 let result = self.device.get(u8::from(StepperBrickFunction::GetSpitfpBaudrate), &payload).await?;
1078 Ok(u32::from_le_byte_slice(result.body()))
1079 }
1080
1081 pub async fn get_spitfp_error_count(&mut self, bricklet_port: char) -> Result<SpitfpErrorCount, TinkerforgeError> {
1096 let mut payload = [0; 1];
1097 bricklet_port.write_to_slice(&mut payload[0..1]);
1098
1099 #[allow(unused_variables)]
1100 let result = self.device.get(u8::from(StepperBrickFunction::GetSpitfpErrorCount), &payload).await?;
1101 Ok(SpitfpErrorCount::from_le_byte_slice(result.body()))
1102 }
1103
1104 pub async fn enable_status_led(&mut self) -> Result<(), TinkerforgeError> {
1114 let payload = [0; 0];
1115
1116 #[allow(unused_variables)]
1117 let result = self.device.set(u8::from(StepperBrickFunction::EnableStatusLed), &payload).await?;
1118 Ok(())
1119 }
1120
1121 pub async fn disable_status_led(&mut self) -> Result<(), TinkerforgeError> {
1131 let payload = [0; 0];
1132
1133 #[allow(unused_variables)]
1134 let result = self.device.set(u8::from(StepperBrickFunction::DisableStatusLed), &payload).await?;
1135 Ok(())
1136 }
1137
1138 pub async fn is_status_led_enabled(&mut self) -> Result<bool, TinkerforgeError> {
1143 let payload = [0; 0];
1144
1145 #[allow(unused_variables)]
1146 let result = self.device.get(u8::from(StepperBrickFunction::IsStatusLedEnabled), &payload).await?;
1147 Ok(bool::from_le_byte_slice(result.body()))
1148 }
1149
1150 pub async fn get_protocol1_bricklet_name(&mut self, port: char) -> Result<Protocol1BrickletName, TinkerforgeError> {
1156 let mut payload = [0; 1];
1157 port.write_to_slice(&mut payload[0..1]);
1158
1159 #[allow(unused_variables)]
1160 let result = self.device.get(u8::from(StepperBrickFunction::GetProtocol1BrickletName), &payload).await?;
1161 Ok(Protocol1BrickletName::from_le_byte_slice(result.body()))
1162 }
1163
1164 pub async fn get_chip_temperature(&mut self) -> Result<i16, TinkerforgeError> {
1171 let payload = [0; 0];
1172
1173 #[allow(unused_variables)]
1174 let result = self.device.get(u8::from(StepperBrickFunction::GetChipTemperature), &payload).await?;
1175 Ok(i16::from_le_byte_slice(result.body()))
1176 }
1177
1178 pub async fn reset(&mut self) -> Result<(), TinkerforgeError> {
1185 let payload = [0; 0];
1186
1187 #[allow(unused_variables)]
1188 let result = self.device.set(u8::from(StepperBrickFunction::Reset), &payload).await?;
1189 Ok(())
1190 }
1191
1192 pub async fn write_bricklet_plugin(&mut self, port: char, offset: u8, chunk: &[u8; 32]) -> Result<(), TinkerforgeError> {
1198 let mut payload = [0; 34];
1199 port.write_to_slice(&mut payload[0..1]);
1200 offset.write_to_slice(&mut payload[1..2]);
1201 chunk.write_to_slice(&mut payload[2..34]);
1202
1203 #[allow(unused_variables)]
1204 let result = self.device.set(u8::from(StepperBrickFunction::WriteBrickletPlugin), &payload).await?;
1205 Ok(())
1206 }
1207
1208 pub async fn read_bricklet_plugin(&mut self, port: char, offset: u8) -> Result<Box<[u8; 32]>, TinkerforgeError> {
1214 let mut payload = [0; 2];
1215 port.write_to_slice(&mut payload[0..1]);
1216 offset.write_to_slice(&mut payload[1..2]);
1217
1218 #[allow(unused_variables)]
1219 let result = self.device.get(u8::from(StepperBrickFunction::ReadBrickletPlugin), &payload).await?;
1220 Ok(Box::<[u8; 32]>::from_le_byte_slice(result.body()))
1221 }
1222
1223 pub async fn get_identity(&mut self) -> Result<Identity, TinkerforgeError> {
1232 let payload = [0; 0];
1233
1234 #[allow(unused_variables)]
1235 let result = self.device.get(u8::from(StepperBrickFunction::GetIdentity), &payload).await?;
1236 Ok(Identity::from_le_byte_slice(result.body()))
1237 }
1238}