moto-hses-client

Async UDP client for Yaskawa High-Speed Ethernet Server (HSES) communication.

Overview

This crate provides a high-level, type-safe, asynchronous Rust client for communicating with Yaskawa robots using the HSES (High Speed Ethernet Server) protocol over UDP. It's built on top of Tokio and provides a modern async/await API.

Verified Robot Models

The following robot models have been tested and verified for compatibility:

Supported Commands

Robot Control Commands

File Control Commands

Features

• Async/await support: Built on Tokio for high-performance async I/O
• Type-safe API: Leverages Rust's type system for compile-time safety
• Comprehensive operations: Support for all HSES protocol operations

Installation

Add this to your Cargo.toml:

[dependencies]
moto-hses-client = "0.2"
tokio = { version = "1.0", features = ["full"] }

Usage

use moto_hses_client::HsesClient;
use moto_hses_proto::AlarmAttribute;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create client
    let client = HsesClient::new("192.168.0.3:10040").await?;

    // Read alarm data
    let alarm = client.read_alarm_data(1, AlarmAttribute::All).await?;
    println!("Alarm Code: {}", alarm.code);
    println!("Alarm Name: {}", alarm.name);

    // Reset alarm
    client.reset_alarm().await?;
    println!("Alarm reset completed");

    Ok(())
}

Examples

The crate includes comprehensive examples in the examples/ directory:

• alarm_operations.rs - Alarm data handling
• byte_variable_operations.rs - Byte variable (B) read/write operations
• cycle_mode_control.rs - Cycle mode switching operations
• double_variable_operations.rs - Double variable (D) read/write operations
• file_operations.rs - File transfer operations
• hold_servo_control.rs - Servo control operations
• integer_variable_operations.rs - Integer variable (I) read/write operations
• io_operations.rs - I/O operations
• job_select.rs - Job selection operations
• job_start.rs - Job start operations
• position_operations.rs - Position data operations
• read_executing_job_info.rs - Job information
• read_status.rs - Status monitoring
• real_variable_operations.rs - Real variable (R) read/write operations
• register_operations.rs - Register operations
• string_variable_operations.rs - String variable (S) read/write operations

Running Examples

# Run a specific example
RUST_LOG=info cargo run --example alarm_operations -- 192.168.0.3 10040

Testing

The crate can be tested using the separate moto-hses-mock crate:

[dev-dependencies]
moto-hses-mock = "0.2"

use moto_hses_client::HsesClient;
use moto_hses_mock::{MockServer, MockServerBuilder};
use moto_hses_proto::Alarm;

#[tokio::test]
async fn test_alarm_operations() {
    // Start mock server with test alarm
    let server = MockServerBuilder::new()
        .host("127.0.0.1")
        .robot_port(10040)
        .file_port(10041)
        .with_alarm(Alarm::new(1001, 0, 0, "2024-01-01 12:00:00".to_string(), "Test alarm".to_string()))
        .build()
        .await
        .unwrap();
    
    // Start the server in the background
    let server_handle = tokio::spawn(async move {
        server.run().await.unwrap();
    });
    
    let client = HsesClient::new("127.0.0.1:10040").await.unwrap();
    
    // Test alarm operations
    let alarm = client.read_alarm_data(1, AlarmAttribute::All).await.unwrap();
    assert_eq!(alarm.code, 1001);
    assert_eq!(alarm.name, "Test alarm");
    
    // Test alarm reset
    client.reset_alarm().await.unwrap();
    
    // Clean up
    server_handle.abort();
}

License

This project is licensed under the Apache License, Version 2.0. See the LICENSE file for details.

Related Crates

• moto-hses-proto - Protocol definitions and serialization
• moto-hses-mock - Mock HSES server for testing

References

• Yaskawa HSES Manual
• fizyr/yaskawa_ethernet - C++ reference implementation
• hsinkoyu/fs100 - Python reference implementation