Struct ActionDriver 

pub struct ActionDriver { /* private fields */ }

Direct 1:1 translation layer between Actions and NanonisClient calls No safety checks, no validation - maximum performance and flexibility

Implementations

impl ActionDriver

pub fn new(addr: &str, port: u16) -> Result<Self, NanonisError>

Create a new ActionDriver with the given client

Examples found in repository

examples/tip_shaper.rs (line 6)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut driver = ActionDriver::new("127.0.0.1", 6501)?;

    for _ in 0..10 {
        driver.execute_chain(vec![
            rusty_tip::Action::AutoApproach {
                wait_until_finished: true,
                timeout: Duration::from_secs(10),
            },
            rusty_tip::Action::PulseRetract {
                pulse_width: Duration::from_millis(500),
                pulse_height_v: 5.0,
            },
            rusty_tip::Action::Withdraw {
                wait_until_finished: true,
                timeout: Duration::from_secs(1),
            },
        ])?;

        sleep(Duration::from_secs(1));
    }
    Ok(())
}

examples/test_stable_signal.rs (line 5)

fn main() -> Result<(), Box<dyn Error>> {
    let mut driver = ActionDriver::new("127.0.0.1", 6501)?;

    let _freq_shift = rusty_tip::SignalIndex(76);

    let z_pos = rusty_tip::SignalIndex(30);

    driver.execute(rusty_tip::Action::Withdraw {
        wait_until_finished: true,
        timeout: Duration::from_secs(5),
    })?;

    driver.execute(rusty_tip::Action::AutoApproach {
        wait_until_finished: true,
        timeout: Duration::from_secs(300),
    })?;

    if let Some(osci_data) = driver.read_oscilloscope_with_stability(
        z_pos,
        // Some(TriggerConfig::new(
        //     rusty_tip::types::OsciTriggerMode::Level,
        //     rusty_tip::TriggerSlope::Falling,
        //     49.0e-12,
        //     0.0,
        // )),
        None,
        rusty_tip::types::DataToGet::Stable {
            readings: 1,
            timeout: Duration::from_secs(2),
        },
        stability::trend_analysis_stability,
    )? {
        // Use the new plotting function - much cleaner!
        rusty_tip::plot_values(&osci_data.data, Some("Z-Position Oscilloscope Data"), None, None)?;

        let is_stable = stability::trend_analysis_stability(&osci_data.data);
        println!("Stability result: {}", is_stable);
    };

    Ok(())
}

examples/tip_prep_demo.rs (line 20)

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_nanonis_client(client: NanonisClient) -> Self

Convenience method to create with NanonisClient

pub fn client(&self) -> &NanonisClient

Get a reference to the underlying NanonisClient

pub fn client_mut(&mut self) -> &mut NanonisClient

Get a mutable reference to the underlying NanonisClient

pub fn execute(&mut self, action: Action) -> Result<ActionResult, NanonisError>

Execute a single action with direct 1:1 mapping to client methods

Examples found in repository

examples/test_stable_signal.rs (lines 11-14)

fn main() -> Result<(), Box<dyn Error>> {
    let mut driver = ActionDriver::new("127.0.0.1", 6501)?;

    let _freq_shift = rusty_tip::SignalIndex(76);

    let z_pos = rusty_tip::SignalIndex(30);

    driver.execute(rusty_tip::Action::Withdraw {
        wait_until_finished: true,
        timeout: Duration::from_secs(5),
    })?;

    driver.execute(rusty_tip::Action::AutoApproach {
        wait_until_finished: true,
        timeout: Duration::from_secs(300),
    })?;

    if let Some(osci_data) = driver.read_oscilloscope_with_stability(
        z_pos,
        // Some(TriggerConfig::new(
        //     rusty_tip::types::OsciTriggerMode::Level,
        //     rusty_tip::TriggerSlope::Falling,
        //     49.0e-12,
        //     0.0,
        // )),
        None,
        rusty_tip::types::DataToGet::Stable {
            readings: 1,
            timeout: Duration::from_secs(2),
        },
        stability::trend_analysis_stability,
    )? {
        // Use the new plotting function - much cleaner!
        rusty_tip::plot_values(&osci_data.data, Some("Z-Position Oscilloscope Data"), None, None)?;

        let is_stable = stability::trend_analysis_stability(&osci_data.data);
        println!("Stability result: {}", is_stable);
    };

    Ok(())
}

pub fn execute_expecting<T>( &mut self, action: Action, ) -> Result<T, NanonisError>

where ActionResult: ExpectFromAction<T>,

Execute action and extract specific type with validation

This is a convenience method that combines execute() with type extraction, providing better ergonomics while preserving type safety.

Example

use rusty_tip::{ActionDriver, Action, SignalIndex};
use rusty_tip::types::{DataToGet, OsciData};

let mut driver = ActionDriver::new("127.0.0.1", 6501)?;
let osci_data: OsciData = driver.execute_expecting(Action::ReadOsci {
    signal: SignalIndex(24),
    trigger: None,
    data_to_get: DataToGet::Current,
    is_stable: None,
})?;

pub fn execute_chain( &mut self, chain: impl Into<ActionChain>, ) -> Result<Vec<ActionResult>, NanonisError>

Execute a chain of actions sequentially

Examples found in repository

examples/tip_shaper.rs (lines 9-22)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut driver = ActionDriver::new("127.0.0.1", 6501)?;

    for _ in 0..10 {
        driver.execute_chain(vec![
            rusty_tip::Action::AutoApproach {
                wait_until_finished: true,
                timeout: Duration::from_secs(10),
            },
            rusty_tip::Action::PulseRetract {
                pulse_width: Duration::from_millis(500),
                pulse_height_v: 5.0,
            },
            rusty_tip::Action::Withdraw {
                wait_until_finished: true,
                timeout: Duration::from_secs(1),
            },
        ])?;

        sleep(Duration::from_secs(1));
    }
    Ok(())
}

pub fn execute_chain_final( &mut self, chain: impl Into<ActionChain>, ) -> Result<ActionResult, NanonisError>

Execute chain and return only the final result

pub fn execute_chain_partial( &mut self, chain: impl Into<ActionChain>, ) -> Result<Vec<ActionResult>, (Vec<ActionResult>, NanonisError)>

Execute chain with early termination on error, returning partial results

pub fn clear_storage(&mut self)

Clear all stored values

pub fn stored_keys(&self) -> Vec<&String>

Get all stored value keys

pub fn read_oscilloscope( &mut self, signal: SignalIndex, trigger: Option<TriggerConfig>, data_to_get: DataToGet, ) -> Result<Option<OsciData>, NanonisError>

Convenience method to read oscilloscope data directly

pub fn read_oscilloscope_with_stability( &mut self, signal: SignalIndex, trigger: Option<TriggerConfig>, data_to_get: DataToGet, is_stable: fn(&[f64]) -> bool, ) -> Result<Option<OsciData>, NanonisError>

Convenience method to read oscilloscope data with custom stability function

Examples found in repository

examples/test_stable_signal.rs (lines 21-35)

fn main() -> Result<(), Box<dyn Error>> {
    let mut driver = ActionDriver::new("127.0.0.1", 6501)?;

    let _freq_shift = rusty_tip::SignalIndex(76);

    let z_pos = rusty_tip::SignalIndex(30);

    driver.execute(rusty_tip::Action::Withdraw {
        wait_until_finished: true,
        timeout: Duration::from_secs(5),
    })?;

    driver.execute(rusty_tip::Action::AutoApproach {
        wait_until_finished: true,
        timeout: Duration::from_secs(300),
    })?;

    if let Some(osci_data) = driver.read_oscilloscope_with_stability(
        z_pos,
        // Some(TriggerConfig::new(
        //     rusty_tip::types::OsciTriggerMode::Level,
        //     rusty_tip::TriggerSlope::Falling,
        //     49.0e-12,
        //     0.0,
        // )),
        None,
        rusty_tip::types::DataToGet::Stable {
            readings: 1,
            timeout: Duration::from_secs(2),
        },
        stability::trend_analysis_stability,
    )? {
        // Use the new plotting function - much cleaner!
        rusty_tip::plot_values(&osci_data.data, Some("Z-Position Oscilloscope Data"), None, None)?;

        let is_stable = stability::trend_analysis_stability(&osci_data.data);
        println!("Stability result: {}", is_stable);
    };

    Ok(())
}

impl ActionDriver

Extension for ActionDriver with execution statistics

pub fn execute_chain_with_stats( &mut self, chain: impl Into<ActionChain>, ) -> Result<(Vec<ActionResult>, ExecutionStats), NanonisError>

Execute chain with detailed statistics