【Qt】Linux HID API

Linux下HID可以使用libusb与hidapi结合，我是将hidapi略作修改变成一个自己的interface，以下在Qt中使用。

1、首先编译libusb(这里是libusb-1.0.21)，本机直接make install --prefix=$(pwd)/_libusb，交叉编译需要设定对应编译器。

2、复制libusb.h和libusb的动态库(.so)和静态库(.a)到自己建立的文件夹，例如hidapi，我这里建立了三个平台的库，并且使用静态库。

3、使用修改hidapi的Qt程序如下，hidapi.h和hid-libusb.c从hidapi中提取修改，hidinterface为再封装的代码，其中可以自行修改PIC和VID，main的c为使用实例：

a) .pro文件

QT -= coreQT -= guiCONFIG += c++11TARGET = HIDAPICONFIG += consoleCONFIG -= app_bundleTEMPLATE = appSOURCES += \    hidlib/hid-libusb.c \    hidlib/hidinterface.c \    main.cHEADERS += \    hidlib/hidapi.h \    hidlib/hidinterface.h#staticmessage("$$myPlatform compile")INCLUDEPATH += $$PWD/lib/$$myPlatform/libusb/include/libusb-1.0/LIBS += $$PWD/lib/$$myPlatform/libusb/lib/libusb-1.0.a

b) hidapi.h

/******************************************************* HIDAPI - Multi-Platform library for communication with HID devices. Alan Ott Signal 11 Software 8/22/2009 Copyright 2009, All Rights Reserved. At the discretion of the user of this library, this software may be licensed under the terms of the GNU Public License v3, a BSD-Style license, or the original HIDAPI license as outlined in the LICENSE.txt, LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt files located at the root of the source distribution. These files may also be found in the public source code repository located at:        http://github.com/signal11/hidapi .********************************************************//** @file * @defgroup API hidapi API */#ifndef HIDAPI_H__#define HIDAPI_H__#include <wchar.h>#ifdef _WIN32      #define HID_API_EXPORT __declspec(dllexport)      #define HID_API_CALL#else      #define HID_API_EXPORT /**< API export macro */      #define HID_API_CALL /**< API call macro */#endif#define HID_API_EXPORT_CALL HID_API_EXPORT HID_API_CALL /**< API export and call macro*/#ifdef __cplusplusextern "C" {#endifstruct hid_device_;typedef struct hid_device_ hid_device; /**< opaque hidapi structure *//** hidapi info structure */struct hid_device_info {/** Platform-specific device path */char *path;/** Device Vendor ID */unsigned short vendor_id;/** Device Product ID */unsigned short product_id;/** Serial Number */wchar_t *serial_number;/** Device Release Number in binary-coded decimal,    also known as Device Version Number */unsigned short release_number;/** Manufacturer String */wchar_t *manufacturer_string;/** Product string */wchar_t *product_string;/** Usage Page for this Device/Interface    (Windows/Mac only). */unsigned short usage_page;/** Usage for this Device/Interface    (Windows/Mac only).*/unsigned short usage;/** The USB interface which this logical device    represents. Valid on both Linux implementations    in all cases, and valid on the Windows implementation    only if the device contains more than one interface. */int interface_number;/** Pointer to the next device */struct hid_device_info *next;};/** @brief Initialize the HIDAPI library.This function initializes the HIDAPI library. Calling it is notstrictly necessary, as it will be called automatically byhid_enumerate() and any of the hid_open_*() functions if it isneeded.  This function should be called at the beginning ofexecution however, if there is a chance of HIDAPI handlesbeing opened by different threads simultaneously.@ingroup API@returnsThis function returns 0 on success and -1 on error.*/int HID_API_EXPORT HID_API_CALL hid_init(void);/** @brief Finalize the HIDAPI library.This function frees all of the static data associated withHIDAPI. It should be called at the end of execution to avoidmemory leaks.@ingroup API    @returnsThis function returns 0 on success and -1 on error.*/int HID_API_EXPORT HID_API_CALL hid_exit(void);/** @brief Enumerate the HID Devices.This function returns a linked list of all the HID devicesattached to the system which match vendor_id and product_id.If @p vendor_id and @p product_id are both set to 0, thenall HID devices will be returned.@ingroup API@param vendor_id The Vendor ID (VID) of the types of deviceto open.@param product_id The Product ID (PID) of the types ofdevice to open.    @returns    This function returns a pointer to a linked list of type    struct #hid_device, containing information about the HID devices    attached to the system, or NULL in the case of failure. Free    this linked list by calling hid_free_enumeration().*/struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id);/** @brief Free an enumeration Linked List    This function frees a linked list created by hid_enumerate().@ingroup API    @param devs Pointer to a list of struct_device returned from          hid_enumerate().*/void  HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs);/** @brief Open a HID device using a Vendor ID (VID), Product ID(PID) and optionally a serial number.If @p serial_number is NULL, the first device with thespecified VID and PID is opened.@ingroup API@param vendor_id The Vendor ID (VID) of the device to open.@param product_id The Product ID (PID) of the device to open.@param serial_number The Serial Number of the device to open               (Optionally NULL).@returnsThis function returns a pointer to a #hid_device object onsuccess or NULL on failure.*/HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, wchar_t *serial_number);/** @brief Open a HID device by its path name.The path name be determined by calling hid_enumerate(), or aplatform-specific path name can be used (eg: /dev/hidraw0 onLinux).@ingroup API    @param path The path name of the device to open@returnsThis function returns a pointer to a #hid_device object onsuccess or NULL on failure.*/HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path);/** @brief Write an Output report to a HID device.The first byte of @p data[] must contain the Report ID. Fordevices which only support a single report, this must be setto 0x0. The remaining bytes contain the report data. Sincethe Report ID is mandatory, calls to hid_write() will alwayscontain one more byte than the report contains. For example,if a hid report is 16 bytes long, 17 bytes must be passed tohid_write(), the Report ID (or 0x0, for devices with asingle report), followed by the report data (16 bytes). Inthis example, the length passed in would be 17.hid_write() will send the data on the first OUT endpoint, ifone exists. If it does not, it will send the data throughthe Control Endpoint (Endpoint 0).@ingroup API@param device A device handle returned from hid_open().@param data The data to send, including the report number asthe first byte.@param length The length in bytes of the data to send.@returnsThis function returns the actual number of bytes written and-1 on error.*/int  HID_API_EXPORT HID_API_CALL hid_write(hid_device *device, const unsigned char *data, size_t length);/** @brief Read an Input report from a HID device with timeout.Input reports are returnedto the host through the INTERRUPT IN endpoint. The first byte willcontain the Report number if the device uses numbered reports.@ingroup API@param device A device handle returned from hid_open().@param data A buffer to put the read data into.@param length The number of bytes to read. For devices withmultiple reports, make sure to read an extra byte forthe report number.@param milliseconds timeout in milliseconds or -1 for blocking wait.@returnsThis function returns the actual number of bytes read and-1 on error.*/int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds);/** @brief Read an Input report from a HID device.Input reports are returned    to the host through the INTERRUPT IN endpoint. The first byte willcontain the Report number if the device uses numbered reports.@ingroup API@param device A device handle returned from hid_open().@param data A buffer to put the read data into.@param length The number of bytes to read. For devices withmultiple reports, make sure to read an extra byte forthe report number.@returnsThis function returns the actual number of bytes read and-1 on error.*/int  HID_API_EXPORT HID_API_CALL hid_read(hid_device *device, unsigned char *data, size_t length);/** @brief Set the device handle to be non-blocking.In non-blocking mode calls to hid_read() will returnimmediately with a value of 0 if there is no data to beread. In blocking mode, hid_read() will wait (block) untilthere is data to read before returning.Nonblocking can be turned on and off at any time.@ingroup API@param device A device handle returned from hid_open().@param nonblock enable or not the nonblocking reads - 1 to enable nonblocking - 0 to disable nonblocking.@returnsThis function returns 0 on success and -1 on error.*/int  HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *device, int nonblock);/** @brief Send a Feature report to the device.Feature reports are sent over the Control endpoint as aSet_Report transfer.  The first byte of @p data[] mustcontain the Report ID. For devices which only support asingle report, this must be set to 0x0. The remaining bytescontain the report data. Since the Report ID is mandatory,calls to hid_send_feature_report() will always contain onemore byte than the report contains. For example, if a hidreport is 16 bytes long, 17 bytes must be passed tohid_send_feature_report(): the Report ID (or 0x0, fordevices which do not use numbered reports), followed by thereport data (16 bytes). In this example, the length passedin would be 17.@ingroup API@param device A device handle returned from hid_open().@param data The data to send, including the report number asthe first byte.@param length The length in bytes of the data to send, includingthe report number.@returnsThis function returns the actual number of bytes written and-1 on error.*/int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *device, const unsigned char *data, size_t length);/** @brief Get a feature report from a HID device.Make sure to set the first byte of @p data[] to the ReportID of the report to be read.  Make sure to allow space forthis extra byte in @p data[].@ingroup API@param device A device handle returned from hid_open().@param data A buffer to put the read data into, includingthe Report ID. Set the first byte of @p data[] to theReport ID of the report to be read.@param length The number of bytes to read, including anextra byte for the report ID. The buffer can be longerthan the actual report.@returnsThis function returns the number of bytes read and-1 on error.*/int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *device, unsigned char *data, size_t length);/** @brief Close a HID device.@ingroup API@param device A device handle returned from hid_open().*/void HID_API_EXPORT HID_API_CALL hid_close(hid_device *device);/** @brief Get The Manufacturer String from a HID device.@ingroup API@param device A device handle returned from hid_open().@param string A wide string buffer to put the data into.@param maxlen The length of the buffer in multiples of wchar_t.@returnsThis function returns 0 on success and -1 on error.*/int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *device, wchar_t *string, size_t maxlen);/** @brief Get The Product String from a HID device.@ingroup API@param device A device handle returned from hid_open().@param string A wide string buffer to put the data into.@param maxlen The length of the buffer in multiples of wchar_t.@returnsThis function returns 0 on success and -1 on error.*/int HID_API_EXPORT_CALL hid_get_product_string(hid_device *device, wchar_t *string, size_t maxlen);/** @brief Get The Serial Number String from a HID device.@ingroup API@param device A device handle returned from hid_open().@param string A wide string buffer to put the data into.@param maxlen The length of the buffer in multiples of wchar_t.@returnsThis function returns 0 on success and -1 on error.*/int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *device, wchar_t *string, size_t maxlen);/** @brief Get a string from a HID device, based on its string index.@ingroup API@param device A device handle returned from hid_open().@param string_index The index of the string to get.@param string A wide string buffer to put the data into.@param maxlen The length of the buffer in multiples of wchar_t.@returnsThis function returns 0 on success and -1 on error.*/int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *device, int string_index, wchar_t *string, size_t maxlen);/** @brief Get a string describing the last error which occurred.@ingroup API@param device A device handle returned from hid_open().@returnsThis function returns a string containing the last errorwhich occurred or NULL if none has occurred.*/HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *device);#ifdef __cplusplus}#endif#endif

c) hidapi-libusb.c

/******************************************************* HIDAPI - Multi-Platform library for communication with HID devices. Alan Ott Signal 11 Software 8/22/2009 Linux Version - 6/2/2010 Libusb Version - 8/13/2010 Copyright 2009, All Rights Reserved.  At the discretion of the user of this library, this software may be licensed under the terms of the GNU Public License v3, a BSD-Style license, or the original HIDAPI license as outlined in the LICENSE.txt, LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt files located at the root of the source distribution. These files may also be found in the public source code repository located at:        http://github.com/signal11/hidapi .********************************************************/#define _GNU_SOURCE // needed for wcsdup() before glibc 2.10/* C */#include <stdio.h>#include <string.h>#include <stdlib.h>#include <ctype.h>#include <locale.h>#include <errno.h>/* Unix */#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <sys/ioctl.h>#include <sys/utsname.h>#include <fcntl.h>#include <pthread.h>#include <wchar.h>/* GNU / LibUSB */#include <libusb.h>#include "iconv.h"#include "hidapi.h"#ifdef __cplusplusextern "C" {#endif#ifdef DEBUG_PRINTF#define LOG(...) fprintf(stderr, __VA_ARGS__)#else#define LOG(...) do {} while (0)#endif/* Uncomment to enable the retrieval of Usage and Usage Page inhid_enumerate(). Warning, this is very invasive as it requires the detachand re-attach of the kernel driver. See comments inside hid_enumerate().Linux/libusb HIDAPI programs are encouraged to use the interface numberinstead to differentiate between interfaces on a composite HID device. *//*#define INVASIVE_GET_USAGE*//* Linked List of input reports received from the device. */struct input_report {uint8_t *data;size_t len;struct input_report *next;};struct hid_device_ {/* Handle to the actual device. */libusb_device_handle *device_handle;/* Endpoint information */int input_endpoint;int output_endpoint;int input_ep_max_packet_size;/* The interface number of the HID */int interface;/* Indexes of Strings */int manufacturer_index;int product_index;int serial_index;/* Whether blocking reads are used */int blocking; /* boolean *//* Read thread objects */pthread_t thread;pthread_mutex_t mutex; /* Protects input_reports */pthread_cond_t condition;pthread_barrier_t barrier; /* Ensures correct startup sequence */int shutdown_thread;struct libusb_transfer *transfer;/* List of received input reports. */struct input_report *input_reports;};static int initialized = 0;uint16_t get_usb_code_for_current_locale(void);static int return_data(hid_device *dev, unsigned char *data, size_t length);static hid_device *new_hid_device(void){hid_device *dev = calloc(1, sizeof(hid_device));dev->device_handle = NULL;dev->input_endpoint = 0;dev->output_endpoint = 0;dev->input_ep_max_packet_size = 0;dev->interface = 0;dev->manufacturer_index = 0;dev->product_index = 0;dev->serial_index = 0;dev->blocking = 1;dev->shutdown_thread = 0;dev->transfer = NULL;dev->input_reports = NULL;pthread_mutex_init(&dev->mutex, NULL);pthread_cond_init(&dev->condition, NULL);pthread_barrier_init(&dev->barrier, NULL, 2);return dev;}static void free_hid_device(hid_device *dev){/* Clean up the thread objects */pthread_barrier_destroy(&dev->barrier);pthread_cond_destroy(&dev->condition);pthread_mutex_destroy(&dev->mutex);/* Free the device itself */free(dev);}#if 0//TODO: Implement this funciton on Linux.static void register_error(hid_device *device, const char *op){}#endif#ifdef INVASIVE_GET_USAGE/* Get bytes from a HID Report Descriptor.   Only call with a num_bytes of 0, 1, 2, or 4. */static uint32_t get_bytes(uint8_t *rpt, size_t len, size_t num_bytes, size_t cur){/* Return if there aren't enough bytes. */if (cur + num_bytes >= len)return 0;if (num_bytes == 0)return 0;else if (num_bytes == 1) {return rpt[cur+1];}else if (num_bytes == 2) {return (rpt[cur+2] * 256 + rpt[cur+1]);}else if (num_bytes == 4) {return (rpt[cur+4] * 0x01000000 +        rpt[cur+3] * 0x00010000 +        rpt[cur+2] * 0x00000100 +        rpt[cur+1] * 0x00000001);}elsereturn 0;}/* Retrieves the device's Usage Page and Usage from the report   descriptor. The algorithm is simple, as it just returns the first   Usage and Usage Page that it finds in the descriptor.   The return value is 0 on success and -1 on failure. */static int get_usage(uint8_t *report_descriptor, size_t size,                     unsigned short *usage_page, unsigned short *usage){int i = 0;int size_code;int data_len, key_size;int usage_found = 0, usage_page_found = 0;while (i < size) {int key = report_descriptor[i];int key_cmd = key & 0xfc;//printf("key: %02hhx\n", key);if ((key & 0xf0) == 0xf0) {/* This is a Long Item. The next byte contains the   length of the data section (value) for this key.   See the HID specification, version 1.11, section   6.2.2.3, titled "Long Items." */if (i+1 < size)data_len = report_descriptor[i+1];elsedata_len = 0; /* malformed report */key_size = 3;}else {/* This is a Short Item. The bottom two bits of the   key contain the size code for the data section   (value) for this key.  Refer to the HID   specification, version 1.11, section 6.2.2.2,   titled "Short Items." */size_code = key & 0x3;switch (size_code) {case 0:case 1:case 2:data_len = size_code;break;case 3:data_len = 4;break;default:/* Can't ever happen since size_code is & 0x3 */data_len = 0;break;};key_size = 1;}if (key_cmd == 0x4) {*usage_page  = get_bytes(report_descriptor, size, data_len, i);usage_page_found = 1;//printf("Usage Page: %x\n", (uint32_t)*usage_page);}if (key_cmd == 0x8) {*usage = get_bytes(report_descriptor, size, data_len, i);usage_found = 1;//printf("Usage: %x\n", (uint32_t)*usage);}if (usage_page_found && usage_found)return 0; /* success *//* Skip over this key and it's associated data */i += data_len + key_size;}return -1; /* failure */}#endif // INVASIVE_GET_USAGE/* Get the first language the device says it reports. This comes from   USB string #0. */static uint16_t get_first_language(libusb_device_handle *dev){uint16_t buf[32];int len;/* Get the string from libusb. */len = libusb_get_string_descriptor(dev,0x0, /* String ID */0x0, /* Language */(unsigned char*)buf,sizeof(buf));if (len < 4)return 0x0;return buf[1]; // First two bytes are len and descriptor type.}static int is_language_supported(libusb_device_handle *dev, uint16_t lang){uint16_t buf[32];int len;int i;/* Get the string from libusb. */len = libusb_get_string_descriptor(dev,0x0, /* String ID */0x0, /* Language */(unsigned char*)buf,sizeof(buf));if (len < 4)return 0x0;len /= 2; /* language IDs are two-bytes each. *//* Start at index 1 because there are two bytes of protocol data. */for (i = 1; i < len; i++) {if (buf[i] == lang)return 1;}return 0;}/* This function returns a newly allocated wide string containing the USB   device string numbered by the index. The returned string must be freed   by using free(). */static wchar_t *get_usb_string(libusb_device_handle *dev, uint8_t idx){char buf[512];int len;wchar_t *str = NULL;wchar_t wbuf[256];/* iconv variables */iconv_t ic;size_t inbytes;size_t outbytes;size_t res;char *inptr;char *outptr;/* Determine which language to use. */uint16_t lang;lang = get_usb_code_for_current_locale();if (!is_language_supported(dev, lang))lang = get_first_language(dev);/* Get the string from libusb. */len = libusb_get_string_descriptor(dev,idx,lang,(unsigned char*)buf,sizeof(buf));if (len < 0)return NULL;buf[sizeof(buf)-1] = '\0';if (len+1 < sizeof(buf))buf[len+1] = '\0';/* Initialize iconv. */ic = iconv_open("UTF-32", "UTF-16");if (ic == (iconv_t)-1)return NULL;/* Convert to UTF-32 (wchar_t on glibc systems).   Skip the first character (2-bytes). */inptr = buf+2;inbytes = len-2;outptr = (char*) wbuf;outbytes = sizeof(wbuf);res = iconv(ic, &inptr, &inbytes, &outptr, &outbytes);if (res == (size_t)-1)goto err;/* Write the terminating NULL. */wbuf[sizeof(wbuf)/sizeof(wbuf[0])-1] = 0x00000000;if (outbytes >= sizeof(wbuf[0]))*((wchar_t*)outptr) = 0x00000000;/* Allocate and copy the string. */str = wcsdup(wbuf+1);err:iconv_close(ic);return str;}static char *make_path(libusb_device *dev, int interface_number){char str[64];snprintf(str, sizeof(str), "%04x:%04x:%02x",libusb_get_bus_number(dev),libusb_get_device_address(dev),interface_number);str[sizeof(str)-1] = '\0';return strdup(str);}int HID_API_EXPORT hid_init(void){if (!initialized) {if (libusb_init(NULL))return -1;initialized = 1;}return 0;}int HID_API_EXPORT hid_exit(void){if (initialized) {libusb_exit(NULL);initialized = 0;}return 0;}struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id){libusb_device **devs;libusb_device *dev;libusb_device_handle *handle;ssize_t num_devs;int i = 0;struct hid_device_info *root = NULL; // return objectstruct hid_device_info *cur_dev = NULL;setlocale(LC_ALL,"");if (!initialized)hid_init();num_devs = libusb_get_device_list(NULL, &devs);if (num_devs < 0)return NULL;while ((dev = devs[i++]) != NULL) {struct libusb_device_descriptor desc;struct libusb_config_descriptor *conf_desc = NULL;int j, k;int interface_num = 0;int res = libusb_get_device_descriptor(dev, &desc);unsigned short dev_vid = desc.idVendor;unsigned short dev_pid = desc.idProduct;/* HID's are defined at the interface level. */if (desc.bDeviceClass != LIBUSB_CLASS_PER_INTERFACE)continue;res = libusb_get_active_config_descriptor(dev, &conf_desc);if (res < 0)libusb_get_config_descriptor(dev, 0, &conf_desc);if (conf_desc) {for (j = 0; j < conf_desc->bNumInterfaces; j++) {const struct libusb_interface *intf = &conf_desc->interface[j];for (k = 0; k < intf->num_altsetting; k++) {const struct libusb_interface_descriptor *intf_desc;intf_desc = &intf->altsetting[k];if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) {interface_num = intf_desc->bInterfaceNumber;/* Check the VID/PID against the arguments */if ((vendor_id == 0x0 && product_id == 0x0) ||    (vendor_id == dev_vid && product_id == dev_pid)) {struct hid_device_info *tmp;/* VID/PID match. Create the record. */tmp = calloc(1, sizeof(struct hid_device_info));if (cur_dev) {cur_dev->next = tmp;}else {root = tmp;}cur_dev = tmp;/* Fill out the record */cur_dev->next = NULL;cur_dev->path = make_path(dev, interface_num);res = libusb_open(dev, &handle);if (res >= 0) {/* Serial Number */if (desc.iSerialNumber > 0)cur_dev->serial_number =get_usb_string(handle, desc.iSerialNumber);/* Manufacturer and Product strings */if (desc.iManufacturer > 0)cur_dev->manufacturer_string =get_usb_string(handle, desc.iManufacturer);if (desc.iProduct > 0)cur_dev->product_string =get_usb_string(handle, desc.iProduct);#ifdef INVASIVE_GET_USAGE/*This section is removed because it is tooinvasive on the system. Getting a Usage Pageand Usage requires parsing the HID Reportdescriptor. Getting a HID Report descriptorinvolves claiming the interface. Claiming theinterface involves detaching the kernel driver.Detaching the kernel driver is hard on the systembecause it will unclaim interfaces (if anotherapp has them claimed) and the re-attachment ofthe driver will sometimes change /dev entry names.It is for these reasons that this section is#if 0. For composite devices, use the interfacefield in the hid_device_info struct to distinguishbetween interfaces. */int detached = 0;unsigned char data[256];/* Usage Page and Usage */res = libusb_kernel_driver_active(handle, interface_num);if (res == 1) {res = libusb_detach_kernel_driver(handle, interface_num);if (res < 0)LOG("Couldn't detach kernel driver, even though a kernel driver was attached.");elsedetached = 1;}res = libusb_claim_interface(handle, interface_num);if (res >= 0) {/* Get the HID Report Descriptor. */res = libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN|LIBUSB_RECIPIENT_INTERFACE, LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_REPORT << 8)|interface_num, 0, data, sizeof(data), 5000);if (res >= 0) {unsigned short page=0, usage=0;/* Parse the usage and usage page   out of the report descriptor. */get_usage(data, res,  &page, &usage);cur_dev->usage_page = page;cur_dev->usage = usage;}elseLOG("libusb_control_transfer() for getting the HID report failed with %d\n", res);/* Release the interface */res = libusb_release_interface(handle, interface_num);if (res < 0)LOG("Can't release the interface.\n");}elseLOG("Can't claim interface %d\n", res);/* Re-attach kernel driver if necessary. */if (detached) {res = libusb_attach_kernel_driver(handle, interface_num);if (res < 0)LOG("Couldn't re-attach kernel driver.\n");}#endif /*******************/libusb_close(handle);}/* VID/PID */cur_dev->vendor_id = dev_vid;cur_dev->product_id = dev_pid;/* Release Number */cur_dev->release_number = desc.bcdDevice;/* Interface Number */cur_dev->interface_number = interface_num;}}} /* altsettings */} /* interfaces */libusb_free_config_descriptor(conf_desc);}}libusb_free_device_list(devs, 1);return root;}void  HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs){struct hid_device_info *d = devs;while (d) {struct hid_device_info *next = d->next;free(d->path);free(d->serial_number);free(d->manufacturer_string);free(d->product_string);free(d);d = next;}}hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, wchar_t *serial_number){struct hid_device_info *devs, *cur_dev;const char *path_to_open = NULL;hid_device *handle = NULL;devs = hid_enumerate(vendor_id, product_id);cur_dev = devs;while (cur_dev) {if (cur_dev->vendor_id == vendor_id &&    cur_dev->product_id == product_id) {if (serial_number) {if (wcscmp(serial_number, cur_dev->serial_number) == 0) {path_to_open = cur_dev->path;break;}}else {path_to_open = cur_dev->path;break;}}cur_dev = cur_dev->next;}if (path_to_open) {/* Open the device */handle = hid_open_path(path_to_open);}hid_free_enumeration(devs);return handle;}static void read_callback(struct libusb_transfer *transfer){hid_device *dev = transfer->user_data;if (transfer->status == LIBUSB_TRANSFER_COMPLETED) {struct input_report *rpt = malloc(sizeof(*rpt));rpt->data = malloc(transfer->actual_length);memcpy(rpt->data, transfer->buffer, transfer->actual_length);rpt->len = transfer->actual_length;rpt->next = NULL;pthread_mutex_lock(&dev->mutex);/* Attach the new report object to the end of the list. */if (dev->input_reports == NULL) {/* The list is empty. Put it at the root. */dev->input_reports = rpt;pthread_cond_signal(&dev->condition);}else {/* Find the end of the list and attach. */struct input_report *cur = dev->input_reports;int num_queued = 0;while (cur->next != NULL) {cur = cur->next;num_queued++;}cur->next = rpt;/* Pop one off if we've reached 30 in the queue. This   way we don't grow forever if the user never reads   anything from the device. */if (num_queued > 30) {return_data(dev, NULL, 0);}}pthread_mutex_unlock(&dev->mutex);}else if (transfer->status == LIBUSB_TRANSFER_CANCELLED) {dev->shutdown_thread = 1;return;}else if (transfer->status == LIBUSB_TRANSFER_NO_DEVICE) {dev->shutdown_thread = 1;return;}else if (transfer->status == LIBUSB_TRANSFER_TIMED_OUT) {//LOG("Timeout (normal)\n");}else {LOG("Unknown transfer code: %d\n", transfer->status);}/* Re-submit the transfer object. */libusb_submit_transfer(transfer);}static void *read_thread(void *param){hid_device *dev = param;unsigned char *buf;const size_t length = dev->input_ep_max_packet_size;/* Set up the transfer object. */buf = malloc(length);dev->transfer = libusb_alloc_transfer(0);libusb_fill_interrupt_transfer(dev->transfer,dev->device_handle,dev->input_endpoint,buf,length,read_callback,dev,5000/*timeout*/);/* Make the first submission. Further submissions are made   from inside read_callback() */libusb_submit_transfer(dev->transfer);// Notify the main thread that the read thread is up and running.pthread_barrier_wait(&dev->barrier);/* Handle all the events. */while (!dev->shutdown_thread) {int res;res = libusb_handle_events(NULL);if (res < 0) {/* There was an error. Break out of this loop. */break;}}/* Cancel any transfer that may be pending. This call will fail   if no transfers are pending, but that's OK. */if (libusb_cancel_transfer(dev->transfer) == 0) {/* The transfer was cancelled, so wait for its completion. */libusb_handle_events(NULL);}/* Now that the read thread is stopping, Wake any threads which are   waiting on data (in hid_read_timeout()). Do this under a mutex to   make sure that a thread which is about to go to sleep waiting on   the condition acutally will go to sleep before the condition is   signaled. */pthread_mutex_lock(&dev->mutex);pthread_cond_broadcast(&dev->condition);pthread_mutex_unlock(&dev->mutex);/* The dev->transfer->buffer and dev->transfer objects are cleaned up   in hid_close(). They are not cleaned up here because this thread   could end either due to a disconnect or due to a user   call to hid_close(). In both cases the objects can be safely   cleaned up after the call to pthread_join() (in hid_close()), but   since hid_close() calls libusb_cancel_transfer(), on these objects,   they can not be cleaned up here. */return NULL;}hid_device * HID_API_EXPORT hid_open_path(const char *path){hid_device *dev = NULL;dev = new_hid_device();libusb_device **devs;libusb_device *usb_dev;ssize_t num_devs;int res;int d = 0;int good_open = 0;setlocale(LC_ALL,"");if (!initialized)hid_init();num_devs = libusb_get_device_list(NULL, &devs);while ((usb_dev = devs[d++]) != NULL) {struct libusb_device_descriptor desc;struct libusb_config_descriptor *conf_desc = NULL;int i,j,k;libusb_get_device_descriptor(usb_dev, &desc);if (libusb_get_active_config_descriptor(usb_dev, &conf_desc) < 0)continue;for (j = 0; j < conf_desc->bNumInterfaces; j++) {const struct libusb_interface *intf = &conf_desc->interface[j];for (k = 0; k < intf->num_altsetting; k++) {const struct libusb_interface_descriptor *intf_desc;intf_desc = &intf->altsetting[k];if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) {char *dev_path = make_path(usb_dev, intf_desc->bInterfaceNumber);if (!strcmp(dev_path, path)) {/* Matched Paths. Open this device */// OPEN HERE //res = libusb_open(usb_dev, &dev->device_handle);if (res < 0) {LOG("can't open device\n");free(dev_path); break;}good_open = 1;/* Detach the kernel driver, but only if the   device is managed by the kernel */if (libusb_kernel_driver_active(dev->device_handle, intf_desc->bInterfaceNumber) == 1) {res = libusb_detach_kernel_driver(dev->device_handle, intf_desc->bInterfaceNumber);if (res < 0) {libusb_close(dev->device_handle);LOG("Unable to detach Kernel Driver\n");free(dev_path);good_open = 0;break;}}res = libusb_claim_interface(dev->device_handle, intf_desc->bInterfaceNumber);if (res < 0) {LOG("can't claim interface %d: %d\n", intf_desc->bInterfaceNumber, res);free(dev_path);libusb_close(dev->device_handle);good_open = 0;break;}/* Store off the string descriptor indexes */dev->manufacturer_index = desc.iManufacturer;dev->product_index      = desc.iProduct;dev->serial_index       = desc.iSerialNumber;/* Store off the interface number */dev->interface = intf_desc->bInterfaceNumber;/* Find the INPUT and OUTPUT endpoints. An   OUTPUT endpoint is not required. */for (i = 0; i < intf_desc->bNumEndpoints; i++) {const struct libusb_endpoint_descriptor *ep= &intf_desc->endpoint[i];/* Determine the type and direction of this   endpoint. */int is_interrupt =(ep->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK)      == LIBUSB_TRANSFER_TYPE_INTERRUPT;int is_output = (ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)      == LIBUSB_ENDPOINT_OUT;int is_input = (ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)      == LIBUSB_ENDPOINT_IN;/* Decide whether to use it for intput or output. */if (dev->input_endpoint == 0 &&    is_interrupt && is_input) {/* Use this endpoint for INPUT */dev->input_endpoint = ep->bEndpointAddress;dev->input_ep_max_packet_size = ep->wMaxPacketSize;}if (dev->output_endpoint == 0 &&    is_interrupt && is_output) {/* Use this endpoint for OUTPUT */dev->output_endpoint = ep->bEndpointAddress;}}pthread_create(&dev->thread, NULL, read_thread, dev);// Wait here for the read thread to be initialized.pthread_barrier_wait(&dev->barrier);}free(dev_path);}}}libusb_free_config_descriptor(conf_desc);}libusb_free_device_list(devs, 1);// If we have a good handle, return it.if (good_open) {return dev;}else {// Unable to open any devices.free_hid_device(dev);return NULL;}}int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t length){int res;int report_number = data[0];int skipped_report_id = 0;if (report_number == 0x0) {data++;length--;skipped_report_id = 1;}if (dev->output_endpoint <= 0) {/* No interrput out endpoint. Use the Control Endpoint */res = libusb_control_transfer(dev->device_handle,LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_OUT,0x09/*HID Set_Report*/,(2/*HID output*/ << 8) | report_number,dev->interface,(unsigned char *)data, length,1000/*timeout millis*/);if (res < 0)return -1;if (skipped_report_id)length++;return length;}else {/* Use the interrupt out endpoint */int actual_length;res = libusb_interrupt_transfer(dev->device_handle,dev->output_endpoint,(unsigned char*)data,length,&actual_length, 1000);if (res < 0)return -1;if (skipped_report_id)actual_length++;return actual_length;}}/* Helper function, to simplify hid_read().   This should be called with dev->mutex locked. */static int return_data(hid_device *dev, unsigned char *data, size_t length){/* Copy the data out of the linked list item (rpt) into the   return buffer (data), and delete the liked list item. */struct input_report *rpt = dev->input_reports;size_t len = (length < rpt->len)? length: rpt->len;if (len > 0)memcpy(data, rpt->data, len);dev->input_reports = rpt->next;free(rpt->data);free(rpt);return len;}static void cleanup_mutex(void *param){hid_device *dev = param;pthread_mutex_unlock(&dev->mutex);}int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds){int bytes_read = -1;#if 0int transferred;int res = libusb_interrupt_transfer(dev->device_handle, dev->input_endpoint, data, length, &transferred, 5000);LOG("transferred: %d\n", transferred);return transferred;#endifpthread_mutex_lock(&dev->mutex);pthread_cleanup_push(&cleanup_mutex, dev);/* There's an input report queued up. Return it. */if (dev->input_reports) {/* Return the first one */bytes_read = return_data(dev, data, length);goto ret;}if (dev->shutdown_thread) {/* This means the device has been disconnected.   An error code of -1 should be returned. */bytes_read = -1;goto ret;}if (milliseconds == -1) {/* Blocking */while (!dev->input_reports && !dev->shutdown_thread) {pthread_cond_wait(&dev->condition, &dev->mutex);}if (dev->input_reports) {bytes_read = return_data(dev, data, length);}}else if (milliseconds > 0) {/* Non-blocking, but called with timeout. */int res;struct timespec ts;clock_gettime(CLOCK_REALTIME, &ts);ts.tv_sec += milliseconds / 1000;ts.tv_nsec += (milliseconds % 1000) * 1000000;if (ts.tv_nsec >= 1000000000L) {ts.tv_sec++;ts.tv_nsec -= 1000000000L;}while (!dev->input_reports && !dev->shutdown_thread) {res = pthread_cond_timedwait(&dev->condition, &dev->mutex, &ts);if (res == 0) {if (dev->input_reports) {bytes_read = return_data(dev, data, length);break;}/* If we're here, there was a spurious wake up   or the read thread was shutdown. Run the   loop again (ie: don't break). */}else if (res == ETIMEDOUT) {/* Timed out. */bytes_read = 0;break;}else {/* Error. */bytes_read = -1;break;}}}else {/* Purely non-blocking */bytes_read = 0;}ret:pthread_mutex_unlock(&dev->mutex);pthread_cleanup_pop(0);return bytes_read;}int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length){return hid_read_timeout(dev, data, length, dev->blocking ? -1 : 0);}int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock){dev->blocking = !nonblock;return 0;}int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length){int res = -1;int skipped_report_id = 0;int report_number = data[0];if (report_number == 0x0) {data++;length--;skipped_report_id = 1;}res = libusb_control_transfer(dev->device_handle,LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_OUT,0x09/*HID set_report*/,(3/*HID feature*/ << 8) | report_number,dev->interface,(unsigned char *)data, length,1000/*timeout millis*/);if (res < 0)return -1;/* Account for the report ID */if (skipped_report_id)length++;return length;}int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length){int res = -1;int skipped_report_id = 0;int report_number = data[0];if (report_number == 0x0) {/* Offset the return buffer by 1, so that the report ID   will remain in byte 0. */data++;length--;skipped_report_id = 1;}res = libusb_control_transfer(dev->device_handle,LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_IN,0x01/*HID get_report*/,(3/*HID feature*/ << 8) | report_number,dev->interface,(unsigned char *)data, length,1000/*timeout millis*/);if (res < 0)return -1;if (skipped_report_id)res++;return res;}void HID_API_EXPORT hid_close(hid_device *dev){if (!dev)return;/* Cause read_thread() to stop. */dev->shutdown_thread = 1;libusb_cancel_transfer(dev->transfer);/* Wait for read_thread() to end. */pthread_join(dev->thread, NULL);/* Clean up the Transfer objects allocated in read_thread(). */free(dev->transfer->buffer);libusb_free_transfer(dev->transfer);/* release the interface */libusb_release_interface(dev->device_handle, dev->interface);/* Close the handle */libusb_close(dev->device_handle);/* Clear out the queue of received reports. */pthread_mutex_lock(&dev->mutex);while (dev->input_reports) {return_data(dev, NULL, 0);}pthread_mutex_unlock(&dev->mutex);free_hid_device(dev);}int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen){return hid_get_indexed_string(dev, dev->manufacturer_index, string, maxlen);}int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen){return hid_get_indexed_string(dev, dev->product_index, string, maxlen);}int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen){return hid_get_indexed_string(dev, dev->serial_index, string, maxlen);}int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen){wchar_t *str;str = get_usb_string(dev->device_handle, string_index);if (str) {wcsncpy(string, str, maxlen);string[maxlen-1] = L'\0';free(str);return 0;}elsereturn -1;}HID_API_EXPORT const wchar_t * HID_API_CALL  hid_error(hid_device *dev){return NULL;}struct lang_map_entry {const char *name;const char *string_code;uint16_t usb_code;};#define LANG(name,code,usb_code) { name, code, usb_code }static struct lang_map_entry lang_map[] = {LANG("Afrikaans", "af", 0x0436),LANG("Albanian", "sq", 0x041C),LANG("Arabic - United Arab Emirates", "ar_ae", 0x3801),LANG("Arabic - Bahrain", "ar_bh", 0x3C01),LANG("Arabic - Algeria", "ar_dz", 0x1401),LANG("Arabic - Egypt", "ar_eg", 0x0C01),LANG("Arabic - Iraq", "ar_iq", 0x0801),LANG("Arabic - Jordan", "ar_jo", 0x2C01),LANG("Arabic - Kuwait", "ar_kw", 0x3401),LANG("Arabic - Lebanon", "ar_lb", 0x3001),LANG("Arabic - Libya", "ar_ly", 0x1001),LANG("Arabic - Morocco", "ar_ma", 0x1801),LANG("Arabic - Oman", "ar_om", 0x2001),LANG("Arabic - Qatar", "ar_qa", 0x4001),LANG("Arabic - Saudi Arabia", "ar_sa", 0x0401),LANG("Arabic - Syria", "ar_sy", 0x2801),LANG("Arabic - Tunisia", "ar_tn", 0x1C01),LANG("Arabic - Yemen", "ar_ye", 0x2401),LANG("Armenian", "hy", 0x042B),LANG("Azeri - Latin", "az_az", 0x042C),LANG("Azeri - Cyrillic", "az_az", 0x082C),LANG("Basque", "eu", 0x042D),LANG("Belarusian", "be", 0x0423),LANG("Bulgarian", "bg", 0x0402),LANG("Catalan", "ca", 0x0403),LANG("Chinese - China", "zh_cn", 0x0804),LANG("Chinese - Hong Kong SAR", "zh_hk", 0x0C04),LANG("Chinese - Macau SAR", "zh_mo", 0x1404),LANG("Chinese - Singapore", "zh_sg", 0x1004),LANG("Chinese - Taiwan", "zh_tw", 0x0404),LANG("Croatian", "hr", 0x041A),LANG("Czech", "cs", 0x0405),LANG("Danish", "da", 0x0406),LANG("Dutch - Netherlands", "nl_nl", 0x0413),LANG("Dutch - Belgium", "nl_be", 0x0813),LANG("English - Australia", "en_au", 0x0C09),LANG("English - Belize", "en_bz", 0x2809),LANG("English - Canada", "en_ca", 0x1009),LANG("English - Caribbean", "en_cb", 0x2409),LANG("English - Ireland", "en_ie", 0x1809),LANG("English - Jamaica", "en_jm", 0x2009),LANG("English - New Zealand", "en_nz", 0x1409),LANG("English - Phillippines", "en_ph", 0x3409),LANG("English - Southern Africa", "en_za", 0x1C09),LANG("English - Trinidad", "en_tt", 0x2C09),LANG("English - Great Britain", "en_gb", 0x0809),LANG("English - United States", "en_us", 0x0409),LANG("Estonian", "et", 0x0425),LANG("Farsi", "fa", 0x0429),LANG("Finnish", "fi", 0x040B),LANG("Faroese", "fo", 0x0438),LANG("French - France", "fr_fr", 0x040C),LANG("French - Belgium", "fr_be", 0x080C),LANG("French - Canada", "fr_ca", 0x0C0C),LANG("French - Luxembourg", "fr_lu", 0x140C),LANG("French - Switzerland", "fr_ch", 0x100C),LANG("Gaelic - Ireland", "gd_ie", 0x083C),LANG("Gaelic - Scotland", "gd", 0x043C),LANG("German - Germany", "de_de", 0x0407),LANG("German - Austria", "de_at", 0x0C07),LANG("German - Liechtenstein", "de_li", 0x1407),LANG("German - Luxembourg", "de_lu", 0x1007),LANG("German - Switzerland", "de_ch", 0x0807),LANG("Greek", "el", 0x0408),LANG("Hebrew", "he", 0x040D),LANG("Hindi", "hi", 0x0439),LANG("Hungarian", "hu", 0x040E),LANG("Icelandic", "is", 0x040F),LANG("Indonesian", "id", 0x0421),LANG("Italian - Italy", "it_it", 0x0410),LANG("Italian - Switzerland", "it_ch", 0x0810),LANG("Japanese", "ja", 0x0411),LANG("Korean", "ko", 0x0412),LANG("Latvian", "lv", 0x0426),LANG("Lithuanian", "lt", 0x0427),LANG("F.Y.R.O. Macedonia", "mk", 0x042F),LANG("Malay - Malaysia", "ms_my", 0x043E),LANG("Malay – Brunei", "ms_bn", 0x083E),LANG("Maltese", "mt", 0x043A),LANG("Marathi", "mr", 0x044E),LANG("Norwegian - Bokml", "no_no", 0x0414),LANG("Norwegian - Nynorsk", "no_no", 0x0814),LANG("Polish", "pl", 0x0415),LANG("Portuguese - Portugal", "pt_pt", 0x0816),LANG("Portuguese - Brazil", "pt_br", 0x0416),LANG("Raeto-Romance", "rm", 0x0417),LANG("Romanian - Romania", "ro", 0x0418),LANG("Romanian - Republic of Moldova", "ro_mo", 0x0818),LANG("Russian", "ru", 0x0419),LANG("Russian - Republic of Moldova", "ru_mo", 0x0819),LANG("Sanskrit", "sa", 0x044F),LANG("Serbian - Cyrillic", "sr_sp", 0x0C1A),LANG("Serbian - Latin", "sr_sp", 0x081A),LANG("Setsuana", "tn", 0x0432),LANG("Slovenian", "sl", 0x0424),LANG("Slovak", "sk", 0x041B),LANG("Sorbian", "sb", 0x042E),LANG("Spanish - Spain (Traditional)", "es_es", 0x040A),LANG("Spanish - Argentina", "es_ar", 0x2C0A),LANG("Spanish - Bolivia", "es_bo", 0x400A),LANG("Spanish - Chile", "es_cl", 0x340A),LANG("Spanish - Colombia", "es_co", 0x240A),LANG("Spanish - Costa Rica", "es_cr", 0x140A),LANG("Spanish - Dominican Republic", "es_do", 0x1C0A),LANG("Spanish - Ecuador", "es_ec", 0x300A),LANG("Spanish - Guatemala", "es_gt", 0x100A),LANG("Spanish - Honduras", "es_hn", 0x480A),LANG("Spanish - Mexico", "es_mx", 0x080A),LANG("Spanish - Nicaragua", "es_ni", 0x4C0A),LANG("Spanish - Panama", "es_pa", 0x180A),LANG("Spanish - Peru", "es_pe", 0x280A),LANG("Spanish - Puerto Rico", "es_pr", 0x500A),LANG("Spanish - Paraguay", "es_py", 0x3C0A),LANG("Spanish - El Salvador", "es_sv", 0x440A),LANG("Spanish - Uruguay", "es_uy", 0x380A),LANG("Spanish - Venezuela", "es_ve", 0x200A),LANG("Southern Sotho", "st", 0x0430),LANG("Swahili", "sw", 0x0441),LANG("Swedish - Sweden", "sv_se", 0x041D),LANG("Swedish - Finland", "sv_fi", 0x081D),LANG("Tamil", "ta", 0x0449),LANG("Tatar", "tt", 0X0444),LANG("Thai", "th", 0x041E),LANG("Turkish", "tr", 0x041F),LANG("Tsonga", "ts", 0x0431),LANG("Ukrainian", "uk", 0x0422),LANG("Urdu", "ur", 0x0420),LANG("Uzbek - Cyrillic", "uz_uz", 0x0843),LANG("Uzbek – Latin", "uz_uz", 0x0443),LANG("Vietnamese", "vi", 0x042A),LANG("Xhosa", "xh", 0x0434),LANG("Yiddish", "yi", 0x043D),LANG("Zulu", "zu", 0x0435),LANG(NULL, NULL, 0x0),};uint16_t get_usb_code_for_current_locale(void){char *locale;char search_string[64];char *ptr;/* Get the current locale. */locale = setlocale(0, NULL);if (!locale)return 0x0;/* Make a copy of the current locale string. */strncpy(search_string, locale, sizeof(search_string));search_string[sizeof(search_string)-1] = '\0';/* Chop off the encoding part, and make it lower case. */ptr = search_string;while (*ptr) {*ptr = tolower(*ptr);if (*ptr == '.') {*ptr = '\0';break;}ptr++;}/* Find the entry which matches the string code of our locale. */struct lang_map_entry *lang = lang_map;while (lang->string_code) {if (!strcmp(lang->string_code, search_string)) {return lang->usb_code;}lang++;}/* There was no match. Find with just the language only. *//* Chop off the variant. Chop it off at the '_'. */ptr = search_string;while (*ptr) {*ptr = tolower(*ptr);if (*ptr == '_') {*ptr = '\0';break;}ptr++;}#if 0 // TODO: Do we need this?/* Find the entry which matches the string code of our language. */lang = lang_map;while (lang->string_code) {if (!strcmp(lang->string_code, search_string)) {return lang->usb_code;}lang++;}#endif/* Found nothing. */return 0x0;}#ifdef __cplusplus}#endif

d) hidinterface.h

#ifndef DeltaHIDINTERFACE_H#define DeltaHIDINTERFACE_H#include <stdio.h>#include <wchar.h>#include <string.h>#include <stdlib.h>#include "hidapi.h"// Headers needed for sleeping.#include <unistd.h>#define hidDataLength 64//hid data receive callback functiontypedef void (*DataArriveCallBackFunc)(unsigned char *recData,unsigned char length);DataArriveCallBackFunc hidDataArriveCallBack;hid_device *handle;unsigned char isOpen;int hidApi_Init(DataArriveCallBackFunc DataArriveCallBack);int hidApi_Write(unsigned char *data, unsigned char length);//when data arrived, the function will be calledvoid hidApi_DataReceive(unsigned char *recData,unsigned char length);int hidApi_Close(void);#endif // HIDINTERFACE_H

e) hidinterface.c

/******************************************************* Windows HID simplification Alan Ott Signal 11 Software 8/22/2009 Copyright 2009, All Rights Reserved.  This contents of this file may be used by anyone for any reason without any conditions and may be used as a starting point for your own applications which use HIDAPI.********************************************************/#include "hidinterface.h"#include <pthread.h>void hidRead_thread(void);int hidApi_Init(DataArriveCallBackFunc DataArriveCallBack){    hidDataArriveCallBack = NULL;    // Open the device using the VID, PID,    // and optionally the Serial number.    ////handle = hid_open(0x4d8, 0x3f, L"12345");    handle = hid_open(0x4d8, 0x3f, NULL);    if (!handle) {        printf("unable to open device\n");        isOpen = 0;        return -1;    }    printf("open device success\n");    isOpen = 1;    hidDataArriveCallBack = DataArriveCallBack;    hidRead_thread();    // Set the hid_read() function to be non-blocking.    hid_set_nonblocking(handle, 1);    return 0;}int hidApi_Write(unsigned char *data, unsigned char length){    int res;    unsigned char realData[length+1];    realData[0]=length;    int i;    for(i=0;i<length;i++)    {        realData[i+1]=data[i];    }    res = hid_write(handle, realData, length+1);    if (res < 0) {        printf("Unable to write()\n");        printf("Error: %ls\n", hid_error(handle));        return -1;    }    printf("write success\n");    return 0;}void hidApi_DataReceive(unsigned char *recData,unsigned char length){    if(hidDataArriveCallBack==NULL)        return;    hidDataArriveCallBack(recData,length);}void hidApi_Read(){    unsigned char recData[hidDataLength];    int res;    while (isOpen==1) {        res = hid_read(handle, recData, hidDataLength);        if (res == 0)            ;//printf("waiting...\n");        else if (res < 0)        {            printf("Unable to read()\n");            return -1;        }        else        {            int i;//            printf("Data read:\n   ");//            // Print out the returned buffer.////            for (i = 0; i < res; i++)//                printf("%02hhx ", recData[i]);//            printf("\n");            unsigned char length = recData[0];            unsigned char datas[length];            for(i=0;i<length;i++)            {                datas[i]=recData[i+1];            }            hidApi_DataReceive(datas,length);        }        usleep(50*1000);    }}void hidRead_thread(void){   pthread_t id;   int ret, i;   ret=pthread_create(&id,NULL,(void *) hidApi_Read,NULL); // 成功返回0，错误返回错误编号   if(ret!=0) {       printf ("Create pthread error!\n");       exit (1);   }   //pthread_join(id,NULL);   printf ("Create pthread success!\n");}int hidApi_Close(void){    hid_close(handle);    isOpen = 0;    /* Free static HIDAPI objects. */    hid_exit();    return 0;}

f) main.c

#include <hidlib/hidinterface.h>// down 50000 50 : FA 00 00 04 03 01 00 00 00 50 C3 00 00 32 00 00 00 A7 A5unsigned char bufferDown50[] = {0xFA, 0x00, 0x00, 0x04, 0x03, 0x01, 0x00, 0x00, 0x00, 0x50, 0xC3, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0xA7, 0xA5};// down 50000 10 : FA 00 00 04 03 01 00 00 00 50 C3 00 00 0A 00 00 00 9F A5unsigned char bufferDown10[] = {0xFA, 0x00, 0x00, 0x04, 0x03, 0x01, 0x00, 0x00, 0x00, 0x50, 0xC3, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x9F, 0xA5};// up 50000 50 : FA 00 00 04 03 00 00 00 00 50 C3 00 00 32 00 00 00 A6 A5unsigned char bufferUp50[] = {0xFA, 0x00, 0x00, 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x50, 0xC3, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0xA6, 0xA5};// up 50000 10 : FA 00 00 04 03 00 00 00 00 50 C3 00 00 0A 00 00 00 9E A5unsigned char bufferUp10[] = {0xFA, 0x00, 0x00, 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x50, 0xC3, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x9E, 0xA5};// go home FA 00 02 04 03 00 00 00 00 00 00 00 00 0A 00 00 00 0D A5unsigned char bufferGoHome[] = { 0xFA, 0x00, 0x02, 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x0D, 0xA5};char isReponse = 0;void datarec(unsigned char *recData,unsigned char length){    printf("Data Receive: ");    int i;    for(i=0;i<length;i++)    {        printf("%02hhx ", recData[i]);    }    printf("\n");    isReponse = 1;}int main(int argc, char* argv[]){    hidApi_Init(datarec);    isReponse = 1;    while(1)    {        while(isReponse==0) usleep(500*1000);        isReponse =0;        hidApi_Write(bufferGoHome,0x13);        usleep(500*1000);        while(isReponse==0) usleep(500*1000);        isReponse =0;        hidApi_Write(bufferDown10,0x13);        usleep(500*1000);        while(isReponse==0) usleep(500*1000);        isReponse =0;        hidApi_Write(bufferDown50,0x13);        while(isReponse==0) usleep(500*1000);        isReponse =0;        hidApi_Write(bufferDown10,0x13);        usleep(500*1000);        usleep(2*1000*1000);        while(isReponse==0) usleep(500*1000);        isReponse =0;        hidApi_Write(bufferGoHome,0x13);        usleep(2*1000*1000);    }    hidApi_Close();    return 0;}