Main Site Documentation

USBClient - HID Device


#1

I have one question. Can be custom USBClient class used to create normal HID device(not mouse or keyboard) for example in PC I will use Win32Usb class to access to device? Because I already have developers which are make different applications to use this device I can’t change comunication protocols…
reference hardware use PIC 18F2550 but I would like replace it with USBizi100 that I can myself make FW upgrades…
Reference device is by windows detected as:


public const byte VendorID          = 0x0;
public const byte ProductID    = 0x2;

Will init code like this work:


if (Configuration.DebugInterface.GetCurrent() == Configuration.DebugInterface.Port.USB1)
	throw new InvalidOperationException("Current debug interface is USB.");

ushort myVID = 0x0000;
ushort myPID = 0x0002;
ushort myDeviceVersion = 0x0001;
ushort myDeviceMaxPower = 100; // in milli amps
string companyName = "My Company";
string productName = "My Product";
string myDeviceSerialNumber = "0";

USBC_Device device = new USBC_Device(myVID, myPID, myDeviceVersion, myDeviceMaxPower, companyName, productName, myDeviceSerialNumber);

byte readEPNumber = device.ReserveNewEndpoint();
byte writeEPNumber = device.ReserveNewEndpoint();

MS.Configuration.Endpoint[] epDesc = {
                new MS.Configuration.Endpoint(writeEPNumber, MS.Configuration.Endpoint.ATTRIB_Write | MS.Configuration.Endpoint.ATTRIB_Bulk),
                new MS.Configuration.Endpoint(readEPNumber, MS.Configuration.Endpoint.ATTRIB_Read | MS.Configuration.Endpoint.ATTRIB_Bulk),
            };
epDesc[0].wMaxPacketSize = 64;
epDesc[1].wMaxPacketSize = 64;

MS.Configuration.UsbInterface usbInterface = new MS.Configuration.UsbInterface(0, epDesc);

usbInterface.bInterfaceClass = 0xFF; // vendor defined
usbInterface.bInterfaceSubClass = 0xFF;
usbInterface.bInterfaceProtocol = 0xFF;

byte interfaceIndex = device.AddInterface(usbInterface, "My interface name");

USBC_Stream stream = device.CreateUSBStream(writeEPNumber, readEPNumber);

USBClientController.Start(device);

//Do something with device...

Or Im miss something in custom USBClient understanding?
If this can be done can I simulate two devices with one hardware? For example another have:

ushort myPID = 0x0003;

In attachment is screenshot how current device is detected by windows.

Thanks for any help.


#2

When I plug original device to USB is detected like this device marked with red box on picture in attachment.
So can be USBizi100? Im try use FEZMini but something do not work ok.
Can someone recommend me some application which output all USB device Info that I can compare settings from PIC and USBizi?
Thanks for any help.


#3

Ok Im find one tool USBDeview and check USB Infos.
Here is report from ORIGINAL Device:


==================================================
Device Name       : Port_#0001.Hub_#0007
Description       : USB Input Device
Device Type       : HID (Human Interface Device)
Connected         : Yes
Safe To Unplug    : Yes
Disabled          : No
USB Hub           : No
Drive Letter      : 
Serial Number     : 
Created Date      : 12.4.2012 21:25:06
Last Plug/Unplug Date: 12.4.2012 21:25:07
VendorID          : 0000
ProductID         : 0002
Firmware Revision : 0.01
USB Class         : 03
USB SubClass      : 00
USB Protocol      : 00
Hub / Port        : Hub 4, Port 1
Computer Name     : 
Vendor Name       : 
Product Name      : 
ParentId Prefix   : 6&49bda1c&2
Service Name      : HidUsb
Service Description: Microsoft HID Class Driver
Driver Filename   : hidusb.sys
Device Class      : HIDClass
Device Mfg        : @ input.inf,%stdmfg%;(Standard system devices)
Power             : 100 mA
USB Version       : 2.00
Driver Description: USB Input Device
Driver Version    : 6.1.7601.17514
Instance ID       : USB\VID_0000&PID_0002\5&37559649&0&1
==================================================

and this is from my FEZMini when I create USBClient:

==================================================
Device Name       : Port_#0001.Hub_#0007
Description       : USB Input Device
Device Type       : HID (Human Interface Device)
Connected         : No
Safe To Unplug    : No
Disabled          : No
USB Hub           : No
Drive Letter      : 
Serial Number     : 5&37559649&0&2
Created Date      : 12.4.2012 21:32:48
Last Plug/Unplug Date: 12.4.2012 21:32:49
VendorID          : 0000
ProductID         : 0002
Firmware Revision : 0.01
USB Class         : 03
USB SubClass      : 00
USB Protocol      : 00
Hub / Port        : 
Computer Name     : 
Vendor Name       : 
Product Name      : 
ParentId Prefix   : 
Service Name      : HidUsb
Service Description: Microsoft HID Class Driver
Driver Filename   : hidusb.sys
Device Class      : HIDClass
Device Mfg        : @ input.inf,%stdmfg%;(Standard system devices)
Power             : 100 mA
USB Version       : 2.00
Driver Description: USB Input Device
Driver Version    : 6.1.7601.17514
Instance ID       : USB\VID_0000&PID_0002\5&37559649&0&2
==================================================

It show In device manager but with Error 10. Screenshot is in attachment.


#4

Code which I use for USB Configuration:


private static void USB_Init()
        {
            ushort myVID = 0x0000;
            ushort myPID = 0x0002;
            ushort myDeviceVersion = 0x0001;
            ushort myDeviceMaxPower = 100; // in milli amps
            string companyName = "www.carpc.si";
            string productName = "Parking Sensor USB";
            string myDeviceSerialNumber = "5&37559649&0&2";

            USBC_Device device = new USBC_Device(myVID, myPID, myDeviceVersion, myDeviceMaxPower, companyName, productName, myDeviceSerialNumber);

            byte readEPNumber = device.ReserveNewEndpoint();
            byte writeEPNumber = device.ReserveNewEndpoint();

            MS.Configuration.Endpoint[] epDesc = 
            {
                new MS.Configuration.Endpoint(writeEPNumber, MS.Configuration.Endpoint.ATTRIB_Write | MS.Configuration.Endpoint.ATTRIB_Bulk),
                new MS.Configuration.Endpoint(readEPNumber, MS.Configuration.Endpoint.ATTRIB_Read | MS.Configuration.Endpoint.ATTRIB_Bulk),
            };
            epDesc[0].wMaxPacketSize = 8;
            //epDesc[0].bInterval = 1;
            epDesc[1].wMaxPacketSize = 8;
            //epDesc[1].bInterval = 1;

            MS.Configuration.UsbInterface usbInterface = new MS.Configuration.UsbInterface(0, epDesc);

            usbInterface.bInterfaceClass = 0x03; // vendor defined
            usbInterface.bInterfaceSubClass = 0x00;
            usbInterface.bInterfaceProtocol = 0x00;

            MS.Configuration.StringDescriptor manufacturerNameStringDescriptor = new MS.Configuration.StringDescriptor(1, companyName);
            device.AddDescriptor(manufacturerNameStringDescriptor);

            MS.Configuration.StringDescriptor productNameStringDescriptor = new MS.Configuration.StringDescriptor(2, productName);
            device.AddDescriptor(productNameStringDescriptor);

            byte interfaceIndex = device.AddInterface(usbInterface, productName);

            USBC_Stream stream = device.CreateUSBStream(writeEPNumber, readEPNumber);

            USBClientController.Start(device);

            Debug.Print("Waiting to connect to PC...");
        }


#5

This should help http://forums.netduino.com/index.php?/topic/1514-driverless-pc-netduino-communication-using-usb/page__p__10713__hl__hid__fromsearch__1#entry10713


#6

Gus thanks for your reply and help.
Im try use project from their first post but do not work. What Im do:
1.)Extract project to HDD
2.)Put jumper on MOD & GND pins on FEZMini "SD Interface Connector"
3.)Open project and set
Deployement Transport: Serial
Deployement Device: COM1
4.)Remove from References:

[quote]SecretLabs.NETMF.Hardware
SecretLabs.NETMF.Hardware.Netduino[/quote]
5.)Add GHI References:

[quote]FEZMini_GHIElectronics.NETMF.FEZ
GHIElectronics.NETMF.Hardware[/quote]
6.)In Program.cs change from:


using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;

to:


using GHIHardware = GHIElectronics.NETMF.Hardware;
using GHIElectronics.NETMF.FEZ;

6.)Connect PC COM1 to FEZMini IN/OUT Pins.
7.)Connect FEZMini to PC USB
8.)Change project to Release and deploy it to FEZMini

Any hint what Im do wrong that device is not recognised right(Screenshot in attachment)? Can you try to do same thing on one FEZMini and test if you have same problems(Whole procedure take max 10 minutes)?


#7

What Im try:
Power FEZMini with connecting 5V to GND and “5V out USB-powered 5V to 9VIn” pin wait few seconds and then connect USB Cable. But don’t help.


#8

Not sure myself


#9

I did something on FEZ Cobra in the past, I’ll search the code. I can also recommend this tool from MS: http://bit.ly/HG4Ufm

It will show you the USB descriptors too.


#10

Here you go, an example that enumerates as a HID Pen device. It is test code and not cleaned up, maybe hard to read, but you’ll figure it out :slight_smile: For your project you’ll just need to change the hidGenericReportDescriptorPayload I guess.


using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using GHIElectronics.NETMF.FEZ;
using GHIElectronics.NETMF.USBClient;
using GHIElectronics.NETMF.Hardware;

using MS = Microsoft.SPOT.Hardware.UsbClient;
using Microsoft.SPOT.Net.NetworkInformation;
using Microsoft.SPOT.Touch;

namespace USBClient_Example
{
    public class Program
    {
        const int USBSTREAM_WRITE_ENDPOINT = 1;
        const int USBSTREAM_READ_ENDPOINT = 2;
        const int MAXPOWER_MILLIAMPS = 280; // default; can be up to 500mA

        const int HID_DESCRIPTOR_TYPE = 0x21;

        public static void Main()
        {
            NetworkInterface interf = NetworkInterface.GetAllNetworkInterfaces()[0];
            interf.EnableStaticIP("192.168.1.200", "255.255.255.0", "192.168.1.1");

            OutputPort LED;
            LED = new OutputPort((Cpu.Pin)FEZ_Pin.Digital.LED, true);

            TouchPanel touch = Touch.ActiveTouchPanel;
            touch.Enabled = true;


            InputPort buttonUp = new InputPort((Cpu.Pin)FEZ_Pin.Digital.ButtonUp, true, Port.ResistorMode.PullUp);
            InputPort buttonDown = new InputPort((Cpu.Pin)FEZ_Pin.Digital.ButtonDown, true, Port.ResistorMode.PullUp);
            InputPort buttonSelect = new InputPort((Cpu.Pin)FEZ_Pin.Digital.ButtonSelect, true, Port.ResistorMode.PullUp);

            // Check debug interface
            if (Configuration.DebugInterface.GetCurrent() == Configuration.DebugInterface.Port.USB1)
            {
                Configuration.DebugInterface.Set(Configuration.DebugInterface.Port.Sockets1, Configuration.DebugInterface.Port.USB1);
                throw new InvalidOperationException("Current debug interface is USB. Please restart your board.");
            }


            ushort myVID = 0x1234;
            ushort myPID = 0x0007;
            ushort myDeviceVersion = 0x100;
            ushort myDeviceMaxPower = 250; // in milli amps
            string companyName = "FastloadMedia";
            string productName = "Pen device";
            string myDeviceSerialNumber = "0";

            // Create the device. Assume it just has one read and one write endpoints.
            USBC_Device device = new USBC_Device(myVID, myPID, myDeviceVersion, myDeviceMaxPower, companyName, productName, myDeviceSerialNumber);
            
            // Endpoints
            byte writeEPNumber = device.ReserveNewEndpoint();
            byte readEPNumber = device.ReserveNewEndpoint();
            MS.Configuration.Endpoint[] epDesc = {
                new MS.Configuration.Endpoint(writeEPNumber, MS.Configuration.Endpoint.ATTRIB_Write | MS.Configuration.Endpoint.ATTRIB_Interrupt),
                new MS.Configuration.Endpoint(readEPNumber, MS.Configuration.Endpoint.ATTRIB_Read | MS.Configuration.Endpoint.ATTRIB_Interrupt),
            };
            epDesc[0].wMaxPacketSize = 16;
            epDesc[0].bInterval = 10;
            epDesc[1].wMaxPacketSize = 16;
            epDesc[1].bInterval = 10;

            // HID report descriptor
            byte[] hidGenericReportDescriptorPayload = new byte[]
            {
        0x05, 0x0d,                         // USAGE_PAGE (Digitizers)          0
    0x09, 0x02,                         // USAGE (Pen)                      2
    0xa1, 0x01,                         // COLLECTION (Application)         4
    0x85, 0x01,                        //   REPORT_ID (Pen)                6
    0x09, 0x20,                         //   USAGE (Stylus)                 8
    0xa1, 0x00,                         //   COLLECTION (Physical)          10
    0x09, 0x42,                         //     USAGE (Tip Switch)           12
    0x09, 0x44,                         //     USAGE (Barrel Switch)        14
    0x09, 0x45,                         //     USAGE (Eraser Switch)        16
    0x09, 0x3c,                         //     USAGE (Invert)               18
    0x09, 0x32,                         //     USAGE (In Range)             20
    0x15, 0x00,                         //     LOGICAL_MINIMUM (0)          22
    0x25, 0x01,                         //     LOGICAL_MAXIMUM (1)          24
    0x75, 0x01,                         //     REPORT_SIZE (1)              26
    0x95, 0x05,                         //     REPORT_COUNT (5)             28
    0x81, 0x02,                         //     INPUT (Data,Var,Abs)         30
    0x95, 0x0b,                         //     REPORT_COUNT (11)            32
    0x81, 0x03,                         //     INPUT (Cnst,Var,Abs)         34
    0x05, 0x01,                         //     USAGE_PAGE (Generic Desktop) 36
    0x26, 0xff, 0x7f,                   //     LOGICAL_MAXIMUM (32767)      38
    0x75, 0x10,                         //     REPORT_SIZE (16)             41
    0x95, 0x01,                         //     REPORT_COUNT (1)             43
    0xa4,                               //     PUSH                         45
    0x55, 0x0d,                         //     UNIT_EXPONENT (-3)           46
    0x65, 0x33,                         //     UNIT (Inch,EngLinear)        48
    0x09, 0x30,                         //     USAGE (X)                    50
    0x35, 0x00,                         //     PHYSICAL_MINIMUM (0)         52
    0x46, 0x00, 0x00,                   //     PHYSICAL_MAXIMUM (0)         54
    0x81, 0x02,                         //     INPUT (Data,Var,Abs)         57
    0x09, 0x31,                         //     USAGE (Y)                    59
    0x46, 0x00, 0x00,                   //     PHYSICAL_MAXIMUM (0)         61
    0x81, 0x02,                         //     INPUT (Data,Var,Abs)         64
    0xb4,                               //     POP                          66
    0x05, 0x0d,                         //     USAGE_PAGE (Digitizers)      67
    0x09, 0x30,                         //     USAGE (Tip Pressure)         69
    0x81, 0x02,                         //     INPUT (Data,Var,Abs)         71
    0x09, 0x3d,                         //     USAGE (X Tilt)               73
    0x09, 0x3e,                         //     USAGE (Y Tilt)               75
    0x16, 0x01, 0x80,                   //     LOGICAL_MINIMUM (-32767)     77
    0x95, 0x02,                         //     REPORT_COUNT (2)             80
    0x81, 0x02,                         //     INPUT (Data,Var,Abs)         82/84
    0xc0,                               //   END_COLLECTION                 0/1
    0xc0,                               // END_COLLECTION                   0/1
            };

            // Class Descriptor
            byte[] hidClassDescriptorPayload = new byte[] 
            {
                0x01, 0x01,     // bcdHID (v1.01)
                0x00,           // bCountryCode
                0x01,           // bNumDescriptors
                0x22,           // bDescriptorType (report)
                (byte)hidGenericReportDescriptorPayload.Length, 0x00      // wDescriptorLength (report descriptor size in bytes)
            };
            // HID class descriptor
            MS.Configuration.ClassDescriptor hidClassDescriptor = new MS.Configuration.ClassDescriptor(HID_DESCRIPTOR_TYPE, hidClassDescriptorPayload);
            // Interface
            MS.Configuration.UsbInterface usbInterface = new MS.Configuration.UsbInterface(0, epDesc);
            usbInterface.classDescriptors = new MS.Configuration.ClassDescriptor[] { hidClassDescriptor };
            usbInterface.bInterfaceClass = 0x03; // HID
            usbInterface.bInterfaceSubClass = 0x00;
            usbInterface.bInterfaceProtocol = 0x00;
            // Attach interface
            byte interfaceIndex = device.AddInterface(usbInterface, "My interface name");
                       
                        
            MS.Configuration.GenericDescriptor hidGenericReportDescriptor = new MS.Configuration.GenericDescriptor(0x81, 0x2200, hidGenericReportDescriptorPayload);
            hidGenericReportDescriptor.bRequest = 0x06; // GET_DESCRIPTOR
            hidGenericReportDescriptor.wIndex = 0x00; // INTERFACE 0 (zero)
            // attach descriptor
            device.AddDescriptor(hidGenericReportDescriptor);

            // Strings
            MS.Configuration.StringDescriptor stringDescriptor1 = new MS.Configuration.StringDescriptor(1, "String 1");
            MS.Configuration.StringDescriptor stringDescriptor2 = new MS.Configuration.StringDescriptor(2, "String 2");
            device.AddDescriptor(stringDescriptor1);
            device.AddDescriptor(stringDescriptor2);

            // This is used for reading and writing
            USBC_Stream stream = device.CreateUSBStream(writeEPNumber, readEPNumber);

            // All done, you can start the device now
            USBClientController.Start(device);

            byte[] report = new byte[13];

            int x = 0;
            int y = 0;

            while (USBClientController.GetState() != USBClientController.State.Running)
            {
                Debug.Print("Waiting to connect to PC...");
                Thread.Sleep(1000);
            }

            while (true)
            {
                Thread.Sleep(20);

                // Check if connected to PC

                if (!buttonUp.Read())
                    x += 32;

                if (!buttonDown.Read())
                    y += 32;

                report[0] = 0x01;

                bool pressed = !buttonSelect.Read();

                report[1] = (byte)(pressed ? 0x31 : 0x30);
                report[3] = (byte)x;
                report[4] = (byte)((x >> 8) & 0x7f);
                report[5] = (byte)y;
                report[6] = (byte)((y >> 8) & 0x7f);
                report[7] = (byte)(pressed ? 0xFF : 0x00);
                report[8] = 0x0;

                stream.Write(report, 0, report.Length);
                    
                //report[9] = 0;
                //report[10] = 0;

                //report[11] = 0;
                //report[12] = 0;

                
            }
        }

    }
}



#11

Here: http://www.usb.org/developers/hidpage/ you’ll find a tool (HID Descriptor Tool) that enables you to create and validate HID report descriptors.


#12

Wouter Huysentruit THANKS for your help and code example. It work on FEZMini and Windows detect it as HID Pen device. Im only remove network, buttons, touch from it and work first time…
Now I must build own HID report descriptor(hidGenericReportDescriptorPayload) that device will be detected as original device… Im pretty close :slight_smile:
Original device:


Device Descriptor:
bcdUSB:             0x0200
bDeviceClass:         0x00
bDeviceSubClass:      0x00
bDeviceProtocol:      0x00
bMaxPacketSize0:      0x08 (8)
idVendor:           0x0000
idProduct:          0x0003
bcdDevice:          0x0001
iManufacturer:        0x01
0x0409: "Muntaner's Technology"
iProduct:             0x02
0x0409: "Parking Sensor USB"
iSerialNumber:        0x00
bNumConfigurations:   0x01

ConnectionStatus: DeviceConnected
Current Config Value: 0x01
Device Bus Speed:     Full
Device Address:       0x01
Open Pipes:              2

Endpoint Descriptor:
bEndpointAddress:     0x81  IN
Transfer Type:   Interrupt
wMaxPacketSize:     0x0040 (64)
bInterval:            0x01

Endpoint Descriptor:
bEndpointAddress:     0x01  OUT
Transfer Type:   Interrupt
wMaxPacketSize:     0x0040 (64)
bInterval:            0x01

Configuration Descriptor:
wTotalLength:       0x0029
bNumInterfaces:       0x01
bConfigurationValue:  0x01
iConfiguration:       0x00
bmAttributes:         0xA0 (Bus Powered Remote Wakeup)
MaxPower:             0x32 (100 Ma)

Interface Descriptor:
bInterfaceNumber:     0x00
bAlternateSetting:    0x00
bNumEndpoints:        0x02
bInterfaceClass:      0x03 (HID)
bInterfaceSubClass:   0x00
bInterfaceProtocol:   0x00
iInterface:           0x00

HID Descriptor:
bcdHID:             0x0101
bCountryCode:         0x00
bNumDescriptors:      0x01
bDescriptorType:      0x22
wDescriptorLength:  0x002F

Endpoint Descriptor:
bEndpointAddress:     0x81  IN
Transfer Type:   Interrupt
wMaxPacketSize:     0x0040 (64)
bInterval:            0x01

Endpoint Descriptor:
bEndpointAddress:     0x01  OUT
Transfer Type:   Interrupt
wMaxPacketSize:     0x0040 (64)
bInterval:            0x01

My current device:


Device Descriptor:
bcdUSB:             0x0200
bDeviceClass:         0x00
bDeviceSubClass:      0x00
bDeviceProtocol:      0x00
bMaxPacketSize0:      0x40 (64)
idVendor:           0x0000
idProduct:          0x0003
bcdDevice:          0x0001
iManufacturer:        0x0A
0x0409: "Muntaner's Technology"
iProduct:             0x0B
0x0409: "Parking Sensor USB"
iSerialNumber:        0x0C
0x0409: "0"
bNumConfigurations:   0x01

ConnectionStatus: DeviceConnected
Current Config Value: 0x01
Device Bus Speed:     Full
Device Address:       0x01
Open Pipes:              2

Endpoint Descriptor:
bEndpointAddress:     0x81  IN
Transfer Type:   Interrupt
wMaxPacketSize:     0x0040 (64)
bInterval:            0x01

Endpoint Descriptor:
bEndpointAddress:     0x02  OUT
Transfer Type:   Interrupt
wMaxPacketSize:     0x0040 (64)
bInterval:            0x01

Configuration Descriptor:
wTotalLength:       0x0029
bNumInterfaces:       0x01
bConfigurationValue:  0x01
iConfiguration:       0x00
bmAttributes:         0x80 (Bus Powered )
MaxPower:             0x32 (100 Ma)

Interface Descriptor:
bInterfaceNumber:     0x00
bAlternateSetting:    0x00
bNumEndpoints:        0x02
bInterfaceClass:      0x03 (HID)
bInterfaceSubClass:   0x00
bInterfaceProtocol:   0x00
iInterface:           0x00

HID Descriptor:
bcdHID:             0x0101
bCountryCode:         0x00
bNumDescriptors:      0x01
bDescriptorType:      0x22
wDescriptorLength:  0x0056

Endpoint Descriptor:
bEndpointAddress:     0x81  IN
Transfer Type:   Interrupt
wMaxPacketSize:     0x0040 (64)
bInterval:            0x01

Endpoint Descriptor:
bEndpointAddress:     0x02  OUT
Transfer Type:   Interrupt
wMaxPacketSize:     0x0040 (64)
bInterval:            0x01

Thanks again for your time, help and code(I think that you can upload snippet to forum that it will be easier to find it).


#13

Your original device has a HID descriptor length of:
wDescriptorLength: 0x002F (== 47 bytes)

The Pen device has a HID descriptor length of:
wDescriptorLength: 0x0056 (== 86 bytes)

86 is exactly the number of bytes passed in the hidGenericReportDescriptorPayload array. Now it seems like USB view doesn’t show you the HID descriptor, which is really what you are looking for. Search for a tool that shows you that information, some kind of USB sniffer (search for USB Snoopy) Once you have the 47 bytes HID descriptor from your original device, you can copy paste them into the array, et voila :slight_smile:


#14

Im find descriptor which is used on device:


byte[] hidGenericReportDescriptorPayload = new byte[]
                {
                     0x06, 0xA0, 0xFF,
                     0x09, 0x01, 
                     0xA1, 0x01, 
                     0x09, 0x03, 
                     0x15, 0x00, 
                     0x26, 0x00, 0xFF, 
                     0x75, 0x08, 
                     0x95, 0x05, 
                     0x81, 0x02, 
                     0x09, 0x04, 
                     0x15, 0x00, 
                     0x26, 0x00, 0xFF,
                     0x75, 0x08, 
                     0x95, 0x01, 
                     0x91, 0x02, 
                     0x09, 0x05, 
                     0x15, 0x00, 
                     0x26, 0x00, 0xFF, 
                     0x75, 0x08, 
                     0x95, 0x02, 
                     0xB1, 0x02, 
                     0xC0,
                }

Im try use it on FEZMini and create some simulator on it and try it with software and work as must :slight_smile:
Thanks for your help.


#15

You’re welcome.


#16

Thanks wouter