moteus 0.5.5

Rust client library for moteus brushless motor controllers
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

// Copyright 2026 mjbots Robotic Systems, LLC.  info@mjbots.com
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! This example commands a single servo to hold the current position
//! indefinitely, and prints the state of the servo to the console.
//!
//! Usage:
//!   tools/bazel run //lib/rust:simple
//!   tools/bazel run //lib/rust:simple -- --fdcanusb /dev/ttyACM0
//!   tools/bazel run //lib/rust:simple -- --id 1
//!   tools/bazel run //lib/rust:simple -- --async

use crate::command::PositionCommand;
use crate::transport::args::parse_with_transport_args;
use crate::TransportOptions;
use crate::{AsyncController, BlockingController};
use clap::Parser;
use std::time::Duration;

/// Command a single servo to hold position.
#[derive(Parser)]
#[command(about = "Command a single servo to hold position")]
struct Args {
    /// Servo ID
    #[arg(long, default_value = "1")]
    id: u8,

    /// Use async transport instead of blocking
    #[arg(long)]
    r#async: bool,
}

fn run_blocking(args: &Args, transport: &TransportOptions) -> Result<(), crate::Error> {
    // Create a controller with the specified ID and transport options.
    // By default, this picks an arbitrary CAN-FD transport, preferring
    // an attached fdcanusb if available.
    let mut c = BlockingController::with_options(args.id, transport)?;

    // Clear any faults by sending a stop command.
    c.set_stop()?;

    loop {
        // `set_position` accepts a PositionCommand built with the builder
        // pattern. If a given field is omitted, then that register is
        // omitted from the command itself, with semantics as described
        // in the reference manual.
        //
        // The return type of `set_position` is a QueryResult type which
        // contains the current state of the servo.
        let state = c.set_position(PositionCommand::new().position(f32::NAN))?;

        // Print out everything.
        println!("{:?}", state);

        // Print out just the position register.
        println!("Position: {}", state.position);

        // And a blank line so we can separate one iteration from the next.
        println!();

        // Wait 20ms between iterations. By default, when commanded
        // over CAN, there is a watchdog which requires commands to be
        // sent at least every 100ms or the controller will enter a
        // latched fault state.
        std::thread::sleep(Duration::from_millis(20));
    }
}

#[tokio::main]
async fn run_async(args: &Args, transport: &TransportOptions) -> Result<(), crate::Error> {
    // Create a controller with the specified ID and transport options.
    // By default, this picks an arbitrary CAN-FD transport, preferring
    // an attached fdcanusb if available.
    let mut c = AsyncController::with_options(args.id, transport).await?;

    // Clear any faults by sending a stop command.
    c.set_stop().await?;

    loop {
        // `set_position` accepts a PositionCommand built with the builder
        // pattern. If a given field is omitted, then that register is
        // omitted from the command itself, with semantics as described
        // in the reference manual.
        //
        // The return type of `set_position` is a QueryResult type which
        // contains the current state of the servo.
        let state = c
            .set_position(PositionCommand::new().position(f32::NAN))
            .await?;

        // Print out everything.
        println!("{:?}", state);

        // Print out just the position register.
        println!("Position: {}", state.position);

        // And a blank line so we can separate one iteration from the next.
        println!();

        // Wait 20ms between iterations. By default, when commanded
        // over CAN, there is a watchdog which requires commands to be
        // sent at least every 100ms or the controller will enter a
        // latched fault state.
        tokio::time::sleep(Duration::from_millis(20)).await;
    }
}

/// Run this example.
///
/// `register_transports` is invoked before argument parsing, so an
/// embedding binary may register extra transport factories (e.g. a
/// pi3hat) and have their arguments participate in parsing and
/// `--help`.  Pass `|| {}` to use only the built-in transports.
pub fn run(register_transports: impl FnOnce()) -> Result<(), crate::Error> {
    register_transports();

    let (args, transport) = parse_with_transport_args::<Args>().map_err(crate::Error::Protocol)?;

    if args.r#async {
        run_async(&args, &transport)
    } else {
        run_blocking(&args, &transport)
    }
}