Unit HID
Return to Unit Reference
Description
Ultibo Human Interface Device (HID) Interface unit
The Human Interface Device (HID) class is intended to provide a flexible model that allows a wide range of control types to be expressed using a standard set of tags in a report descriptor that each device provides during initialization.
HID devices can represent common items such as mice, keyboards, touchscreens, gamepads and joysticks but can also appear as controls within many other types of devices.
A headset for example will primarily be an audio device but the volume and mute buttons can be defined using the HID standard and easily recognized by software without requiring a custom driver for each and every device.
The Ultibo HID implementation creates an intermediate device layer that is mostly agnostic to both the bus type being used by an underlying provider (such as USB) and the devices recognized by HID consumers such as mice and keyboards.
A provider such as USB HID locates devices from the provider specific bus and creates HID devices to represent them along with obtaining report descriptors and other information.
These HID devices are then passed to registered HID consumers (drivers) to determine if they recognize the collections, reports and usages described by the device. A consumer can accept a device and bind to it during this process and create its own devices to represent the functionality described by the HID device.
While HID itself is intended to be bus agnostic this implementation is based heavily on the USB HID standards as those are the most widely adopted at this time. It is anticipated that HID adoption will expand over time to include a range other bus types, Bluetooth is already using HID and there are existing implementations of HID over I2C, SPI and PCI.
Expanding the Ultibo HID support to other bus types simply requires a new HID provider for that bus to be written along with any necessary changes or extensions to the HID layer itself.
Constants
HID_NAME_*
HID_NAME_PREFIX = 'HID';
|
Name prefix for HID Devices |
HID_TYPE_*
HID_TYPE_NONE = 0;
|
|
HID_TYPE_USB = 1;
|
|
HID_TYPE_MAX = 1;
|
|
HID device type name | |
HID_TYPE_NAMES:array[HID_TYPE_NONE..HID_TYPE_MAX] of String = (
| |
'HID_TYPE_NONE',
|
|
'HID_TYPE_USB');
|
HID_STATE_*
HID_STATE_DETACHED = 0;
|
|
HID_STATE_DETACHING = 1;
|
|
HID_STATE_ATTACHING = 2;
|
|
HID_STATE_ATTACHED = 3;
|
|
HID_STATE_MAX = 3;
|
|
HID device state name | |
HID_STATE_NAMES:array[HID_STATE_DETACHED..HID_STATE_MAX] of String = (
| |
'HID_STATE_DETACHED',
|
|
'HID_STATE_DETACHING',
|
|
'HID_STATE_ATTACHING',
|
|
'HID_STATE_ATTACHED');
|
HID_FLAG_*
HID_FLAG_NONE = $00000000;
|
HID_SUBCLASS_*
See USB HID v1.11 specification (Section 4.2) | |
HID_SUBCLASS_NONE = 0;
|
|
HID_SUBCLASS_BOOT = 1;
|
HID_BOOT_PROTOCOL_*
See USB HID v1.11 specification (Section 4.3) | |
HID_BOOT_PROTOCOL_NONE = 0;
|
|
HID_BOOT_PROTOCOL_KEYBOARD = 1;
|
|
HID_BOOT_PROTOCOL_MOUSE = 2;
|
HID_DESCRIPTOR_TYPE*
See USB HID v1.11 specification (Section 7.1) | |
HID_DESCRIPTOR_TYPE_HID = $21;
|
|
HID_DESCRIPTOR_TYPE_REPORT = $22;
|
|
HID_DESCRIPTOR_TYPE_PHYSICAL_DESCRIPTOR = $23;
|
HID_REQUEST_*
See Section 7.2 | |
HID_REQUEST_GET_REPORT = $01;
|
|
HID_REQUEST_GET_IDLE = $02;
|
|
HID_REQUEST_GET_PROTOCOL = $03;
|
|
HID_REQUEST_SET_REPORT = $09;
|
|
HID_REQUEST_SET_IDLE = $0A;
|
|
HID_REQUEST_SET_PROTOCOL = $0B;
|
HID_PROTOCOL_*
See Section 7.2.5 | |
HID_PROTOCOL_BOOT = 0;
|
|
HID_PROTOCOL_REPORT = 1;
|
HID_REPORT_*
See Section 7.2.1 | |
HID_REPORT_INPUT = 1;
|
|
HID_REPORT_OUTPUT = 2;
|
|
HID_REPORT_FEATURE = 3;
|
HID_REPORTID_*
See Section 7.2.1 | |
HID_REPORTID_NONE = 0;
|
HID_SIZE_*
See Section 6.2.2.2 | |
HID_SIZE_0 = (0 shl 0);
|
|
HID_SIZE_1 = (1 shl 0);
|
|
HID_SIZE_2 = (2 shl 0);
|
|
HID_SIZE_4 = (3 shl 0);
|
|
HID_SIZE_MASK = $03;
|
HID_TYPE_*
See Section 6.2.2.2 | |
HID_TYPE_MAIN = (0 shl 2);
|
|
HID_TYPE_GLOBAL = (1 shl 2);
|
|
HID_TYPE_LOCAL = (2 shl 2);
|
|
HID_TYPE_RESERVED = (3 shl 2);
|
|
HID_TYPE_MASK = $0C;
|
HID_TAG_MAIN_*
See Section 6.2.2.1 and Section 6.2.2.4 | |
HID_TAG_MAIN_INPUT = $80;
|
Input |
HID_TAG_MAIN_OUTPUT = $90;
|
Output |
HID_TAG_MAIN_FEATURE = $B0;
|
Feature |
HID_TAG_MAIN_COLLECTION = $A0;
|
Collection |
HID_TAG_MAIN_END_COLLECTION = $C0;
|
End Collection |
HID_TAG_GLOBAL_*
See Section 6.2.2.7 | |
HID_TAG_GLOBAL_USAGE_PAGE = $04;
|
Usage Page |
HID_TAG_GLOBAL_LOGICAL_MINIMUM = $14;
|
Logical Minimum |
HID_TAG_GLOBAL_LOGICAL_MAXIMUM = $24;
|
Logical Maximum |
HID_TAG_GLOBAL_PHYSICAL_MINIMUM = $34;
|
Physical Minimum |
HID_TAG_GLOBAL_PHYSICAL_MAXIMUM = $44;
|
Physical Maximum |
HID_TAG_GLOBAL_UNIT_EXPONENT = $54;
|
Unit Exponent |
HID_TAG_GLOBAL_UNIT = $64;
|
Unit |
HID_TAG_GLOBAL_REPORT_SIZE = $74;
|
Report Size |
HID_TAG_GLOBAL_REPORT_ID = $84;
|
Report ID |
HID_TAG_GLOBAL_REPORT_COUNT = $94;
|
Report Count |
HID_TAG_GLOBAL_PUSH = $A4;
|
Push |
HID_TAG_GLOBAL_POP = $B4;
|
Pop |
HID_TAG_LOCAL_*
See Section 6.2.2.8 | |
HID_TAG_LOCAL_USAGE = $08;
|
Usage |
HID_TAG_LOCAL_USAGE_MINIMUM = $18;
|
Usage Minimum |
HID_TAG_LOCAL_USAGE_MAXIMUM = $28;
|
Usage Maximum |
HID_TAG_LOCAL_DESIGNATOR_INDEX = $38;
|
Designator Index |
HID_TAG_LOCAL_DESIGNATOR_MINIMUM = $48;
|
Designator Minimum |
HID_TAG_LOCAL_DESIGNATOR_MAXIMUM = $58;
|
Designator Maximum |
HID_TAG_LOCAL_STRING_INDEX = $78;
|
String Index |
HID_TAG_LOCAL_STRING_MINIMUM = $88;
|
String Minimum |
HID_TAG_LOCAL_STRING_MAXIMUM = $98;
|
String Maximum |
HID_TAG_LOCAL_DELIMITER = $A8;
|
Delimiter |
HID_TAG_LONG = $FC;
|
Always HID_SIZE_2 (Followed by 1 byte DataSize / 1 byte LongItemTag / n bytes Data) |
HID_TAG_MASK = $FC;
|
HID_MAIN_ITEM_*
See Section 6.2.2.5 | |
HID_MAIN_ITEM_CONSTANT = (1 shl 0);
|
Constant (1) |
HID_MAIN_ITEM_VARIABLE = (1 shl 1);
|
Variable (1) |
HID_MAIN_ITEM_RELATIVE = (1 shl 2);
|
Relative (1) |
HID_MAIN_ITEM_WRAP = (1 shl 3);
|
Wrap (1) |
HID_MAIN_ITEM_NON_LINEAR = (1 shl 4);
|
Non Linear (1) |
HID_MAIN_ITEM_NO_PREFERRED = (1 shl 5);
|
No Preferred (1) |
HID_MAIN_ITEM_NULL_STATE = (1 shl 6);
|
Null state(1) |
HID_MAIN_ITEM_RESERVED1 = (1 shl 7);
|
Reserved (0) |
HID_MAIN_ITEM_BUFFERED_BYTES = (1 shl 8);
|
Buffered Bytes (1) |
HID_MAIN_ITEM_RESERVED2 = ($FFFFFE00 shl 9);
|
Reserved (0) |
HID_MAIN_COLLECTION_*
See Section 6.2.2.6 | |
HID_MAIN_COLLECTION_PHYSICAL = $00;
|
Physical (Group of axes) |
HID_MAIN_COLLECTION_APPLICATION = $01;
|
Application (Mouse, Keyboard) |
HID_MAIN_COLLECTION_LOGICAL = $02;
|
Logical (Interrelated data) |
HID_MAIN_COLLECTION_REPORT = $03;
|
Report |
HID_MAIN_COLLECTION_NAMED_ARRAY = $04;
|
Named Array |
HID_MAIN_COLLECTION_USAGE_SWITCH = $05;
|
Usage Switch |
HID_MAIN_COLLECTION_USAGE_MODIFIER = $06;
|
Usage Modifier |
0x07 to 0x7F Reserved | |
0x80 to 0xFF Vendor Defined |
HID_GLOBAL_UNIT_*
See Section 6.2.2.7 For more information see https://physics.nist.gov/cuu/Units/units.html | |
HID_GLOBAL_UNIT_SYSTEM_MASK = $F;
|
System of Measurement |
HID_GLOBAL_UNIT_SYSTEM_SHIFT = 0;
|
|
HID_GLOBAL_UNIT_SYSTEM_NONE = 0;
|
|
HID_GLOBAL_UNIT_SYSTEM_SI_LINEAR = 1;
|
SI linear unit |
HID_GLOBAL_UNIT_SYSTEM_SI_ROTATION = 2;
|
SI rotational units |
HID_GLOBAL_UNIT_SYSTEM_ENGLISH_LINEAR = 3;
|
English (Imperial) linear units |
HID_GLOBAL_UNIT_SYSTEM_ENGLISH_ROTATION = 4;
|
English (Imperial) rotational units |
HID_GLOBAL_UNIT_LENGTH_MASK = $F;
|
Length (Centimeters in SI, Inches in English) |
HID_GLOBAL_UNIT_LENGTH_SHIFT = 4;
|
|
HID_GLOBAL_UNIT_ROTATION_MASK = $F;
|
Rotation (Radians in SI, Degrees in English) |
HID_GLOBAL_UNIT_ROTATION_SHIFT = 4;
|
|
HID_GLOBAL_UNIT_MASS_MASK = $F;
|
Mass (Grams in SI, Slugs in English) |
HID_GLOBAL_UNIT_MASS_SHIFT = 8;
|
|
HID_GLOBAL_UNIT_TIME_MASK = $F;
|
Time (Seconds) |
HID_GLOBAL_UNIT_TIME_SHIFT = 12;
|
|
HID_GLOBAL_UNIT_TEMPERATURE_MASK = $F;
|
Temperature (Kelvin in SI, Fahrenheit in English) |
HID_GLOBAL_UNIT_TEMPERATURE_SHIFT = 16;
|
|
HID_GLOBAL_UNIT_CURRENT_MASK = $F;
|
Current (Amperes) |
HID_GLOBAL_UNIT_CURRENT_SHIFT = 20;
|
|
HID_GLOBAL_UNIT_LIGHT_MASK = $F;
|
Luminous Intensity (Candelas) |
HID_GLOBAL_UNIT_LIGHT_SHIFT = 24;
|
|
Common HID Global Item Unit Value | |
For a more detailed list see the k.0UNIT definitions in https://github.com/abend0c1/hidrdd/blob/master/rd.rex | |
SI Base Units | |
HID_GLOBAL_UNIT_SI_ROTATION = $00000012;
|
Rotation (Radians) |
HID_GLOBAL_UNIT_SI_LENGTH = $00000011;
|
Length (Centimeters) |
HID_GLOBAL_UNIT_SI_MASS = $00000101;
|
Mass (Grams) |
HID_GLOBAL_UNIT_SI_TIME = $00001001;
|
Time (Seconds) |
HID_GLOBAL_UNIT_SI_TEMPERATURE = $00010001;
|
Temperature (Kelvin) |
HID_GLOBAL_UNIT_SI_CURRENT = $00100001;
|
Current (Amperes) |
HID_GLOBAL_UNIT_SI_LIGHT = $01000001;
|
Luminous Intensity (Candelas) |
SI Derived Unit | |
HID_GLOBAL_UNIT_SI_AREA = $00000021;
|
Area (Square Centimeters) |
HID_GLOBAL_UNIT_SI_VOLUME = $00000031;
|
Volume (Cubic Centimeters) |
HID_GLOBAL_UNIT_SI_VELOCITY = $0000F011;
|
Velocity (Centimeters per second) |
HID_GLOBAL_UNIT_SI_ACCELERATION = $0000E011;
|
Acceleration (Centimeters per second squared) |
HID_GLOBAL_UNIT_SI_FREQUENCY = $0000F001;
|
Frequency (Hertz) |
HID_GLOBAL_UNIT_SI_FORCE = $0000E111;
|
Force (Newtons) |
HID_GLOBAL_UNIT_SI_PRESSURE = $0000E1F1;
|
Pressure (Pascals) |
HID_GLOBAL_UNIT_SI_ENERGY = $0000E121;
|
Energy (Joules) |
HID_GLOBAL_UNIT_SI_POWER = $0000D121;
|
Power (Watts) |
English Base Unit | |
HID_GLOBAL_UNIT_ENGLISH_ROTATION = $00000014;
|
Rotation (Degrees) |
HID_GLOBAL_UNIT_ENGLISH_LENGTH = $00000013;
|
Length (Inches) |
HID_GLOBAL_UNIT_ENGLISH_TIME = $00001003;
|
Time (Seconds) |
HID_GLOBAL_UNIT_ENGLISH_TEMPERATURE = $00010003;
|
Temperature (Fahrenheit) |
HID_GLOBAL_UNIT_ENGLISH_CURRENT = $00100003;
|
Current (Amperes) |
HID_GLOBAL_UNIT_ENGLISH_LIGHT = $01000003;
|
Luminous Intensity (Candelas) |
HID_GLOBAL_UNIT_ENGLISH_AREA = $00000023;
|
Area (Square Inches) |
HID_GLOBAL_UNIT_ENGLISH_VOLUME = $00000033;
|
Volume (Cubic Inches) |
HID Global Item Unit Exponent Values | |
See Section 6.2.2.7 | |
HID_GLOBAL_UNIT_EXPONENTS:array[$0..$F] of LongInt = ( | |
0,
|
|
1,
|
|
2,
|
|
3,
|
|
4,
|
|
5,
|
|
6,
|
|
7,
|
|
-8,
|
|
-7,
|
|
-6,
|
|
-5,
|
|
-4,
|
|
-3,
|
|
-2,
|
|
-1);
|
|
HID_GLOBAL_UNIT_MULTIPLIERS:array[$0..$F] of Double = ( | |
1,
|
10^0 |
10,
|
10^1 |
100,
|
10^2 |
1000,
|
10^3 |
10000,
|
10^4 |
100000,
|
10^5 |
1000000,
|
10^6 |
10000000,
|
10^7 |
0.00000001,
|
10^-8 |
0.0000001,
|
10^-7 |
0.000001,
|
10^-6 |
0.00001,
|
10^-5 |
0.0001,
|
10^-4 |
0.001,
|
10^-3 |
0.01,
|
10^-2 |
0.1);
|
10^-1 |
HID_LOCAL_DELIMITER_*
See Section 6.2.2.8 | |
HID_LOCAL_DELIMITER_CLOSE = 0;
|
|
HID_LOCAL_DELIMITER_OPEN = 1;
|
HID_PHYSICAL_BIAS_*
See Section 6.2.3 | |
HID_PHYSICAL_BIAS_NONE = (0 shl 5);
|
Not applicable |
HID_PHYSICAL_BIAS_RIGHT_HAND = (1 shl 5);
|
Right hand |
HID_PHYSICAL_BIAS_LEFT_HAND = (2 shl 5);
|
Left hand |
HID_PHYSICAL_BIAS_BOTH_HANDS = (3 shl 5);
|
Both hands |
HID_PHYSICAL_BIAS_EITHER_HAND = (4 shl 5);
|
Either hand |
HID_PHYSICAL_DESIGNATOR_*
See Section 6.2.3 | |
HID_PHYSICAL_DESIGNATOR_NONE = $00;
|
None |
HID_PHYSICAL_DESIGNATOR_HAND = $01;
|
Hand |
HID_PHYSICAL_DESIGNATOR_EYEBALL = $02;
|
Eyeball |
HID_PHYSICAL_DESIGNATOR_EYEBROW = $03;
|
Eyebrow |
HID_PHYSICAL_DESIGNATOR_EYELID = $04;
|
Eyelid |
HID_PHYSICAL_DESIGNATOR_EAR = $05;
|
Ear |
HID_PHYSICAL_DESIGNATOR_NOSE = $06;
|
Nose |
HID_PHYSICAL_DESIGNATOR_MOUTH = $07;
|
Mouth |
HID_PHYSICAL_DESIGNATOR_UPPER_LIP = $08;
|
Upper lip |
HID_PHYSICAL_DESIGNATOR_LOWER_LIP = $09;
|
Lower lip |
HID_PHYSICAL_DESIGNATOR_JAW = $0A;
|
Jaw |
HID_PHYSICAL_DESIGNATOR_NECK = $0B;
|
Neck |
HID_PHYSICAL_DESIGNATOR_UPPER_ARM = $0C;
|
Upper arm |
HID_PHYSICAL_DESIGNATOR_ELBOW = $0D;
|
Elbow |
HID_PHYSICAL_DESIGNATOR_FOREARM = $0E;
|
Forearm |
HID_PHYSICAL_DESIGNATOR_WRIST = $0F;
|
Wrist |
HID_PHYSICAL_DESIGNATOR_PALM = $10;
|
Palm |
HID_PHYSICAL_DESIGNATOR_THUMB = $11;
|
Thumb |
HID_PHYSICAL_DESIGNATOR_INDEX_FINGER = $12;
|
Index finger |
HID_PHYSICAL_DESIGNATOR_MIDDLE_FINGER = $13;
|
Middle finger |
HID_PHYSICAL_DESIGNATOR_RING_FINGER = $14;
|
Ring finger |
HID_PHYSICAL_DESIGNATOR_LITTLE_FINGER = $15;
|
Little finger |
HID_PHYSICAL_DESIGNATOR_HEAD = $16;
|
Head |
HID_PHYSICAL_DESIGNATOR_SHOULDER = $17;
|
Shoulder |
HID_PHYSICAL_DESIGNATOR_HIP = $18;
|
Hip |
HID_PHYSICAL_DESIGNATOR_WAIST = $19;
|
Waist |
HID_PHYSICAL_DESIGNATOR_THIGH = $1A;
|
Thigh |
HID_PHYSICAL_DESIGNATOR_KNEE = $1B;
|
Knee |
HID_PHYSICAL_DESIGNATOR_CALF = $1C;
|
Calf |
HID_PHYSICAL_DESIGNATOR_ANKLE = $1D;
|
Ankle |
HID_PHYSICAL_DESIGNATOR_FOOT = $1E;
|
Foot |
HID_PHYSICAL_DESIGNATOR_HEEL = $1F;
|
Heel |
HID_PHYSICAL_DESIGNATOR_BALL_OF_FOOT = $20;
|
Ball of foot |
HID_PHYSICAL_DESIGNATOR_BIG_TOE = $21;
|
Big toe |
HID_PHYSICAL_DESIGNATOR_SECOND_TOE = $22;
|
Second toe |
HID_PHYSICAL_DESIGNATOR_THIRD_TOE = $23;
|
Third toe |
HID_PHYSICAL_DESIGNATOR_FOURTH_TOE = $24;
|
Fourth toe |
HID_PHYSICAL_DESIGNATOR_LITTLE_TOE = $25;
|
Little toe |
HID_PHYSICAL_DESIGNATOR_BROW = $26;
|
Brow |
HID_PHYSICAL_DESIGNATOR_CHEEK = $27;
|
Cheek |
HID_PHYSICAL_QUALIFIER_*
See Section 6.2.3 | |
HID_PHYSICAL_QUALIFIER_NONE = (0 shl 5);
|
Not applicable |
HID_PHYSICAL_QUALIFIER_RIGHT = (1 shl 5);
|
Right |
HID_PHYSICAL_QUALIFIER_LEFT = (2 shl 5);
|
Left |
HID_PHYSICAL_QUALIFIER_BOTH = (3 shl 5);
|
Both |
HID_PHYSICAL_QUALIFIER_EITHER = (4 shl 5);
|
Either |
HID_PHYSICAL_QUALIFIER_CENTER = (5 shl 5);
|
Center |
HID_PAGE_*
See HID Usage Tables 1.3 | |
HID_PAGE_UNDEFINED = $00;
|
Undefined |
HID_PAGE_GENERIC_DESKTOP = $01;
|
Generic Desktop Page |
HID_PAGE_SIMULATION_CONTROLS = $02;
|
Simulation Controls Page |
HID_PAGE_VR_CONTROLS = $03;
|
VR Controls Page |
HID_PAGE_SPORT_CONTROLS = $04;
|
Sport Controls Page |
HID_PAGE_GAME_CONTROLS = $05;
|
Game Controls Page |
HID_PAGE_GENERIC_DEVICE_CONTROLS = $06;
|
Generic Device Controls Page |
HID_PAGE_KEYBOARD_KEYPAD = $07;
|
Keyboard/Keypad Page |
HID_PAGE_LED = $08;
|
LED Page |
HID_PAGE_BUTTON = $09;
|
Button Page |
HID_PAGE_ORDINAL = $0A;
|
Ordinal Page |
HID_PAGE_TELEPHONY_DEVICE = $0B;
|
Telephony Device Page |
HID_PAGE_CONSUMER = $0C;
|
Consumer Page |
HID_PAGE_DIGITIZERS = $0D;
|
Digitizers Page |
HID_PAGE_HAPTICS = $0E;
|
Haptics Page |
HID_PAGE_PHYSICAL_INPUT_DEVICE = $0F;
|
Physical Input Device Page |
HID_PAGE_UNICODE = $10;
|
Unicode Page |
0x11-0x11 Reserved | |
HID_PAGE_EYE_AND_HEAD_TRACKERS = $12;
|
Eye and Head Trackers Page |
0x13-0x13 Reserved | |
HID_PAGE_AUXILIARY_DISPLAY = $14;
|
Auxiliary Display Page |
0x15-0x1F Reserved | |
HID_PAGE_SENSORS = $20;
|
Sensors Page |
0x21-0x3F Reserved | |
HID_PAGE_MEDICAL_INSTRUMENT = $40;
|
Medical Instrument Page |
HID_PAGE_BRAILLE_DISPLAY = $41;
|
Braille Display Page |
0x42-0x58 Reserved | |
HID_PAGE_LIGHTING_AND_ILLUMINATION = $59;
|
Lighting And Illumination Page |
0x5A-0x7F Reserved | |
HID_PAGE_MONITOR = $80;
|
Monitor Page |
HID_PAGE_MONITOR_ENUMERATED = $81;
|
Monitor Enumerated Page |
HID_PAGE_VESA_VIRTUAL_CONTROLS = $82;
|
VESA Virtual Controls Page |
0x83-0x83 Reserved | |
HID_PAGE_POWER = $84;
|
Power Page |
HID_PAGE_BATTERY_SYSTEM = $85;
|
Battery System Page |
0x86-0x8B Reserved | |
HID_PAGE_BARCODE_SCANNER = $8C;
|
Barcode Scanner Page |
HID_PAGE_SCALES = $8D;
|
Scales Page |
HID_PAGE_MAGNETIC_STRIPE_READER = $8E;
|
Magnetic Stripe Reader Page |
0x8F-0x8F Reserved | |
HID_PAGE_CAMERA_CONTROL = $90;
|
Camera Control Page |
HID_PAGE_ARCADE = $91;
|
Arcade Page |
HID_PAGE_GAMING_DEVICE = $92;
|
Gaming Device Page |
0x93-0xF1CF Reserved | |
HID_PAGE_FIDO_ALLIANCE = $F1D0;
|
FIDO Alliance Page |
0xF1D1-0xFEFF Reserved | |
0xFF00-0xFFFF Vendor-defined |
HID_DESKTOP_*
See HID Usage Tables 1.3) | |
HID Generic Desktop Page (Partial) | |
HID_DESKTOP_UNDEFINED = $00;
|
Undefined |
HID_DESKTOP_POINTER = $01;
|
Pointer |
HID_DESKTOP_MOUSE = $02;
|
Mouse |
0x03-0x03 Reserved | |
HID_DESKTOP_JOYSTICK = $04;
|
Joystick |
HID_DESKTOP_GAMEPAD = $05;
|
Gamepad |
HID_DESKTOP_KEYBOARD = $06;
|
Keyboard |
HID_DESKTOP_KEYPAD = $07;
|
Keypad |
HID_DESKTOP_MULTI_AXIS_CONTROLLER = $08;
|
Multi-axis Controller |
HID_DESKTOP_TABLET_PC_SYSTEM_CONTROLS = $09;
|
Tablet PC System Controls |
HID_DESKTOP_WATER_COOLING_DEVICE = $0A;
|
Water Cooling Device |
HID_ID_DESKTOP_COMPUTER_CHASSIS_DEVICE = $0B;
|
Computer Chassis Device |
HHID_DESKTOP_WIRELESS_RADIO_CONTROLS = $0C;
|
Wireless Radio Controls |
HID_DESKTOP_PORTABLE_DEVICE_CONTROL = $0D;
|
Portable Device Control |
HID_DESKTOP_SYSTEM_MULTI_AXIS_CONTROLLER = $0E;
|
System Multi-Axis Controller |
HID_DESKTOP_SPATIAL_CONTROLLER = $0F;
|
Spatial Controller |
HID_DESKTOP_ASSISTIVE_CONTROL = $10;
|
Assistive Control |
HID_DESKTOP_DEVICE_DOCK = $11;
|
Device Dock |
HID_DESKTOP_DOCKABLE_DEVICE = $12;
|
Dockable Device |
HID_DESKTOP_CALL_STATE_MANAGEMENT_CONTROL = $13;
|
Call State Management Control |
0x14-0x2F Reserved | |
HID_DESKTOP_X = $30;
|
X |
HID_DESKTOP_Y = $31;
|
Y |
HID_DESKTOP_Z = $32;
|
Z |
HID_DESKTOP_RX = $33;
|
Rx |
HID_DESKTOP_RY = $34;
|
Ry |
HID_DESKTOP_RZ = $35;
|
Rz |
HID_DESKTOP_SLIDER = $36;
|
Slider |
HID_DESKTOP_DIAL = $37;
|
Dial |
HID_DESKTOP_WHEEL = $38;
|
Wheel |
HID_DESKTOP_HAT_SWITCH = $39;
|
Hat Switch |
HID_DESKTOP_COUNTED_BUFFER = $3A;
|
Counted Buffer |
HID_DESKTOP_BYTE_COUNT = $3B;
|
Byte Count |
HID_DESKTOP_MOTION_WAKEUP = $3C;
|
Motion Wakeup |
HID_DESKTOP_START = $3D;
|
Start |
HID_DESKTOP_SELECT = $3E;
|
Select |
0x3F-0x3F Reserved | |
HID_DESKTOP_VX = $40;
|
Vx |
HID_DESKTOP_VY = $41;
|
Vy |
HID_DESKTOP_VZ = $42;
|
Vz |
HID_DESKTOP_VBRX = $43;
|
Vbrx |
HID_DESKTOP_VBRY = $44;
|
Vbry |
HID_DESKTOP_VBRZ = $45;
|
Vbrz |
HID_DESKTOP_VNO = $46;
|
Vno |
HID_DESKTOP_FEATURE_NOTIFICATION = $47;
|
Feature Notification |
HID_DESKTOP_RESOLUTION_MULTIPLIER = $48;
|
Resolution Multiplier |
HID_DESKTOP_QX = $49;
|
Qx |
HID_DESKTOP_QY = $4A;
|
Qy |
HID_DESKTOP_QZ = $4B;
|
Qz |
HID_DESKTOP_QW = $4C;
|
Qw |
SCAN_CODE_*
Note: These are the same as the SCAN_CODE_* values in GlobalConst |
HID_LED_*
HID_LED_UNDEFINED = 00;
|
Undefined |
HID_LED_NUM_LOCK = 01;
|
Num Lock |
HID_LED_CAPS_LOCK = 02;
|
Caps Lock |
HID_LED_SCROLL_LOCK = 03;
|
Scroll Lock |
HID_LED_COMPOSE = 04;
|
Compose |
HID_LED_KANA = 05;
|
Kana |
HID_LED_POWER = 06;
|
Power |
HID_LED_SHIFT = 07;
|
Shift |
HID_LED_DO_NOT_DISTURB = 08;
|
Do Not Disturb |
HID_LED_MUTE = 09;
|
Mute |
HID_BUTTON_*
HID_BUTTON_NONE = 0;
|
|
HID_BUTTON_1 = 1;
|
|
HID_BUTTON_2 = 2;
|
|
HID_BUTTON_3 = 3;
|
|
HID_BUTTON_4 = 4;
|
|
HID_BUTTON_5 = 5;
|
|
HID_BUTTON_PRIMARY = HID_BUTTON_1;
|
|
HID_BUTTON_SECONDARY = HID_BUTTON_2;
|
|
HID_BUTTON_TERTIARY = HID_BUTTON_3;
|
|
Note: Buttons are defined as Button 1 to Button 65535 | |
HID_BUTTON_65535 = $FFFF;
|
HID_DIGITIZERS_*
HID_DIGITIZERS_UNDEFINED = $00;
|
Undefined |
HID_DIGITIZERS_DIGITIZER = $01;
|
Digitizer |
HID_DIGITIZERS_PEN = $02;
|
Pen |
HID_DIGITIZERS_LIGHT_PEN = $03;
|
Light Pen |
HID_DIGITIZERS_TOUCH_SCREEN = $04;
|
Touch Screen |
HID_DIGITIZERS_TOUCH_PAD = $05;
|
Touch Pad |
HID_DIGITIZERS_WHITEBOARD = $06;
|
Whiteboard |
HID_DIGITIZERS_COORD_MEASURING = $07;
|
Coordinate Measuring Machine |
HID_DIGITIZERS_3D_DIGITIZER = $08;
|
3D Digitizer |
HID_DIGITIZERS_STEREO_PLOTTER = $09;
|
Stereo Plotter |
HID_DIGITIZERS_ARTICULATED_ARM = $0A;
|
Articulated Arm |
HID_DIGITIZERS_ARMATURE = $0B;
|
Armature |
HID_DIGITIZERS_MULTI_POINT_DIGITIZER = $0C;
|
Multiple Point Digitizer |
HID_DIGITIZERS_FREE_SPACE_WAND = $0D;
|
Free Space Wand |
HID_DIGITIZERS_DEVICE_CONFIGURATION = $0E;
|
Device Configuration |
HID_DIGITIZERS_CAPACITIVE_HEAT_MAP = $0F;
|
Capacitive Heat Map Digitizer |
0x10-0x1F Reserved | |
HID_DIGITIZERS_STYLUS = $20;
|
Stylus |
HID_DIGITIZERS_PUCK = $21;
|
Puck |
HID_DIGITIZERS_FINGER = $22;
|
Finger |
HID_DIGITIZERS_DEVICE_SETTINGS = $23;
|
Device settings |
HID_DIGITIZERS_CHARACTER_GESTURE = $24;
|
Character Gesture |
0x25-0x2F Reserved | |
HID_DIGITIZERS_TIP_PRESSURE = $30;
|
Tip Pressure |
HID_DIGITIZERS_BARREL_PRESSURE = $31;
|
Barrel Pressure |
HID_DIGITIZERS_IN_RANGE = $32;
|
In Range |
HID_DIGITIZERS_TOUCH = $33;
|
Touch |
HID_DIGITIZERS_UNTOUCH = $34;
|
Untouch |
HID_DIGITIZERS_TAP = $35;
|
Tap |
HID_DIGITIZERS_QUALITY = $36;
|
Quality |
HID_DIGITIZERS_DATA_VALID = $37;
|
Data Valid |
HID_DIGITIZERS_TRANSDUCER_INDEX = $38;
|
Transducer Index |
HID_DIGITIZERS_TABLET_FUNCTION_KEYS = $39;
|
Tablet Function Keys |
HID_DIGITIZERS_PROGRAM_CHANGE_KEYS = $3A;
|
Program Change Keys |
HID_DIGITIZERS_BATTERY_STRENGTH = $3B;
|
Battery Strength |
HID_DIGITIZERS_INVERT = $3C;
|
Invert |
HID_DIGITIZERS_X_TILT = $3D;
|
X Tilt |
HID_DIGITIZERS_Y_TILT = $3E;
|
Y Tilt |
HID_DIGITIZERS_AZIMUTH = $3F;
|
Azimuth |
HID_DIGITIZERS_ALTITUDE = $40;
|
Altitude |
HID_DIGITIZERS_TWIST = $41;
|
Twist |
HID_DIGITIZERS_TIP_SWITCH = $42;
|
Tip Switch |
HID_DIGITIZERS_SECONDARY_TIP_SWITCH = $43;
|
Secondary Tip Switch |
HID_DIGITIZERS_BARREL_SWITCH = $44;
|
Barrel Switch |
HID_DIGITIZERS_ERASER = $45;
|
Eraser |
HID_DIGITIZERS_TABLET_PICK = $46;
|
Tablet Pick |
HID_DIGITIZERS_TOUCH_VALID = $47;
|
Touch Valid (Confidence) |
HID_DIGITIZERS_WIDTH = $48;
|
Width |
HID_DIGITIZERS_HEIGHT = $49;
|
Height |
0x4A-0x50 Reserved | |
HID_DIGITIZERS_CONTACT_IDENTIFIER = $51;
|
Contact Identifier |
HID_DIGITIZERS_DEVICE_MODE = $52;
|
Device Mode |
HID_DIGITIZERS_DEVICE_IDENTIFIER = $53;
|
Device Identifier |
HID_DIGITIZERS_CONTACT_COUNT = $54;
|
Contact Count |
HID_DIGITIZERS_CONTACT_COUNT_MAXIMUM = $55;
|
Contact Count Maximum |
HID_DIGITIZERS_SCAN_TIME = $56;
|
Scan Time |
HID_LOG_*
HID_LOG_LEVEL_DEBUG = LOG_LEVEL_DEBUG;
|
HID debugging messages |
HID_LOG_LEVEL_INFO = LOG_LEVEL_INFO;
|
HID informational messages, such as a device being attached or detached. |
HID_LOG_LEVEL_WARN = LOG_LEVEL_WARN;
|
HID warning messages |
HID_LOG_LEVEL_ERROR = LOG_LEVEL_ERROR;
|
HID error messages |
HID_LOG_LEVEL_NONE = LOG_LEVEL_NONE;
|
No HID messages |
Type definitions
HID descriptor
PHIDDescriptor = ^THIDDescriptor;
THIDDescriptor = packed record
See Section 6.2.1 | |
bLength:Byte;
|
|
bDescriptorType:Byte;
|
|
bcdHID:Word;
|
|
bCountryCode:Byte;
|
|
bNumDescriptors:Byte;
|
|
bHIDDescriptorType:Byte;
|
|
wHIDDescriptorLength:Word;
|
|
Note: Up to two optional bHIDDescriptorType/wHIDDescriptorLength pairs after the Report descriptor details |
HID report descriptor
PHIDReportDescriptor = Pointer;
See Section 6.2.2 | |
HID physical descriptor
PHIDPhysicalDescriptor = ^THIDPhysicalDescriptor;
THIDPhysicalDescriptor = packed record
See Section 6.2.3 | |
bDesignator:Byte;
|
Indicates which part of the body affects the item |
bFlags:Byte;
|
Bits specifying flags (7..5 Qualifier / 4..0 Effort) |
HID physical descriptor set0
PHIDPhysicalDescriptorSet0 = ^THIDPhysicalDescriptorSet0;
THIDPhysicalDescriptorSet0 = packed record
bNumber:Byte;
|
Number of Physical Descriptor sets not including Physical Descriptor set 0 |
wLength:Word;
|
Length of each Physical descriptor set |
HID physical descriptor set
PHIDPhysicalDescriptorSet = ^THIDPhysicalDescriptorSet;
THIDPhysicalDescriptorSet = packed record
bPhysicalInfo:Byte;
|
Bits specifying physical information (7..5 Bias / 4..0 Preference) |
wPhysicalDescriptor:array[0..0] of THIDPhysicalDescriptor;
|
Physical descriptor data |
HID state
PHIDState = ^THIDState;
THIDState = record
Local State | |
Usage:LongWord;
|
|
UsageCount:LongWord;
|
Provides UsageMinimum/UsageMaximum |
DesignatorIndex:LongWord;
|
|
DesignatorCount:LongWord;
|
Provides DesignatorMinimum/DesignatorMaximum |
StringIndex:LongWord;
|
|
StringCount:LongWord;
|
Provides StringMinimum/StringMaximum |
Delimiter:Boolean;
|
|
Global State | |
UsagePage:Word;
|
|
LogicalMinimum:LongInt;
|
|
LogicalMaximum:LongInt;
|
|
PhysicalMinimum:LongInt;
|
|
PhysicalMaximum:LongInt;
|
|
UnitType:LongWord;
|
|
UnitExponent:LongWord;
|
|
ReportSize:LongWord;
|
|
ReportId:LongWord;
|
|
ReportCount:LongWord;
|
HID stack
PHIDStack = ^THIDStack;
THIDStack = record
State:PHIDState;
|
|
Next:PHIDStack;
|
HID usages
PHIDUsages = ^THIDUsages;
THIDUsages = array[0..0] of PHIDUsage;
HID usage
PHIDUsage = ^THIDUsage;
THIDUsage = record
Page:Word;
|
The usage page this usage refers to |
Usage:Word;
|
The usage within the usage page |
Count:Word;
|
The total number of sequential usages where Usage represents the minimum value or 1 for a single usage (Usage range is from Usage to Usage + Count - 1) |
Index:LongWord;
|
The index of this usage in the report (First usage is 0) |
StringIndex:LongWord;
|
The string index for this usage |
StringCount:LongWord;
|
The total number of sequential string index values where string index represents the minimum value or 1 for a single string |
DesignatorIndex:LongWord;
|
The designator index for this usage |
DesignatorCount:LongWord;
|
The total number of sequential designator index values where designator index represents the minimum value or 1 for a single designator |
LogicalMinimum:LongInt;
|
The logical minimum value for this usage |
LogicalMaximum:LongInt;
|
The logical maximum value for this usage |
PhysicalMinimum:LongInt;
|
The physical minimum value for this usage (in Units) |
PhysicalMaximum:LongInt;
|
The physical maximum value for this usage (in Units) |
UnitType:LongWord;
|
The unit type for this usage |
UnitExponent:LongWord;
|
The unit exponent index for this usage |
Aliases:PHIDUsages;
|
The list of aliased usages for this control (See Delimiters in Section 6.2.2.8) |
AliasCount:LongWord;
|
The number of aliased usages contained for this control |
Report:PHIDReport;
|
The report this usage belongs to |
HID reports
PHIDReports = ^THIDReports;
THIDReports = array[0..0] of PHIDReport;
HID report
PHIDReport = ^THIDReport;
THIDReport = record
Id:Byte;
|
The Id of this report |
Kind:Byte;
|
The type of report (Input, Output or Feature) (eg HID_REPORT_INPUT) |
Flags:LongWord;
|
The main item flags for this report (eg HID_MAIN_ITEM_VARIABLE) |
Size:LongWord;
|
The number of bits per field in this report |
Count:LongWord;
|
The number of fields in this report |
Index:LongWord;
|
The index of this report in the collection (First report is 0) |
Sequence:LongWord;
|
The sequence of this report in all collections (First report is 0) |
Usages:PHIDUsages;
|
The list of usages contained in this report |
UsageCount:LongWord;
|
The number of usages contained in this report |
Collection:PHIDCollection;
|
The collection this report belongs to |
HID collections
PHIDCollections = ^THIDCollections;
THIDCollections = array[0..0] of PHIDCollection;
HID collection
PHIDCollection = ^THIDCollection;
THIDCollection = record
Page:Word;
|
The usage page this collection refers to (eg HID_PAGE_GENERIC_DESKTOP) |
Usage:Word;
|
The usage within the usage page (eg HID_DESKTOP_MOUSE) |
Flags:LongWord;
|
The main item flags for this collection (eg HID_MAIN_COLLECTION_APPLICATION) |
Start:LongWord;
|
The first byte of this collection in the report descriptor |
Reports:PHIDReports;
|
The list of reports contained in this collection |
ReportCount:LongWord;
|
The number of reports contained in this collection |
Collections:PHIDCollections;
|
The list of collections contained in this collection |
CollectionCount:LongWord;
|
The number of collections contained in this collection |
Parent:PHIDCollection;
|
The parent collection or nil if this is a top level collection |
Device:PHIDDevice;
|
The device this collection belongs to |
Consumer:PHIDConsumer;
|
The consumer which is bound to this collection (or nil if not bound) |
PrivateData:Pointer;
|
Private data for the consumer of this collection |
HID device enumeration callback
THIDDeviceEnumerate = function(Device:PHIDDevice;Data:Pointer):LongWord;
|
HID device notification callback
THIDDeviceNotification = function(Device:PDevice; Data:Pointer; Notification:LongWord):LongWord;
|
HID device get idle
THIDDeviceGetIdle = function(Device:PHIDDevice; var Duration:Word; ReportId:Byte):LongWord;
|
HID device set idle
THIDDeviceSetIdle = function(Device:PHIDDevice; Duration:Word; ReportId:Byte):LongWord;
|
HID device get report
THIDDeviceGetReport = function(Device:PHIDDevice; ReportType,ReportId:Byte; ReportData:Pointer; ReportSize:LongWord):LongWord;
|
HID device set report
THIDDeviceSetReport = function(Device:PHIDDevice; ReportType,ReportId:Byte; ReportData:Pointer; ReportSize:LongWord):LongWord;
|
HID device allocate report
THIDDeviceAllocateReport = function(Device:PHIDDevice; Collection:PHIDCollection; ReportId:Byte; ReportSize:LongWord):LongWord;
|
HID device release report
THIDDeviceReleaseReport = function(Device:PHIDDevice; ReportId:Byte):LongWord;
|
HID device submit report
THIDDeviceSubmitReport = function(Device:PHIDDevice; ReportId:Byte):LongWord;
|
HID device cancel report
THIDDeviceCancelReport = function(Device:PHIDDevice; ReportId:Byte):LongWord;
|
HID device get protocol
THIDDeviceGetProtocol = function(Device:PHIDDevice; var Protocol:Byte):LongWord;
|
HID device set protocol
THIDDeviceSetProtocol = function(Device:PHIDDevice; Protocol:Byte):LongWord;
|
HID device get interval
THIDDeviceGetInterval = function(Device:PHIDDevice; var Interval:LongWord):LongWord;
|
HID device set interval
THIDDeviceSetInterval = function(Device:PHIDDevice; Interval:LongWord):LongWord;
|
HID device get report descriptor
THIDDeviceGetReportDescriptor = function(Device:PHIDDevice; Descriptor:PHIDReportDescriptor; Size:LongWord):LongWord;
|
HID device get physical descriptor set0
THIDDeviceGetPhysicalDescriptorSet0 = function(Device:PHIDDevice; Descriptor:PHIDPhysicalDescriptorSet0):LongWord;
|
HID device get physical descriptor set
THIDDeviceGetPhysicalDescriptorSet = function(Device:PHIDDevice; Descriptor:PHIDPhysicalDescriptorSet; Index:Byte; Size:LongWord):LongWord;
|
HID device
PHIDDevice = ^THIDDevice;
THIDDevice = record
Device Properties | |
Device:TDevice;
|
The Device entry for this HID |
HID Properties | |
HIDId:LongWord;
|
Unique Id of this HID in the HID device table |
HIDState:LongWord;
|
HID device state (eg HID_STATE_ATTACHED) |
Consumer:PHIDConsumer;
|
The consumer which is bound to this device (or nil if not bound) |
DeviceGetIdle:THIDDeviceGetIdle;
|
A device specific GetIdle method (If supported by provider) |
DeviceSetIdle:THIDDeviceSetIdle;
|
A device specific SetIdle method (If supported by provider) |
DeviceGetReport:THIDDeviceGetReport;
|
A device specific GetReport method (If supported by provider) |
DeviceSetReport:THIDDeviceSetReport;
|
A device specific SetReport method (If supported by provider) |
DeviceAllocateReport:THIDDeviceAllocateReport;
|
A device specific AllocateReport method (If supported by provider) |
DeviceReleaseReport:THIDDeviceReleaseReport;
|
A device specific ReleaseReport method (If supported by provider) |
DeviceSubmitReport:THIDDeviceSubmitReport;
|
A device specific SubmitReport method (If supported by provider) |
DeviceCancelReport:THIDDeviceCancelReport;
|
A device specific CancelReport method (If supported by provider) |
DeviceGetProtocol:THIDDeviceGetProtocol;
|
A device specific GetProtocol method (If supported by provider) |
DeviceSetProtocol:THIDDeviceSetProtocol;
|
A device specific SetProtocol method (If supported by provider) |
DeviceGetInterval:THIDDeviceGetInterval;
|
A device specific GetInterval method (If supported by provider) |
DeviceSetInterval:THIDDeviceSetInterval;
|
A device specific SetInterval method (If supported by provider) |
DeviceGetReportDescriptor:THIDDeviceGetReportDescriptor;
|
A device specific GetReportDescriptor method (If supported by provider) |
DeviceGetPhysicalDescriptorSet0:THIDDeviceGetPhysicalDescriptorSet0;
|
A device specific GetPhysicalDescriptorSet0 method (If supported by provider) |
DeviceGetPhysicalDescriptorSet:THIDDeviceGetPhysicalDescriptorSet;
|
A device specific GetPhysicalDescriptorSet method (If supported by provider) |
Driver Properties | |
Lock:TMutexHandle;
|
HID device lock |
PrivateData:Pointer;
|
Private data for the consumer of this HID device (If applicable) |
Collections:PHIDCollections;
|
The parsed report descriptor with collections, reports and usages |
CollectionCount:LongWord;
|
The number of top level collections contained in the report descriptor |
Descriptor:PHIDReportDescriptor;
|
The raw report descriptor obtained from the device |
DescriptorSize:LongWord;
|
The size of the data pointed to by Descriptor |
Statistics Properties | |
ReceiveCount:LongWord;
|
|
ReceiveErrors:LongWord;
|
|
Internal Properties | |
Prev:PHIDDevice;
|
Previous entry in Device table |
Next:PHIDDevice;
|
Next entry in Device table |
HID consumer enumeration callback
THIDConsumerEnumerate = function(Consumer:PHIDConsumer; Data:Pointer):LongWord;
|
HID device bind
THIDDeviceBind = function(Device:PHIDDevice):LongWord;
|
HID device unbind
THIDDeviceUnbind = function(Device:PHIDDevice):LongWord;
|
HID collection bind
THIDCollectionBind = function(Device:PHIDDevice; Collection:PHIDCollection):LongWord;
|
HID collection unbind
THIDCollectionUnbind = function(Device:PHIDDevice; Collection:PHIDCollection):LongWord;
|
HID report receive
THIDReportReceive = function(Collection:PHIDCollection; ReportId:Byte; ReportData:Pointer; ReportSize:LongWord):LongWord;
|
HID consumer
PHIDConsumer = ^THIDConsumer;
THIDConsumer = record
Driver Properties | |
Driver:TDriver;
|
The Driver entry for this HID Consumer |
Consumer Properties | |
DeviceBind:THIDDeviceBind;
|
A Device Bind method to be called when a HID device bind is requested by a provider (Optional) |
DeviceUnbind:THIDDeviceUnbind;
|
A Device Ubind method to be called when a HID device unbind is requested by a provider (Optional) |
CollectionBind:THIDCollectionBind;
|
A Collection Bind method to be called when a HID collection bind is requested by a provider (Mandatory) |
CollectionUnbind:THIDCollectionUnbind;
|
A Collection Unbind method to be called when a HID collection unbind is requested by a provider (Mandatory) |
ReportReceive:THIDReportReceive;
|
A Report Receive method to be called when a HID input report is received by a provider (Mandatory) |
Interface Properties | |
Lock:TMutexHandle;
|
Consumer lock |
Internal Properties | |
Prev:PHIDConsumer;
|
Previous entry in Consumer table |
Next:PHIDConsumer;
|
Next entry in Consumer table |
HID report extent
PHIDExtent = ^THIDExtent;
THIDExtent = record
Minimum:LongInt;
|
The minimum value for this extent |
Maximum:LongInt;
|
The maximum value for this extent |
HID report field
PHIDField = ^THIDField;
THIDField = record
Page:Word;
|
The usage page of this field |
Usage:Word;
|
The usage within the usage page |
Count:LongWord;
|
The total number of sequential usages where Usage represents the minimum value or 1 for a single usage (Usage range is from Usage to Usage + Count - 1) |
Flags:LongWord;
|
The flags for this field |
Size:LongWord;
|
The length in bytes of this field within the input, output or feature report |
Bits:LongWord;
|
The length in bits of this field within the input, output or feature report |
Offset:LongWord;
|
The byte offset of this field within the input, output or feature report |
Shift:LongWord;
|
The number shift bits to access this field in the input, output or feature report |
Logical:THIDExtent;
|
The minimum and maximum logical values for this field |
Physical:THIDExtent;
|
The minimum and maximum physical values for this field |
Multiplier:Double;
|
The conversion multiplier for this field from logical to physical units |
Resolution:Double;
|
The unit resolution for this field in counts per physical unit |
Next:PHIDField;
|
The next field in the list |
HID report definition
PHIDDefinition = ^THIDDefinition;
THIDDefinition = record
Id:Byte;
|
The Id of this report |
Kind:Byte;
|
The type of this report (Input, Output or Feature) |
Size:LongWord;
|
The total length of this input, output or feature report in bytes (Including the Id byte) |
Fields:PHIDField;
|
Linked list of fields in this input, output or feature report |
Next:PHIDDefinition;
|
The next definition in the list |
Public variables
HID logging
HID_DEFAULT_LOG_LEVEL:LongWord = HID_LOG_LEVEL_DEBUG;
|
Minimum level for HID messages. Only messages with level greater than or equal to this will be printed. |
HID_LOG_ENABLED:Boolean;
|
Function declarations
Initialization functions
procedure HIDInit;
Note | Called only during system startup |
---|
HID functions
function HIDParserParseCollections(Device:PHIDDevice; var Collections:PHIDCollections; var Count:LongWord):LongWord;
Device | The HID device to parse collections for |
---|---|
Collections | A pointer to the top level collections array to be populated |
Count | A variable to return the number of top level collections |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDParserFreeCollections(Collections:PHIDCollections; Count:LongWord):LongWord;
Collections | A pointer to the top level collections array to be freed |
---|---|
Count | The number of top level collections in the array |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDParserCountCollections(Device:PHIDDevice; Parent:PHIDCollection):LongWord;
Device | The HID device to count collections for |
---|---|
Parent | The parent HID collection, if supplied count child collections else count top level collections |
Return | The number of collections found, 0 if none for or on error |
function HIDParserCountReports(Device:PHIDDevice; Collection:PHIDCollection):LongWord;
Device | The HID device to count reports for |
---|---|
Collection | The HID collection to count reports for |
Return | The number of reports found, 0 if none for or on error |
function HIDParserCountUsages(Device:PHIDDevice; Report:PHIDReport):LongWord;
Device | The HID device to count usages for |
---|---|
Report | The HID report to count usages for |
Return | The number of usages found, 0 if none for or on error |
function HIDParserAllocateCollection(Device:PHIDDevice; Parent:PHIDCollection; State:PHIDState; Flags,Start:LongWord):PHIDCollection;
Device | The HID device containing the collection |
---|---|
Parent | The HID collection containing the collection (or nil for a top level collection) |
State | The current HID parser state |
Flags | The flags for the collection from the HID report descriptor |
Start | The starting byte offset of the collection in the HID report descriptor |
Return | A pointer to the HID collection or nil on error |
function HIDParserAllocateReport(Device:PHIDDevice; Collection:PHIDCollection; State:PHIDState; Kind:Byte; Flags,Index,Sequence:LongWord):PHIDReport;
Device | The HID device containing the report |
---|---|
Collection | The HID collection containing the report |
State | The current HID parser state |
Kind | The report kind (eg HID_REPORT_INPUT) |
Flags | The flags for the report from the HID report descriptor |
Index | The index of this report in the collection (First report is 0) |
Sequence | The sequence of this report in all collections (First report is 0) |
Return | A pointer to the HID report or nil on error |
function HIDParserAllocateUsage(Device:PHIDDevice; Report:PHIDReport; State:PHIDState; Index:LongWord):PHIDUsage;
Device | The HID device containing the usage |
---|---|
Report | The HID report containing the usage |
State | The current HID parser state |
Index | The index of this usage in the report (First usage is 0) |
Return | A pointer to the HID usage or nil on error |
function HIDParserUpdateUsage(Device:PHIDDevice; Report:PHIDReport; State:PHIDState; Usage:PHIDUsage):Boolean;
Device | The HID device containing the usage |
---|---|
Report | The HID report containing the usage |
State | The current HID parser state |
Usage | The HID usage to update |
Return | True if completed or False on error |
Note | As usages must precede the main item they relate to in the HID report descriptor they need to be allocated before all the required information is known, this function updates the usage after the main item is found. |
function HIDParserFreeUsage(Device:PHIDDevice;Usage:PHIDUsage):Boolean;
Device | The HID device containing the usage |
---|---|
Usage | The HID usage to free |
Return | True if completed or False on error |
function HIDParserPopStack(var Stack:PHIDStack; var State:PHIDState):LongWord;
Stack | The HID parser stack |
---|---|
State | The HID parser state to replace |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDParserPushStack(Stack:PHIDStack):LongWord;
Stack | The HID parser stack |
---|---|
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDParserFreeStack(Stack:PHIDStack):LongWord;
Stack | The HID parser stack |
---|---|
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDParserResetState(State:PHIDState):LongWord;
State | The HID parser state to reset |
---|---|
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDParserCleanState(State:PHIDState):LongWord;
State | The HID parser state to clean |
---|---|
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDFindCollection(Device:PHIDDevice; Page,Usage:Word):PHIDCollection;
Device | The HID device to find collections from |
---|---|
Page | The HID Usage Page to match (eg HID_PAGE_GENERIC_DESKTOP) |
Usage | The HID Usage to match (eg HID_DESKTOP_MOUSE) |
Return | A pointer to the first matching collection or nil if not matched |
function HIDFindReportIds(Device:PHIDDevice; Collection:PHIDCollection; var MinId,MaxId:Byte):LongWord;
Device | The HID device to find report ids from |
---|---|
Collection | The HID collection to find report ids from (or nil to find from all collections) |
MinId | A variable to receive the minimum report id number |
MaxId | A variable to receive the maximum report id number |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDFindReportSizes(Device:PHIDDevice; Collection:PHIDCollection; Kind:Byte; var MinSize,MaxSize:LongWord):LongWord;
Device | The HID device to find report sizes from |
---|---|
Collection | The HID collection to find report sizes from (or nil to find from all collections) |
Kind | The report kind to find sizes for (eg HID_REPORT_INPUT) |
MinSize | A variable to receive the minimum report size |
MaxSize | A variable to receive the maximum report size |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDCountReports(Device:PHIDDevice; Collection:PHIDCollection; Kind,Id:Byte; var Count:LongWord):LongWord;
Device | The HID device to get the report count from |
---|---|
Collection | The HID collection to get the report count from |
Kind | The report kind to count reports for (eg HID_REPORT_INPUT) |
Id | The report id to count reports for (must be less than or equal to the maximum report id) |
Count | A variable to return the number of reports |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDFindReports(Device:PHIDDevice; Collection:PHIDCollection; Kind,Id:Byte; Reports:PHIDReports; Count:LongWord):LongWord;
Device | The HID device to get the reports from |
---|---|
Collection | The HID collection to get the reports from |
Kind | The report kind to get reports for (eg HID_REPORT_INPUT) |
Id | The report id to get reports for (must be less than or equal to the maximum report id) |
Reports | A pointer to an array to return the list of reports |
Count | The number of reports able to be returned in the reports array |
Return | ERROR_SUCCESS if completed or another error code on failure |
Note | The caller is responsible for allocating the reports array which must be large enough to hold a pointer to every report in the returned list. When finished the array should be freed by the caller but not the reports themselves. Call HIDCountReports first to obtain the correct size to be allocated for the array. |
function HIDAllocateDefinition(Device:PHIDDevice; Collection:PHIDCollection; Kind,Id:Byte):PHIDDefinition;
Device | The HID device to create the report definition from |
---|---|
Collection | The HID collection to create the report definition from |
Kind | The report kind to create a definition for (eg HID_REPORT_INPUT) |
Id | The report id to create a definition for (must be less than or equal to the maximum report id) |
Return | A pointer to the allocated definition or nil on error |
function HIDFreeDefinition(Definition:PHIDDefinition):LongWord;
Definition | The HID definition to be freed |
---|---|
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDInsertBitField(Field:PHIDField; Buffer:Pointer; Size:LongWord; Value:Boolean):LongWord;
Field | The field to insert into the report |
---|---|
Buffer | A pointer to the report buffer |
Size | The size in bytes of the report buffer |
Value | The value to insert into the buffer |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDInsertSignedField(Field:PHIDField; Buffer:Pointer; Size:LongWord; Value:LongInt):LongWord;
Field | The field to insert into the report |
---|---|
Buffer | A pointer to the report buffer |
Size | The size in bytes of the report buffer |
Value | The value to insert into the buffer |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDInsertUnsignedField(Field:PHIDField; Buffer:Pointer; Size,Value:LongWord):LongWord;
Field | The field to insert into the report |
---|---|
Buffer | A pointer to the report buffer |
Size | The size in bytes of the report buffer |
Value | The value to insert into the buffer |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDExtractBitField(Field:PHIDField; Buffer:Pointer; Size:LongWord; var Value:Boolean):LongWord;
Field | The field to extract from the report |
---|---|
Buffer | A pointer to the report buffer |
Size | The size in bytes of the report buffer |
Value | A variable to receive the extracted value |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDExtractSignedField(Field:PHIDField; Buffer:Pointer; Size:LongWord; var Value:LongInt):LongWord;
Field | The field to extract from the report |
---|---|
Buffer | A pointer to the report buffer |
Size | The size in bytes of the report buffer |
Value | A variable to receive the extracted value |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDExtractUnsignedField(Field:PHIDField; Buffer:Pointer; Size:LongWord; var Value:LongWord):LongWord;
Field | The field to extract from the report |
---|---|
Buffer | A pointer to the report buffer |
Size | The size in bytes of the report buffer |
Value | A variable to receive the extracted value |
Return | ERROR_SUCCESS if completed or another error code on failure |
HID Device functions
function HIDDeviceSetState(Device:PHIDDevice; State:LongWord):LongWord;
Device | The HID device to set the state for |
---|---|
State | The new state to set and notify (eg HID_STATE_ATTACHED) |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceGetIdle(Device:PHIDDevice; var Duration:Word; ReportId:Byte):LongWord;
Device | The HID device to get the idle rate from |
---|---|
Duration | A variable to receive the idle rate (in Milliseconds) |
ReportId | The report id to get the idle rate from |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceSetIdle(Device:PHIDDevice; Duration:Word; ReportId:Byte):LongWord;
Device | The HID device to set the idle rate for |
---|---|
Duration | The idle rate to set (in Milliseconds) |
ReportId | The report id to set the idle rate for |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceGetReport(Device:PHIDDevice; ReportType,ReportId:Byte; ReportData:Pointer; ReportSize:LongWord):LongWord;
Device | The HID device to read the report from |
---|---|
ReportType | The report type to read (eg HID_REPORT_INPUT) |
ReportId | The report id to read (eg HID_REPORTID_NONE) |
ReportData | A pointer to a buffer to receive the report data |
ReportSize | The size in bytes of the buffer pointed to by report data |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceSetReport(Device:PHIDDevice; ReportType,ReportId:Byte; ReportData:Pointer; ReportSize:LongWord):LongWord;
Device | The HID device to write the report to |
---|---|
ReportType | The report type to write (eg HID_REPORT_OUTPUT) |
ReportId | The report id to write (eg HID_REPORTID_NONE) |
ReportData | A pointer to a buffer containing the report data |
ReportSize | The size in bytes of the buffer pointed to by report data |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceAllocateReport(Device:PHIDDevice; Collection:PHIDCollection; ReportId:Byte; ReportSize:LongWord):LongWord;
Device | The HID device to allocate the report on |
---|---|
Collection | The HID collection this request corresponds to |
ReportId | The report id to allocate (eg HID_REPORTID_NONE) |
ReportSize | The size in bytes to allocate for the report (Provider will handle alignment and other requirements) |
Return | ERROR_SUCCESS if completed or another error code on failure |
Note | An allocated report must be submitted before reports will be received from the device |
function HIDDeviceReleaseReport(Device:PHIDDevice; ReportId:Byte):LongWord;
Device | The HID device to release the report from |
---|---|
ReportId | The report id to allocate (eg HID_REPORTID_NONE) |
Return | ERROR_SUCCESS if completed or another error code on failure |
Note | If the report has been submitted it must be cancelled before being released |
function HIDDeviceSubmitReport(Device:PHIDDevice; ReportId:Byte):LongWord;
Device | The HID device to submit the report on |
---|---|
ReportId | The report id to submit (eg HID_REPORTID_NONE) |
Return | ERROR_SUCCESS if completed or another error code on failure |
Note | The report must be allocated then submitted before reports will be received from the device |
function HIDDeviceCancelReport(Device:PHIDDevice; ReportId:Byte):LongWord;
Device | The HID device to cancel the report on |
---|---|
ReportId | The report id to cancel (eg HID_REPORTID_NONE) |
Return | ERROR_SUCCESS if completed or another error code on failure |
Note | The report should be cancelled then released to stop receiving reports from the device |
function HIDDeviceGetProtocol(Device:PHIDDevice; var Protocol:Byte):LongWord;
Device | The HID device to get the report protocol from |
---|---|
Protocol | A variable to receive the report protocol (eg HID_PROTOCOL_REPORT) |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceSetProtocol(Device:PHIDDevice; Protocol:Byte):LongWord;
Device | The HID device to set the report protocol for |
---|---|
Protocol | The report protocol to set (eg HID_PROTOCOL_REPORT) |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceGetInterval(Device:PHIDDevice; var Interval:LongWord):LongWord;
Device | The HID device to get the polling interval from |
---|---|
Interval | A variable to receive the polling interval (in Milliseconds) |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceSetInterval(Device:PHIDDevice; Interval:LongWord):LongWord;
Device | The HID device to set the polling interval for |
---|---|
Interval | The polling interval to set (in Milliseconds) |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceGetReportDescriptor(Device:PHIDDevice; Descriptor:PHIDReportDescriptor; Size:LongWord):LongWord;
Device | The HID device to get the descriptor for |
---|---|
Descriptor | Pointer to a buffer to return the HID Report Descriptor |
Size | The size in bytes of the buffer pointed to by Descriptor |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceGetPhysicalDescriptorSet0(Device:PHIDDevice; Descriptor:PHIDPhysicalDescriptorSet0):LongWord;
Device | The HID device to get the descriptor for |
---|---|
Descriptor | Pointer to a HID Physical Descriptor Set 0 structure for the returned data |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceGetPhysicalDescriptorSet(Device:PHIDDevice; Descriptor:PHIDPhysicalDescriptorSet; Index:Byte; Size:LongWord):LongWord;
Device | The HID device to get the descriptor for |
---|---|
Descriptor | Pointer to a HID Physical Descriptor Set structure for the returned data |
Index | The index of the physical descriptor set to return |
Size | The size in bytes of the buffer pointed to by Descriptor |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceBindDevice(Device:PHIDDevice):LongWord;
Device | The HID device to attempt to bind a consumer to |
---|---|
Return | ERROR_SUCCESS if completed, ERROR_NOT_SUPPORTED if unsupported or another error code on failure |
function HIDDeviceUnbindDevice(Device:PHIDDevice; Consumer:PHIDConsumer):LongWord;
Device | The HID device to unbind a consumer from |
---|---|
Consumer | The consumer to unbind the device from (nil to unbind from current consumer) |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceBindCollections(Device:PHIDDevice):LongWord;
Device | The HID device containing the collections to attempt to bind a consumer to |
---|---|
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceUnbindCollections(Device:PHIDDevice; Consumer:PHIDConsumer):LongWord;
Device | The HID device containing the collections to unbind a consumer from |
---|---|
Consumer | The consumer to unbind the collections from (nil to unbind from current consumer) |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceCreate:PHIDDevice;
Return | Pointer to new HID device entry or nil if HID device could not be created |
---|
function HIDDeviceCreateEx(Size:LongWord):PHIDDevice;
Size | Size in bytes to allocate for new HID device (Including the HID device entry) |
---|---|
Return | Pointer to new HID device entry or nil if HID device could not be created |
function HIDDeviceDestroy(Device:PHIDDevice):LongWord;
Device | The HID device to destroy |
---|---|
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceRegister(Device:PHIDDevice):LongWord;
Device | The HID device to register |
---|---|
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceDeregister(Device:PHIDDevice):LongWord;
Device | The HID device to deregister |
---|---|
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceFind(HIDId:LongWord):PHIDDevice;
HIDId | The ID number of the HID device to find |
---|---|
Return | Pointer to HID device entry or nil if not found |
function HIDDeviceFindByName(const Name:String):PHIDDevice; inline;
Name | The name of the HID device to find (eg HID0) |
---|---|
Return | Pointer to HID device entry or nil if not found |
function HIDDeviceFindByDescription(const Description:String):PHIDDevice; inline;
Description | The description of the HID to find (eg Optical USB Mouse) |
---|---|
Return | Pointer to HID device entry or nil if not found |
function HIDDeviceEnumerate(Callback:THIDDeviceEnumerate; Data:Pointer):LongWord;
Callback | The callback function to call for each HID device in the table |
---|---|
Data | A private data pointer to pass to callback for each HID device in the table |
Return | ERROR_SUCCESS if completed or another error code on failure |
function HIDDeviceNotification(Device:PHIDDevice; Callback:THIDDeviceNotification; Data:Pointer; Notification,Flags:LongWord):LongWord;
Device | The HID device to notify changes for (Optional, pass nil for all HID devices) |
---|---|
Callback | The function to call when a notification event occurs |
Data | A private data pointer to pass to callback when a notification event occurs |
Notification | The events to register for notification of (eg DEVICE_NOTIFICATION_REGISTER) |
Flags | The flags to control the notification (eg NOTIFIER_FLAG_WORKER) |
HID consumer functions
function HIDConsumerCreate:PHIDConsumer;
Return | Pointer to new Consumer entry or nil if consumer could not be created |
---|
function HIDConsumerCreateEx(Size:LongWord):PHIDConsumer;
Size | Size in bytes to allocate for new consumer (Including the consumer entry) |
---|---|
Return | Pointer to new Consumer entry or nil if consumer could not be created |
function HIDConsumerDestroy(Consumer:PHIDConsumer):LongWord;
Note | None documented |
---|
function HIDConsumerRegister(Consumer:PHIDConsumer):LongWord;
Note | None documented |
---|
function HIDConsumerDeregister(Consumer:PHIDConsumer):LongWord;
Note | None documented |
---|
function HIDConsumerFind(ConsumerId:LongWord):PHIDConsumer;
Note | None documented |
---|
function HIDConsumerFindByName(const Name:String):PHIDConsumer; inline;
Note | None documented |
---|
function HIDConsumerEnumerate(Callback:THIDConsumerEnumerate; Data:Pointer):LongWord;
Note | None documented |
---|
HID helper functions
function HIDIsBitField(Field:PHIDField):Boolean;
Note | None documented |
---|
function HIDIsByteField(Field:PHIDField):Boolean;
Note | None documented |
---|
function HIDIsWordField(Field:PHIDField):Boolean;
Note | None documented |
---|
function HIDIsLongField(Field:PHIDField):Boolean;
Note | None documented |
---|
function HIDIsSignedField(Field:PHIDField):Boolean;
Note | None documented |
---|
function HIDPageToString(Page:Word):String;
Note | None documented |
---|
function HIDUsageToString(Page,Usage,Count:Word):String;
Note | None documented |
---|
function HIDUnitTypeToString(UnitType:LongWord):String;
Note | None documented |
---|
function HIDReportKindToString(Kind:Byte):String;
Note | None documented |
---|
function HIDReportFlagsToString(Flags:LongWord):String;
Note | None documented |
---|
function HIDCollectionFlagsToString(Flags:LongWord):String;
Note | None documented |
---|
procedure HIDLog(Level:LongWord; Device:PHIDDevice; const AText:String);
Note | None documented |
---|
procedure HIDLogInfo(Device:PHIDDevice; const AText:String);
Note | None documented |
---|
procedure HIDLogWarn(Device:PHIDDevice; const AText:String);
Note | None documented |
---|
procedure HIDLogError(Device:PHIDDevice; const AText:String);
Note | None documented |
---|
procedure HIDLogDebug(Device:PHIDDevice; const AText:String);
Note | None documented |
---|
HID device helper functions
function HIDDeviceGetCount:LongWord;
Note | None documented |
---|
function HIDDeviceCheck(Device:PHIDDevice):PHIDDevice;
Note | None documented |
---|
function HIDDeviceTypeToString(HIDType:LongWord):String;
Note | None documented |
---|
function HIDDeviceStateToString(HIDState:LongWord):String;
Note | None documented |
---|
function HIDDeviceStateToNotification(State:LongWord):LongWord;
Note | None documented |
---|
HID consumer helper functions
function HIDConsumerGetCount:LongWord;
Note | None documented |
---|
function HIDConsumerCheck(Consumer:PHIDConsumer):PHIDConsumer;
Note | None documented |
---|
Return to Unit Reference