Struct BluetoothConnection 

pub struct BluetoothConnection {
    pub peripheral: Peripheral,
    pub system_tx: Characteristic,
    pub system_rx: Characteristic,
    pub user_tx: Characteristic,
    pub user_rx: Characteristic,
    pub pairing: Characteristic,
    /* private fields */
}

Fields

peripheral: Peripheral

system_tx: Characteristic

system_rx: Characteristic

user_tx: Characteristic

user_rx: Characteristic

pairing: Characteristic

Implementations

impl BluetoothConnection

pub const MAX_PACKET_SIZE: usize = 244usize

pub async fn open(device: BluetoothDevice) -> Result<Self, BluetoothError>

pub async fn is_paired(&self) -> Result<bool, BluetoothError>

pub async fn request_pairing(&mut self) -> Result<(), BluetoothError>

pub async fn authenticate_pairing( &mut self, pin: [u8; 4], ) -> Result<(), BluetoothError>

Trait Implementations

impl Connection for BluetoothConnection

type Error = BluetoothError

fn connection_type(&self) -> ConnectionType

async fn send(&mut self, packet: impl Encode) -> Result<(), BluetoothError>

Sends a packet.

async fn recv<P: Decode + CheckHeader>( &mut self, timeout: Duration, ) -> Result<P, BluetoothError>

Receives a packet.

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

Read user program output.

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

Write to user program stdio.

fn execute_command<C: Command>( &mut self, command: C, ) -> impl Future<Output = Result<C::Output, Self::Error>>

Executes a Command.

async fn handshake<D: Decode + CheckHeader>( &mut self, timeout: Duration, retries: usize, packet: impl Encode + Clone, ) -> Result<D, Self::Error>

Sends a packet and waits for a response.

impl From<BluetoothConnection> for GenericConnection

fn from(c: BluetoothConnection) -> Self

Converts to this type from the input type.