Struct RadioLink

pub struct RadioLink { /* private fields */ }

VEXLink Wireless Radio Link

VEXLink is a point-to-point wireless communications protocol between two VEXNet radios. For further information, see https://www.vexforum.com/t/vexlink-documentaton/84538

Implementations

impl RadioLink

pub const INTERNAL_BUFFER_SIZE: usize = 512usize

The length of the link’s FIFO input and output buffers.

pub fn open(port: SmartPort, id: &str, link_type: LinkType) -> Self

Opens a radio link from a VEXNet radio plugged into a Smart Port. Once opened, other VEXNet functionality such as controller tethering on this specific radio will be disabled. Other radios connected to the Brain can take over this functionality.

Panics

• Panics if a NUL (0x00) character was found anywhere in the specified id.

Examples

use vexide::prelude::*;

#[vexide::main]
async fn main(peripherals: Peripherals) {
    let link = RadioLink::open(port_1, "643A", LinkType::Manager);
}

pub fn unread_bytes(&self) -> Result<usize, LinkError>

Returns the number of bytes that are waiting to be read from the radio’s input buffer.

Errors

• A LinkError::ReadFailed error is returned if the input buffer could not be accessed.

Examples

use vexide::prelude::*;

#[vexide::main]
async fn main(peripherals: Peripherals) {
    let mut link = RadioLink::open(port_1, "643A", LinkType::Manager);

    let mut buffer = vec![0; 2048];

    // Read into `buffer` if there are unread bytes.
    if link.unread_bytes().is_ok_and(|bytes| bytes > 0) {
        _ = link.read(&mut buffer);
    }
}

pub fn available_write_bytes(&self) -> Result<usize, LinkError>

Returns the number of bytes free in the radio’s output buffer.

Errors

• A LinkError::ReadFailed error is returned if the output buffer could not be accessed.

Examples

use vexide::prelude::*;

#[vexide::main]
async fn main(peripherals: Peripherals) {
    let mut link = RadioLink::open(port_1, "643A", LinkType::Manager);

    // Write a byte if there's free space in the buffer.
    if link.available_write_bytes().is_ok_and(|available| available > 0) {
        _ = link.write(0x80);
    }
}

pub fn is_linked(&self) -> bool

Returns true if there is a link established with another radio.

Examples

use vexide::prelude::*;

#[vexide::main]
async fn main(peripherals: Peripherals) {
    let mut link = RadioLink::open(port_1, "643A", LinkType::Manager);

    // Write a byte if we are connected to another radio.
    if link.is_linked() == Ok(true) {
        _ = link.write(0x80);
    }
}

Trait Implementations

impl Debug for RadioLink

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

Formats the value using the given formatter.

impl From<RadioLink> for SmartPort

fn from(device: RadioLink) -> Self

Converts to this type from the input type.

impl PartialEq for RadioLink

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Read for RadioLink

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Read some bytes sent to the radio into the specified buffer, returning how many bytes were read.

Errors

• An error with the kind io::ErrorKind::AddrNotAvailable is returned if there is no device connected.
• An error with the kind io::ErrorKind::AddrInUse is returned a device other than a radio is connected.
• An error with the kind io::ErrorKind::NotConnected is returned if a connection with another radio has not been established. Use RadioLink::is_linked to check this if needed.
• An error with the kind io::ErrorKind::Other is returned if an unexpected internal read error occurred.

Examples

use vexide::prelude::*;

#[vexide::main]
async fn main(peripherals: Peripherals) {
    let mut link = RadioLink::open(port_1, "643A", LinkType::Manager);

    let mut buffer = vec![0; 2048];

    loop {
        _ = link.read(&mut buffer);
        sleep(core::time::Duration::from_millis(10)).await;
    }
}

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

unsafe fn initializer(&self) -> Initializer

Determines if this Reader can work with buffers of uninitialized memory.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adaptor which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adaptor which will read at most limit bytes from it.

impl SmartDevice for RadioLink

const UPDATE_INTERVAL: Duration

The interval at which the V5 brain reads packets from Smart devices.

fn port_number(&self) -> u8

Returns the port number of the SmartPort this device is registered on.

fn device_type(&self) -> SmartDeviceType

Returns the variant of SmartDeviceType that this device is associated with.

fn is_connected(&self) -> bool

Determine if this device type is currently connected to the SmartPort that it’s registered to.

fn timestamp(&self) -> Result<SmartDeviceTimestamp, PortError>

Returns the timestamp recorded by this device’s internal clock.

fn validate_port(&self) -> Result<(), PortError>

Verify that the device type is currently plugged into this port, returning an appropriate PortError if not available.

impl Write for RadioLink

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into the radio’s output buffer, returning how many bytes were written.

Errors

• An error with the kind io::ErrorKind::NotConnected is returned if a connection with another radio has not been established. Use RadioLink::is_linked to check this if needed.
• An error with the kind io::ErrorKind::Other is returned if an unexpected internal write error occurred.

Examples

use vexide::prelude::*;

#[vexide::main]
async fn main(peripherals: Peripherals) {
    let mut link = RadioLink::open(port_1, "643A", LinkType::Manager);

    _ = link.write(b"yo");
}

fn flush(&mut self) -> Result<()>

This function does nothing.

VEXLink immediately sends and clears data sent into the write buffer.

Errors

• An error with the kind io::ErrorKind::NotConnected is returned if a connection with another radio has not been established. Use RadioLink::is_linked to check this if needed.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adaptor for this instance of Write.

impl Eq for RadioLink

impl Send for RadioLink

impl StructuralPartialEq for RadioLink

impl Sync for RadioLink