0x6100 · touchpadRawXY

Raw multi-touch data from an integrated touchpad. getTouchpadInfo (function 0) returns static pad characteristics: physical dimensions (x_size / y_size in native units), max_finger_count, native sensor dpi, coordinate origin, and pen-input support. getRawReportState / setRawReportState (functions 1–2) read and write the active reporting flags; setting RawReportFlags::RAW enables the DualXy event stream.

Each DualXy event carries a DualXyData frame: a running timestamp, up to two TouchPoint contacts, a physical-button flag, an end_of_frame flag, and the total finger_count. Frames covering more than two fingers are split across consecutive events sharing the same timestamp. The z and area bytes of each TouchPoint are mode-dependent; the active RawReportFlags can repurpose them for 16-bit force, width/height, or major/minor/orientation data.

• RawReportFlags — bitflags: RAW (enable raw reporting), ENHANCED, WIDTH_HEIGHT, NATIVE_GESTURE, MAJOR_MINOR, WIDTH_HEIGHT_8BIT, FORCE_ADD (deprecated).
• Origin — coordinate origin viewed from above: LowerLeft, LowerRight, UpperLeft, UpperRight.
• TouchPoint — 14-bit x/y coordinates, 4-bit finger_id, contact_type, contact_status, plus mode-dependent z/area.

Spec: Logitech HID++ 2.0 — touchpadRawXY. Used by: Typed wrapper in openlogi-hidpp.

Function reference

The TouchpadRawXyFeature wrapper (0x6100) exposes:

Methods

All async methods return Result<…, Hidpp20Error>. listen is synchronous and returns a channel receiver directly.

Types

TouchpadInfo

Touchpad characteristics returned by get_touchpad_info.

RawReportFlags

Raw-report mode flags used by get_raw_report_state and set_raw_report_state. Some combinations are mutually exclusive; common valid bitmaps are 0x00 (off), 0x05, 0x09, 0x21, and 0x41.

Origin

The position of a touchpad's coordinate origin, viewed from above.

DualXyData

A frame of raw touch data carrying up to two touch points. Frames describing more than two fingers are split across several events sharing the same timestamp; the last packet sets end_of_frame.

TouchPoint

One touch point within a DualXyData frame. x/y are 14-bit device coordinates. z and area are mode-dependent; the active RawReportFlags can repurpose them for 16-bit force, width/height, or major/minor data.

Events

TouchpadRawXyFeature implements EmittingFeature<TouchpadRawEvent>; call listen() to obtain an async_channel::Receiver<TouchpadRawEvent>. Raw events are only delivered while RawReportFlags::RAW is set via set_raw_report_state.

TouchpadRawEvent

An event emitted by TouchpadRawXyFeature.

Wire format

All three functions use a 3-byte request payload; responses are read from the 16-byte long payload returned by the device.

get_touchpad_info (fn 0)

Request: [0x00, 0x00, 0x00] (no parameters)

Response (byte → field):

get_raw_report_state (fn 1)

Request: [0x00, 0x00, 0x00] (no parameters)

Response (byte → field):

set_raw_report_state (fn 2)

Request: [flags, 0x00, 0x00] where flags = RawReportFlags::bits().

Response: acknowledged but not read by the crate (Ok(())).

DualXy event (sub-id 0)

Emitted asynchronously with a 16-byte payload. Both touch points use the same encoding; coord14(high, low) = (high & 0x3f) << 8 | low (14-bit coordinate).

Frame-level fields:

Touch point 1 (touch1):

Touch point 2 (touch2):

Usage (Rust)

use std::sync::Arc;
use hidpp::{channel::HidppChannel, device::Device, feature::touchpad_raw_xy::{TouchpadRawXyFeature, RawReportFlags}};
use hidpp::feature::EmittingFeature;

// channel: Arc<HidppChannel>, already set up
let mut device = Device::new(Arc::clone(&channel), 0x02).await?;
device.enumerate_features().await?;
if let Some(feat) = device.get_feature::<TouchpadRawXyFeature>() {
    // Query static touchpad characteristics.
    let info = feat.get_touchpad_info().await?;
    println!("pad {}x{} at {} dpi, up to {} fingers",
        info.x_size, info.y_size, info.dpi, info.max_finger_count);

    // Enable raw reporting and subscribe to touch events.
    feat.set_raw_report_state(RawReportFlags::RAW).await?;
    let rx = feat.listen();
    while let Ok(event) = rx.recv().await {
        println!("{event:?}");
    }
}