【Qt】Linux HID API

来源：互联网发布：约维蒂奇知乎编辑：程序博客网时间：2024/04/28 15:42

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文件

[cpp] view plain copy
QT -= core  
QT -= gui  
  
CONFIG += c++11  
  
TARGET = HIDAPI  
CONFIG += console  
CONFIG -= app_bundle  
  
TEMPLATE = app  
  
SOURCES += \  
    hidlib/hid-libusb.c \  
    hidlib/hidinterface.c \  
    main.c  
  
  
HEADERS += \  
    hidlib/hidapi.h \  
    hidlib/hidinterface.h  
  
#static  
  
message("$$myPlatform compile")  
INCLUDEPATH += PWD/lib/
myPlatform/libusb/include/libusb-1.0/  
LIBS += PWD/lib/
myPlatform/libusb/lib/libusb-1.0.a  

b) hidapi.h

[cpp] view plain copy
/******************************************************* 
 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 __cplusplus  
extern "C" {  
#endif  
        struct 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 not 
            strictly necessary, as it will be called automatically by 
            hid_enumerate() and any of the hid_open_*() functions if it is 
            needed.  This function should be called at the beginning of 
            execution however, if there is a chance of HIDAPI handles 
            being opened by different threads simultaneously. 
             
            @ingroup API 
 
            @returns 
                This 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 with 
            HIDAPI. It should be called at the end of execution to avoid 
            memory leaks. 
 
            @ingroup API 
 
            @returns 
                This 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 devices 
            attached to the system which match vendor_id and product_id. 
            If @p vendor_id and @p product_id are both set to 0, then 
            all HID devices will be returned. 
 
            @ingroup API 
            @param vendor_id The Vendor ID (VID) of the types of device 
                to open. 
            @param product_id The Product ID (PID) of the types of 
                device 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 the 
            specified 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). 
 
            @returns 
                This function returns a pointer to a #hid_device object on 
                success 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 a 
            platform-specific path name can be used (eg: /dev/hidraw0 on 
            Linux). 
 
            @ingroup API 
            @param path The path name of the device to open 
 
            @returns 
                This function returns a pointer to a #hid_device object on 
                success 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. For 
            devices which only support a single report, this must be set 
            to 0x0. The remaining bytes contain the report data. Since 
            the Report ID is mandatory, calls to hid_write() will always 
            contain one more byte than the report contains. For example, 
            if a hid report is 16 bytes long, 17 bytes must be passed to 
            hid_write(), the Report ID (or 0x0, for devices with a 
            single report), followed by the report data (16 bytes). In 
            this example, the length passed in would be 17. 
 
            hid_write() will send the data on the first OUT endpoint, if 
            one exists. If it does not, it will send the data through 
            the 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 as 
                the first byte. 
            @param length The length in bytes of the data to send. 
 
            @returns 
                This 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 returned 
            to the host through the INTERRUPT IN endpoint. The first byte will 
            contain 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 with 
                multiple reports, make sure to read an extra byte for 
                the report number. 
            @param milliseconds timeout in milliseconds or -1 for blocking wait. 
 
            @returns 
                This 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 will 
            contain 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 with 
                multiple reports, make sure to read an extra byte for 
                the report number. 
 
            @returns 
                This 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 return 
            immediately with a value of 0 if there is no data to be 
            read. In blocking mode, hid_read() will wait (block) until 
            there 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. 
 
            @returns 
                This 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 a 
            Set_Report transfer.  The first byte of @p data[] must 
            contain the Report ID. For devices which only support a 
            single report, this must be set to 0x0. The remaining bytes 
            contain the report data. Since the Report ID is mandatory, 
            calls to hid_send_feature_report() will always contain one 
            more byte than the report contains. For example, if a hid 
            report is 16 bytes long, 17 bytes must be passed to 
            hid_send_feature_report(): the Report ID (or 0x0, for 
            devices which do not use numbered reports), followed by the 
            report data (16 bytes). In this example, the length passed 
            in would be 17. 
 
            @ingroup API 
            @param device A device handle returned from hid_open(). 
            @param data The data to send, including the report number as 
                the first byte. 
            @param length The length in bytes of the data to send, including 
                the report number. 
 
            @returns 
                This 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 Report 
            ID of the report to be read.  Make sure to allow space for 
            this 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, including 
                the Report ID. Set the first byte of @p data[] to the 
                Report ID of the report to be read. 
            @param length The number of bytes to read, including an 
                extra byte for the report ID. The buffer can be longer 
                than the actual report. 
 
            @returns 
                This 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. 
 
            @returns 
                This 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. 
 
            @returns 
                This 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. 
 
            @returns 
                This 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. 
 
            @returns 
                This 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(). 
 
            @returns 
                This function returns a string containing the last error 
                which 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

[cpp] view plain copy
/******************************************************* 
 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 __cplusplus  
extern "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 in 
hid_enumerate(). Warning, this is very invasive as it requires the detach 
and re-attach of the kernel driver. See comments inside hid_enumerate(). 
Linux/libusb HIDAPI programs are encouraged to use the interface number 
instead 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);  
    }  
    else  
        return 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];  
            else  
                data_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 object  
    struct 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 too 
                            invasive on the system. Getting a Usage Page 
                            and Usage requires parsing the HID Report 
                            descriptor. Getting a HID Report descriptor 
                            involves claiming the interface. Claiming the 
                            interface involves detaching the kernel driver. 
                            Detaching the kernel driver is hard on the system 
                            because it will unclaim interfaces (if another 
                            app has them claimed) and the re-attachment of 
                            the driver will sometimes change /dev entry names. 
                            It is for these reasons that this section is 
                            #if 0. For composite devices, use the interface 
                            field in the hid_device_info struct to distinguish 
                            between 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.");  
                                    else  
                                        detached = 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;  
                                    }  
                                    else  
                                        LOG("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");  
                                }  
                                else  
                                    LOG("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 0  
    int transferred;  
    int res = libusb_interrupt_transfer(dev->device_handle, dev->input_endpoint, data, length, &transferred, 5000);  
    LOG("transferred: %d\n", transferred);  
    return transferred;  
#endif  
  
    pthread_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;  
    }  
    else  
        return -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

[cpp] view plain copy
#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 function  
typedef 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 called  
void hidApi_DataReceive(unsigned char *recData,unsigned char length);  
  
int hidApi_Close(void);  
  
#endif // HIDINTERFACE_H  

e) hidinterface.c

[cpp] view plain copy
/******************************************************* 
 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

[cpp] view plain copy
#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 A5  
unsigned 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 A5  
unsigned 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 A5  
unsigned 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 A5  
unsigned 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 A5  
unsigned 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;  
}  

from: http://blog.csdn.net/u010875635/article/details/73277779

阅读全文

0 0