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

// 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 demonstrates the diagnostic protocol for configuration
//! and debugging.
//!
//! The diagnostic protocol should not be used during active control, but
//! is useful for setup, provisioning, and debugging.
//!
//! Usage:
//!   tools/bazel run //lib/rust:diagnostic_protocol
//!   tools/bazel run //lib/rust:diagnostic_protocol -- --fdcanusb /dev/ttyACM0
//!   tools/bazel run //lib/rust:diagnostic_protocol -- --id 1
//!   tools/bazel run //lib/rust:diagnostic_protocol -- --async

use crate::diagnostic::{AsyncDiagnosticStream, DiagnosticStream};
use crate::transport::args::parse_with_transport_args;
use crate::TransportOptions;
use crate::{AsyncController, BlockingController};
use clap::Parser;

/// Demonstrate the diagnostic protocol.
#[derive(Parser)]
#[command(about = "Demonstrate the diagnostic protocol")]
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> {
    let mut ctrl = BlockingController::with_options(args.id, transport)?;
    let mut stream = DiagnosticStream::new(&mut ctrl);

    // Applications like tview may leave the controller "spewing" on the
    // diagnostic channel (sending unsolicited data). Stop telemetry and
    // flush all data before issuing commands.
    println!("Stopping telemetry and flushing...");
    stream.write_message(b"tel stop")?;
    stream.flush_read()?;

    // Read a configuration value. The `conf get` command replies with a
    // single line, so use `command_oneline`.
    let old_kp = stream.command_oneline(b"conf get servo.pid_position.kp")?;
    let old_kp_str = String::from_utf8_lossy(&old_kp);
    let old_kp: f64 = old_kp_str.trim().parse().unwrap_or(0.0);

    let new_kp = 4.0;

    // Set a configuration value (waits for "OK").
    let cmd = format!("conf set servo.pid_position.kp {}", new_kp);
    stream.command(cmd.as_bytes())?;

    println!("Changed kp from {} to {}", old_kp, new_kp);

    Ok(())
}

#[tokio::main]
async fn run_async(args: &Args, transport: &TransportOptions) -> Result<(), crate::Error> {
    let mut ctrl = AsyncController::with_options(args.id, transport).await?;
    let mut stream = AsyncDiagnosticStream::new(&mut ctrl);

    // Stop telemetry and flush pending data.
    println!("Stopping telemetry and flushing...");
    stream.write_message(b"tel stop").await?;
    stream.flush_read().await?;

    // Read a configuration value. The `conf get` command replies with a
    // single line, so use `command_oneline`.
    let old_kp = stream
        .command_oneline(b"conf get servo.pid_position.kp")
        .await?;
    let old_kp_str = String::from_utf8_lossy(&old_kp);
    let old_kp: f64 = old_kp_str.trim().parse().unwrap_or(0.0);

    let new_kp = 4.0;

    // Set a configuration value (waits for "OK").
    let cmd = format!("conf set servo.pid_position.kp {}", new_kp);
    stream.command(cmd.as_bytes()).await?;

    println!("Changed kp from {} to {}", old_kp, new_kp);

    Ok(())
}

/// Run this example.
///
/// `register_transports` is invoked after argument parsing but before
/// any transport is created, so an embedding binary may register extra
/// transport factories (e.g. a pi3hat).  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)
    }
}