Struct DeviceConfig 

pub struct DeviceConfig { /* private fields */ }

Configuration for KM003C device communication

Specifies which USB interface to use. The interface determines the connection mode:

• Vendor (Interface 0): Full mode - all features including AdcQueue
• HID (Interface 3): Basic mode - ADC/PD polling only

Examples

use km003c_lib::{KM003C, DeviceConfig};

// Full mode with vendor interface (fastest, all features)
let device = KM003C::new(DeviceConfig::vendor()).await?;

// Basic mode with HID interface (most compatible, ADC/PD only)
let device = KM003C::new(DeviceConfig::hid()).await?;

// With options
let device = KM003C::new(DeviceConfig::vendor().skip_reset()).await?;

Implementations

impl DeviceConfig

pub fn vendor() -> Self

Vendor interface (Interface 0) - Full mode with all features

This is the fastest option with ~0.6ms latency (6x faster than HID). Enables all features including AdcQueue streaming.

Performance:

• Latency: ~600 µs per request
• Throughput: ~200 KB/s

Features: Full mode - ADC, PD, AdcQueue, device info, authentication

Note: On Linux, requires detaching the powerz kernel driver, which this library handles automatically.

Examples found in repository

examples/settings.rs (line 7)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut device = KM003C::new(DeviceConfig::vendor().skip_reset()).await?;
    let settings = device.request_settings().await?;

    println!("Device name: {}", settings.device_name().unwrap_or("<invalid UTF-8>"));
    println!("Language selection: {}", settings.language_selection());
    println!("Uncalibrated: {}", settings.is_uncalibrated());
    println!("Brightness: {}%", settings.brightness().get::<percent>());
    println!(
        "Sample interval: {} us",
        settings.sample_interval().get::<microsecond>()
    );
    println!("Screen orientation: {}", settings.screen_orientation());
    println!("Mtools device mode: {}", settings.mtools_device_mode());
    println!("Selected main page: {}", settings.selected_main_page());

    Ok(())
}

examples/calibration_auth.rs (line 7)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut device = KM003C::new(DeviceConfig::vendor().skip_reset()).await?;
    let initial_level = device.state().map(|state| state.auth_level).unwrap_or(0);
    println!("Initial authentication level: {initial_level}");

    let result = device.authenticate_calibration().await?;
    println!(
        "Calibration authentication level: {} (attribute 0x{:04x})",
        result.auth_level, result.attribute
    );

    device.start_graph_mode(GraphSampleRate::Sps50).await?;
    tokio::time::sleep(Duration::from_millis(200)).await;
    let response = device.request_data(AttributeSet::single(Attribute::AdcQueue)).await;
    device.stop_graph_mode().await?;

    let response = response?;
    let samples = response.get_adc_queue().map(|queue| queue.samples.len()).unwrap_or(0);
    println!("AdcQueue samples received after level-2 auth: {samples}");

    Ok(())
}

pub fn hid() -> Self

HID interface (Interface 3) - Basic mode for ADC/PD polling

This is the most compatible option that works on all platforms without custom drivers. Only supports basic ADC and PD polling.

Performance:

• Latency: ~3.8 ms per request
• Throughput: ~60 KB/s

Features: Basic mode - ADC and PD polling only (no AdcQueue, no device info)

Advantages:

• Works without driver installation on Windows/Mac/Linux
• Uses standard HID protocol
• No permission issues

pub fn skip_reset(self) -> Self

Skip USB reset during connection

Some systems (particularly MacOS) may have issues with USB reset. Use this if device connection fails with reset errors.

Examples found in repository

examples/settings.rs (line 7)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut device = KM003C::new(DeviceConfig::vendor().skip_reset()).await?;
    let settings = device.request_settings().await?;

    println!("Device name: {}", settings.device_name().unwrap_or("<invalid UTF-8>"));
    println!("Language selection: {}", settings.language_selection());
    println!("Uncalibrated: {}", settings.is_uncalibrated());
    println!("Brightness: {}%", settings.brightness().get::<percent>());
    println!(
        "Sample interval: {} us",
        settings.sample_interval().get::<microsecond>()
    );
    println!("Screen orientation: {}", settings.screen_orientation());
    println!("Mtools device mode: {}", settings.mtools_device_mode());
    println!("Selected main page: {}", settings.selected_main_page());

    Ok(())
}

examples/calibration_auth.rs (line 7)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut device = KM003C::new(DeviceConfig::vendor().skip_reset()).await?;
    let initial_level = device.state().map(|state| state.auth_level).unwrap_or(0);
    println!("Initial authentication level: {initial_level}");

    let result = device.authenticate_calibration().await?;
    println!(
        "Calibration authentication level: {} (attribute 0x{:04x})",
        result.auth_level, result.attribute
    );

    device.start_graph_mode(GraphSampleRate::Sps50).await?;
    tokio::time::sleep(Duration::from_millis(200)).await;
    let response = device.request_data(AttributeSet::single(Attribute::AdcQueue)).await;
    device.stop_graph_mode().await?;

    let response = response?;
    let samples = response.get_adc_queue().map(|queue| queue.samples.len()).unwrap_or(0);
    println!("AdcQueue samples received after level-2 auth: {samples}");

    Ok(())
}

pub fn select(self, selector: DeviceSelector) -> Self

Open a specific KM003C instead of the first one found.

Examples

use km003c_lib::{DeviceConfig, DeviceSelector, KM003C};

let config = DeviceConfig::vendor()
    .select(DeviceSelector::SerialNumber("007965".to_string()))
    .skip_reset();
let device = KM003C::new(config).await?;

pub fn selector(&self) -> &DeviceSelector

Which KM003C this config opens.

pub fn is_vendor(&self) -> bool

Check if this config uses vendor interface (full mode)

pub fn is_hid(&self) -> bool

Check if this config uses HID interface (basic mode)

Trait Implementations

impl Clone for DeviceConfig

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DeviceConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.