LinuxQuestions.org
Share your knowledge at the LQ Wiki.
Go Back   LinuxQuestions.org > Forums > Non-*NIX Forums > Programming
User Name
Password
Programming This forum is for all programming questions.
The question does not have to be directly related to Linux and any language is fair game.

Notices


Reply
  Search this Thread
Old 05-07-2006, 09:31 PM   #1
AngryLlama
Member
 
Registered: Sep 2004
Location: /dev/urandom
Distribution: Gentoo
Posts: 171

Rep: Reputation: 31
Communicating with PIC over USB HID


Hello,

I have been researching methods to communicate with a MicroChip PIC connected through the USB port. The firmware on the device is designed to receive 22byte reports which change the state of the device. The firmware is also designed to output a report perodically that contains the status of the device (a usb-controlled FM radio)

My problem: sending and receiving these strings over USB. After some reasearch I get the impression that using a HIDDEV device is the best method. So I now have /dev/usb/hiddev0 and I can use a program based on Example 2 from http://www.frogmouth.net/hid-doco/c514.html to recognize the device.

Now what? I've read through a great deal of the USB HID specification and understand the basics on how reports are used, but I don't know how to use the API to send or receive one. I don't know what I should initialize these structs to, etc... I do have the following information from lsusb:

Code:
llamabox hqct # lsusb -d 04d8:000a -vvv

Bus 001 Device 002: ID 04d8:000a Microchip Technology, Inc.
Device Descriptor:
  bLength                18
  bDescriptorType         1
  bcdUSB               2.00
  bDeviceClass            0 (Defined at Interface level)
  bDeviceSubClass         0
  bDeviceProtocol         0
  bMaxPacketSize0         8
  idVendor           0x04d8 Microchip Technology, Inc.
  idProduct          0x000a
  bcdDevice            0.01
  iManufacturer           1 Datalex
  iProduct                2 Car-Radio
  iSerial                 0
  bNumConfigurations      1
  Configuration Descriptor:
    bLength                 9
    bDescriptorType         2
    wTotalLength           41
    bNumInterfaces          1
    bConfigurationValue     1
    iConfiguration          0
    bmAttributes         0xa0
      Remote Wakeup
    MaxPower              100mA
    Interface Descriptor:
      bLength                 9
      bDescriptorType         4
      bInterfaceNumber        0
      bAlternateSetting       0
      bNumEndpoints           2
      bInterfaceClass         3 Human Interface Devices
      bInterfaceSubClass      0 No Subclass
      bInterfaceProtocol      0 None
      iInterface              0
        HID Device Descriptor:
          bLength                 9
          bDescriptorType        33
          bcdHID               1.01
          bCountryCode            0 Not supported
          bNumDescriptors         1
          bDescriptorType        34 Report
          wDescriptorLength      47
          Report Descriptor: (length is 47)
            Item(Global): Usage Page, data= [ 0xa0 0xff ] 65440
                            (null)
            Item(Local ): Usage, data= [ 0x01 ] 1
                            (null)
            Item(Main  ): Collection, data= [ 0x01 ] 1
                            Application
            Item(Local ): Usage, data= [ 0x03 ] 3
                            (null)
            Item(Global): Logical Minimum, data= [ 0x00 ] 0
            Item(Global): Logical Maximum, data= [ 0x00 0xff ] 65280
            Item(Global): Report Size, data= [ 0x08 ] 8
            Item(Global): Report Count, data= [ 0x20 ] 32
            Item(Main  ): Input, data= [ 0x02 ] 2
                            Data Variable Absolute No_Wrap Linear
                            Preferred_State No_Null_Position Non_Volatile Bitfield
            Item(Local ): Usage, data= [ 0x04 ] 4
                            (null)
            Item(Global): Logical Minimum, data= [ 0x00 ] 0
            Item(Global): Logical Maximum, data= [ 0x00 0xff ] 65280
            Item(Global): Report Size, data= [ 0x08 ] 8
            Item(Global): Report Count, data= [ 0x20 ] 32
            Item(Main  ): Output, data= [ 0x02 ] 2
                            Data Variable Absolute No_Wrap Linear
                            Preferred_State No_Null_Position Non_Volatile Bitfield
            Item(Local ): Usage, data= [ 0x05 ] 5
                            (null)
            Item(Global): Logical Minimum, data= [ 0x00 ] 0
            Item(Global): Logical Maximum, data= [ 0x00 0xff ] 65280
            Item(Global): Report Size, data= [ 0x08 ] 8
            Item(Global): Report Count, data= [ 0x02 ] 2
            Item(Main  ): Feature, data= [ 0x02 ] 2
                            Data Variable Absolute No_Wrap Linear
                            Preferred_State No_Null_Position Non_Volatile Bitfield
            Item(Main  ): End Collection, data=none
      Endpoint Descriptor:
        bLength                 7
        bDescriptorType         5
        bEndpointAddress     0x81  EP 1 IN
        bmAttributes            3
          Transfer Type            Interrupt
          Synch Type               None
          Usage Type               Data
        wMaxPacketSize     0x0040  1x 64 bytes
        bInterval               1
      Endpoint Descriptor:
        bLength                 7
        bDescriptorType         5
        bEndpointAddress     0x01  EP 1 OUT
        bmAttributes            3
          Transfer Type            Interrupt
          Synch Type               None
          Usage Type               Data
        wMaxPacketSize     0x0040  1x 64 bytes
        bInterval               1
I've tried using libusb and libhid but I did not have luck with them. Besides, I think using hiddev is a better solution. I understand the basic technique but I don't know how to get the usage and report info I need.

I can see an input and an output usage, how do I access them? I notice they are in usage page 0xffa0, and input and output are usages 0x03 and 0x04, respectively. Basically I need to figure out how to use the SUSAGE and SREPORT ioctl calls to send a report. Please help with any information you can provide.

Thanks.

Last edited by AngryLlama; 05-08-2006 at 07:44 PM.
 
Old 05-08-2006, 08:40 PM   #2
AngryLlama
Member
 
Registered: Sep 2004
Location: /dev/urandom
Distribution: Gentoo
Posts: 171

Original Poster
Rep: Reputation: 31
I also noticed that the unit is using (none) driver instead of the hid driver. Could this be a problem?
Code:
llamabox hqct # cat /proc/bus/usb/devices
...
T:  Bus=01 Lev=01 Prnt=01 Port=01 Cnt=01 Dev#=  2 Spd=12  MxCh= 0
D:  Ver= 2.00 Cls=00(>ifc ) Sub=00 Prot=00 MxPS= 8 #Cfgs=  1
P:  Vendor=04d8 ProdID=000a Rev= 0.01
S:  Manufacturer=Datalex
S:  Product=Car-Radio
C:* #Ifs= 1 Cfg#= 1 Atr=a0 MxPwr=100mA
I:  If#= 0 Alt= 0 #EPs= 2 Cls=03(HID  ) Sub=00 Prot=00 Driver=(none)
E:  Ad=81(I) Atr=03(Int.) MxPS=  64 Ivl=1ms
E:  Ad=01(O) Atr=03(Int.) MxPS=  64 Ivl=1ms
 
Old 05-09-2006, 12:29 AM   #3
AngryLlama
Member
 
Registered: Sep 2004
Location: /dev/urandom
Distribution: Gentoo
Posts: 171

Original Poster
Rep: Reputation: 31
More Information... This is the data as it is set on the PIC Microcontroller. This shows all the hard-coded values used in the tables and reports.
Code:
it is an HID device using reports, each 32 bytes long (fixed)


const
 BufferInSize  = 32;
 BufferOutSize = 32;
 // vendor and product ID constants...
 VENDOR_ID     = 1240;
 PRODUCT_ID    = 10;


//******************************************************************************
// The number of bytes in each report,
// calculated from Report Size and Report Count in the report descriptor
//******************************************************************************
 const HID_INPUT_REPORT_BYTES      = 32;
 const HID_OUTPUT_REPORT_BYTES     = 32;

 const HID_FEATURE_REPORT_BYTES    = 2;

 
//******************************************************************************
// Byte constants
//******************************************************************************
 const NUM_ENDPOINTS               = 2;
 const ConfigDescr_wTotalLength    = USB_CONFIG_DESCRIPTOR_LEN + 
                                     USB_INTERF_DESCRIPTOR_LEN + 
                                     USB_HID_DESCRIPTOR_LEN + 
                                     (NUM_ENDPOINTS * USB_ENDP_DESCRIPTOR_LEN);
 const HID_ReportDesc_len          = 47;

 const Low_HID_ReportDesc_len      = HID_ReportDesc_len;
 const High_HID_ReportDesc_len     = HID_ReportDesc_len shr 8;

 const Low_HID_PACKET_SIZE         = HID_PACKET_SIZE;
 const High_HID_PACKET_SIZE        = HID_PACKET_SIZE shr 8;

 
//******************************************************************************
// Descriptor Tables
//******************************************************************************
 const DeviceDescr : array[USB_DEVICE_DESCRIPTOR_LEN*2] of byte = (
   USB_DEVICE_DESCRIPTOR_LEN, 0,           // bLength               - Length of Device descriptor (always 0x12)
   USB_DEVICE_DESCRIPTOR_TYPE, 0,          // bDescriptorType       - 1 = DEVICE descriptor
   0x00, 0,                                // bcdUSB                - USB revision 2.00 (low byte)
   0x02, 0,                                //                           (high byte)
   0x00, 0,                                // bDeviceClass          - Zero means each interface operates independently (class code in the interface descriptor)
   0x00, 0,                                // bDeviceSubClass
   0x00, 0,                                // bDeviceProtocol
   EP0_PACKET_SIZE, 0,                     // bMaxPacketSize0       - maximum size of a data packet for a control transfer over EP0
   0xD8, 0,                                // idVendor              - Vendor  ID (low byte)
   0x04, 0,                                //                           (high byte)
   0x0A, 0,                                // idProduct             - Product ID (low byte)
   0x00, 0,                                //                         (high byte)
   0x01, 0,                                // bcdDevice             - (low byte)
   0x00, 0,                                //                           (highbyte)
   0x01, 0,                                // iManufacturer         - String1
   0x02, 0,                                // iProduct              - String2
   0x00, 0,                                // iSerialNumber         - ( None )
   0x01, 0                                 // bNumConfigurations    - 1
);
 
//******************************************************************************
 const ConfigDescr : array[USB_CONFIG_DESCRIPTOR_LEN*2] of byte = (
   USB_CONFIG_DESCRIPTOR_LEN, 0,           // bLength               - Length of Configuration descriptor (always 0x09)
   USB_CONFIG_DESCRIPTOR_TYPE, 0,          // bDescriptorType       - 2 = CONFIGURATION descriptor
   ConfigDescr_wTotalLength, 0,            // wTotalLength          - Total length of this config. descriptor plus the interface and endpoint descriptors that are part of the configuration.
   0x00, 0,                                //                           (high byte)
   0x01, 0,                                // bNumInterfaces        - Number of interfaces
   0x01, 0,                                // bConfigurationValue   - Configuration Value
   0x00, 0,                                // iConfiguration        - String Index for this configuration ( None )
   0xA0, 0,                                // bmAttributes          - attributes - "Bus powered" and "Remote wakeup"
   50, 0                                   // MaxPower              - bus-powered draws 50*2 mA from the bus.
);
 
//******************************************************************************
 const InterfaceDescr : array[USB_INTERF_DESCRIPTOR_LEN*2] of byte = (
   USB_INTERF_DESCRIPTOR_LEN, 0,           // bLength               - Length of Interface descriptor (always 0x09)
   USB_INTERFACE_DESCRIPTOR_TYPE, 0,       // bDescriptorType       - 4 = INTERFACE descriptor
   0x00, 0,                                // bInterfaceNumber      - Number of interface, 0 based array
   0x00, 0,                                // bAlternateSetting     - Alternate setting
   NUM_ENDPOINTS, 0,                       // bNumEndPoints         - Number of endpoints used in this interface
   0x03, 0,                                // bInterfaceClass       - assigned by the USB
   0x00, 0,                                // bInterfaceSubClass    - Not A boot device
   0x00, 0,                                // bInterfaceProtocol    - none 
   0x00, 0                                 // iInterface            - Index to string descriptor that describes this interface ( None )
);
 
//******************************************************************************
 const HID_Descriptor : array[USB_HID_DESCRIPTOR_LEN*2] of byte = (
   USB_HID_DESCRIPTOR_LEN, 0,              // bLength               - Length of HID descriptor (always 0x09)
   USB_HID_DESCRIPTOR_TYPE, 0,             // bDescriptorType       - 0x21 = HID descriptor
   0x01, 0,                                // HID class release number (1.01)
   0x01, 0,
   0x00, 0,                                // Localized country code (none)
   0x01, 0,                                // # of HID class descriptor to follow (1)
   0x22, 0,                                // Report descriptor type (HID)
   Low_HID_ReportDesc_len, 0,
   High_HID_ReportDesc_len, 0
);
 
//******************************************************************************
 const EP1_RXDescr : array[USB_ENDP_DESCRIPTOR_LEN*2] of byte = (
   USB_ENDP_DESCRIPTOR_LEN, 0,             // bLength               - length of descriptor (always 0x07)
   USB_ENDPOINT_DESCRIPTOR_TYPE, 0,        // bDescriptorType       - 5 = ENDPOINT descriptor
   0x81, 0,                                // bEndpointAddress      - In, EP1
   USB_ENDPOINT_TYPE_INTERRUPT, 0,         // bmAttributes          - Endpoint Type - Interrupt
   Low_HID_PACKET_SIZE, 0,                 // wMaxPacketSize        - max packet size - low order byte
   High_HID_PACKET_SIZE, 0,                //                       - max packet size - high order byte
   1, 0                                    // bInterval             - polling interval (1 ms)
);
 
//******************************************************************************
 const EP1_TXDescr : array[USB_ENDP_DESCRIPTOR_LEN*2] of byte = (
   USB_ENDP_DESCRIPTOR_LEN, 0,             // bLength               - length of descriptor (always 0x07)
   USB_ENDPOINT_DESCRIPTOR_TYPE, 0,        // bDescriptorType       - 5 = ENDPOINT descriptor
   0x01, 0,                                // bEndpointAddress      - Out, EP1
   USB_ENDPOINT_TYPE_INTERRUPT, 0,         // bmAttributes          - Endpoint Type - Interrupt
   Low_HID_PACKET_SIZE, 0,                 // wMaxPacketSize        - max packet size - low order byte
   High_HID_PACKET_SIZE, 0,                //                       - max packet size - high order byte
   1, 0                                    // bInterval             - polling interval (1 ms)
);
 
//******************************************************************************
 const HID_ReportDesc : array[HID_ReportDesc_len*2] of byte = (
   0x06, 0,                                // USAGE_PAGE (Vendor Defined)
   0xA0, 0,
   0xFF, 0,
   0x09, 0,                                // USAGE ID (Vendor Usage 1)
   0x01, 0,
   0xA1, 0,                                // COLLECTION (Application)
   0x01, 0,
//  The Input report
   0x09, 0,                                // USAGE ID - Vendor defined
   0x03, 0,
   0x15, 0,                                //   LOGICAL_MINIMUM (0)
   0x00, 0,
   0x26, 0,                                //   LOGICAL_MAXIMUM (255)
   0x00, 0,
   0xFF, 0,
   0x75, 0,                                //   REPORT_SIZE (8)
   0x08, 0,
   0x95, 0,                                //   REPORT_COUNT (2)
   HID_INPUT_REPORT_BYTES, 0,
   0x81, 0,                                //   INPUT (Data,Var,Abs)
   0x02, 0,
//  The Output report
   0x09, 0,                                // USAGE ID - Vendor defined
   0x04, 0,
   0x15, 0,                                //   LOGICAL_MINIMUM (0)
   0x00, 0,
   0x26, 0,                                //   LOGICAL_MAXIMUM (255)
   0x00, 0,
   0xFF, 0,
   0x75, 0,                                //   REPORT_SIZE (8)
   0x08, 0,
   0x95, 0,                                //   REPORT_COUNT (2)
   HID_OUTPUT_REPORT_BYTES, 0,
   0x91, 0,                                //   OUTPUT (Data,Var,Abs)
   0x02, 0,
//  The Feature report
   0x09, 0,                                // USAGE ID - Vendor defined
   0x05, 0,
   0x15, 0,                                //   LOGICAL_MINIMUM (0)
   0x00, 0,
   0x26, 0,                                //   LOGICAL_MAXIMUM (255)
   0x00, 0,
   0xFF, 0,
   0x75, 0,                                //   REPORT_SIZE (8)
   0x08, 0,
   0x95, 0,                                //   REPORT_COUNT (2)
   HID_FEATURE_REPORT_BYTES, 0,
   0xB1, 0,                                //   FEATURE (Data,Var,Abs)
   0x02, 0,
//  End Collection
   0xC0, 0                                 // END_COLLECTION
);

//******************************************************************************
 const LangIDDescr : array[8] of byte = (
   0x04, 0,
   USB_STRING_DESCRIPTOR_TYPE, 0,
   0x09, 0,                                // LangID (0x0409) - Low
   0x04, 0                                 //                 - High
);

//******************************************************************************
 const StrUnknownDescr : array[4] of byte = (
   2, 0,
   USB_STRING_DESCRIPTOR_TYPE, 0
);

//******************************************************************************
I'm sure someone has interfaced with a PIC in Linux. I have tried using libhid and writing a kernel module based off of the usb-skel driver.
Someone help me write a few bytes to the usb port.
 
Old 05-10-2006, 07:21 PM   #4
AngryLlama
Member
 
Registered: Sep 2004
Location: /dev/urandom
Distribution: Gentoo
Posts: 171

Original Poster
Rep: Reputation: 31
I get the following dmesg from modprobe usbhid:
Code:
usbcore: registered new driver hiddev
drivers/usb/input/hid-core.c: usb_submit_urb(ctrl) failed
drivers/usb/input/hid-core.c: timeout initializing reports
hiddev96: USB HID v1.01 Device [Datalex Car-Radio] on usb-0000:00:07.2-2
usbcore: registered new driver usbhid
drivers/usb/input/hid-core.c: v2.6:USB HID core driver
Here is the program I am trying to use to communicate with the USB device. I can hear a small amount of talk over the datalines, so it is trying to communicate. The first time running the program: HIDIOCSREPORT returns immediately. After that, running the program cause HIDIOCSREPORT to block for a few seconds before returning.

Code:
#include <stdlib.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <asm/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <linux/hiddev.h>

struct hiddev_usage_ref   uref_out;
struct hiddev_report_info rinfo_out;
int found_out = 0;

unsigned char go_am[] = "\x00\x18\x30\x40\x0f\x9f\x01\x00\x30\x50\x50\x74\x6f\x6a\xd0\x03\x03\x20\x0A\x0c\x01\x01\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00";

static void showReports(int fd, unsigned report_type)
{
    struct hiddev_report_info rinfo;
    struct hiddev_field_info finfo;
    struct hiddev_usage_ref uref;
    int i, j, ret;

    rinfo.report_type = report_type;
    rinfo.report_id = HID_REPORT_ID_FIRST;
    ret = ioctl(fd, HIDIOCGREPORTINFO, &rinfo);

    // Get Reports
    while (ret >= 0)
    {
        printf("HIDIOCGREPORTINFO: report_id=0x%X (%u fields)\n",
            rinfo.report_id, rinfo.num_fields);

        // Copy the output report
        if( report_type == HID_REPORT_TYPE_OUTPUT ) {
            memcpy(&rinfo_out, &rinfo, sizeof(rinfo));
            found_out = 1;
        }

        // Get Fields
        for (i = 0; i < rinfo.num_fields; i++)
        {
            finfo.report_type = rinfo.report_type;
            finfo.report_id   = rinfo.report_id;
            finfo.field_index = i;
            ioctl(fd, HIDIOCGFIELDINFO, &finfo);

            printf("HIDIOCGFIELDINFO: field_index=%u maxusage=%u flags=0x%X\n"
                "\tphysical=0x%X logical=0x%X application=0x%X\n"
                "\tlogical_minimum=%d,maximum=%d physical_minimum=%d,maximum=%d\n",
                finfo.field_index, finfo.maxusage, finfo.flags,
                finfo.physical, finfo.logical, finfo.application,
                finfo.logical_minimum,  finfo.logical_maximum,
                finfo.physical_minimum, finfo.physical_maximum);


            // Get usages
            for (j = 0; j < finfo.maxusage; j++)
            {
                uref.report_type = finfo.report_type;
                uref.report_id   = finfo.report_id;
                uref.field_index = i;
                uref.usage_index = j;
                ioctl(fd, HIDIOCGUCODE, &uref);
                ioctl(fd, HIDIOCGUSAGE, &uref);

                printf(" >> usage_index=%u usage_code=0x%X () value=0x%X\n",
                    uref.usage_index,
                    uref.usage_code,
                    uref.value);

                // First output usage: grab it.
                if(uref.report_type == HID_REPORT_TYPE_OUTPUT && j==0) {
                    memcpy(&uref_out, &uref, sizeof(uref));
                }

            }


        }
        printf("\n");

        rinfo.report_id |= HID_REPORT_ID_NEXT;
        ret = ioctl(fd, HIDIOCGREPORTINFO, &rinfo);
    }
}


int main (int argc, char **argv) {

    int fd = -1;
    int i;

    struct hiddev_report_info report;
    struct hiddev_usage_ref usage;
    struct hiddev_event {
        unsigned hid;
        signed int value;
    };

    struct hiddev_event ev;

    if (argc != 2) {
        fprintf(stderr, "usage: %s hiddevice - probably /dev/usb/hiddev0\n", argv[0]);
        exit(1);
    }
    if ((fd = open(argv[1], O_RDONLY)) < 0) {
        perror("hiddev open");
        exit(1);
    }

    printf("\n*** INPUT:\n"); showReports(fd, HID_REPORT_TYPE_INPUT);
    printf("\n*** OUTPUT:\n"); showReports(fd, HID_REPORT_TYPE_OUTPUT);
    printf("\n*** FEATURE:\n"); showReports(fd, HID_REPORT_TYPE_FEATURE);

    if( found_out ) {
        printf("The output report was found, trying to send: \n");

        printf("HIDIOCGREPORTINFO: report_id=0x%X (%u fields)\n",
                rinfo_out.report_id, rinfo_out.num_fields);

        for(i = 0; i < 32; i++) {
            uref_out.usage_index = i;
            uref_out.value = go_am[i];

            printf(" << usage_index=%u usage_code=0x%X () value=0x%X\n",
                uref_out.usage_index,
                uref_out.usage_code,
                uref_out.value);
            ioctl(fd,HIDIOCSUSAGE, &uref_out);
        }

        printf(" << sending report\n");
        ioctl(fd,HIDIOCSREPORT,&rinfo_out);
        printf(" <<<<eport sent\n");
    }

    close(fd);

    return 0;
}
Please provide any information if you have it.
 
Old 05-11-2006, 11:51 AM   #5
AngryLlama
Member
 
Registered: Sep 2004
Location: /dev/urandom
Distribution: Gentoo
Posts: 171

Original Poster
Rep: Reputation: 31
OK,

Aparently this forum is not for more advanced questions. Can anyone recommend a forum that discusses more than fwrite, compiler errors, and for loops?

Thanks
 
Old 12-28-2006, 05:53 AM   #6
eknv
LQ Newbie
 
Registered: Dec 2006
Posts: 1

Rep: Reputation: 0
HIDDEV example

Quote:
Originally Posted by AngryLlama
OK,

Aparently this forum is not for more advanced questions. Can anyone recommend a forum that discusses more than fwrite, compiler errors, and for loops?

Thanks
Have you already found some example using the HIDDEV for accessing HID usb-devices? I am also not sure using HIDDEV or libhid (libusb)..
 
Old 12-29-2006, 11:40 AM   #7
MicahCarrick
Member
 
Registered: Jul 2004
Distribution: Fedora
Posts: 241

Rep: Reputation: 31
You may have better luck in the PIC Microchip forums. Although I have interfaced with a PIC in linux, it was using an FTDI chip and thus more a serial interface than a USB interface as far as the software was concerned.
 
Old 12-29-2006, 11:55 AM   #8
MicahCarrick
Member
 
Registered: Jul 2004
Distribution: Fedora
Posts: 241

Rep: Reputation: 31
Oh yeah... may also want to try the gnupic mailing list http://www.gnupic.org/
 
  


Reply


Thread Tools Search this Thread
Search this Thread:

Advanced Search

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is Off
HTML code is Off



Similar Threads
Thread Thread Starter Forum Replies Last Post
Talking to USB-HID ectech Programming 1 10-24-2005 06:24 AM
Talking to USB HID ectech Programming 0 12-30-2003 10:50 AM
USB hid.o hijacking my USB Printer Relativity Linux - Hardware 0 12-09-2003 08:56 PM
Usb-hid RanmaPhreak79 Linux - Hardware 1 07-18-2003 08:32 PM
Usb + Hid vexer Slackware 4 05-28-2003 09:46 PM

LinuxQuestions.org > Forums > Non-*NIX Forums > Programming

All times are GMT -5. The time now is 12:51 AM.

Main Menu
Advertisement
My LQ
Write for LQ
LinuxQuestions.org is looking for people interested in writing Editorials, Articles, Reviews, and more. If you'd like to contribute content, let us know.
Main Menu
Syndicate
RSS1  Latest Threads
RSS1  LQ News
Twitter: @linuxquestions
Open Source Consulting | Domain Registration