Struct Tmc2209 

pub struct Tmc2209<U> { /* private fields */ }

TMC2209 driver over UART.

This struct provides methods for reading and writing TMC2209 registers via a UART interface. Both blocking and async versions are available depending on enabled features.

Type Parameters

• U - UART peripheral type implementing embedded_io::Read + embedded_io::Write or embedded_io_async::Read + embedded_io_async::Write

Example (blocking)

use tmc2209::{Tmc2209, registers::IholdIrun};

let mut driver = Tmc2209::new(uart, 0);

// Read a register
let status = driver.read_register::<DrvStatus>()?;

// Write a register
let mut irun = IholdIrun::new();
irun.set_irun(16).set_ihold(8);
driver.write_register(&irun)?;

Implementations

impl<U> Tmc2209<U>

pub fn new(uart: U, slave_addr: u8) -> Self

Create a new TMC2209 driver.

Arguments

• uart - UART peripheral for communication
• slave_addr - Slave address (0-3)

Panics

Panics if slave_addr is greater than 3.

Examples found in repository

examples/basic.rs (line 25)

fn basic_motor_control<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    // Create driver with slave address 0
    let mut driver = Tmc2209::new(uart, 0);

    // Check if the driver is responding
    if !driver.is_connected() {
        // Handle connection error
        return Err(tmc2209_uart::Error::NoResponse);
    }

    // Clear any previous errors
    driver.clear_gstat()?;

    // Configure motor current
    // IRUN=20 (run current), IHOLD=10 (hold current), IHOLDDELAY=6
    driver.set_current(20, 10, 6)?;

    // Set microstep resolution to 16 with interpolation to 256
    driver.set_microsteps(MicrostepResolution::M16)?;
    driver.set_interpolation(true)?;

    // Enable StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Enable the driver
    driver.set_enabled(true)?;

    // Start moving the motor forward
    driver.set_velocity(5000)?;

    // Check status
    let status = driver.drv_status()?;

    if status.ot() {
        // Overtemperature shutdown - stop immediately!
        driver.stop()?;
        driver.set_enabled(false)?;
    }

    if status.otpw() {
        // Overtemperature warning - reduce current or add cooling
        println!("Warning: Motor temperature is high");
    }

    // Reverse direction
    driver.set_velocity(-5000)?;

    // Stop the motor
    driver.stop()?;

    Ok(())
}

examples/sensorless_homing.rs (line 24)

fn sensorless_homing<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // =========================================================================
    // Step 1: Basic Configuration
    // =========================================================================

    // Set appropriate current for homing (usually lower than running current)
    driver.set_current(12, 6, 4)?;

    // Use lower microstep resolution for more reliable stall detection
    driver.set_microsteps(MicrostepResolution::M16)?;

    // =========================================================================
    // Step 2: Configure StallGuard
    // =========================================================================

    // CRITICAL: Use SpreadCycle mode for StallGuard
    driver.enable_spreadcycle()?;

    // Configure stall detection
    driver.configure_stall_detection(50)?;

    // Set TCOOLTHRS - StallGuard is only active when TSTEP < TCOOLTHRS
    driver.set_coolstep_threshold(0xFFFFF)?;

    driver.set_enabled(true)?;

    // =========================================================================
    // Step 3: Perform Homing
    // =========================================================================

    // Move towards the endstop
    let homing_velocity = -2000i32;
    driver.set_velocity(homing_velocity)?;

    // Poll for stall detection
    let max_iterations = 10000u32;

    for _ in 0..max_iterations {
        if driver.is_stalled()? {
            break;
        }
        // Add platform-specific delay here
    }

    // Stop the motor immediately
    driver.stop()?;

    // =========================================================================
    // Step 4: Post-Homing Configuration
    // =========================================================================

    // Switch back to StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Restore normal running current
    driver.set_current(20, 10, 6)?;

    Ok(())
}

/// Alternative: Home in both directions to find center.
#[cfg(feature = "blocking")]
fn home_to_center<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Configure for homing
    driver.set_current(12, 6, 4)?;
    driver.enable_spreadcycle()?;
    driver.configure_stall_detection(50)?;
    driver.set_coolstep_threshold(0xFFFFF)?;
    driver.set_enabled(true)?;

    // Home to minimum position
    driver.set_velocity(-2000)?;
    while !driver.is_stalled()? {
        // Wait or add timeout
    }
    driver.stop()?;
    let _min_position = 0i32;

    // Home to maximum position
    driver.set_velocity(2000)?;
    let mut step_count = 0i32;
    while !driver.is_stalled()? {
        step_count += 1;
    }
    driver.stop()?;
    let max_position = step_count;

    // Move to center
    let _center = max_position / 2;
    driver.set_velocity(-2000)?;
    // Move for half the counted steps
    driver.stop()?;

    Ok(())
}

examples/stealthchop.rs (line 16)

fn configure_stealthchop<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Basic setup
    driver.set_current(16, 8, 4)?;
    driver.set_microsteps(MicrostepResolution::M256)?;

    // =========================================================================
    // StealthChop Configuration
    // =========================================================================

    // Enable StealthChop mode (this is the default)
    driver.enable_stealthchop()?;

    // Configure StealthChop PWM parameters
    // - pwm_ofs: Base PWM amplitude (0-255)
    // - pwm_grad: PWM amplitude gradient (0-255)
    // - autoscale: Enable automatic current scaling
    // - autograd: Enable automatic gradient adaptation
    driver.configure_stealthchop(
        36,   // pwm_ofs (default)
        14,   // pwm_grad (default)
        true, // autoscale enabled (recommended)
        true, // autograd enabled (recommended)
    )?;

    // =========================================================================
    // Velocity-Based Mode Switching
    // =========================================================================

    // Set StealthChop/SpreadCycle velocity threshold (TPWMTHRS)
    // Below this TSTEP value, StealthChop is used
    // Above this velocity (lower TSTEP), SpreadCycle is used
    driver.set_stealthchop_threshold(500)?;

    // =========================================================================
    // Chopper Configuration
    // =========================================================================

    // Fine-tune chopper parameters for your motor
    driver.configure_chopper(
        3, // toff
        4, // hstrt
        1, // hend
        2, // tbl
    )?;

    // =========================================================================
    // Current Sense Configuration
    // =========================================================================

    // For high-current motors, use low sensitivity VSENSE
    driver.set_vsense(false)?;

    // Enable the driver
    driver.set_enabled(true)?;

    // =========================================================================
    // Monitor StealthChop Status
    // =========================================================================

    // Start moving
    driver.set_velocity(1000)?;

    // Check if StealthChop or SpreadCycle is active
    let _is_stealth = driver.is_stealthchop_active()?;

    // Check actual current being used
    let _actual_cs = driver.actual_current_scale()?;

    Ok(())
}

pub fn slave_addr(&self) -> u8

Get the slave address.

pub fn set_slave_addr(&mut self, addr: u8)

Set the slave address.

Panics

Panics if addr is greater than 3.

pub fn uart(&self) -> &U

Get a reference to the UART peripheral.

pub fn uart_mut(&mut self) -> &mut U

Get a mutable reference to the UART peripheral.

pub fn release(self) -> U

Release the UART peripheral.

impl<U, E> Tmc2209<U>

where U: Read<Error = E> + Write<Error = E>,

pub fn read_register<R: ReadableRegister>(&mut self) -> Result<R, Error<E>>

Read a register (blocking).

Sends a read request and waits for the response.

Type Parameters

• R - Register type to read (must implement ReadableRegister)

Returns

The register value, or an error if communication fails.

pub fn write_register<R: WritableRegister>( &mut self, reg: &R, ) -> Result<(), Error<E>>

Write a register (blocking).

Sends a write request to update a register value.

Arguments

• reg - Register value to write

Returns

Ok(()) on success, or an error if communication fails.

pub fn read_raw(&mut self, reg_addr: u8) -> Result<u32, Error<E>>

Read a register by raw address (blocking).

Use this when you need to read a register by its raw address value.

pub fn write_raw(&mut self, reg_addr: u8, data: u32) -> Result<(), Error<E>>

Write a register by raw address (blocking).

Use this when you need to write a register by its raw address value.

pub fn is_connected(&mut self) -> bool

Check if the driver is communicating properly.

Reads IFCNT and verifies we get a valid response.

Examples found in repository

examples/basic.rs (line 28)

fn basic_motor_control<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    // Create driver with slave address 0
    let mut driver = Tmc2209::new(uart, 0);

    // Check if the driver is responding
    if !driver.is_connected() {
        // Handle connection error
        return Err(tmc2209_uart::Error::NoResponse);
    }

    // Clear any previous errors
    driver.clear_gstat()?;

    // Configure motor current
    // IRUN=20 (run current), IHOLD=10 (hold current), IHOLDDELAY=6
    driver.set_current(20, 10, 6)?;

    // Set microstep resolution to 16 with interpolation to 256
    driver.set_microsteps(MicrostepResolution::M16)?;
    driver.set_interpolation(true)?;

    // Enable StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Enable the driver
    driver.set_enabled(true)?;

    // Start moving the motor forward
    driver.set_velocity(5000)?;

    // Check status
    let status = driver.drv_status()?;

    if status.ot() {
        // Overtemperature shutdown - stop immediately!
        driver.stop()?;
        driver.set_enabled(false)?;
    }

    if status.otpw() {
        // Overtemperature warning - reduce current or add cooling
        println!("Warning: Motor temperature is high");
    }

    // Reverse direction
    driver.set_velocity(-5000)?;

    // Stop the motor
    driver.stop()?;

    Ok(())
}

pub fn ifcnt(&mut self) -> Result<u8, Error<E>>

Get the interface transmission counter.

This counter increments on each successful UART write. Useful for verifying communication.

pub fn gstat(&mut self) -> Result<Gstat, Error<E>>

Get the global status flags.

pub fn clear_gstat(&mut self) -> Result<(), Error<E>>

Clear the global status flags (write to clear).

Examples found in repository

examples/basic.rs (line 34)

fn basic_motor_control<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    // Create driver with slave address 0
    let mut driver = Tmc2209::new(uart, 0);

    // Check if the driver is responding
    if !driver.is_connected() {
        // Handle connection error
        return Err(tmc2209_uart::Error::NoResponse);
    }

    // Clear any previous errors
    driver.clear_gstat()?;

    // Configure motor current
    // IRUN=20 (run current), IHOLD=10 (hold current), IHOLDDELAY=6
    driver.set_current(20, 10, 6)?;

    // Set microstep resolution to 16 with interpolation to 256
    driver.set_microsteps(MicrostepResolution::M16)?;
    driver.set_interpolation(true)?;

    // Enable StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Enable the driver
    driver.set_enabled(true)?;

    // Start moving the motor forward
    driver.set_velocity(5000)?;

    // Check status
    let status = driver.drv_status()?;

    if status.ot() {
        // Overtemperature shutdown - stop immediately!
        driver.stop()?;
        driver.set_enabled(false)?;
    }

    if status.otpw() {
        // Overtemperature warning - reduce current or add cooling
        println!("Warning: Motor temperature is high");
    }

    // Reverse direction
    driver.set_velocity(-5000)?;

    // Stop the motor
    driver.stop()?;

    Ok(())
}

pub fn ioin(&mut self) -> Result<Ioin, Error<E>>

Get the input pin states.

pub fn drv_status(&mut self) -> Result<DrvStatus, Error<E>>

Get the driver status.

Examples found in repository

examples/basic.rs (line 54)

fn basic_motor_control<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    // Create driver with slave address 0
    let mut driver = Tmc2209::new(uart, 0);

    // Check if the driver is responding
    if !driver.is_connected() {
        // Handle connection error
        return Err(tmc2209_uart::Error::NoResponse);
    }

    // Clear any previous errors
    driver.clear_gstat()?;

    // Configure motor current
    // IRUN=20 (run current), IHOLD=10 (hold current), IHOLDDELAY=6
    driver.set_current(20, 10, 6)?;

    // Set microstep resolution to 16 with interpolation to 256
    driver.set_microsteps(MicrostepResolution::M16)?;
    driver.set_interpolation(true)?;

    // Enable StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Enable the driver
    driver.set_enabled(true)?;

    // Start moving the motor forward
    driver.set_velocity(5000)?;

    // Check status
    let status = driver.drv_status()?;

    if status.ot() {
        // Overtemperature shutdown - stop immediately!
        driver.stop()?;
        driver.set_enabled(false)?;
    }

    if status.otpw() {
        // Overtemperature warning - reduce current or add cooling
        println!("Warning: Motor temperature is high");
    }

    // Reverse direction
    driver.set_velocity(-5000)?;

    // Stop the motor
    driver.stop()?;

    Ok(())
}

pub fn tstep(&mut self) -> Result<u32, Error<E>>

Get the current step time (inverse of velocity).

pub fn sg_result(&mut self) -> Result<u16, Error<E>>

Get the StallGuard result.

pub fn mscnt(&mut self) -> Result<u16, Error<E>>

Get the microstep counter position (0-1023).

pub fn set_current( &mut self, run_current: u8, hold_current: u8, hold_delay: u8, ) -> Result<(), Error<E>>

Set the motor currents.

Arguments

• run_current - Run current (0-31)
• hold_current - Hold current (0-31)
• hold_delay - Delay before reducing to hold current (0-15)

Examples found in repository

examples/basic.rs (line 38)

fn basic_motor_control<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    // Create driver with slave address 0
    let mut driver = Tmc2209::new(uart, 0);

    // Check if the driver is responding
    if !driver.is_connected() {
        // Handle connection error
        return Err(tmc2209_uart::Error::NoResponse);
    }

    // Clear any previous errors
    driver.clear_gstat()?;

    // Configure motor current
    // IRUN=20 (run current), IHOLD=10 (hold current), IHOLDDELAY=6
    driver.set_current(20, 10, 6)?;

    // Set microstep resolution to 16 with interpolation to 256
    driver.set_microsteps(MicrostepResolution::M16)?;
    driver.set_interpolation(true)?;

    // Enable StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Enable the driver
    driver.set_enabled(true)?;

    // Start moving the motor forward
    driver.set_velocity(5000)?;

    // Check status
    let status = driver.drv_status()?;

    if status.ot() {
        // Overtemperature shutdown - stop immediately!
        driver.stop()?;
        driver.set_enabled(false)?;
    }

    if status.otpw() {
        // Overtemperature warning - reduce current or add cooling
        println!("Warning: Motor temperature is high");
    }

    // Reverse direction
    driver.set_velocity(-5000)?;

    // Stop the motor
    driver.stop()?;

    Ok(())
}

examples/sensorless_homing.rs (line 31)

fn sensorless_homing<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // =========================================================================
    // Step 1: Basic Configuration
    // =========================================================================

    // Set appropriate current for homing (usually lower than running current)
    driver.set_current(12, 6, 4)?;

    // Use lower microstep resolution for more reliable stall detection
    driver.set_microsteps(MicrostepResolution::M16)?;

    // =========================================================================
    // Step 2: Configure StallGuard
    // =========================================================================

    // CRITICAL: Use SpreadCycle mode for StallGuard
    driver.enable_spreadcycle()?;

    // Configure stall detection
    driver.configure_stall_detection(50)?;

    // Set TCOOLTHRS - StallGuard is only active when TSTEP < TCOOLTHRS
    driver.set_coolstep_threshold(0xFFFFF)?;

    driver.set_enabled(true)?;

    // =========================================================================
    // Step 3: Perform Homing
    // =========================================================================

    // Move towards the endstop
    let homing_velocity = -2000i32;
    driver.set_velocity(homing_velocity)?;

    // Poll for stall detection
    let max_iterations = 10000u32;

    for _ in 0..max_iterations {
        if driver.is_stalled()? {
            break;
        }
        // Add platform-specific delay here
    }

    // Stop the motor immediately
    driver.stop()?;

    // =========================================================================
    // Step 4: Post-Homing Configuration
    // =========================================================================

    // Switch back to StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Restore normal running current
    driver.set_current(20, 10, 6)?;

    Ok(())
}

/// Alternative: Home in both directions to find center.
#[cfg(feature = "blocking")]
fn home_to_center<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Configure for homing
    driver.set_current(12, 6, 4)?;
    driver.enable_spreadcycle()?;
    driver.configure_stall_detection(50)?;
    driver.set_coolstep_threshold(0xFFFFF)?;
    driver.set_enabled(true)?;

    // Home to minimum position
    driver.set_velocity(-2000)?;
    while !driver.is_stalled()? {
        // Wait or add timeout
    }
    driver.stop()?;
    let _min_position = 0i32;

    // Home to maximum position
    driver.set_velocity(2000)?;
    let mut step_count = 0i32;
    while !driver.is_stalled()? {
        step_count += 1;
    }
    driver.stop()?;
    let max_position = step_count;

    // Move to center
    let _center = max_position / 2;
    driver.set_velocity(-2000)?;
    // Move for half the counted steps
    driver.stop()?;

    Ok(())
}

examples/stealthchop.rs (line 19)

fn configure_stealthchop<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Basic setup
    driver.set_current(16, 8, 4)?;
    driver.set_microsteps(MicrostepResolution::M256)?;

    // =========================================================================
    // StealthChop Configuration
    // =========================================================================

    // Enable StealthChop mode (this is the default)
    driver.enable_stealthchop()?;

    // Configure StealthChop PWM parameters
    // - pwm_ofs: Base PWM amplitude (0-255)
    // - pwm_grad: PWM amplitude gradient (0-255)
    // - autoscale: Enable automatic current scaling
    // - autograd: Enable automatic gradient adaptation
    driver.configure_stealthchop(
        36,   // pwm_ofs (default)
        14,   // pwm_grad (default)
        true, // autoscale enabled (recommended)
        true, // autograd enabled (recommended)
    )?;

    // =========================================================================
    // Velocity-Based Mode Switching
    // =========================================================================

    // Set StealthChop/SpreadCycle velocity threshold (TPWMTHRS)
    // Below this TSTEP value, StealthChop is used
    // Above this velocity (lower TSTEP), SpreadCycle is used
    driver.set_stealthchop_threshold(500)?;

    // =========================================================================
    // Chopper Configuration
    // =========================================================================

    // Fine-tune chopper parameters for your motor
    driver.configure_chopper(
        3, // toff
        4, // hstrt
        1, // hend
        2, // tbl
    )?;

    // =========================================================================
    // Current Sense Configuration
    // =========================================================================

    // For high-current motors, use low sensitivity VSENSE
    driver.set_vsense(false)?;

    // Enable the driver
    driver.set_enabled(true)?;

    // =========================================================================
    // Monitor StealthChop Status
    // =========================================================================

    // Start moving
    driver.set_velocity(1000)?;

    // Check if StealthChop or SpreadCycle is active
    let _is_stealth = driver.is_stealthchop_active()?;

    // Check actual current being used
    let _actual_cs = driver.actual_current_scale()?;

    Ok(())
}

pub fn set_microsteps( &mut self, resolution: MicrostepResolution, ) -> Result<(), Error<E>>

Set the microstep resolution.

Examples found in repository

examples/basic.rs (line 41)

fn basic_motor_control<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    // Create driver with slave address 0
    let mut driver = Tmc2209::new(uart, 0);

    // Check if the driver is responding
    if !driver.is_connected() {
        // Handle connection error
        return Err(tmc2209_uart::Error::NoResponse);
    }

    // Clear any previous errors
    driver.clear_gstat()?;

    // Configure motor current
    // IRUN=20 (run current), IHOLD=10 (hold current), IHOLDDELAY=6
    driver.set_current(20, 10, 6)?;

    // Set microstep resolution to 16 with interpolation to 256
    driver.set_microsteps(MicrostepResolution::M16)?;
    driver.set_interpolation(true)?;

    // Enable StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Enable the driver
    driver.set_enabled(true)?;

    // Start moving the motor forward
    driver.set_velocity(5000)?;

    // Check status
    let status = driver.drv_status()?;

    if status.ot() {
        // Overtemperature shutdown - stop immediately!
        driver.stop()?;
        driver.set_enabled(false)?;
    }

    if status.otpw() {
        // Overtemperature warning - reduce current or add cooling
        println!("Warning: Motor temperature is high");
    }

    // Reverse direction
    driver.set_velocity(-5000)?;

    // Stop the motor
    driver.stop()?;

    Ok(())
}

examples/sensorless_homing.rs (line 34)

fn sensorless_homing<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // =========================================================================
    // Step 1: Basic Configuration
    // =========================================================================

    // Set appropriate current for homing (usually lower than running current)
    driver.set_current(12, 6, 4)?;

    // Use lower microstep resolution for more reliable stall detection
    driver.set_microsteps(MicrostepResolution::M16)?;

    // =========================================================================
    // Step 2: Configure StallGuard
    // =========================================================================

    // CRITICAL: Use SpreadCycle mode for StallGuard
    driver.enable_spreadcycle()?;

    // Configure stall detection
    driver.configure_stall_detection(50)?;

    // Set TCOOLTHRS - StallGuard is only active when TSTEP < TCOOLTHRS
    driver.set_coolstep_threshold(0xFFFFF)?;

    driver.set_enabled(true)?;

    // =========================================================================
    // Step 3: Perform Homing
    // =========================================================================

    // Move towards the endstop
    let homing_velocity = -2000i32;
    driver.set_velocity(homing_velocity)?;

    // Poll for stall detection
    let max_iterations = 10000u32;

    for _ in 0..max_iterations {
        if driver.is_stalled()? {
            break;
        }
        // Add platform-specific delay here
    }

    // Stop the motor immediately
    driver.stop()?;

    // =========================================================================
    // Step 4: Post-Homing Configuration
    // =========================================================================

    // Switch back to StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Restore normal running current
    driver.set_current(20, 10, 6)?;

    Ok(())
}

examples/stealthchop.rs (line 20)

fn configure_stealthchop<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Basic setup
    driver.set_current(16, 8, 4)?;
    driver.set_microsteps(MicrostepResolution::M256)?;

    // =========================================================================
    // StealthChop Configuration
    // =========================================================================

    // Enable StealthChop mode (this is the default)
    driver.enable_stealthchop()?;

    // Configure StealthChop PWM parameters
    // - pwm_ofs: Base PWM amplitude (0-255)
    // - pwm_grad: PWM amplitude gradient (0-255)
    // - autoscale: Enable automatic current scaling
    // - autograd: Enable automatic gradient adaptation
    driver.configure_stealthchop(
        36,   // pwm_ofs (default)
        14,   // pwm_grad (default)
        true, // autoscale enabled (recommended)
        true, // autograd enabled (recommended)
    )?;

    // =========================================================================
    // Velocity-Based Mode Switching
    // =========================================================================

    // Set StealthChop/SpreadCycle velocity threshold (TPWMTHRS)
    // Below this TSTEP value, StealthChop is used
    // Above this velocity (lower TSTEP), SpreadCycle is used
    driver.set_stealthchop_threshold(500)?;

    // =========================================================================
    // Chopper Configuration
    // =========================================================================

    // Fine-tune chopper parameters for your motor
    driver.configure_chopper(
        3, // toff
        4, // hstrt
        1, // hend
        2, // tbl
    )?;

    // =========================================================================
    // Current Sense Configuration
    // =========================================================================

    // For high-current motors, use low sensitivity VSENSE
    driver.set_vsense(false)?;

    // Enable the driver
    driver.set_enabled(true)?;

    // =========================================================================
    // Monitor StealthChop Status
    // =========================================================================

    // Start moving
    driver.set_velocity(1000)?;

    // Check if StealthChop or SpreadCycle is active
    let _is_stealth = driver.is_stealthchop_active()?;

    // Check actual current being used
    let _actual_cs = driver.actual_current_scale()?;

    Ok(())
}

pub fn set_enabled(&mut self, enabled: bool) -> Result<(), Error<E>>

Enable or disable the driver.

When TOFF=0, the driver is disabled.

Examples found in repository

examples/basic.rs (line 48)

fn basic_motor_control<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    // Create driver with slave address 0
    let mut driver = Tmc2209::new(uart, 0);

    // Check if the driver is responding
    if !driver.is_connected() {
        // Handle connection error
        return Err(tmc2209_uart::Error::NoResponse);
    }

    // Clear any previous errors
    driver.clear_gstat()?;

    // Configure motor current
    // IRUN=20 (run current), IHOLD=10 (hold current), IHOLDDELAY=6
    driver.set_current(20, 10, 6)?;

    // Set microstep resolution to 16 with interpolation to 256
    driver.set_microsteps(MicrostepResolution::M16)?;
    driver.set_interpolation(true)?;

    // Enable StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Enable the driver
    driver.set_enabled(true)?;

    // Start moving the motor forward
    driver.set_velocity(5000)?;

    // Check status
    let status = driver.drv_status()?;

    if status.ot() {
        // Overtemperature shutdown - stop immediately!
        driver.stop()?;
        driver.set_enabled(false)?;
    }

    if status.otpw() {
        // Overtemperature warning - reduce current or add cooling
        println!("Warning: Motor temperature is high");
    }

    // Reverse direction
    driver.set_velocity(-5000)?;

    // Stop the motor
    driver.stop()?;

    Ok(())
}

examples/sensorless_homing.rs (line 49)

fn sensorless_homing<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // =========================================================================
    // Step 1: Basic Configuration
    // =========================================================================

    // Set appropriate current for homing (usually lower than running current)
    driver.set_current(12, 6, 4)?;

    // Use lower microstep resolution for more reliable stall detection
    driver.set_microsteps(MicrostepResolution::M16)?;

    // =========================================================================
    // Step 2: Configure StallGuard
    // =========================================================================

    // CRITICAL: Use SpreadCycle mode for StallGuard
    driver.enable_spreadcycle()?;

    // Configure stall detection
    driver.configure_stall_detection(50)?;

    // Set TCOOLTHRS - StallGuard is only active when TSTEP < TCOOLTHRS
    driver.set_coolstep_threshold(0xFFFFF)?;

    driver.set_enabled(true)?;

    // =========================================================================
    // Step 3: Perform Homing
    // =========================================================================

    // Move towards the endstop
    let homing_velocity = -2000i32;
    driver.set_velocity(homing_velocity)?;

    // Poll for stall detection
    let max_iterations = 10000u32;

    for _ in 0..max_iterations {
        if driver.is_stalled()? {
            break;
        }
        // Add platform-specific delay here
    }

    // Stop the motor immediately
    driver.stop()?;

    // =========================================================================
    // Step 4: Post-Homing Configuration
    // =========================================================================

    // Switch back to StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Restore normal running current
    driver.set_current(20, 10, 6)?;

    Ok(())
}

/// Alternative: Home in both directions to find center.
#[cfg(feature = "blocking")]
fn home_to_center<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Configure for homing
    driver.set_current(12, 6, 4)?;
    driver.enable_spreadcycle()?;
    driver.configure_stall_detection(50)?;
    driver.set_coolstep_threshold(0xFFFFF)?;
    driver.set_enabled(true)?;

    // Home to minimum position
    driver.set_velocity(-2000)?;
    while !driver.is_stalled()? {
        // Wait or add timeout
    }
    driver.stop()?;
    let _min_position = 0i32;

    // Home to maximum position
    driver.set_velocity(2000)?;
    let mut step_count = 0i32;
    while !driver.is_stalled()? {
        step_count += 1;
    }
    driver.stop()?;
    let max_position = step_count;

    // Move to center
    let _center = max_position / 2;
    driver.set_velocity(-2000)?;
    // Move for half the counted steps
    driver.stop()?;

    Ok(())
}

examples/stealthchop.rs (line 70)

fn configure_stealthchop<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Basic setup
    driver.set_current(16, 8, 4)?;
    driver.set_microsteps(MicrostepResolution::M256)?;

    // =========================================================================
    // StealthChop Configuration
    // =========================================================================

    // Enable StealthChop mode (this is the default)
    driver.enable_stealthchop()?;

    // Configure StealthChop PWM parameters
    // - pwm_ofs: Base PWM amplitude (0-255)
    // - pwm_grad: PWM amplitude gradient (0-255)
    // - autoscale: Enable automatic current scaling
    // - autograd: Enable automatic gradient adaptation
    driver.configure_stealthchop(
        36,   // pwm_ofs (default)
        14,   // pwm_grad (default)
        true, // autoscale enabled (recommended)
        true, // autograd enabled (recommended)
    )?;

    // =========================================================================
    // Velocity-Based Mode Switching
    // =========================================================================

    // Set StealthChop/SpreadCycle velocity threshold (TPWMTHRS)
    // Below this TSTEP value, StealthChop is used
    // Above this velocity (lower TSTEP), SpreadCycle is used
    driver.set_stealthchop_threshold(500)?;

    // =========================================================================
    // Chopper Configuration
    // =========================================================================

    // Fine-tune chopper parameters for your motor
    driver.configure_chopper(
        3, // toff
        4, // hstrt
        1, // hend
        2, // tbl
    )?;

    // =========================================================================
    // Current Sense Configuration
    // =========================================================================

    // For high-current motors, use low sensitivity VSENSE
    driver.set_vsense(false)?;

    // Enable the driver
    driver.set_enabled(true)?;

    // =========================================================================
    // Monitor StealthChop Status
    // =========================================================================

    // Start moving
    driver.set_velocity(1000)?;

    // Check if StealthChop or SpreadCycle is active
    let _is_stealth = driver.is_stealthchop_active()?;

    // Check actual current being used
    let _actual_cs = driver.actual_current_scale()?;

    Ok(())
}

pub fn set_velocity(&mut self, velocity: i32) -> Result<(), Error<E>>

Set velocity for internal motion controller (VACTUAL).

Arguments

• velocity - Velocity value (signed, 23-bit range)
  • Positive: Forward motion
  • Negative: Reverse motion
  • 0: Stop

Examples found in repository

examples/basic.rs (line 51)

fn basic_motor_control<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    // Create driver with slave address 0
    let mut driver = Tmc2209::new(uart, 0);

    // Check if the driver is responding
    if !driver.is_connected() {
        // Handle connection error
        return Err(tmc2209_uart::Error::NoResponse);
    }

    // Clear any previous errors
    driver.clear_gstat()?;

    // Configure motor current
    // IRUN=20 (run current), IHOLD=10 (hold current), IHOLDDELAY=6
    driver.set_current(20, 10, 6)?;

    // Set microstep resolution to 16 with interpolation to 256
    driver.set_microsteps(MicrostepResolution::M16)?;
    driver.set_interpolation(true)?;

    // Enable StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Enable the driver
    driver.set_enabled(true)?;

    // Start moving the motor forward
    driver.set_velocity(5000)?;

    // Check status
    let status = driver.drv_status()?;

    if status.ot() {
        // Overtemperature shutdown - stop immediately!
        driver.stop()?;
        driver.set_enabled(false)?;
    }

    if status.otpw() {
        // Overtemperature warning - reduce current or add cooling
        println!("Warning: Motor temperature is high");
    }

    // Reverse direction
    driver.set_velocity(-5000)?;

    // Stop the motor
    driver.stop()?;

    Ok(())
}

examples/sensorless_homing.rs (line 57)

fn sensorless_homing<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // =========================================================================
    // Step 1: Basic Configuration
    // =========================================================================

    // Set appropriate current for homing (usually lower than running current)
    driver.set_current(12, 6, 4)?;

    // Use lower microstep resolution for more reliable stall detection
    driver.set_microsteps(MicrostepResolution::M16)?;

    // =========================================================================
    // Step 2: Configure StallGuard
    // =========================================================================

    // CRITICAL: Use SpreadCycle mode for StallGuard
    driver.enable_spreadcycle()?;

    // Configure stall detection
    driver.configure_stall_detection(50)?;

    // Set TCOOLTHRS - StallGuard is only active when TSTEP < TCOOLTHRS
    driver.set_coolstep_threshold(0xFFFFF)?;

    driver.set_enabled(true)?;

    // =========================================================================
    // Step 3: Perform Homing
    // =========================================================================

    // Move towards the endstop
    let homing_velocity = -2000i32;
    driver.set_velocity(homing_velocity)?;

    // Poll for stall detection
    let max_iterations = 10000u32;

    for _ in 0..max_iterations {
        if driver.is_stalled()? {
            break;
        }
        // Add platform-specific delay here
    }

    // Stop the motor immediately
    driver.stop()?;

    // =========================================================================
    // Step 4: Post-Homing Configuration
    // =========================================================================

    // Switch back to StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Restore normal running current
    driver.set_current(20, 10, 6)?;

    Ok(())
}

/// Alternative: Home in both directions to find center.
#[cfg(feature = "blocking")]
fn home_to_center<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Configure for homing
    driver.set_current(12, 6, 4)?;
    driver.enable_spreadcycle()?;
    driver.configure_stall_detection(50)?;
    driver.set_coolstep_threshold(0xFFFFF)?;
    driver.set_enabled(true)?;

    // Home to minimum position
    driver.set_velocity(-2000)?;
    while !driver.is_stalled()? {
        // Wait or add timeout
    }
    driver.stop()?;
    let _min_position = 0i32;

    // Home to maximum position
    driver.set_velocity(2000)?;
    let mut step_count = 0i32;
    while !driver.is_stalled()? {
        step_count += 1;
    }
    driver.stop()?;
    let max_position = step_count;

    // Move to center
    let _center = max_position / 2;
    driver.set_velocity(-2000)?;
    // Move for half the counted steps
    driver.stop()?;

    Ok(())
}

examples/stealthchop.rs (line 77)

fn configure_stealthchop<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Basic setup
    driver.set_current(16, 8, 4)?;
    driver.set_microsteps(MicrostepResolution::M256)?;

    // =========================================================================
    // StealthChop Configuration
    // =========================================================================

    // Enable StealthChop mode (this is the default)
    driver.enable_stealthchop()?;

    // Configure StealthChop PWM parameters
    // - pwm_ofs: Base PWM amplitude (0-255)
    // - pwm_grad: PWM amplitude gradient (0-255)
    // - autoscale: Enable automatic current scaling
    // - autograd: Enable automatic gradient adaptation
    driver.configure_stealthchop(
        36,   // pwm_ofs (default)
        14,   // pwm_grad (default)
        true, // autoscale enabled (recommended)
        true, // autograd enabled (recommended)
    )?;

    // =========================================================================
    // Velocity-Based Mode Switching
    // =========================================================================

    // Set StealthChop/SpreadCycle velocity threshold (TPWMTHRS)
    // Below this TSTEP value, StealthChop is used
    // Above this velocity (lower TSTEP), SpreadCycle is used
    driver.set_stealthchop_threshold(500)?;

    // =========================================================================
    // Chopper Configuration
    // =========================================================================

    // Fine-tune chopper parameters for your motor
    driver.configure_chopper(
        3, // toff
        4, // hstrt
        1, // hend
        2, // tbl
    )?;

    // =========================================================================
    // Current Sense Configuration
    // =========================================================================

    // For high-current motors, use low sensitivity VSENSE
    driver.set_vsense(false)?;

    // Enable the driver
    driver.set_enabled(true)?;

    // =========================================================================
    // Monitor StealthChop Status
    // =========================================================================

    // Start moving
    driver.set_velocity(1000)?;

    // Check if StealthChop or SpreadCycle is active
    let _is_stealth = driver.is_stealthchop_active()?;

    // Check actual current being used
    let _actual_cs = driver.actual_current_scale()?;

    Ok(())
}

pub fn stop(&mut self) -> Result<(), Error<E>>

Stop the motor (set VACTUAL to 0).

Examples found in repository

examples/basic.rs (line 58)

fn basic_motor_control<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    // Create driver with slave address 0
    let mut driver = Tmc2209::new(uart, 0);

    // Check if the driver is responding
    if !driver.is_connected() {
        // Handle connection error
        return Err(tmc2209_uart::Error::NoResponse);
    }

    // Clear any previous errors
    driver.clear_gstat()?;

    // Configure motor current
    // IRUN=20 (run current), IHOLD=10 (hold current), IHOLDDELAY=6
    driver.set_current(20, 10, 6)?;

    // Set microstep resolution to 16 with interpolation to 256
    driver.set_microsteps(MicrostepResolution::M16)?;
    driver.set_interpolation(true)?;

    // Enable StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Enable the driver
    driver.set_enabled(true)?;

    // Start moving the motor forward
    driver.set_velocity(5000)?;

    // Check status
    let status = driver.drv_status()?;

    if status.ot() {
        // Overtemperature shutdown - stop immediately!
        driver.stop()?;
        driver.set_enabled(false)?;
    }

    if status.otpw() {
        // Overtemperature warning - reduce current or add cooling
        println!("Warning: Motor temperature is high");
    }

    // Reverse direction
    driver.set_velocity(-5000)?;

    // Stop the motor
    driver.stop()?;

    Ok(())
}

examples/sensorless_homing.rs (line 70)

fn sensorless_homing<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // =========================================================================
    // Step 1: Basic Configuration
    // =========================================================================

    // Set appropriate current for homing (usually lower than running current)
    driver.set_current(12, 6, 4)?;

    // Use lower microstep resolution for more reliable stall detection
    driver.set_microsteps(MicrostepResolution::M16)?;

    // =========================================================================
    // Step 2: Configure StallGuard
    // =========================================================================

    // CRITICAL: Use SpreadCycle mode for StallGuard
    driver.enable_spreadcycle()?;

    // Configure stall detection
    driver.configure_stall_detection(50)?;

    // Set TCOOLTHRS - StallGuard is only active when TSTEP < TCOOLTHRS
    driver.set_coolstep_threshold(0xFFFFF)?;

    driver.set_enabled(true)?;

    // =========================================================================
    // Step 3: Perform Homing
    // =========================================================================

    // Move towards the endstop
    let homing_velocity = -2000i32;
    driver.set_velocity(homing_velocity)?;

    // Poll for stall detection
    let max_iterations = 10000u32;

    for _ in 0..max_iterations {
        if driver.is_stalled()? {
            break;
        }
        // Add platform-specific delay here
    }

    // Stop the motor immediately
    driver.stop()?;

    // =========================================================================
    // Step 4: Post-Homing Configuration
    // =========================================================================

    // Switch back to StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Restore normal running current
    driver.set_current(20, 10, 6)?;

    Ok(())
}

/// Alternative: Home in both directions to find center.
#[cfg(feature = "blocking")]
fn home_to_center<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Configure for homing
    driver.set_current(12, 6, 4)?;
    driver.enable_spreadcycle()?;
    driver.configure_stall_detection(50)?;
    driver.set_coolstep_threshold(0xFFFFF)?;
    driver.set_enabled(true)?;

    // Home to minimum position
    driver.set_velocity(-2000)?;
    while !driver.is_stalled()? {
        // Wait or add timeout
    }
    driver.stop()?;
    let _min_position = 0i32;

    // Home to maximum position
    driver.set_velocity(2000)?;
    let mut step_count = 0i32;
    while !driver.is_stalled()? {
        step_count += 1;
    }
    driver.stop()?;
    let max_position = step_count;

    // Move to center
    let _center = max_position / 2;
    driver.set_velocity(-2000)?;
    // Move for half the counted steps
    driver.stop()?;

    Ok(())
}

pub fn set_stall_threshold(&mut self, threshold: u8) -> Result<(), Error<E>>

Set the StallGuard threshold.

Higher values make stall detection more sensitive.

pub fn enable_stealthchop(&mut self) -> Result<(), Error<E>>

Enable StealthChop mode.

Examples found in repository

examples/basic.rs (line 45)

fn basic_motor_control<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    // Create driver with slave address 0
    let mut driver = Tmc2209::new(uart, 0);

    // Check if the driver is responding
    if !driver.is_connected() {
        // Handle connection error
        return Err(tmc2209_uart::Error::NoResponse);
    }

    // Clear any previous errors
    driver.clear_gstat()?;

    // Configure motor current
    // IRUN=20 (run current), IHOLD=10 (hold current), IHOLDDELAY=6
    driver.set_current(20, 10, 6)?;

    // Set microstep resolution to 16 with interpolation to 256
    driver.set_microsteps(MicrostepResolution::M16)?;
    driver.set_interpolation(true)?;

    // Enable StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Enable the driver
    driver.set_enabled(true)?;

    // Start moving the motor forward
    driver.set_velocity(5000)?;

    // Check status
    let status = driver.drv_status()?;

    if status.ot() {
        // Overtemperature shutdown - stop immediately!
        driver.stop()?;
        driver.set_enabled(false)?;
    }

    if status.otpw() {
        // Overtemperature warning - reduce current or add cooling
        println!("Warning: Motor temperature is high");
    }

    // Reverse direction
    driver.set_velocity(-5000)?;

    // Stop the motor
    driver.stop()?;

    Ok(())
}

examples/sensorless_homing.rs (line 77)

fn sensorless_homing<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // =========================================================================
    // Step 1: Basic Configuration
    // =========================================================================

    // Set appropriate current for homing (usually lower than running current)
    driver.set_current(12, 6, 4)?;

    // Use lower microstep resolution for more reliable stall detection
    driver.set_microsteps(MicrostepResolution::M16)?;

    // =========================================================================
    // Step 2: Configure StallGuard
    // =========================================================================

    // CRITICAL: Use SpreadCycle mode for StallGuard
    driver.enable_spreadcycle()?;

    // Configure stall detection
    driver.configure_stall_detection(50)?;

    // Set TCOOLTHRS - StallGuard is only active when TSTEP < TCOOLTHRS
    driver.set_coolstep_threshold(0xFFFFF)?;

    driver.set_enabled(true)?;

    // =========================================================================
    // Step 3: Perform Homing
    // =========================================================================

    // Move towards the endstop
    let homing_velocity = -2000i32;
    driver.set_velocity(homing_velocity)?;

    // Poll for stall detection
    let max_iterations = 10000u32;

    for _ in 0..max_iterations {
        if driver.is_stalled()? {
            break;
        }
        // Add platform-specific delay here
    }

    // Stop the motor immediately
    driver.stop()?;

    // =========================================================================
    // Step 4: Post-Homing Configuration
    // =========================================================================

    // Switch back to StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Restore normal running current
    driver.set_current(20, 10, 6)?;

    Ok(())
}

examples/stealthchop.rs (line 27)

fn configure_stealthchop<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Basic setup
    driver.set_current(16, 8, 4)?;
    driver.set_microsteps(MicrostepResolution::M256)?;

    // =========================================================================
    // StealthChop Configuration
    // =========================================================================

    // Enable StealthChop mode (this is the default)
    driver.enable_stealthchop()?;

    // Configure StealthChop PWM parameters
    // - pwm_ofs: Base PWM amplitude (0-255)
    // - pwm_grad: PWM amplitude gradient (0-255)
    // - autoscale: Enable automatic current scaling
    // - autograd: Enable automatic gradient adaptation
    driver.configure_stealthchop(
        36,   // pwm_ofs (default)
        14,   // pwm_grad (default)
        true, // autoscale enabled (recommended)
        true, // autograd enabled (recommended)
    )?;

    // =========================================================================
    // Velocity-Based Mode Switching
    // =========================================================================

    // Set StealthChop/SpreadCycle velocity threshold (TPWMTHRS)
    // Below this TSTEP value, StealthChop is used
    // Above this velocity (lower TSTEP), SpreadCycle is used
    driver.set_stealthchop_threshold(500)?;

    // =========================================================================
    // Chopper Configuration
    // =========================================================================

    // Fine-tune chopper parameters for your motor
    driver.configure_chopper(
        3, // toff
        4, // hstrt
        1, // hend
        2, // tbl
    )?;

    // =========================================================================
    // Current Sense Configuration
    // =========================================================================

    // For high-current motors, use low sensitivity VSENSE
    driver.set_vsense(false)?;

    // Enable the driver
    driver.set_enabled(true)?;

    // =========================================================================
    // Monitor StealthChop Status
    // =========================================================================

    // Start moving
    driver.set_velocity(1000)?;

    // Check if StealthChop or SpreadCycle is active
    let _is_stealth = driver.is_stealthchop_active()?;

    // Check actual current being used
    let _actual_cs = driver.actual_current_scale()?;

    Ok(())
}

pub fn enable_spreadcycle(&mut self) -> Result<(), Error<E>>

Enable SpreadCycle mode.

Examples found in repository

examples/sensorless_homing.rs (line 41)

fn sensorless_homing<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // =========================================================================
    // Step 1: Basic Configuration
    // =========================================================================

    // Set appropriate current for homing (usually lower than running current)
    driver.set_current(12, 6, 4)?;

    // Use lower microstep resolution for more reliable stall detection
    driver.set_microsteps(MicrostepResolution::M16)?;

    // =========================================================================
    // Step 2: Configure StallGuard
    // =========================================================================

    // CRITICAL: Use SpreadCycle mode for StallGuard
    driver.enable_spreadcycle()?;

    // Configure stall detection
    driver.configure_stall_detection(50)?;

    // Set TCOOLTHRS - StallGuard is only active when TSTEP < TCOOLTHRS
    driver.set_coolstep_threshold(0xFFFFF)?;

    driver.set_enabled(true)?;

    // =========================================================================
    // Step 3: Perform Homing
    // =========================================================================

    // Move towards the endstop
    let homing_velocity = -2000i32;
    driver.set_velocity(homing_velocity)?;

    // Poll for stall detection
    let max_iterations = 10000u32;

    for _ in 0..max_iterations {
        if driver.is_stalled()? {
            break;
        }
        // Add platform-specific delay here
    }

    // Stop the motor immediately
    driver.stop()?;

    // =========================================================================
    // Step 4: Post-Homing Configuration
    // =========================================================================

    // Switch back to StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Restore normal running current
    driver.set_current(20, 10, 6)?;

    Ok(())
}

/// Alternative: Home in both directions to find center.
#[cfg(feature = "blocking")]
fn home_to_center<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Configure for homing
    driver.set_current(12, 6, 4)?;
    driver.enable_spreadcycle()?;
    driver.configure_stall_detection(50)?;
    driver.set_coolstep_threshold(0xFFFFF)?;
    driver.set_enabled(true)?;

    // Home to minimum position
    driver.set_velocity(-2000)?;
    while !driver.is_stalled()? {
        // Wait or add timeout
    }
    driver.stop()?;
    let _min_position = 0i32;

    // Home to maximum position
    driver.set_velocity(2000)?;
    let mut step_count = 0i32;
    while !driver.is_stalled()? {
        step_count += 1;
    }
    driver.stop()?;
    let max_position = step_count;

    // Move to center
    let _center = max_position / 2;
    driver.set_velocity(-2000)?;
    // Move for half the counted steps
    driver.stop()?;

    Ok(())
}

pub fn is_standstill(&mut self) -> Result<bool, Error<E>>

Check if motor is in standstill.

pub fn is_overtemperature_warning(&mut self) -> Result<bool, Error<E>>

Check if overtemperature warning is active.

pub fn is_overtemperature_shutdown(&mut self) -> Result<bool, Error<E>>

Check if overtemperature shutdown is active.

pub fn enable_coolstep(&mut self, semin: u8, semax: u8) -> Result<(), Error<E>>

Enable CoolStep adaptive current control.

CoolStep automatically reduces motor current when load is low, saving power and reducing heat.

Arguments

• semin - Minimum StallGuard value for current increase (1-15, 0 disables)
• semax - Hysteresis for current decrease (0-15)

Example

// Enable CoolStep with moderate sensitivity
driver.enable_coolstep(4, 2)?;

pub fn disable_coolstep(&mut self) -> Result<(), Error<E>>

Disable CoolStep.

pub fn set_coolstep_threshold(&mut self, threshold: u32) -> Result<(), Error<E>>

Set the CoolStep velocity threshold (TCOOLTHRS).

CoolStep and StallGuard are only active when TSTEP < TCOOLTHRS. Below this velocity, CoolStep and stall detection are disabled.

Arguments

• threshold - TSTEP threshold value (0 = disabled, 0xFFFFF = always active)

Examples found in repository

examples/sensorless_homing.rs (line 47)

fn sensorless_homing<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // =========================================================================
    // Step 1: Basic Configuration
    // =========================================================================

    // Set appropriate current for homing (usually lower than running current)
    driver.set_current(12, 6, 4)?;

    // Use lower microstep resolution for more reliable stall detection
    driver.set_microsteps(MicrostepResolution::M16)?;

    // =========================================================================
    // Step 2: Configure StallGuard
    // =========================================================================

    // CRITICAL: Use SpreadCycle mode for StallGuard
    driver.enable_spreadcycle()?;

    // Configure stall detection
    driver.configure_stall_detection(50)?;

    // Set TCOOLTHRS - StallGuard is only active when TSTEP < TCOOLTHRS
    driver.set_coolstep_threshold(0xFFFFF)?;

    driver.set_enabled(true)?;

    // =========================================================================
    // Step 3: Perform Homing
    // =========================================================================

    // Move towards the endstop
    let homing_velocity = -2000i32;
    driver.set_velocity(homing_velocity)?;

    // Poll for stall detection
    let max_iterations = 10000u32;

    for _ in 0..max_iterations {
        if driver.is_stalled()? {
            break;
        }
        // Add platform-specific delay here
    }

    // Stop the motor immediately
    driver.stop()?;

    // =========================================================================
    // Step 4: Post-Homing Configuration
    // =========================================================================

    // Switch back to StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Restore normal running current
    driver.set_current(20, 10, 6)?;

    Ok(())
}

/// Alternative: Home in both directions to find center.
#[cfg(feature = "blocking")]
fn home_to_center<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Configure for homing
    driver.set_current(12, 6, 4)?;
    driver.enable_spreadcycle()?;
    driver.configure_stall_detection(50)?;
    driver.set_coolstep_threshold(0xFFFFF)?;
    driver.set_enabled(true)?;

    // Home to minimum position
    driver.set_velocity(-2000)?;
    while !driver.is_stalled()? {
        // Wait or add timeout
    }
    driver.stop()?;
    let _min_position = 0i32;

    // Home to maximum position
    driver.set_velocity(2000)?;
    let mut step_count = 0i32;
    while !driver.is_stalled()? {
        step_count += 1;
    }
    driver.stop()?;
    let max_position = step_count;

    // Move to center
    let _center = max_position / 2;
    driver.set_velocity(-2000)?;
    // Move for half the counted steps
    driver.stop()?;

    Ok(())
}

pub fn set_stealthchop_threshold( &mut self, threshold: u32, ) -> Result<(), Error<E>>

Set the StealthChop velocity threshold (TPWMTHRS).

Above this velocity, the driver switches from StealthChop to SpreadCycle.

Arguments

• threshold - TSTEP threshold value (0 = only SpreadCycle, 0xFFFFF = only StealthChop)

Examples found in repository

examples/stealthchop.rs (line 48)

fn configure_stealthchop<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Basic setup
    driver.set_current(16, 8, 4)?;
    driver.set_microsteps(MicrostepResolution::M256)?;

    // =========================================================================
    // StealthChop Configuration
    // =========================================================================

    // Enable StealthChop mode (this is the default)
    driver.enable_stealthchop()?;

    // Configure StealthChop PWM parameters
    // - pwm_ofs: Base PWM amplitude (0-255)
    // - pwm_grad: PWM amplitude gradient (0-255)
    // - autoscale: Enable automatic current scaling
    // - autograd: Enable automatic gradient adaptation
    driver.configure_stealthchop(
        36,   // pwm_ofs (default)
        14,   // pwm_grad (default)
        true, // autoscale enabled (recommended)
        true, // autograd enabled (recommended)
    )?;

    // =========================================================================
    // Velocity-Based Mode Switching
    // =========================================================================

    // Set StealthChop/SpreadCycle velocity threshold (TPWMTHRS)
    // Below this TSTEP value, StealthChop is used
    // Above this velocity (lower TSTEP), SpreadCycle is used
    driver.set_stealthchop_threshold(500)?;

    // =========================================================================
    // Chopper Configuration
    // =========================================================================

    // Fine-tune chopper parameters for your motor
    driver.configure_chopper(
        3, // toff
        4, // hstrt
        1, // hend
        2, // tbl
    )?;

    // =========================================================================
    // Current Sense Configuration
    // =========================================================================

    // For high-current motors, use low sensitivity VSENSE
    driver.set_vsense(false)?;

    // Enable the driver
    driver.set_enabled(true)?;

    // =========================================================================
    // Monitor StealthChop Status
    // =========================================================================

    // Start moving
    driver.set_velocity(1000)?;

    // Check if StealthChop or SpreadCycle is active
    let _is_stealth = driver.is_stealthchop_active()?;

    // Check actual current being used
    let _actual_cs = driver.actual_current_scale()?;

    Ok(())
}

pub fn configure_stall_detection( &mut self, threshold: u8, ) -> Result<(), Error<E>>

Configure stall detection for sensorless homing.

This sets up the StallGuard feature to detect when the motor hits an endstop or obstacle.

Arguments

• threshold - StallGuard threshold (0-255, higher = more sensitive)

Note

For sensorless homing to work properly:

• Use SpreadCycle mode (not StealthChop)
• Set appropriate TCOOLTHRS (stall detection only works above this velocity)
• Move at a consistent, moderate speed

Example

// Configure for sensorless homing
driver.configure_stall_detection(50)?;
driver.enable_spreadcycle()?;
driver.set_coolstep_threshold(0)?; // Enable at all velocities

// Move towards endstop
driver.set_velocity(-1000)?;

// Poll for stall
loop {
    if driver.is_stalled()? {
        driver.stop()?;
        break;
    }
}

Examples found in repository

examples/sensorless_homing.rs (line 44)

fn sensorless_homing<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // =========================================================================
    // Step 1: Basic Configuration
    // =========================================================================

    // Set appropriate current for homing (usually lower than running current)
    driver.set_current(12, 6, 4)?;

    // Use lower microstep resolution for more reliable stall detection
    driver.set_microsteps(MicrostepResolution::M16)?;

    // =========================================================================
    // Step 2: Configure StallGuard
    // =========================================================================

    // CRITICAL: Use SpreadCycle mode for StallGuard
    driver.enable_spreadcycle()?;

    // Configure stall detection
    driver.configure_stall_detection(50)?;

    // Set TCOOLTHRS - StallGuard is only active when TSTEP < TCOOLTHRS
    driver.set_coolstep_threshold(0xFFFFF)?;

    driver.set_enabled(true)?;

    // =========================================================================
    // Step 3: Perform Homing
    // =========================================================================

    // Move towards the endstop
    let homing_velocity = -2000i32;
    driver.set_velocity(homing_velocity)?;

    // Poll for stall detection
    let max_iterations = 10000u32;

    for _ in 0..max_iterations {
        if driver.is_stalled()? {
            break;
        }
        // Add platform-specific delay here
    }

    // Stop the motor immediately
    driver.stop()?;

    // =========================================================================
    // Step 4: Post-Homing Configuration
    // =========================================================================

    // Switch back to StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Restore normal running current
    driver.set_current(20, 10, 6)?;

    Ok(())
}

/// Alternative: Home in both directions to find center.
#[cfg(feature = "blocking")]
fn home_to_center<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Configure for homing
    driver.set_current(12, 6, 4)?;
    driver.enable_spreadcycle()?;
    driver.configure_stall_detection(50)?;
    driver.set_coolstep_threshold(0xFFFFF)?;
    driver.set_enabled(true)?;

    // Home to minimum position
    driver.set_velocity(-2000)?;
    while !driver.is_stalled()? {
        // Wait or add timeout
    }
    driver.stop()?;
    let _min_position = 0i32;

    // Home to maximum position
    driver.set_velocity(2000)?;
    let mut step_count = 0i32;
    while !driver.is_stalled()? {
        step_count += 1;
    }
    driver.stop()?;
    let max_position = step_count;

    // Move to center
    let _center = max_position / 2;
    driver.set_velocity(-2000)?;
    // Move for half the counted steps
    driver.stop()?;

    Ok(())
}

pub fn is_stalled(&mut self) -> Result<bool, Error<E>>

Check if the motor is currently stalled.

Returns true if the StallGuard result is below the threshold. Only valid when motor is moving and TSTEP < TCOOLTHRS.

Examples found in repository

examples/sensorless_homing.rs (line 63)

fn sensorless_homing<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // =========================================================================
    // Step 1: Basic Configuration
    // =========================================================================

    // Set appropriate current for homing (usually lower than running current)
    driver.set_current(12, 6, 4)?;

    // Use lower microstep resolution for more reliable stall detection
    driver.set_microsteps(MicrostepResolution::M16)?;

    // =========================================================================
    // Step 2: Configure StallGuard
    // =========================================================================

    // CRITICAL: Use SpreadCycle mode for StallGuard
    driver.enable_spreadcycle()?;

    // Configure stall detection
    driver.configure_stall_detection(50)?;

    // Set TCOOLTHRS - StallGuard is only active when TSTEP < TCOOLTHRS
    driver.set_coolstep_threshold(0xFFFFF)?;

    driver.set_enabled(true)?;

    // =========================================================================
    // Step 3: Perform Homing
    // =========================================================================

    // Move towards the endstop
    let homing_velocity = -2000i32;
    driver.set_velocity(homing_velocity)?;

    // Poll for stall detection
    let max_iterations = 10000u32;

    for _ in 0..max_iterations {
        if driver.is_stalled()? {
            break;
        }
        // Add platform-specific delay here
    }

    // Stop the motor immediately
    driver.stop()?;

    // =========================================================================
    // Step 4: Post-Homing Configuration
    // =========================================================================

    // Switch back to StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Restore normal running current
    driver.set_current(20, 10, 6)?;

    Ok(())
}

/// Alternative: Home in both directions to find center.
#[cfg(feature = "blocking")]
fn home_to_center<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Configure for homing
    driver.set_current(12, 6, 4)?;
    driver.enable_spreadcycle()?;
    driver.configure_stall_detection(50)?;
    driver.set_coolstep_threshold(0xFFFFF)?;
    driver.set_enabled(true)?;

    // Home to minimum position
    driver.set_velocity(-2000)?;
    while !driver.is_stalled()? {
        // Wait or add timeout
    }
    driver.stop()?;
    let _min_position = 0i32;

    // Home to maximum position
    driver.set_velocity(2000)?;
    let mut step_count = 0i32;
    while !driver.is_stalled()? {
        step_count += 1;
    }
    driver.stop()?;
    let max_position = step_count;

    // Move to center
    let _center = max_position / 2;
    driver.set_velocity(-2000)?;
    // Move for half the counted steps
    driver.stop()?;

    Ok(())
}

pub fn load_indicator(&mut self) -> Result<u16, Error<E>>

Get the current load indicator from StallGuard.

Returns a value from 0 (high load/stall) to 510 (no load). Useful for load monitoring and stall detection tuning.

pub fn configure_stealthchop( &mut self, pwm_ofs: u8, pwm_grad: u8, autoscale: bool, autograd: bool, ) -> Result<(), Error<E>>

Configure StealthChop PWM settings.

Arguments

• pwm_ofs - PWM amplitude offset (0-255)
• pwm_grad - PWM amplitude gradient (0-255)
• autoscale - Enable automatic current scaling
• autograd - Enable automatic gradient adaptation

Examples found in repository

examples/stealthchop.rs (lines 34-39)

fn configure_stealthchop<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Basic setup
    driver.set_current(16, 8, 4)?;
    driver.set_microsteps(MicrostepResolution::M256)?;

    // =========================================================================
    // StealthChop Configuration
    // =========================================================================

    // Enable StealthChop mode (this is the default)
    driver.enable_stealthchop()?;

    // Configure StealthChop PWM parameters
    // - pwm_ofs: Base PWM amplitude (0-255)
    // - pwm_grad: PWM amplitude gradient (0-255)
    // - autoscale: Enable automatic current scaling
    // - autograd: Enable automatic gradient adaptation
    driver.configure_stealthchop(
        36,   // pwm_ofs (default)
        14,   // pwm_grad (default)
        true, // autoscale enabled (recommended)
        true, // autograd enabled (recommended)
    )?;

    // =========================================================================
    // Velocity-Based Mode Switching
    // =========================================================================

    // Set StealthChop/SpreadCycle velocity threshold (TPWMTHRS)
    // Below this TSTEP value, StealthChop is used
    // Above this velocity (lower TSTEP), SpreadCycle is used
    driver.set_stealthchop_threshold(500)?;

    // =========================================================================
    // Chopper Configuration
    // =========================================================================

    // Fine-tune chopper parameters for your motor
    driver.configure_chopper(
        3, // toff
        4, // hstrt
        1, // hend
        2, // tbl
    )?;

    // =========================================================================
    // Current Sense Configuration
    // =========================================================================

    // For high-current motors, use low sensitivity VSENSE
    driver.set_vsense(false)?;

    // Enable the driver
    driver.set_enabled(true)?;

    // =========================================================================
    // Monitor StealthChop Status
    // =========================================================================

    // Start moving
    driver.set_velocity(1000)?;

    // Check if StealthChop or SpreadCycle is active
    let _is_stealth = driver.is_stealthchop_active()?;

    // Check actual current being used
    let _actual_cs = driver.actual_current_scale()?;

    Ok(())
}

pub fn set_vsense(&mut self, high_sensitivity: bool) -> Result<(), Error<E>>

Set VSENSE for current sense resistor scaling.

Arguments

• high_sensitivity - true for high sensitivity (low current range), false for low sensitivity (high current range)

Examples found in repository

examples/stealthchop.rs (line 67)

fn configure_stealthchop<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Basic setup
    driver.set_current(16, 8, 4)?;
    driver.set_microsteps(MicrostepResolution::M256)?;

    // =========================================================================
    // StealthChop Configuration
    // =========================================================================

    // Enable StealthChop mode (this is the default)
    driver.enable_stealthchop()?;

    // Configure StealthChop PWM parameters
    // - pwm_ofs: Base PWM amplitude (0-255)
    // - pwm_grad: PWM amplitude gradient (0-255)
    // - autoscale: Enable automatic current scaling
    // - autograd: Enable automatic gradient adaptation
    driver.configure_stealthchop(
        36,   // pwm_ofs (default)
        14,   // pwm_grad (default)
        true, // autoscale enabled (recommended)
        true, // autograd enabled (recommended)
    )?;

    // =========================================================================
    // Velocity-Based Mode Switching
    // =========================================================================

    // Set StealthChop/SpreadCycle velocity threshold (TPWMTHRS)
    // Below this TSTEP value, StealthChop is used
    // Above this velocity (lower TSTEP), SpreadCycle is used
    driver.set_stealthchop_threshold(500)?;

    // =========================================================================
    // Chopper Configuration
    // =========================================================================

    // Fine-tune chopper parameters for your motor
    driver.configure_chopper(
        3, // toff
        4, // hstrt
        1, // hend
        2, // tbl
    )?;

    // =========================================================================
    // Current Sense Configuration
    // =========================================================================

    // For high-current motors, use low sensitivity VSENSE
    driver.set_vsense(false)?;

    // Enable the driver
    driver.set_enabled(true)?;

    // =========================================================================
    // Monitor StealthChop Status
    // =========================================================================

    // Start moving
    driver.set_velocity(1000)?;

    // Check if StealthChop or SpreadCycle is active
    let _is_stealth = driver.is_stealthchop_active()?;

    // Check actual current being used
    let _actual_cs = driver.actual_current_scale()?;

    Ok(())
}

pub fn configure_chopper( &mut self, toff: u8, hstrt: u8, hend: u8, tbl: u8, ) -> Result<(), Error<E>>

Configure chopper settings for optimal performance.

Arguments

• toff - Off-time (1-15, 0 disables driver)
• hstrt - Hysteresis start (0-7)
• hend - Hysteresis end (0-15)
• tbl - Comparator blank time (0-3)

Examples found in repository

examples/stealthchop.rs (lines 55-60)

fn configure_stealthchop<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Basic setup
    driver.set_current(16, 8, 4)?;
    driver.set_microsteps(MicrostepResolution::M256)?;

    // =========================================================================
    // StealthChop Configuration
    // =========================================================================

    // Enable StealthChop mode (this is the default)
    driver.enable_stealthchop()?;

    // Configure StealthChop PWM parameters
    // - pwm_ofs: Base PWM amplitude (0-255)
    // - pwm_grad: PWM amplitude gradient (0-255)
    // - autoscale: Enable automatic current scaling
    // - autograd: Enable automatic gradient adaptation
    driver.configure_stealthchop(
        36,   // pwm_ofs (default)
        14,   // pwm_grad (default)
        true, // autoscale enabled (recommended)
        true, // autograd enabled (recommended)
    )?;

    // =========================================================================
    // Velocity-Based Mode Switching
    // =========================================================================

    // Set StealthChop/SpreadCycle velocity threshold (TPWMTHRS)
    // Below this TSTEP value, StealthChop is used
    // Above this velocity (lower TSTEP), SpreadCycle is used
    driver.set_stealthchop_threshold(500)?;

    // =========================================================================
    // Chopper Configuration
    // =========================================================================

    // Fine-tune chopper parameters for your motor
    driver.configure_chopper(
        3, // toff
        4, // hstrt
        1, // hend
        2, // tbl
    )?;

    // =========================================================================
    // Current Sense Configuration
    // =========================================================================

    // For high-current motors, use low sensitivity VSENSE
    driver.set_vsense(false)?;

    // Enable the driver
    driver.set_enabled(true)?;

    // =========================================================================
    // Monitor StealthChop Status
    // =========================================================================

    // Start moving
    driver.set_velocity(1000)?;

    // Check if StealthChop or SpreadCycle is active
    let _is_stealth = driver.is_stealthchop_active()?;

    // Check actual current being used
    let _actual_cs = driver.actual_current_scale()?;

    Ok(())
}

pub fn set_interpolation(&mut self, enabled: bool) -> Result<(), Error<E>>

Enable interpolation to 256 microsteps.

When enabled, the driver interpolates between microsteps for smoother motion, even at lower microstep settings.

Examples found in repository

examples/basic.rs (line 42)

fn basic_motor_control<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    // Create driver with slave address 0
    let mut driver = Tmc2209::new(uart, 0);

    // Check if the driver is responding
    if !driver.is_connected() {
        // Handle connection error
        return Err(tmc2209_uart::Error::NoResponse);
    }

    // Clear any previous errors
    driver.clear_gstat()?;

    // Configure motor current
    // IRUN=20 (run current), IHOLD=10 (hold current), IHOLDDELAY=6
    driver.set_current(20, 10, 6)?;

    // Set microstep resolution to 16 with interpolation to 256
    driver.set_microsteps(MicrostepResolution::M16)?;
    driver.set_interpolation(true)?;

    // Enable StealthChop for quiet operation
    driver.enable_stealthchop()?;

    // Enable the driver
    driver.set_enabled(true)?;

    // Start moving the motor forward
    driver.set_velocity(5000)?;

    // Check status
    let status = driver.drv_status()?;

    if status.ot() {
        // Overtemperature shutdown - stop immediately!
        driver.stop()?;
        driver.set_enabled(false)?;
    }

    if status.otpw() {
        // Overtemperature warning - reduce current or add cooling
        println!("Warning: Motor temperature is high");
    }

    // Reverse direction
    driver.set_velocity(-5000)?;

    // Stop the motor
    driver.stop()?;

    Ok(())
}

pub fn actual_current_scale(&mut self) -> Result<u8, Error<E>>

Read the actual motor current scale being used.

This reflects CoolStep adjustments if enabled. Returns a value from 0-31.

Examples found in repository

examples/stealthchop.rs (line 83)

fn configure_stealthchop<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Basic setup
    driver.set_current(16, 8, 4)?;
    driver.set_microsteps(MicrostepResolution::M256)?;

    // =========================================================================
    // StealthChop Configuration
    // =========================================================================

    // Enable StealthChop mode (this is the default)
    driver.enable_stealthchop()?;

    // Configure StealthChop PWM parameters
    // - pwm_ofs: Base PWM amplitude (0-255)
    // - pwm_grad: PWM amplitude gradient (0-255)
    // - autoscale: Enable automatic current scaling
    // - autograd: Enable automatic gradient adaptation
    driver.configure_stealthchop(
        36,   // pwm_ofs (default)
        14,   // pwm_grad (default)
        true, // autoscale enabled (recommended)
        true, // autograd enabled (recommended)
    )?;

    // =========================================================================
    // Velocity-Based Mode Switching
    // =========================================================================

    // Set StealthChop/SpreadCycle velocity threshold (TPWMTHRS)
    // Below this TSTEP value, StealthChop is used
    // Above this velocity (lower TSTEP), SpreadCycle is used
    driver.set_stealthchop_threshold(500)?;

    // =========================================================================
    // Chopper Configuration
    // =========================================================================

    // Fine-tune chopper parameters for your motor
    driver.configure_chopper(
        3, // toff
        4, // hstrt
        1, // hend
        2, // tbl
    )?;

    // =========================================================================
    // Current Sense Configuration
    // =========================================================================

    // For high-current motors, use low sensitivity VSENSE
    driver.set_vsense(false)?;

    // Enable the driver
    driver.set_enabled(true)?;

    // =========================================================================
    // Monitor StealthChop Status
    // =========================================================================

    // Start moving
    driver.set_velocity(1000)?;

    // Check if StealthChop or SpreadCycle is active
    let _is_stealth = driver.is_stealthchop_active()?;

    // Check actual current being used
    let _actual_cs = driver.actual_current_scale()?;

    Ok(())
}

pub fn is_stealthchop_active(&mut self) -> Result<bool, Error<E>>

Check if the driver is currently in StealthChop mode.

Examples found in repository

examples/stealthchop.rs (line 80)

fn configure_stealthchop<U, E>(uart: U) -> Result<(), tmc2209_uart::Error<E>>
where
    U: embedded_io::Read<Error = E> + embedded_io::Write<Error = E>,
{
    let mut driver = Tmc2209::new(uart, 0);

    // Basic setup
    driver.set_current(16, 8, 4)?;
    driver.set_microsteps(MicrostepResolution::M256)?;

    // =========================================================================
    // StealthChop Configuration
    // =========================================================================

    // Enable StealthChop mode (this is the default)
    driver.enable_stealthchop()?;

    // Configure StealthChop PWM parameters
    // - pwm_ofs: Base PWM amplitude (0-255)
    // - pwm_grad: PWM amplitude gradient (0-255)
    // - autoscale: Enable automatic current scaling
    // - autograd: Enable automatic gradient adaptation
    driver.configure_stealthchop(
        36,   // pwm_ofs (default)
        14,   // pwm_grad (default)
        true, // autoscale enabled (recommended)
        true, // autograd enabled (recommended)
    )?;

    // =========================================================================
    // Velocity-Based Mode Switching
    // =========================================================================

    // Set StealthChop/SpreadCycle velocity threshold (TPWMTHRS)
    // Below this TSTEP value, StealthChop is used
    // Above this velocity (lower TSTEP), SpreadCycle is used
    driver.set_stealthchop_threshold(500)?;

    // =========================================================================
    // Chopper Configuration
    // =========================================================================

    // Fine-tune chopper parameters for your motor
    driver.configure_chopper(
        3, // toff
        4, // hstrt
        1, // hend
        2, // tbl
    )?;

    // =========================================================================
    // Current Sense Configuration
    // =========================================================================

    // For high-current motors, use low sensitivity VSENSE
    driver.set_vsense(false)?;

    // Enable the driver
    driver.set_enabled(true)?;

    // =========================================================================
    // Monitor StealthChop Status
    // =========================================================================

    // Start moving
    driver.set_velocity(1000)?;

    // Check if StealthChop or SpreadCycle is active
    let _is_stealth = driver.is_stealthchop_active()?;

    // Check actual current being used
    let _actual_cs = driver.actual_current_scale()?;

    Ok(())
}

pub fn status_summary(&mut self) -> Result<(bool, bool, bool), Error<E>>

Get a comprehensive status summary.

Returns a tuple of (errors_present, warnings_present, is_running).

impl<U, E> Tmc2209<U>

where U: Read<Error = E> + Write<Error = E>,

pub async fn read_register_async<R: ReadableRegister>( &mut self, ) -> Result<R, Error<E>>

Read a register (async).

Sends a read request and waits for the response.

pub async fn write_register_async<R: WritableRegister>( &mut self, reg: &R, ) -> Result<(), Error<E>>

Write a register (async).

Sends a write request to update a register value.

pub async fn read_raw_async(&mut self, reg_addr: u8) -> Result<u32, Error<E>>

Read a register by raw address (async).

pub async fn write_raw_async( &mut self, reg_addr: u8, data: u32, ) -> Result<(), Error<E>>

Write a register by raw address (async).

pub async fn is_connected_async(&mut self) -> bool

Check if the driver is communicating properly (async).

pub async fn ifcnt_async(&mut self) -> Result<u8, Error<E>>

Get the interface transmission counter (async).

pub async fn drv_status_async(&mut self) -> Result<DrvStatus, Error<E>>

Get the driver status (async).

pub async fn set_current_async( &mut self, run_current: u8, hold_current: u8, hold_delay: u8, ) -> Result<(), Error<E>>

Set the motor currents (async).

pub async fn set_microsteps_async( &mut self, resolution: MicrostepResolution, ) -> Result<(), Error<E>>

Set the microstep resolution (async).

pub async fn set_velocity_async( &mut self, velocity: i32, ) -> Result<(), Error<E>>

Set velocity for internal motion controller (async).

pub async fn stop_async(&mut self) -> Result<(), Error<E>>

Stop the motor (async).

pub async fn enable_coolstep_async( &mut self, semin: u8, semax: u8, ) -> Result<(), Error<E>>

Enable CoolStep adaptive current control (async).

pub async fn disable_coolstep_async(&mut self) -> Result<(), Error<E>>

Disable CoolStep (async).

pub async fn set_coolstep_threshold_async( &mut self, threshold: u32, ) -> Result<(), Error<E>>

Set the CoolStep velocity threshold (async).

pub async fn set_stealthchop_threshold_async( &mut self, threshold: u32, ) -> Result<(), Error<E>>

Set the StealthChop velocity threshold (async).

pub async fn configure_stall_detection_async( &mut self, threshold: u8, ) -> Result<(), Error<E>>

Configure stall detection for sensorless homing (async).

pub async fn is_stalled_async(&mut self) -> Result<bool, Error<E>>

Check if the motor is currently stalled (async).

pub async fn load_indicator_async(&mut self) -> Result<u16, Error<E>>

Get the current load indicator from StallGuard (async).

pub async fn enable_stealthchop_async(&mut self) -> Result<(), Error<E>>

Enable StealthChop mode (async).

pub async fn enable_spreadcycle_async(&mut self) -> Result<(), Error<E>>

Enable SpreadCycle mode (async).

pub async fn set_enabled_async(&mut self, enabled: bool) -> Result<(), Error<E>>

Enable or disable the driver (async).

pub async fn is_standstill_async(&mut self) -> Result<bool, Error<E>>

Check if motor is in standstill (async).