Struct DeviceAddress 

#[non_exhaustive]
pub struct DeviceAddress {
    pub can_id: Option<u8>,
    pub uuid: Option<Vec<u8>>,
    pub transport_device: Option<usize>,
}

Address for a moteus device.

A device address can include a CAN ID, a UUID (or UUID prefix), and a transport device index. All fields are optional, and both can_id and uuid can be set simultaneously so that clients can see both identifiers.

The transport_device field specifies which transport device to route commands through, bypassing automatic device discovery.

Examples

use moteus::DeviceAddress;

// Address by CAN ID (most common)
let addr = DeviceAddress::can_id(1);
assert_eq!(addr.as_can_id(), Some(1));

// Using From trait
let addr: DeviceAddress = 1.into();

// Address by UUID
let uuid_bytes = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
                  0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10];
let addr = DeviceAddress::uuid(uuid_bytes);

// UUID prefix (for matching)
let addr = DeviceAddress::uuid([0x01, 0x02, 0x03, 0x04]);

// With transport device routing
let addr = DeviceAddress::can_id(1).with_transport_device(0);

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

can_id: Option<u8>

CAN bus ID (1-127), if known.

uuid: Option<Vec<u8>>

UUID or UUID prefix, if known.

transport_device: Option<usize>

Index of the transport device to route through, if known.

Implementations

impl DeviceAddress

pub fn can_id(id: u8) -> Self

Create an address from a CAN ID.

Arguments

• id - CAN bus ID (typically 1-127)

pub fn uuid(uuid: impl Into<Vec<u8>>) -> Self

Create an address from a UUID or UUID prefix.

Arguments

• uuid - Full 16-byte UUID or a prefix for matching

pub fn with_transport_device(self, idx: usize) -> Self

Set the transport device index (builder pattern).

pub fn as_can_id(&self) -> Option<u8>

Returns the CAN ID if set.

pub fn as_uuid(&self) -> Option<&[u8]>

Returns the UUID bytes if set.

pub fn is_can_id(&self) -> bool

Returns true if this address has a CAN ID.

pub fn is_uuid(&self) -> bool

Returns true if this address has a UUID.

pub fn matches(&self, can_id: u8, uuid: Option<&[u8]>) -> bool

Check if this address matches a device with the given CAN ID and UUID.

All set fields must match. A CAN ID address matches by exact ID, a UUID address matches by prefix. If both are set, both must match.

Trait Implementations

impl Clone for DeviceAddress

fn clone(&self) -> DeviceAddress

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DeviceAddress

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for DeviceAddress

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for DeviceAddress

impl From<&[u8]> for DeviceAddress

fn from(uuid: &[u8]) -> Self

Converts to this type from the input type.

impl From<Vec<u8>> for DeviceAddress

fn from(uuid: Vec<u8>) -> Self

Converts to this type from the input type.

impl<const N: usize> From<[u8; N]> for DeviceAddress

fn from(uuid: [u8; N]) -> Self

Converts to this type from the input type.

impl From<i32> for DeviceAddress

fn from(id: i32) -> Self

Converts to this type from the input type.

impl From<u8> for DeviceAddress

fn from(id: u8) -> Self

Converts to this type from the input type.

impl FromStr for DeviceAddress

Parse a device address from a string.

Supports:

• Integer CAN IDs: “1”, “15”, “127”
• Hex UUID or prefix: “01:02:03:04” or “01020304”

type Err = String

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for DeviceAddress

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DeviceAddress

fn eq(&self, other: &DeviceAddress) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for DeviceAddress