kling-motio-control

A Rust crate for precise and flexible motion control, enabling developers to orchestrate complex movements with ease. It provides a high-level API for defining motion profiles, managing axes, and executing coordinated movements.

Installation

Add the following to your Cargo.toml file under the [dependencies] section: toml kling-motio-control = "0.1.0" # Replace with the actual version

Usage Examples

Here are a few examples illustrating how to use kling-motio-control:

1. Simple Linear Motion: rust use kling_motio_control::{Axis, MotionProfile, Controller};

fn main() -> Result<(), Box> { // Create an axis representing a linear stage. let mut axis = Axis::new("X-Axis", 1000.0); // Name and max speed

// Define a motion profile: move to position 500 at a speed of 200.
let profile = MotionProfile::new(500.0, 200.0, 100.0); // Position, Speed, Acceleration

// Create a motion controller and add the axis.
let mut controller = Controller::new();
controller.add_axis(axis);

// Execute the motion profile on the X-Axis.
controller.execute_profile("X-Axis", profile)?;

// Optionally, wait for the motion to complete.  This might involve
// a blocking call or integration with an asynchronous runtime,
// depending on the underlying hardware interface.

Ok(())

}

2. Coordinated Multi-Axis Movement: rust use kling_motio_control::{Axis, MotionProfile, Controller};

fn main() -> Result<(), Box> { // Create two axes, X and Y. let mut axis_x = Axis::new("X-Axis", 1000.0); let mut axis_y = Axis::new("Y-Axis", 800.0);

// Define motion profiles for each axis.
let profile_x = MotionProfile::new(200.0, 150.0, 80.0);
let profile_y = MotionProfile::new(300.0, 120.0, 60.0);

// Create a motion controller and add the axes.
let mut controller = Controller::new();
controller.add_axis(axis_x);
controller.add_axis(axis_y);

// Execute both profiles concurrently.
controller.execute_profile("X-Axis", profile_x)?;
controller.execute_profile("Y-Axis", profile_y)?;

// Again, appropriate synchronization mechanisms would be needed
// to ensure both movements complete before proceeding.

Ok(())

}

3. Defining a Custom Motion Profile (Example - Trapezoidal):

While the crate provides a basic MotionProfile, you might need to implement more complex shapes. rust use kling_motio_control::{Axis, Controller, MotionSegment};

fn main() -> Result<(), Box> { // Create an axis. let mut axis = Axis::new("Z-Axis", 500.0);

// Define motion segments for a trapezoidal profile (acceleration, constant speed, deceleration).
let segment1 = MotionSegment::Acceleration { acceleration: 50.0, time: 2.0 };
let segment2 = MotionSegment::ConstantSpeed { speed: 100.0, time: 3.0 };
let segment3 = MotionSegment::Deceleration { deceleration: 50.0, time: 2.0 };

// Create a vector of segments.
let segments = vec![segment1, segment2, segment3];

// Create a motion controller and add the axis.
let mut controller = Controller::new();
controller.add_axis(axis);

// Execute the custom profile. (This assumes a hypothetical `execute_segments` function)
// controller.execute_segments("Z-Axis", segments)?;

Ok(())

}

4. Getting Axis Status: rust use kling_motio_control::{Axis, MotionProfile, Controller};

fn main() -> Result<(), Box> { let mut axis = Axis::new("A-Axis", 600.0); let profile = MotionProfile::new(400.0, 180.0, 90.0); let mut controller = Controller::new(); controller.add_axis(axis);

controller.execute_profile("A-Axis", profile)?;

// Simulate some time passing (replace with actual waiting mechanism)
std::thread::sleep(std::time::Duration::from_millis(100));

// Get the current status of the axis.  This assumes a hypothetical `get_axis_status` function.
// let status = controller.get_axis_status("A-Axis")?;
// println!("Axis status: {:?}", status);

Ok(())

}

Feature Summary

• Axis Management: Create and manage multiple axes with defined properties.
• Motion Profile Definition: Define motion profiles with target position, speed, and acceleration.
• Coordinated Motion: Execute motion profiles concurrently across multiple axes.
• Extensible Architecture: Designed to be easily extended with custom motion profile types and hardware interfaces.
• Error Handling: Provides robust error handling for detecting and responding to motion control failures.

License

MIT

This crate is part of the kling-motio-control ecosystem. For advanced features and enterprise-grade tools, visit: https://supermaker.ai/blog/what-is-kling-motion-control-ai-how-to-use-motion-control-ai-free-online/