Struct TipController 

pub struct TipController { /* private fields */ }

Enhanced tip controller with pulse voltage stepping

Implementations

impl TipController

pub fn new( driver: ActionDriver, signal_index: SignalIndex, pulse_voltage: f32, bound: (f32, f32), ) -> Self

Create new tip controller with basic signal bounds

Examples found in repository

examples/tip_prep_demo.rs (line 23)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    // Create ActionDriver
    let driver = ActionDriver::new("127.0.0.1", 6501)?;

    // Create controller with custom pulse stepping parameters
    let mut custom_controller = TipController::new(driver, SignalIndex(76), 2.0, (-2.0, 0.0));

    let file_path = create_log_file_path()?;
    println!("{file_path:?}");

    // Configure custom pulse stepping parameters with dynamic threshold
    custom_controller
        //.set_pulse_stepping(1.5, Box::new(|signal| signal.abs() / 10.0), 4, 8.0)
        .set_pulse_stepping_fixed(1.5, 2.0, 4, 10.0)
        .set_stability_threshold(5)
        .with_logger(Logger::new(file_path, 5));

    // Create atomic flag for graceful shutdown
    let running = Arc::new(AtomicBool::new(true));
    let running_clone = Arc::clone(&running);

    // Wrap controller in Arc<Mutex<>> for signal handler
    let controller = Arc::new(Mutex::new(custom_controller));
    let controller_clone = Arc::clone(&controller);

    // Set up Ctrl-C handler to flush logger and signal stop
    ctrlc::set_handler(move || {
        info!("Received Ctrl-C, signaling stop and flushing logger...");
        running_clone.store(false, Ordering::SeqCst);

        if let Ok(mut ctrl) = controller_clone.lock() {
            // Force flush the logger
            match ctrl.flush_logger() {
                Ok(()) => info!("Logger flushed successfully on exit"),
                Err(e) => info!("Failed to flush logger on exit: {}", e),
            }
        }
    })?;

    // Run control loop with periodic checks for the stop signal
    let result: Result<(), Box<dyn std::error::Error>> = {
        let mut ctrl = controller.lock().unwrap();

        // Run in shorter intervals so we can check the stop signal
        let mut total_elapsed = Duration::from_secs(0);
        let max_duration = Duration::from_secs(1000);
        let check_interval = Duration::from_secs(5);

        while total_elapsed < max_duration && running.load(Ordering::SeqCst) {
            let remaining = max_duration - total_elapsed;
            let run_duration = check_interval.min(remaining);

            match ctrl.run(run_duration) {
                Ok(final_state) => {
                    info!("Controller finished with state: {:?}", final_state);
                    break;
                }
                Err(e) if e.to_string().contains("Loop timeout") => {
                    // Expected timeout, continue if still running
                    total_elapsed += run_duration;
                    if !running.load(Ordering::SeqCst) {
                        info!("Stop signal received, exiting gracefully");
                        break;
                    }
                }
                Err(e) => {
                    info!("Controller failed: {}", e);
                    break;
                }
            }
        }

        Ok(())
    };

    match result {
        Ok(()) => {
            info!("Controller loop completed");
        }
        Err(e) => {
            info!("Controller loop failed: {}", e);
        }
    }

    Ok(())
}

pub fn set_pulse_stepping( &mut self, pulse_step: f32, change_threshold: Box<dyn Fn(f32) -> f32 + Send + Sync>, cycles_before_step: u32, max_pulse: f32, ) -> &mut Self

Set pulse stepping parameters with closure-based threshold

pub fn set_pulse_stepping_fixed( &mut self, pulse_step: f32, change_threshold: f32, cycles_before_step: u32, max_pulse: f32, ) -> &mut Self

Set pulse stepping parameters with fixed threshold (convenience method)

Examples found in repository

examples/tip_prep_demo.rs (line 31)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    // Create ActionDriver
    let driver = ActionDriver::new("127.0.0.1", 6501)?;

    // Create controller with custom pulse stepping parameters
    let mut custom_controller = TipController::new(driver, SignalIndex(76), 2.0, (-2.0, 0.0));

    let file_path = create_log_file_path()?;
    println!("{file_path:?}");

    // Configure custom pulse stepping parameters with dynamic threshold
    custom_controller
        //.set_pulse_stepping(1.5, Box::new(|signal| signal.abs() / 10.0), 4, 8.0)
        .set_pulse_stepping_fixed(1.5, 2.0, 4, 10.0)
        .set_stability_threshold(5)
        .with_logger(Logger::new(file_path, 5));

    // Create atomic flag for graceful shutdown
    let running = Arc::new(AtomicBool::new(true));
    let running_clone = Arc::clone(&running);

    // Wrap controller in Arc<Mutex<>> for signal handler
    let controller = Arc::new(Mutex::new(custom_controller));
    let controller_clone = Arc::clone(&controller);

    // Set up Ctrl-C handler to flush logger and signal stop
    ctrlc::set_handler(move || {
        info!("Received Ctrl-C, signaling stop and flushing logger...");
        running_clone.store(false, Ordering::SeqCst);

        if let Ok(mut ctrl) = controller_clone.lock() {
            // Force flush the logger
            match ctrl.flush_logger() {
                Ok(()) => info!("Logger flushed successfully on exit"),
                Err(e) => info!("Failed to flush logger on exit: {}", e),
            }
        }
    })?;

    // Run control loop with periodic checks for the stop signal
    let result: Result<(), Box<dyn std::error::Error>> = {
        let mut ctrl = controller.lock().unwrap();

        // Run in shorter intervals so we can check the stop signal
        let mut total_elapsed = Duration::from_secs(0);
        let max_duration = Duration::from_secs(1000);
        let check_interval = Duration::from_secs(5);

        while total_elapsed < max_duration && running.load(Ordering::SeqCst) {
            let remaining = max_duration - total_elapsed;
            let run_duration = check_interval.min(remaining);

            match ctrl.run(run_duration) {
                Ok(final_state) => {
                    info!("Controller finished with state: {:?}", final_state);
                    break;
                }
                Err(e) if e.to_string().contains("Loop timeout") => {
                    // Expected timeout, continue if still running
                    total_elapsed += run_duration;
                    if !running.load(Ordering::SeqCst) {
                        info!("Stop signal received, exiting gracefully");
                        break;
                    }
                }
                Err(e) => {
                    info!("Controller failed: {}", e);
                    break;
                }
            }
        }

        Ok(())
    };

    match result {
        Ok(()) => {
            info!("Controller loop completed");
        }
        Err(e) => {
            info!("Controller loop failed: {}", e);
        }
    }

    Ok(())
}

pub fn with_logger(&mut self, logger: Logger<LogLine>) -> &mut Self

Provide Json File logger for inspecting behavior

Examples found in repository

examples/tip_prep_demo.rs (line 33)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    // Create ActionDriver
    let driver = ActionDriver::new("127.0.0.1", 6501)?;

    // Create controller with custom pulse stepping parameters
    let mut custom_controller = TipController::new(driver, SignalIndex(76), 2.0, (-2.0, 0.0));

    let file_path = create_log_file_path()?;
    println!("{file_path:?}");

    // Configure custom pulse stepping parameters with dynamic threshold
    custom_controller
        //.set_pulse_stepping(1.5, Box::new(|signal| signal.abs() / 10.0), 4, 8.0)
        .set_pulse_stepping_fixed(1.5, 2.0, 4, 10.0)
        .set_stability_threshold(5)
        .with_logger(Logger::new(file_path, 5));

    // Create atomic flag for graceful shutdown
    let running = Arc::new(AtomicBool::new(true));
    let running_clone = Arc::clone(&running);

    // Wrap controller in Arc<Mutex<>> for signal handler
    let controller = Arc::new(Mutex::new(custom_controller));
    let controller_clone = Arc::clone(&controller);

    // Set up Ctrl-C handler to flush logger and signal stop
    ctrlc::set_handler(move || {
        info!("Received Ctrl-C, signaling stop and flushing logger...");
        running_clone.store(false, Ordering::SeqCst);

        if let Ok(mut ctrl) = controller_clone.lock() {
            // Force flush the logger
            match ctrl.flush_logger() {
                Ok(()) => info!("Logger flushed successfully on exit"),
                Err(e) => info!("Failed to flush logger on exit: {}", e),
            }
        }
    })?;

    // Run control loop with periodic checks for the stop signal
    let result: Result<(), Box<dyn std::error::Error>> = {
        let mut ctrl = controller.lock().unwrap();

        // Run in shorter intervals so we can check the stop signal
        let mut total_elapsed = Duration::from_secs(0);
        let max_duration = Duration::from_secs(1000);
        let check_interval = Duration::from_secs(5);

        while total_elapsed < max_duration && running.load(Ordering::SeqCst) {
            let remaining = max_duration - total_elapsed;
            let run_duration = check_interval.min(remaining);

            match ctrl.run(run_duration) {
                Ok(final_state) => {
                    info!("Controller finished with state: {:?}", final_state);
                    break;
                }
                Err(e) if e.to_string().contains("Loop timeout") => {
                    // Expected timeout, continue if still running
                    total_elapsed += run_duration;
                    if !running.load(Ordering::SeqCst) {
                        info!("Stop signal received, exiting gracefully");
                        break;
                    }
                }
                Err(e) => {
                    info!("Controller failed: {}", e);
                    break;
                }
            }
        }

        Ok(())
    };

    match result {
        Ok(()) => {
            info!("Controller loop completed");
        }
        Err(e) => {
            info!("Controller loop failed: {}", e);
        }
    }

    Ok(())
}

pub fn flush_logger(&mut self) -> Result<(), NanonisError>

Flush the logger (useful for signal handlers)

Examples found in repository

examples/tip_prep_demo.rs (line 50)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    // Create ActionDriver
    let driver = ActionDriver::new("127.0.0.1", 6501)?;

    // Create controller with custom pulse stepping parameters
    let mut custom_controller = TipController::new(driver, SignalIndex(76), 2.0, (-2.0, 0.0));

    let file_path = create_log_file_path()?;
    println!("{file_path:?}");

    // Configure custom pulse stepping parameters with dynamic threshold
    custom_controller
        //.set_pulse_stepping(1.5, Box::new(|signal| signal.abs() / 10.0), 4, 8.0)
        .set_pulse_stepping_fixed(1.5, 2.0, 4, 10.0)
        .set_stability_threshold(5)
        .with_logger(Logger::new(file_path, 5));

    // Create atomic flag for graceful shutdown
    let running = Arc::new(AtomicBool::new(true));
    let running_clone = Arc::clone(&running);

    // Wrap controller in Arc<Mutex<>> for signal handler
    let controller = Arc::new(Mutex::new(custom_controller));
    let controller_clone = Arc::clone(&controller);

    // Set up Ctrl-C handler to flush logger and signal stop
    ctrlc::set_handler(move || {
        info!("Received Ctrl-C, signaling stop and flushing logger...");
        running_clone.store(false, Ordering::SeqCst);

        if let Ok(mut ctrl) = controller_clone.lock() {
            // Force flush the logger
            match ctrl.flush_logger() {
                Ok(()) => info!("Logger flushed successfully on exit"),
                Err(e) => info!("Failed to flush logger on exit: {}", e),
            }
        }
    })?;

    // Run control loop with periodic checks for the stop signal
    let result: Result<(), Box<dyn std::error::Error>> = {
        let mut ctrl = controller.lock().unwrap();

        // Run in shorter intervals so we can check the stop signal
        let mut total_elapsed = Duration::from_secs(0);
        let max_duration = Duration::from_secs(1000);
        let check_interval = Duration::from_secs(5);

        while total_elapsed < max_duration && running.load(Ordering::SeqCst) {
            let remaining = max_duration - total_elapsed;
            let run_duration = check_interval.min(remaining);

            match ctrl.run(run_duration) {
                Ok(final_state) => {
                    info!("Controller finished with state: {:?}", final_state);
                    break;
                }
                Err(e) if e.to_string().contains("Loop timeout") => {
                    // Expected timeout, continue if still running
                    total_elapsed += run_duration;
                    if !running.load(Ordering::SeqCst) {
                        info!("Stop signal received, exiting gracefully");
                        break;
                    }
                }
                Err(e) => {
                    info!("Controller failed: {}", e);
                    break;
                }
            }
        }

        Ok(())
    };

    match result {
        Ok(()) => {
            info!("Controller loop completed");
        }
        Err(e) => {
            info!("Controller loop failed: {}", e);
        }
    }

    Ok(())
}

pub fn set_stability_threshold(&mut self, threshold: u32) -> &mut Self

Set stability threshold (how many good readings needed for stable)

Examples found in repository

examples/tip_prep_demo.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    // Create ActionDriver
    let driver = ActionDriver::new("127.0.0.1", 6501)?;

    // Create controller with custom pulse stepping parameters
    let mut custom_controller = TipController::new(driver, SignalIndex(76), 2.0, (-2.0, 0.0));

    let file_path = create_log_file_path()?;
    println!("{file_path:?}");

    // Configure custom pulse stepping parameters with dynamic threshold
    custom_controller
        //.set_pulse_stepping(1.5, Box::new(|signal| signal.abs() / 10.0), 4, 8.0)
        .set_pulse_stepping_fixed(1.5, 2.0, 4, 10.0)
        .set_stability_threshold(5)
        .with_logger(Logger::new(file_path, 5));

    // Create atomic flag for graceful shutdown
    let running = Arc::new(AtomicBool::new(true));
    let running_clone = Arc::clone(&running);

    // Wrap controller in Arc<Mutex<>> for signal handler
    let controller = Arc::new(Mutex::new(custom_controller));
    let controller_clone = Arc::clone(&controller);

    // Set up Ctrl-C handler to flush logger and signal stop
    ctrlc::set_handler(move || {
        info!("Received Ctrl-C, signaling stop and flushing logger...");
        running_clone.store(false, Ordering::SeqCst);

        if let Ok(mut ctrl) = controller_clone.lock() {
            // Force flush the logger
            match ctrl.flush_logger() {
                Ok(()) => info!("Logger flushed successfully on exit"),
                Err(e) => info!("Failed to flush logger on exit: {}", e),
            }
        }
    })?;

    // Run control loop with periodic checks for the stop signal
    let result: Result<(), Box<dyn std::error::Error>> = {
        let mut ctrl = controller.lock().unwrap();

        // Run in shorter intervals so we can check the stop signal
        let mut total_elapsed = Duration::from_secs(0);
        let max_duration = Duration::from_secs(1000);
        let check_interval = Duration::from_secs(5);

        while total_elapsed < max_duration && running.load(Ordering::SeqCst) {
            let remaining = max_duration - total_elapsed;
            let run_duration = check_interval.min(remaining);

            match ctrl.run(run_duration) {
                Ok(final_state) => {
                    info!("Controller finished with state: {:?}", final_state);
                    break;
                }
                Err(e) if e.to_string().contains("Loop timeout") => {
                    // Expected timeout, continue if still running
                    total_elapsed += run_duration;
                    if !running.load(Ordering::SeqCst) {
                        info!("Stop signal received, exiting gracefully");
                        break;
                    }
                }
                Err(e) => {
                    info!("Controller failed: {}", e);
                    break;
                }
            }
        }

        Ok(())
    };

    match result {
        Ok(()) => {
            info!("Controller loop completed");
        }
        Err(e) => {
            info!("Controller loop failed: {}", e);
        }
    }

    Ok(())
}

pub fn current_pulse_voltage(&self) -> f32

Get current pulse voltage

pub fn signal_history(&self) -> Option<&VecDeque<f32>>

Get signal history (most recent first) for the frequency shift signal

pub fn average_signal(&self) -> Option<f32>

Calculate average of recent signals for the frequency shift signal

pub fn average_signal_for(&self, signal_index: SignalIndex) -> Option<f32>

Calculate average of recent signals for a specific signal

pub fn track_signal(&mut self, signal_index: SignalIndex, value: f32)

Track a signal value in history

pub fn get_signal_change(&self, signal_index: SignalIndex) -> Option<f32>

Get signal change (latest - previous) for a specific signal

pub fn get_signal_history( &self, signal_index: SignalIndex, ) -> Option<&VecDeque<f32>>

Get signal history for a specific signal (most recent first)

pub fn get_last_signal(&self, signal_index: SignalIndex) -> Option<f32>

pub fn clear_all_histories(&mut self)

Clear all signal histories (useful for logger integration)

pub fn clear_signal_history(&mut self, signal_index: SignalIndex)

Clear history for a specific signal

impl TipController

pub fn run_loop(&mut self, timeout: Duration) -> Result<TipState, NanonisError>

Main control loop - with pulse voltage stepping

Trait Implementations

impl Job for TipController

type Output = TipState

The type returned on successful completion

fn run(&mut self, timeout: Duration) -> Result<Self::Output, NanonisError>

Run the job with a timeout