Struct ST3215 

pub struct ST3215 { /* private fields */ }

Implementations

impl ST3215

pub fn new(device: &str) -> Result<Self, String>

Créer une nouvelle instance ST3215

Examples found in repository

examples/basic.rs (line 6)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Créer une instance ST3215 connectée au port COM3
    let servo = ST3215::new("COM3")?;

    // Lister tous les servos disponibles
    let ids = servo.list_servos();
    println!("Servos trouvés: {:?}", ids);

    // Pour chaque servo trouvé
    for id in ids {
        println!("\n=== Servo {} ===", id);
        
        // Lire et afficher les informations du servo
        if let Some(position) = servo.read_position(id) {
            println!("Position actuelle: {}", position);
        }
        
        if let Some(voltage) = servo.read_voltage(id) {
            println!("Tension: {:.1} V", voltage);
        }
        
        if let Some(temp) = servo.read_temperature(id) {
            println!("Température: {} °C", temp);
        }
        
        if let Some(current) = servo.read_current(id) {
            println!("Courant: {:.1} mA", current);
        }

        // Déplacer le servo vers la position
        let deg: u16 = 65;
        let pos: u16 = deg * (4096.0 / 360.0) as u16;

        println!("Déplacement vers la position {}...", deg);

        servo.move_to(id, pos, 2400, 50, true);
        
        println!("Mouvement terminé!");
    }

    Ok(())
}

examples/torque_control.rs (line 14)

fn main() -> Result<(), String> {
    // Remplacer "/dev/ttyUSB0" par le port série approprié
    let device = std::env::var("SERVO_PORT").unwrap_or_else(|_| "/dev/ttyUSB0".to_string());
    
    println!("Connexion au port série: {}", device);
    let controller = ST3215::new(&device)?;
    
    // ID du servo à contrôler (modifier selon votre configuration)
    let servo_id: u8 = 1;
    
    // Vérifier que le servo est présent
    println!("Vérification de la présence du servo {}...", servo_id);
    if !controller.ping_servo(servo_id) {
        return Err(format!("Servo {} non trouvé!", servo_id));
    }
    println!("✓ Servo {} trouvé", servo_id);
    
    // Exemple 1: Activer le torque
    println!("\n--- Activation du torque ---");
    controller.enable_torque(servo_id)?;
    println!("✓ Torque activé pour le servo {}", servo_id);
    
    // Le servo maintient maintenant sa position
    thread::sleep(Duration::from_secs(2));
    
    // Lire la position actuelle
    if let Some(position) = controller.read_position(servo_id) {
        println!("Position actuelle: {}", position);
    }
    
    // Exemple 2: Désactiver le torque
    println!("\n--- Désactivation du torque ---");
    controller.disable_torque(servo_id)?;
    println!("✓ Torque désactivé pour le servo {}", servo_id);
    println!("Le servo peut maintenant être déplacé manuellement");
    
    // Attendre quelques secondes
    thread::sleep(Duration::from_secs(3));
    
    // Exemple 3: Réactiver le torque et déplacer le servo
    println!("\n--- Réactivation et déplacement ---");
    controller.enable_torque(servo_id)?;
    println!("✓ Torque réactivé");
    
    // Déplacer vers la position 2048 (milieu de la course)
    let target_position = 2048;
    let speed = 1000;
    let acceleration = 50;
    println!("Déplacement vers la position {}...", target_position);
    controller.move_to(servo_id, target_position, speed, acceleration, false);
    
    // Attendre que le mouvement soit terminé
    thread::sleep(Duration::from_secs(2));
    
    // Vérifier la position finale
    if let Some(final_position) = controller.read_position(servo_id) {
        println!("Position finale: {}", final_position);
    }
    
    // Exemple 4: Cycle d'activation/désactivation
    println!("\n--- Cycle d'activation/désactivation ---");
    for i in 1..=3 {
        println!("Cycle {}/3", i);
        
        println!("  Désactivation...");
        controller.disable_torque(servo_id)?;
        thread::sleep(Duration::from_millis(500));
        
        println!("  Activation...");
        controller.enable_torque(servo_id)?;
        thread::sleep(Duration::from_millis(500));
    }
    
    // Désactiver le torque à la fin
    println!("\n--- Fin du programme ---");
    controller.disable_torque(servo_id)?;
    println!("✓ Torque désactivé");
    
    Ok(())
}

pub fn ping_servo(&self, sts_id: u8) -> bool

Vérifier la présence d’un servo

Examples found in repository

examples/torque_control.rs (line 21)

fn main() -> Result<(), String> {
    // Remplacer "/dev/ttyUSB0" par le port série approprié
    let device = std::env::var("SERVO_PORT").unwrap_or_else(|_| "/dev/ttyUSB0".to_string());
    
    println!("Connexion au port série: {}", device);
    let controller = ST3215::new(&device)?;
    
    // ID du servo à contrôler (modifier selon votre configuration)
    let servo_id: u8 = 1;
    
    // Vérifier que le servo est présent
    println!("Vérification de la présence du servo {}...", servo_id);
    if !controller.ping_servo(servo_id) {
        return Err(format!("Servo {} non trouvé!", servo_id));
    }
    println!("✓ Servo {} trouvé", servo_id);
    
    // Exemple 1: Activer le torque
    println!("\n--- Activation du torque ---");
    controller.enable_torque(servo_id)?;
    println!("✓ Torque activé pour le servo {}", servo_id);
    
    // Le servo maintient maintenant sa position
    thread::sleep(Duration::from_secs(2));
    
    // Lire la position actuelle
    if let Some(position) = controller.read_position(servo_id) {
        println!("Position actuelle: {}", position);
    }
    
    // Exemple 2: Désactiver le torque
    println!("\n--- Désactivation du torque ---");
    controller.disable_torque(servo_id)?;
    println!("✓ Torque désactivé pour le servo {}", servo_id);
    println!("Le servo peut maintenant être déplacé manuellement");
    
    // Attendre quelques secondes
    thread::sleep(Duration::from_secs(3));
    
    // Exemple 3: Réactiver le torque et déplacer le servo
    println!("\n--- Réactivation et déplacement ---");
    controller.enable_torque(servo_id)?;
    println!("✓ Torque réactivé");
    
    // Déplacer vers la position 2048 (milieu de la course)
    let target_position = 2048;
    let speed = 1000;
    let acceleration = 50;
    println!("Déplacement vers la position {}...", target_position);
    controller.move_to(servo_id, target_position, speed, acceleration, false);
    
    // Attendre que le mouvement soit terminé
    thread::sleep(Duration::from_secs(2));
    
    // Vérifier la position finale
    if let Some(final_position) = controller.read_position(servo_id) {
        println!("Position finale: {}", final_position);
    }
    
    // Exemple 4: Cycle d'activation/désactivation
    println!("\n--- Cycle d'activation/désactivation ---");
    for i in 1..=3 {
        println!("Cycle {}/3", i);
        
        println!("  Désactivation...");
        controller.disable_torque(servo_id)?;
        thread::sleep(Duration::from_millis(500));
        
        println!("  Activation...");
        controller.enable_torque(servo_id)?;
        thread::sleep(Duration::from_millis(500));
    }
    
    // Désactiver le torque à la fin
    println!("\n--- Fin du programme ---");
    controller.disable_torque(servo_id)?;
    println!("✓ Torque désactivé");
    
    Ok(())
}

pub fn list_servos(&self) -> Vec<u8>

Scanner le bus pour déterminer tous les servos présents

Examples found in repository

examples/basic.rs (line 9)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Créer une instance ST3215 connectée au port COM3
    let servo = ST3215::new("COM3")?;

    // Lister tous les servos disponibles
    let ids = servo.list_servos();
    println!("Servos trouvés: {:?}", ids);

    // Pour chaque servo trouvé
    for id in ids {
        println!("\n=== Servo {} ===", id);
        
        // Lire et afficher les informations du servo
        if let Some(position) = servo.read_position(id) {
            println!("Position actuelle: {}", position);
        }
        
        if let Some(voltage) = servo.read_voltage(id) {
            println!("Tension: {:.1} V", voltage);
        }
        
        if let Some(temp) = servo.read_temperature(id) {
            println!("Température: {} °C", temp);
        }
        
        if let Some(current) = servo.read_current(id) {
            println!("Courant: {:.1} mA", current);
        }

        // Déplacer le servo vers la position
        let deg: u16 = 65;
        let pos: u16 = deg * (4096.0 / 360.0) as u16;

        println!("Déplacement vers la position {}...", deg);

        servo.move_to(id, pos, 2400, 50, true);
        
        println!("Mouvement terminé!");
    }

    Ok(())
}

pub fn read_load(&self, sts_id: u8) -> Option<f32>

Lire la charge du servo (en pourcentage)

pub fn read_voltage(&self, sts_id: u8) -> Option<f32>

Lire la tension actuelle du servo (en V)

Examples found in repository

examples/basic.rs (line 21)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Créer une instance ST3215 connectée au port COM3
    let servo = ST3215::new("COM3")?;

    // Lister tous les servos disponibles
    let ids = servo.list_servos();
    println!("Servos trouvés: {:?}", ids);

    // Pour chaque servo trouvé
    for id in ids {
        println!("\n=== Servo {} ===", id);
        
        // Lire et afficher les informations du servo
        if let Some(position) = servo.read_position(id) {
            println!("Position actuelle: {}", position);
        }
        
        if let Some(voltage) = servo.read_voltage(id) {
            println!("Tension: {:.1} V", voltage);
        }
        
        if let Some(temp) = servo.read_temperature(id) {
            println!("Température: {} °C", temp);
        }
        
        if let Some(current) = servo.read_current(id) {
            println!("Courant: {:.1} mA", current);
        }

        // Déplacer le servo vers la position
        let deg: u16 = 65;
        let pos: u16 = deg * (4096.0 / 360.0) as u16;

        println!("Déplacement vers la position {}...", deg);

        servo.move_to(id, pos, 2400, 50, true);
        
        println!("Mouvement terminé!");
    }

    Ok(())
}

pub fn read_current(&self, sts_id: u8) -> Option<f32>

Lire le courant actuel du servo (en mA)

Examples found in repository

examples/basic.rs (line 29)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Créer une instance ST3215 connectée au port COM3
    let servo = ST3215::new("COM3")?;

    // Lister tous les servos disponibles
    let ids = servo.list_servos();
    println!("Servos trouvés: {:?}", ids);

    // Pour chaque servo trouvé
    for id in ids {
        println!("\n=== Servo {} ===", id);
        
        // Lire et afficher les informations du servo
        if let Some(position) = servo.read_position(id) {
            println!("Position actuelle: {}", position);
        }
        
        if let Some(voltage) = servo.read_voltage(id) {
            println!("Tension: {:.1} V", voltage);
        }
        
        if let Some(temp) = servo.read_temperature(id) {
            println!("Température: {} °C", temp);
        }
        
        if let Some(current) = servo.read_current(id) {
            println!("Courant: {:.1} mA", current);
        }

        // Déplacer le servo vers la position
        let deg: u16 = 65;
        let pos: u16 = deg * (4096.0 / 360.0) as u16;

        println!("Déplacement vers la position {}...", deg);

        servo.move_to(id, pos, 2400, 50, true);
        
        println!("Mouvement terminé!");
    }

    Ok(())
}

pub fn read_temperature(&self, sts_id: u8) -> Option<u8>

Lire la température actuelle du servo (en °C)

Examples found in repository

examples/basic.rs (line 25)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Créer une instance ST3215 connectée au port COM3
    let servo = ST3215::new("COM3")?;

    // Lister tous les servos disponibles
    let ids = servo.list_servos();
    println!("Servos trouvés: {:?}", ids);

    // Pour chaque servo trouvé
    for id in ids {
        println!("\n=== Servo {} ===", id);
        
        // Lire et afficher les informations du servo
        if let Some(position) = servo.read_position(id) {
            println!("Position actuelle: {}", position);
        }
        
        if let Some(voltage) = servo.read_voltage(id) {
            println!("Tension: {:.1} V", voltage);
        }
        
        if let Some(temp) = servo.read_temperature(id) {
            println!("Température: {} °C", temp);
        }
        
        if let Some(current) = servo.read_current(id) {
            println!("Courant: {:.1} mA", current);
        }

        // Déplacer le servo vers la position
        let deg: u16 = 65;
        let pos: u16 = deg * (4096.0 / 360.0) as u16;

        println!("Déplacement vers la position {}...", deg);

        servo.move_to(id, pos, 2400, 50, true);
        
        println!("Mouvement terminé!");
    }

    Ok(())
}

pub fn read_acceleration(&self, sts_id: u8) -> Option<u8>

Lire la valeur d’accélération actuelle du servo

pub fn read_mode(&self, sts_id: u8) -> Option<u8>

Lire le mode actuel du servo

• 0: Mode position
• 1: Mode vitesse constante
• 2: Mode PWM
• 3: Mode servo pas à pas

pub fn read_correction(&self, sts_id: u8) -> Option<i16>

Lire la correction de position actuelle du servo

pub fn is_moving(&self, sts_id: u8) -> Option<bool>

Le servo est-il en mouvement ?

pub fn set_acceleration(&self, sts_id: u8, acc: u8) -> Option<bool>

Configurer la valeur d’accélération pour le servo acc: Valeur d’accélération (0-254). Unité: 100 step/s²

pub fn set_speed(&self, sts_id: u8, speed: u16) -> Option<bool>

Configurer la valeur de vitesse pour le servo speed: Valeur de vitesse (0-3400). Unité: Step/s

pub fn disable_torque(&self, sts_id: u8) -> Result<(), String>

Désactiver le torque du servo (Mettre le couple à 0)

Examples found in repository

examples/torque_control.rs (line 41)

fn main() -> Result<(), String> {
    // Remplacer "/dev/ttyUSB0" par le port série approprié
    let device = std::env::var("SERVO_PORT").unwrap_or_else(|_| "/dev/ttyUSB0".to_string());
    
    println!("Connexion au port série: {}", device);
    let controller = ST3215::new(&device)?;
    
    // ID du servo à contrôler (modifier selon votre configuration)
    let servo_id: u8 = 1;
    
    // Vérifier que le servo est présent
    println!("Vérification de la présence du servo {}...", servo_id);
    if !controller.ping_servo(servo_id) {
        return Err(format!("Servo {} non trouvé!", servo_id));
    }
    println!("✓ Servo {} trouvé", servo_id);
    
    // Exemple 1: Activer le torque
    println!("\n--- Activation du torque ---");
    controller.enable_torque(servo_id)?;
    println!("✓ Torque activé pour le servo {}", servo_id);
    
    // Le servo maintient maintenant sa position
    thread::sleep(Duration::from_secs(2));
    
    // Lire la position actuelle
    if let Some(position) = controller.read_position(servo_id) {
        println!("Position actuelle: {}", position);
    }
    
    // Exemple 2: Désactiver le torque
    println!("\n--- Désactivation du torque ---");
    controller.disable_torque(servo_id)?;
    println!("✓ Torque désactivé pour le servo {}", servo_id);
    println!("Le servo peut maintenant être déplacé manuellement");
    
    // Attendre quelques secondes
    thread::sleep(Duration::from_secs(3));
    
    // Exemple 3: Réactiver le torque et déplacer le servo
    println!("\n--- Réactivation et déplacement ---");
    controller.enable_torque(servo_id)?;
    println!("✓ Torque réactivé");
    
    // Déplacer vers la position 2048 (milieu de la course)
    let target_position = 2048;
    let speed = 1000;
    let acceleration = 50;
    println!("Déplacement vers la position {}...", target_position);
    controller.move_to(servo_id, target_position, speed, acceleration, false);
    
    // Attendre que le mouvement soit terminé
    thread::sleep(Duration::from_secs(2));
    
    // Vérifier la position finale
    if let Some(final_position) = controller.read_position(servo_id) {
        println!("Position finale: {}", final_position);
    }
    
    // Exemple 4: Cycle d'activation/désactivation
    println!("\n--- Cycle d'activation/désactivation ---");
    for i in 1..=3 {
        println!("Cycle {}/3", i);
        
        println!("  Désactivation...");
        controller.disable_torque(servo_id)?;
        thread::sleep(Duration::from_millis(500));
        
        println!("  Activation...");
        controller.enable_torque(servo_id)?;
        thread::sleep(Duration::from_millis(500));
    }
    
    // Désactiver le torque à la fin
    println!("\n--- Fin du programme ---");
    controller.disable_torque(servo_id)?;
    println!("✓ Torque désactivé");
    
    Ok(())
}

pub fn enable_torque(&self, sts_id: u8) -> Result<(), String>

Activer le torque du servo (Mettre le couple à 1)

Examples found in repository

examples/torque_control.rs (line 28)

fn main() -> Result<(), String> {
    // Remplacer "/dev/ttyUSB0" par le port série approprié
    let device = std::env::var("SERVO_PORT").unwrap_or_else(|_| "/dev/ttyUSB0".to_string());
    
    println!("Connexion au port série: {}", device);
    let controller = ST3215::new(&device)?;
    
    // ID du servo à contrôler (modifier selon votre configuration)
    let servo_id: u8 = 1;
    
    // Vérifier que le servo est présent
    println!("Vérification de la présence du servo {}...", servo_id);
    if !controller.ping_servo(servo_id) {
        return Err(format!("Servo {} non trouvé!", servo_id));
    }
    println!("✓ Servo {} trouvé", servo_id);
    
    // Exemple 1: Activer le torque
    println!("\n--- Activation du torque ---");
    controller.enable_torque(servo_id)?;
    println!("✓ Torque activé pour le servo {}", servo_id);
    
    // Le servo maintient maintenant sa position
    thread::sleep(Duration::from_secs(2));
    
    // Lire la position actuelle
    if let Some(position) = controller.read_position(servo_id) {
        println!("Position actuelle: {}", position);
    }
    
    // Exemple 2: Désactiver le torque
    println!("\n--- Désactivation du torque ---");
    controller.disable_torque(servo_id)?;
    println!("✓ Torque désactivé pour le servo {}", servo_id);
    println!("Le servo peut maintenant être déplacé manuellement");
    
    // Attendre quelques secondes
    thread::sleep(Duration::from_secs(3));
    
    // Exemple 3: Réactiver le torque et déplacer le servo
    println!("\n--- Réactivation et déplacement ---");
    controller.enable_torque(servo_id)?;
    println!("✓ Torque réactivé");
    
    // Déplacer vers la position 2048 (milieu de la course)
    let target_position = 2048;
    let speed = 1000;
    let acceleration = 50;
    println!("Déplacement vers la position {}...", target_position);
    controller.move_to(servo_id, target_position, speed, acceleration, false);
    
    // Attendre que le mouvement soit terminé
    thread::sleep(Duration::from_secs(2));
    
    // Vérifier la position finale
    if let Some(final_position) = controller.read_position(servo_id) {
        println!("Position finale: {}", final_position);
    }
    
    // Exemple 4: Cycle d'activation/désactivation
    println!("\n--- Cycle d'activation/désactivation ---");
    for i in 1..=3 {
        println!("Cycle {}/3", i);
        
        println!("  Désactivation...");
        controller.disable_torque(servo_id)?;
        thread::sleep(Duration::from_millis(500));
        
        println!("  Activation...");
        controller.enable_torque(servo_id)?;
        thread::sleep(Duration::from_millis(500));
    }
    
    // Désactiver le torque à la fin
    println!("\n--- Fin du programme ---");
    controller.disable_torque(servo_id)?;
    println!("✓ Torque désactivé");
    
    Ok(())
}

pub fn stop_servo(&self, sts_id: u8) -> Option<bool>

👎Deprecated since 0.1.0: Utilisez disable_torque à la place

Arrêter le servo (Mettre le couple à 0)

Deprecated: Utilisez disable_torque à la place

pub fn start_servo(&self, sts_id: u8) -> Result<(), String>

👎Deprecated since 0.1.0: Utilisez enable_torque à la place

Démarrer le servo (Mettre le couple à 1)

Deprecated: Utilisez enable_torque à la place

pub fn set_mode(&self, sts_id: u8, mode: u8) -> Result<(), String>

Configurer le mode opérationnel du servo mode: ID du mode (0, 1, 2 ou 3)

pub fn correct_position( &self, sts_id: u8, correction: i16, ) -> Result<(), String>

Ajouter une correction de position correction: correction (en steps, peut être négatif)

pub fn rotate(&self, sts_id: u8, speed: i16) -> Result<(), String>

Commencer la rotation speed: vitesse du servo (peut être négatif, si oui rotation dans le sens inverse)

pub fn define_middle(&self, sts_id: u8) -> Option<bool>

Définir la position 2048 (Mettre le couple à 128)

pub fn tare_servo(&self, sts_id: u8) -> (Option<u16>, Option<u16>)

Étalonner un servo: Trouver ses positions min et max, puis configurer la nouvelle position 0 ATTENTION: Ne doit être utilisé que pour un servo ayant au moins une position bloquante

pub fn move_to( &self, sts_id: u8, position: u16, speed: u16, acc: u8, wait: bool, ) -> Option<bool>

Déplacer le servo vers une position prédéfinie position: Nouvelle position du servo speed: Vitesse de déplacement en step/s (facultatif, 2400 par défaut) acc: Vitesse d’accélération en step/s² (facultatif, 50 par défaut) wait: Attendre que la position soit atteinte avant le retour de la fonction

Examples found in repository

examples/basic.rs (line 39)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Créer une instance ST3215 connectée au port COM3
    let servo = ST3215::new("COM3")?;

    // Lister tous les servos disponibles
    let ids = servo.list_servos();
    println!("Servos trouvés: {:?}", ids);

    // Pour chaque servo trouvé
    for id in ids {
        println!("\n=== Servo {} ===", id);
        
        // Lire et afficher les informations du servo
        if let Some(position) = servo.read_position(id) {
            println!("Position actuelle: {}", position);
        }
        
        if let Some(voltage) = servo.read_voltage(id) {
            println!("Tension: {:.1} V", voltage);
        }
        
        if let Some(temp) = servo.read_temperature(id) {
            println!("Température: {} °C", temp);
        }
        
        if let Some(current) = servo.read_current(id) {
            println!("Courant: {:.1} mA", current);
        }

        // Déplacer le servo vers la position
        let deg: u16 = 65;
        let pos: u16 = deg * (4096.0 / 360.0) as u16;

        println!("Déplacement vers la position {}...", deg);

        servo.move_to(id, pos, 2400, 50, true);
        
        println!("Mouvement terminé!");
    }

    Ok(())
}

examples/torque_control.rs (line 58)

fn main() -> Result<(), String> {
    // Remplacer "/dev/ttyUSB0" par le port série approprié
    let device = std::env::var("SERVO_PORT").unwrap_or_else(|_| "/dev/ttyUSB0".to_string());
    
    println!("Connexion au port série: {}", device);
    let controller = ST3215::new(&device)?;
    
    // ID du servo à contrôler (modifier selon votre configuration)
    let servo_id: u8 = 1;
    
    // Vérifier que le servo est présent
    println!("Vérification de la présence du servo {}...", servo_id);
    if !controller.ping_servo(servo_id) {
        return Err(format!("Servo {} non trouvé!", servo_id));
    }
    println!("✓ Servo {} trouvé", servo_id);
    
    // Exemple 1: Activer le torque
    println!("\n--- Activation du torque ---");
    controller.enable_torque(servo_id)?;
    println!("✓ Torque activé pour le servo {}", servo_id);
    
    // Le servo maintient maintenant sa position
    thread::sleep(Duration::from_secs(2));
    
    // Lire la position actuelle
    if let Some(position) = controller.read_position(servo_id) {
        println!("Position actuelle: {}", position);
    }
    
    // Exemple 2: Désactiver le torque
    println!("\n--- Désactivation du torque ---");
    controller.disable_torque(servo_id)?;
    println!("✓ Torque désactivé pour le servo {}", servo_id);
    println!("Le servo peut maintenant être déplacé manuellement");
    
    // Attendre quelques secondes
    thread::sleep(Duration::from_secs(3));
    
    // Exemple 3: Réactiver le torque et déplacer le servo
    println!("\n--- Réactivation et déplacement ---");
    controller.enable_torque(servo_id)?;
    println!("✓ Torque réactivé");
    
    // Déplacer vers la position 2048 (milieu de la course)
    let target_position = 2048;
    let speed = 1000;
    let acceleration = 50;
    println!("Déplacement vers la position {}...", target_position);
    controller.move_to(servo_id, target_position, speed, acceleration, false);
    
    // Attendre que le mouvement soit terminé
    thread::sleep(Duration::from_secs(2));
    
    // Vérifier la position finale
    if let Some(final_position) = controller.read_position(servo_id) {
        println!("Position finale: {}", final_position);
    }
    
    // Exemple 4: Cycle d'activation/désactivation
    println!("\n--- Cycle d'activation/désactivation ---");
    for i in 1..=3 {
        println!("Cycle {}/3", i);
        
        println!("  Désactivation...");
        controller.disable_torque(servo_id)?;
        thread::sleep(Duration::from_millis(500));
        
        println!("  Activation...");
        controller.enable_torque(servo_id)?;
        thread::sleep(Duration::from_millis(500));
    }
    
    // Désactiver le torque à la fin
    println!("\n--- Fin du programme ---");
    controller.disable_torque(servo_id)?;
    println!("✓ Torque désactivé");
    
    Ok(())
}

pub fn write_position(&self, sts_id: u8, position: u16) -> Option<bool>

Écrire la position

pub fn read_status(&self, sts_id: u8) -> Option<HashMap<String, bool>>

Obtenir le statut des capteurs

pub fn read_position(&self, sts_id: u8) -> Option<u16>

Obtenir la position actuelle

Examples found in repository

examples/basic.rs (line 17)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Créer une instance ST3215 connectée au port COM3
    let servo = ST3215::new("COM3")?;

    // Lister tous les servos disponibles
    let ids = servo.list_servos();
    println!("Servos trouvés: {:?}", ids);

    // Pour chaque servo trouvé
    for id in ids {
        println!("\n=== Servo {} ===", id);
        
        // Lire et afficher les informations du servo
        if let Some(position) = servo.read_position(id) {
            println!("Position actuelle: {}", position);
        }
        
        if let Some(voltage) = servo.read_voltage(id) {
            println!("Tension: {:.1} V", voltage);
        }
        
        if let Some(temp) = servo.read_temperature(id) {
            println!("Température: {} °C", temp);
        }
        
        if let Some(current) = servo.read_current(id) {
            println!("Courant: {:.1} mA", current);
        }

        // Déplacer le servo vers la position
        let deg: u16 = 65;
        let pos: u16 = deg * (4096.0 / 360.0) as u16;

        println!("Déplacement vers la position {}...", deg);

        servo.move_to(id, pos, 2400, 50, true);
        
        println!("Mouvement terminé!");
    }

    Ok(())
}

examples/torque_control.rs (line 35)

fn main() -> Result<(), String> {
    // Remplacer "/dev/ttyUSB0" par le port série approprié
    let device = std::env::var("SERVO_PORT").unwrap_or_else(|_| "/dev/ttyUSB0".to_string());
    
    println!("Connexion au port série: {}", device);
    let controller = ST3215::new(&device)?;
    
    // ID du servo à contrôler (modifier selon votre configuration)
    let servo_id: u8 = 1;
    
    // Vérifier que le servo est présent
    println!("Vérification de la présence du servo {}...", servo_id);
    if !controller.ping_servo(servo_id) {
        return Err(format!("Servo {} non trouvé!", servo_id));
    }
    println!("✓ Servo {} trouvé", servo_id);
    
    // Exemple 1: Activer le torque
    println!("\n--- Activation du torque ---");
    controller.enable_torque(servo_id)?;
    println!("✓ Torque activé pour le servo {}", servo_id);
    
    // Le servo maintient maintenant sa position
    thread::sleep(Duration::from_secs(2));
    
    // Lire la position actuelle
    if let Some(position) = controller.read_position(servo_id) {
        println!("Position actuelle: {}", position);
    }
    
    // Exemple 2: Désactiver le torque
    println!("\n--- Désactivation du torque ---");
    controller.disable_torque(servo_id)?;
    println!("✓ Torque désactivé pour le servo {}", servo_id);
    println!("Le servo peut maintenant être déplacé manuellement");
    
    // Attendre quelques secondes
    thread::sleep(Duration::from_secs(3));
    
    // Exemple 3: Réactiver le torque et déplacer le servo
    println!("\n--- Réactivation et déplacement ---");
    controller.enable_torque(servo_id)?;
    println!("✓ Torque réactivé");
    
    // Déplacer vers la position 2048 (milieu de la course)
    let target_position = 2048;
    let speed = 1000;
    let acceleration = 50;
    println!("Déplacement vers la position {}...", target_position);
    controller.move_to(servo_id, target_position, speed, acceleration, false);
    
    // Attendre que le mouvement soit terminé
    thread::sleep(Duration::from_secs(2));
    
    // Vérifier la position finale
    if let Some(final_position) = controller.read_position(servo_id) {
        println!("Position finale: {}", final_position);
    }
    
    // Exemple 4: Cycle d'activation/désactivation
    println!("\n--- Cycle d'activation/désactivation ---");
    for i in 1..=3 {
        println!("Cycle {}/3", i);
        
        println!("  Désactivation...");
        controller.disable_torque(servo_id)?;
        thread::sleep(Duration::from_millis(500));
        
        println!("  Activation...");
        controller.enable_torque(servo_id)?;
        thread::sleep(Duration::from_millis(500));
    }
    
    // Désactiver le torque à la fin
    println!("\n--- Fin du programme ---");
    controller.disable_torque(servo_id)?;
    println!("✓ Torque désactivé");
    
    Ok(())
}

pub fn read_speed(&self, sts_id: u8) -> Option<i16>

Obtenir la vitesse actuelle

pub fn lock_eprom(&self, sts_id: u8) -> CommResult

Verrouiller l’EEPROM du servo

pub fn unlock_eprom(&self, sts_id: u8) -> CommResult

Déverrouiller l’EEPROM du servo

pub fn change_id(&self, sts_id: u8, new_id: u8) -> Result<(), String>

Changer l’ID d’un servo sts_id: ID actuel du servo (1 pour un servo neuf) new_id: Nouvel ID pour le servo (0-253)