drew-connect 0.1.0

Couche d'I/O et de décodage de télémétrie agnostique et modulaire : transports (série, UDP) et décodeurs (JSON, binaire) interchangeables via traits.
Documentation
// Copyright (C) 2026 Jorge Andre Castro
// GPL-2.0-or-later

//! Abstraction des canaux de communication (source d'octets bruts).
//!
//! [`Transport`] ne connaît rien du format transporté : c'est au
//! [`crate::decoder::Decoder`] qu'il est confié de donner du sens aux
//! octets lus. Cette séparation permet par exemple de tester un
//! [`crate::Decoder`] avec un transport factice, sans matériel réel.

use std::io::Result;

/// Trait d'abstraction pour les canaux de communication.
pub trait Transport: Send {
    /// Lit des octets dans le tampon fourni. Retourne le nombre d'octets
    /// lus (0 si rien n'est disponible dans le délai imparti).
    fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
}

/// Transport via Port Série (UART / USB). Nécessite la feature `serial`.
#[cfg(feature = "serial")]
pub struct SerialTransport {
    port: Box<dyn serialport::SerialPort>,
}

#[cfg(feature = "serial")]
impl SerialTransport {
    /// Ouvre un port série au débit (baud rate) donné, avec un timeout de
    /// lecture de 100 ms.
    pub fn new(port_name: &str, baud_rate: u32) -> serialport::Result<Self> {
        let port = serialport::new(port_name, baud_rate)
            .timeout(std::time::Duration::from_millis(100))
            .open()?;
        Ok(Self { port })
    }
}

#[cfg(feature = "serial")]
impl Transport for SerialTransport {
    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
        self.port.read(buf)
    }
}

/// Transport via Socket UDP (Wi-Fi / Ethernet). Nécessite la feature `udp`
/// (aucune dépendance supplémentaire : uniquement `std::net`).
#[cfg(feature = "udp")]
pub struct UdpTransport {
    socket: std::net::UdpSocket,
}

#[cfg(feature = "udp")]
impl UdpTransport {
    /// Ouvre un socket UDP en écoute sur `addr`, avec un timeout de lecture
    /// de 100 ms.
    pub fn bind(addr: &str) -> Result<Self> {
        let socket = std::net::UdpSocket::bind(addr)?;
        socket.set_read_timeout(Some(std::time::Duration::from_millis(100)))?;
        Ok(Self { socket })
    }
}

#[cfg(feature = "udp")]
impl Transport for UdpTransport {
    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
        self.socket.recv(buf)
    }
}