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

drew-connect

Crates.io Downloads docs.rs License

Couche d'I/O et de décodage de télémétrie, agnostique et modulaire, pensée pour relier du matériel embarqué à drew-sim ou à n'importe quelle application qui a besoin de lire un flux d'octets en arrière-plan et d'en récupérer des paquets décodés sans bloquer sa boucle principale.

Les trois briques

La bibliothèque tient en trois pièces, chacune remplaçable indépendamment :

Brique Rôle Implémentations fournies
Transport Fournit des octets bruts SerialTransport (UART/USB), UdpTransport (Wi-Fi/Ethernet)
Decoder Traduit ces octets en un paquet typé BinaryDecoder, JsonDecoder (produisent tous deux TelemetryPacket)
ConnectionWorker Fait tourner Transport + Decoder dans un thread et expose un canal non bloquant —

Transport et Decoder ne se connaissent pas : ConnectionWorker est le seul point qui les assemble. Vous pouvez donc changer de transport sans toucher au décodage, et inversement.

Installation

Aucune feature n'est activée par défaut n'ajoutez que ce dont vous avez besoin :

[dependencies]
drew-connect = { version = "0.1", features = ["udp"] }
Feature Ajoute Débloque
json serde, serde_json JsonDecoder, dérive Serialize/Deserialize sur TelemetryPacket
serial serialport SerialTransport (UART/USB)
udp (rien, std uniquement) UdpTransport (Wi-Fi/Ethernet)

BinaryDecoder et TelemetryPacket sont toujours disponibles, sans feature.

Démarrage rapide

Trois étapes, toujours les mêmes quel que soit le transport ou le format choisi :

1. Ouvrir un transport

use drew_connect::UdpTransport;

let transport = UdpTransport::bind("0.0.0.0:9000")?;
# Ok::<(), std::io::Error>(())

2. Choisir un décodeur ici le format binaire compact, adapté à un microcontrôleur :

use drew_connect::BinaryDecoder;

let decoder = BinaryDecoder;

3. Démarrer le worker et lire les paquets

# use drew_connect::{UdpTransport, BinaryDecoder, ConnectionWorker};
# let transport = UdpTransport::bind("0.0.0.0:9000")?;
let worker = ConnectionWorker::spawn(transport, BinaryDecoder);

// Dans votre boucle de rendu ou de mise à jour :
if let Some(packet) = worker.try_recv() {
    println!("{packet:?}");
}
# Ok::<(), std::io::Error>(())

worker lit en continu dans un thread séparé ; try_recv / drain_latest ne bloquent jamais, ce qui les rend sûrs à appeler depuis une boucle de rendu à 60 FPS.

Exemple complet

Une boucle qui écoute des trames binaires sur UDP et n'affiche que le dernier paquet reçu à chaque tick (utile quand la fréquence d'émission dépasse la fréquence d'affichage) :

use drew_connect::{BinaryDecoder, ConnectionWorker, UdpTransport};
use std::time::Duration;

fn main() -> std::io::Result<()> {
    let transport = UdpTransport::bind("0.0.0.0:9000")?;
    let worker = ConnectionWorker::spawn(transport, BinaryDecoder);

    println!("En écoute sur udp://0.0.0.0:9000 ...");

    loop {
        // drain_latest() vide le canal et ne garde que le paquet le plus
        // récent : pas d'accumulation de retard si le microcontrôleur émet
        // plus vite que la boucle ne consomme.
        if let Some(packet) = worker.drain_latest() {
            println!(
                "pos={:?} rot={:?} t={}ms",
                packet.position, packet.rotation, packet.timestamp_ms
            );
        }
        std::thread::sleep(Duration::from_millis(50));
    }
}

Ce même code se lance directement depuis le crate :

cargo run --example udp_binary --features udp

Pour prototyper en JSON plutôt qu'en binaire, seule l'étape 2 change :

# use drew_connect::{UdpTransport, ConnectionWorker};
use drew_connect::JsonDecoder;
# let transport = UdpTransport::bind("0.0.0.0:9000")?;
let worker = ConnectionWorker::spawn(transport, JsonDecoder);
# Ok::<(), std::io::Error>(())

(nécessite la feature json, et que le microcontrôleur envoie des lignes du type {"position":[0.0,1.2,0.5],"rotation":[0.1,0.0,0.3],"timestamp_ms":1024}).

Utiliser un port série

Identique, avec SerialTransport (feature serial) à la place d'UdpTransport :

use drew_connect::{BinaryDecoder, ConnectionWorker, SerialTransport};

let transport = SerialTransport::new("/dev/ttyUSB0", 115_200)?;
let worker = ConnectionWorker::spawn(transport, BinaryDecoder);
# Ok::<(), serialport::Error>(())

Créer son propre transport ou décodeur

Un format ou un canal maison n'a pas besoin de vivre dans ce crate, il suffit d'implémenter le trait correspondant dans votre propre code :

use drew_connect::Decoder;

struct MonPaquet { valeur: u16 }

struct MonDecodeur;

impl Decoder for MonDecodeur {
    type Output = MonPaquet;

    fn decode(&mut self, raw_data: &[u8]) -> Option<MonPaquet> {
        raw_data.get(0..2).map(|b| MonPaquet {
            valeur: u16::from_le_bytes([b[0], b[1]]),
        })
    }
}

ConnectionWorker::spawn(mon_transport, MonDecodeur) fonctionne alors exactement comme avec les types fournis par le crate.

License

GPL-2.0-or-later

Copyright (C) 2026 Jorge Andre Castro