Beispiel #1
0
int open_usb_device()
{
	hid_return ret;

	HIDInterfaceMatcher matcher = { VENDOR_ID, PRODUCT_ID, NULL, NULL, 0 };

	hid_set_debug(HID_DEBUG_NONE);
	hid_set_debug_stream(stderr);
	hid_set_usb_debug(0);

	ret = hid_init();
	if (ret != HID_RET_SUCCESS) {
		fprintf(stderr, "hid_init failed with return code %d\n", ret);
		return -1;
	}

	hid = hid_new_HIDInterface();
	if (hid == 0) {
		fprintf(stderr, "hid_new_HIDInterface() failed, out of memory?\n");
		return -1;
	}
	ret = hid_force_open(hid, IFACE_CONTROL, &matcher, 3);
	if (ret != HID_RET_SUCCESS) {
		fprintf(stderr, "hid_force_open failed with return code %d\n", ret);
		return -1;
	}

	ret = hid_os_force_claim(hid, 0, &matcher, 3); 
	if (ret != HID_RET_SUCCESS) {
		fprintf(stderr, "hid_os_force_claim failed with return code %d\n", ret);
		return -1;
	}
	hid->interface = 1; 
	return 0; 
}
Beispiel #2
0
int main(void){
  HIDInterface* hid;
  hid_return ret;
  HIDInterfaceMatcher matcher = { VENDOR, PRODUCT, NULL, NULL, 0 };
  char packet[PACKET_LEN];

  hid_set_debug(HID_DEBUG_NONE);
  hid_set_debug_stream(stderr);
  hid_set_usb_debug(0);
  
  hid_init();
  hid = hid_new_HIDInterface();
  ret = hid_force_open(hid, 0, &matcher, 3);

  if (ret == HID_RET_FAIL_DETACH_DRIVER) {
      printf("Failed to detach Driver for Device %04x:%04x; Permission?\n", VENDOR, PRODUCT);
      return 1;
  }

  if (ret != HID_RET_SUCCESS) {
      printf("Could not open HID device %04x:%04x (ret was %d)\n", VENDOR, PRODUCT, ret);
      return 1;
  }

  // printf("hid_force_open ret=%d\n", ret);

  // hid_set_idle(hid,0,0);

  // Discard till first '\n'
  do {
    memset(packet,0,sizeof(packet));
    ret = hid_interrupt_read(hid,0x81,packet,PACKET_LEN,1000);
  } while (getTheChar(packet[1]) != '\n');

  while (1) {
    memset(packet,0,sizeof(packet));

    ret = hid_interrupt_read(hid,0x81,packet,PACKET_LEN,1000);

    /*
    if (ret == HID_RET_FAIL_INT_READ) {
        printf("Fail hid_interrupt_read\n");
    } else {
        printf("hid_interrupt_read ret=%d\n", ret);
    }
    */

    if( ret == HID_RET_SUCCESS ) {
      //printPacket(packet,PACKET_LEN);
      showTemperature(packet);
    }
  }

  hid_close(hid);
  hid_delete_HIDInterface(&hid);
  hid_cleanup();
  return 0;
}
Beispiel #3
0
/* -------------------------------------------------------------------------- */
static void *usbhid_new(t_float f) 
{
	t_int i;
	HIDInterfaceMatcher matcher;
	t_usbhid *x = (t_usbhid *)pd_new(usbhid_class);
	
	if(x->debug_level) post("usbhid_new");
	
/* only display the version when the first instance is loaded */
	if(!usbhid_instance_count)
		post("[usbhid] %d.%d, written by Hans-Christoph Steiner <*****@*****.**>",
			 USBHID_MAJOR_VERSION, USBHID_MINOR_VERSION);  
	
	/* create anything outlet used for HID data */ 
	x->x_data_outlet = outlet_new(&x->x_obj, 0);
	x->x_status_outlet = outlet_new(&x->x_obj, 0);

	/* turn off the flood of libhid debug messages by default */
	hid_set_debug(HID_DEBUG_NONE);
	hid_set_debug_stream(stdout);
	hid_set_usb_debug(0);
	
	/* data init */
	x->output = NULL;
	x->output_count = 0;
	for (i = 0 ; i < HID_ID_MAX ; i++)
		hid_id[i] = NULL;
	
	x->x_hidinterface = hid_new_HIDInterface();
	matcher.vendor_id = HID_ID_MATCH_ANY;
	matcher.product_id = HID_ID_MATCH_ANY;
	matcher.matcher_fn = device_iterator;
    x->x_write_path_count = 0;
	
	x->x_device_number = f;
/* Open the device and save settings.  If there is an error, return the object
 * anyway, so that the inlets and outlets are created, thus not breaking the
 * patch.   */
/* 	if (usbhid_open(x,f)) */
/* 		error("[usbhid] device %d did not open",(t_int)f); */

	usbhid_instance_count++;

	return (x);
}
Beispiel #4
0
int main(void)
{
  int i;
  hid_return ret;
  HIDInterface* hid;
  HIDInterfaceMatcher matcher;

  /* hid_write_library_config(stdout); */
  
  /* hid_set_debug(HID_DEBUG_NOTRACES); */
  // hid_set_debug(HID_DEBUG_NONE);
  hid_set_debug(HID_DEBUG_ALL);
  hid_set_debug_stream(stderr);
  hid_set_usb_debug(0);

  /* data init */
  for (i = 0 ; i < 32 ; i++)
	hid_id[i] = NULL;

  ret = hid_init();

  hid = hid_new_HIDInterface();
  matcher.vendor_id = HID_ID_MATCH_ANY;
  matcher.product_id = HID_ID_MATCH_ANY;
  matcher.matcher_fn = device_iterator;

  /* open recursively all HID devices found */
  while ( (ret = hid_force_open(hid, 0, 0, &matcher, 2)) != HID_RET_DEVICE_NOT_FOUND)
	{
	  printf("************************************************************************\n");
	  
	  hid_write_identification(stdout, hid);
	  
	  /* Only dump HID tree if asked */
	  /* hid_dump_tree(stdout, hid); */
	  
	  hid_close(hid);
	}
	 
  hid_delete_HIDInterface(&hid);
  ret = hid_cleanup();
  
  return 0;
}
Beispiel #5
0
/* -------------------------------------------------------------------------- */
static void usbhid_debug(t_usbhid *x, t_float f)
{
	x->debug_level = f;
	
	switch(x->debug_level)
	{
	case 0: hid_set_usb_debug(0); hid_set_debug(HID_DEBUG_NONE); break;
	case 1: hid_set_usb_debug(0); hid_set_debug(HID_DEBUG_ERRORS); break;
	case 2: hid_set_usb_debug(0); 
		hid_set_debug(HID_DEBUG_ERRORS | HID_DEBUG_WARNINGS); break;
	case 3: hid_set_usb_debug(0); 
		hid_set_debug(HID_DEBUG_ERRORS | HID_DEBUG_WARNINGS | HID_DEBUG_NOTICES); break;
	case 4: hid_set_usb_debug(0); hid_set_debug(HID_DEBUG_NOTRACES); break;
	case 5: hid_set_usb_debug(0); hid_set_debug(HID_DEBUG_ALL); break;
	default:
		hid_set_usb_debug(x->debug_level - 5); hid_set_debug(HID_DEBUG_ALL); break;
	}
}
Beispiel #6
0
Datei: main.c Projekt: patzy/rcd
int main(int argc,char **argv)
{
  ir_receiver_t* receiver;

  // parse command line args
  if (argc!=2) {
    printf("You must specify the receiver type: %s type\n",argv[0]);
    printf("Valid values for type are:\n");
    unsigned int i=0;
    for (i=0;i<NB_IRR;i++)
      {
        printf("\t- %s\n",receivers[i].description);
      }
    return 1;
  }
  else {
    unsigned int i=0;
    for (i=0;i<NB_IRR;i++)
      {
        if (strncmp(receivers[i].description,argv[1],256)==0) {
          receiver=&receivers[i];
          break;
        }
      }
  }
  printf("Running for type: %s\n",receiver->description);

  HIDInterface* hid;
  hid_return ret;
  hid_set_debug(0/*HID_DEBUG_ALL*/);
  hid_set_debug_stream(stderr);
  /* passed directly to libusb */
  hid_set_usb_debug(0);
  ret = hid_init();
  if (ret != HID_RET_SUCCESS) {
    fprintf(stderr, "hid_init failed with return code %d\n", ret);
    return 1;
  }

  hid = hid_new_HIDInterface();
  if (hid == 0) {
    fprintf(stderr, "hid_new_HIDInterface() failed, out of memory?\n");
    return 1;
  }

  ret = hid_force_open(hid, 0, &receiver->matcher, 3);
  if (ret != HID_RET_SUCCESS) {
    fprintf(stderr, "hid_force_open failed with return code %d\n", ret);
    return 1;
  }

  ret = hid_write_identification(stderr, hid);
  if (ret != HID_RET_SUCCESS) {
    fprintf(stderr, "hid_write_identification failed with return code %d\n",
            ret);
    return 1;
  }

  ret = hid_dump_tree(stderr, hid);
  if (ret != HID_RET_SUCCESS) {
    fprintf(stderr, "hid_dump_tree failed with return code %d\n", ret);
    return 1;
  }

  /* Infinite parsing loop use C-c to stop the program */

  while (1)
    {
      char packet[receiver->packetSize];
      ret = hid_interrupt_read(hid, 0x81,  packet, receiver->packetSize,10000);
      if (ret == HID_RET_SUCCESS) {
          fflush(stdout);
       }
    }
  ret = hid_close(hid);
  if (ret != HID_RET_SUCCESS) {
    fprintf(stderr, "hid_close failed with return code %d\n", ret);
    return 1;
  }

  hid_delete_HIDInterface(&hid);

  ret = hid_cleanup();
  if (ret != HID_RET_SUCCESS) {
    fprintf(stderr, "hid_cleanup failed with return code %d\n", ret);
    return 1;
  }

  return 0;
}
Beispiel #7
0
int main(int argc, char *argv[])
{
  HIDInterface* hid;
  int iface_num = 2;
  hid_return ret;
  int index=0;
  char buff[42];
  unsigned short vendor_id  = 0x0451;
  unsigned short product_id = 0x2100;
  int flag;
  uint16_t addr=0;

  uint8_t eepromBuff[512];
  memset(eepromBuff, 0x00, 512);

  // HIDInterfaceMatcher matcher = { 0x0925, 0x1237, NULL, NULL, 0 };
  HIDInterfaceMatcher matcher = { vendor_id, product_id, NULL, NULL, 0 };

#if 1
  /* see include/debug.h for possible values */
  hid_set_debug(HID_DEBUG_ALL);
  hid_set_debug_stream(stderr);
  /* passed directly to libusb */
  hid_set_usb_debug(0);
  
  ret = hid_init();
  if (ret != HID_RET_SUCCESS) {
    fprintf(stderr, "hid_init failed with return code %d\n", ret);
    return 1;
  }

  hid = hid_new_HIDInterface();
  if (hid == 0) {
    fprintf(stderr, "hid_new_HIDInterface() failed, out of memory?\n");
    return 1;
  }

  ret = hid_force_open(hid, iface_num, &matcher, 3);
  if (ret != HID_RET_SUCCESS) {
    fprintf(stderr, "hid_force_open failed with return code %d\n", ret);
    return 1;
  }

  ret = hid_write_identification(stdout, hid);
  if (ret != HID_RET_SUCCESS) {
    fprintf(stderr, "hid_write_identification failed with return code %d\n", ret);
    return 1;
  }

  ret = hid_dump_tree(stdout, hid);
  if (ret != HID_RET_SUCCESS) {
    fprintf(stderr, "hid_dump_tree failed with return code %d\n", ret);
    return 1;
  }

//#define _READ
#ifdef _READ
  memset(eepromBuff, 0x00, 512);
  for (index=0;index < 64;index++) {
      memset(buff, 0x00, 42);
      addr = 8*index;
      buff[0] = PCTransfer;
      buff[1] = RequestEepromSectionRead;
      buff[2] = (0xFF00 & addr) >> 8; //M:offset
      buff[3] = 0x00FF & addr; //L:offset
      buff[4] = 8; //bytes

      fprintf(stderr, "sending:\n");
      print_bytes(LOG_ERROR, buff, 42);

      ret = hid_interrupt_write(hid, 0x04, buff, 42, 1000);
      if (ret != HID_RET_SUCCESS) {
        fprintf(stderr, "hid_set_output_report failed with return code %d\n", ret);
      }
      ret = hid_interrupt_read(hid, 0x03, buff, 42, 1000);
      if (ret != HID_RET_SUCCESS) {
        fprintf(stderr, "hid_set_output_report failed with return code %d\n", ret);
      }

      fprintf(stderr, "readed:\n");
      print_bytes(LOG_ERROR, buff, 42);

      if(buff[0] & PCRequestError) {
        logwrite(LOG_ERROR, "USB: request error");
      }

      if(!(buff[1] & RequestDone)) {
        logwrite(LOG_ERROR, "USB: request is not done!");
      }

      logwrite(LOG_ERROR, "USB: retval: %02x", buff[2]);
      memcpy(&eepromBuff[8*index], &buff[3], 8);
  }
#endif

#define _WRITE
#ifdef _WRITE
  memset(eepromBuff, 0xFF, 512);
  int commands = eeprom_data_size()/8;
  if(commands < 0 || commands > 62) {
    logwrite(LOG_ERROR, "WRONG COMMANDS NUMBER: %d", commands);
    exit(1);
  }
  logwrite(LOG_ERROR, "total commands: %d", commands);
  /* 2 bytes of sync + number of commands! */
  eepromBuff[0] = 0xb0;
  eepromBuff[1] = 0x0b;
  eepromBuff[2] = commands;

  for (index=0;index < commands;index++) {
      fprintf(stderr, "w%d: eepromBuff[%d], eepromData[%d]\n", index, (index+1)*8, index*8);
      memcpy(&eepromBuff[(index+1)*8], &eepromData[8*index], 8);
  }

  for (index=0;index <= commands;index++) {
      addr = 8*index;
      memset(buff, 0x00, 42);
      buff[0] = PCTransfer;
      buff[1] = RequestEepromSectionWrite;
      buff[2] = (0xFF00 & addr) >> 8; //M:offset
      buff[3] = 0x00FF & addr; //L:offset
      buff[4] = 8; //bytes
      memcpy(&buff[5], &eepromBuff[8*index], 8);

      fprintf(stderr, "sending:\n");
      print_bytes(LOG_ERROR, buff, 42);

      ret = hid_interrupt_write(hid, 0x04, buff, 42, 1000);
      if (ret != HID_RET_SUCCESS) {
        fprintf(stderr, "hid_set_output_report failed with return code %d\n", ret);
      }
      ret = hid_interrupt_read(hid, 0x03, buff, 42, 1000);
      if (ret != HID_RET_SUCCESS) {
        fprintf(stderr, "hid_set_output_report failed with return code %d\n", ret);
      }

      fprintf(stderr, "readed:\n");
      print_bytes(LOG_ERROR, buff, 42);

      if(buff[0] & PCRequestError) {
        logwrite(LOG_ERROR, "USB: request error");
      }

      if(!(buff[1] & RequestDone)) {
        logwrite(LOG_ERROR, "USB: request is not done!");
      }

      logwrite(LOG_ERROR, "USB: retval: %02x", buff[2]);
  }
#endif

  ret = hid_close(hid);
  if (ret != HID_RET_SUCCESS) {
    fprintf(stderr, "hid_close failed with return code %d\n", ret);
    return 1;
  }

  hid_delete_HIDInterface(&hid);

  ret = hid_cleanup();
  if (ret != HID_RET_SUCCESS) {
    fprintf(stderr, "hid_cleanup failed with return code %d\n", ret);
    return 1;
  }
#endif

  fprintf(stderr, "EEPROM DATA:\n");
  for (index=0;index < 64;index++) {
    print_bytes(LOG_ERROR, &eepromBuff[8*index], 8);
  }


  return 0;
}
Beispiel #8
0
int main (int argc, char *argv[])
{
	char buffer[64];
	HIDInterface* hid;
	HIDInterfaceMatcher matcher = { CH_USB_VID, CH_USB_PID_FIRMWARE, NULL, NULL, 0 };
	hid_return ret;
	int i;
	int iface_num = 0;
	int length;
	unsigned int timeout = 1000; /* ms */

	hid_set_debug (HID_DEBUG_ALL);
	hid_set_debug_stream (stderr);
	hid_set_usb_debug (0);

	ret = hid_init ();
	if (ret != HID_RET_SUCCESS) {
		fprintf (stderr, "hid_init failed with return code %d\n", ret);
		return 1;
	}

	hid = hid_new_HIDInterface ();
	if (hid == 0) {
		fprintf (stderr, "hid_new_HIDInterface () failed\n");
		return 1;
	}

	ret = hid_force_open (hid, iface_num, &matcher, 3);
	if (ret != HID_RET_SUCCESS) {
		fprintf (stderr, "hid_force_open failed with return code %d\n", ret);
		return 1;
	}

	ret = hid_write_identification (stdout, hid);
	if (ret != HID_RET_SUCCESS) {
		fprintf (stderr, "hid_write_identification failed with return code %d\n", ret);
		return 1;
	}

	ret = hid_dump_tree (stdout, hid);
	if (ret != HID_RET_SUCCESS) {
		fprintf (stderr, "hid_dump_tree failed with return code %d\n", ret);
		return 1;
	}

	/* turn all the LEDs on */
	memset (buffer, 0x00, sizeof (buffer));
	buffer[0] = 0x0e;
	buffer[1] = 0x03;
	ret = hid_interrupt_write (hid, 0x01,  buffer, sizeof (buffer), timeout);
	if (ret != HID_RET_SUCCESS) {
		fprintf (stderr, "failed calling hid_interrupt_write\n");
		return 1;
	}

	/* read the return message */
	length = 2;
	ret = hid_interrupt_read (hid, 0x01, buffer, length, timeout);
	if (ret != HID_RET_SUCCESS) {
		printf ("hid_interrupt_read failed\n");
		return 1;
	}
	printf ("Data received from USB device: ");
	for (i=0; i < length; i++) {
		printf ("0x%02x, ", buffer[i]);
	}
	printf ("\n");

	ret = hid_close (hid);
	if (ret != HID_RET_SUCCESS) {
		fprintf (stderr, "hid_close failed with return code %d\n", ret);
		return 1;
	}

	hid_delete_HIDInterface (&hid);

	ret = hid_cleanup ();
	if (ret != HID_RET_SUCCESS) {
		fprintf (stderr, "hid_cleanup failed with return code %d\n", ret);
		return 1;
	}

	return 0;
}