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; }
/* *set cmd len is 8 *set retbuf len is 64 * */ int get_device_package( unsigned char *retbuf) { hid_return ret; ret = hid_interrupt_read(hid, 3, retbuf, 64, 1000); if (ret != HID_RET_SUCCESS) { fprintf(stderr, "hid_close failed with return code %d\n", ret); return -1; } return 0; }
void Set_Attenuation (float AttValue,HIDInterface* hid) { int i; char PACKETreceive[SEND_PACKET_LEN]; PACKET[0]=19; // Set Attenuation code is 19. PACKET[1]= (int)(AttValue); PACKET[2]= (int) ((AttValue-PACKET[1])*4); ret = hid_interrupt_write(hid, 0x01, PACKET, SEND_PACKET_LEN,1000); if (ret != HID_RET_SUCCESS) { fprintf(stderr, "hid_interrupt_write failed with return code %d\\n", ret); } ret = hid_interrupt_read(hid, 0x01, PACKETreceive, SEND_PACKET_LEN,1000); // Read packet Packetreceive[0]=1 if (ret != HID_RET_SUCCESS) { fprintf(stderr, "hid_interrupt_read failed with return code %d\n", ret); } }
void ReadAtt (char* AttStr,HIDInterface* hid) { int i; char PACKETreceive[SEND_PACKET_LEN]; PACKET[0]=18; // Ruturn attenuation code ret = hid_interrupt_write(hid, 0x01, PACKET, SEND_PACKET_LEN,1000); if (ret != HID_RET_SUCCESS) { fprintf(stderr, "hid_interrupt_write failed with return code %d\n", ret); } ret = hid_interrupt_read(hid, 0x01, PACKETreceive, SEND_PACKET_LEN,1000); if (ret == HID_RET_SUCCESS) {strncpy(AttStr,PACKETreceive,SEND_PACKET_LEN); for(i=0;AttStr[i+1]!='\0';i++) { AttStr[i]=AttStr[i+1]; } AttStr[i]='\0';} if (ret != HID_RET_SUCCESS) { fprintf(stderr, "hid_interrupt_read failed with return code %d\n", ret);} }
void Get_PN (char* PNstr,HIDInterface* hid) { int i; char PACKETreceive[SEND_PACKET_LEN]; PACKET[0]=40; // PN code ret = hid_interrupt_write(hid, 0x01, PACKET, SEND_PACKET_LEN,1000); if (ret != HID_RET_SUCCESS) { fprintf(stderr, "hid_interrupt_write failed with return code %d\n", ret); } ret = hid_interrupt_read(hid, 0x01, PACKETreceive, SEND_PACKET_LEN,1000); if (ret == HID_RET_SUCCESS) { strncpy(PNstr,PACKETreceive,SEND_PACKET_LEN); for (i=0;PNstr[i+1]!='\0';i++) { PNstr[i]=PNstr[i+1]; } PNstr[i]='\0'; } if (ret != HID_RET_SUCCESS) { fprintf(stderr, "hid_interrupt_read failed with return code %d\n", ret);} }
static void RFIDCommunication(hid_return ret, HIDInterface** const hid) { int const PATH_IN[] = { PATHIN }; unsigned int SEND_PACKET_LEN1 = 3; unsigned int REPLY_PACKET_LENGTH1 = 3; printf("\n/* * * * * * * * BEGIN COMMUNICATION WITH RFID DEVICE * * * * * * * */"); // SET ANTENNA POWER char PACKET1[] = { 0xC0, 0x03, 0x12 }; ret = hid_set_output_report(*hid, PATH_IN, PATHLEN, PACKET1, SEND_PACKET_LEN1); if (ret != HID_RET_SUCCESS) { fprintf(stderr, "hid_set_output_report failed with return code %d\n", ret); } else { printf("\n\n----->First sent: \n"); printHex(PACKET1, SEND_PACKET_LEN1); } char reply1[REPLY_PACKET_LENGTH1+1]; ret = hid_interrupt_read(*hid, EP_INTERRUPT_IN, reply1, REPLY_PACKET_LENGTH1, 100); if (ret != HID_RET_SUCCESS) { fprintf(stderr, "interrupt read failed with return code %d\n", ret); } else { printf("\n\n----->First reply:\n"); printHex(reply1, REPLY_PACKET_LENGTH1); } // TAG INVENTORY OPERATION // XXX: returns EPC Data unsigned int SEND_PACKET_LEN2 = 3; unsigned int REPLY_PACKET_LENGTH2 = 64; char PACKET2[] = { 0x31, 0x03, 0x01 }; ret = hid_set_output_report(*hid, PATH_IN, PATHLEN, PACKET2, SEND_PACKET_LEN2); if (ret != HID_RET_SUCCESS) { fprintf(stderr, "hid_set_output_report failed with return code %d\n", ret); } else { printf("\n\n----->Second sent:\n"); printHex(PACKET2, SEND_PACKET_LEN2); } char reply2[REPLY_PACKET_LENGTH2+1]; ret = hid_interrupt_read(*hid, EP_INTERRUPT_IN, reply2, REPLY_PACKET_LENGTH2, 100); if (ret != HID_RET_SUCCESS) { fprintf(stderr, "interrupt read failed with return code %d\n", ret); } else { printf("\n\n----->Second reply:\n"); printHex(reply2, REPLY_PACKET_LENGTH2); } // NEXT TAG //unsigned int SEND_PACKET_LEN3 = 3; //unsigned int REPLY_PACKET_LENGTH3 = 64; //char PACKET3[] = { 0x31, 0x03, 0x02 }; //ret = hid_set_output_report(*hid, PATH_IN, PATHLEN, PACKET3, SEND_PACKET_LEN3); //if (ret != HID_RET_SUCCESS) { // fprintf(stderr, "hid_set_output_report failed with return code %d\n", ret); //} else { // printf("\n\n----->Third sent: \n"); // printHex(PACKET3, SEND_PACKET_LEN3); //} //char reply3[REPLY_PACKET_LENGTH3+1]; //ret = hid_interrupt_read(*hid, EP_INTERRUPT_IN, reply3, REPLY_PACKET_LENGTH3, 100); //if (ret != HID_RET_SUCCESS) { // fprintf(stderr, "interrupt read failed with return code %d\n", ret); //} else { // printf("\n\n----->Third reply: \n", reply3); // printHex(reply3, REPLY_PACKET_LENGTH3); //} // TAG SELECT OPERATION unsigned int SEND_PACKET_LEN4 = 15; unsigned int REPLY_PACKET_LENGTH4 = 3; char PACKET4[] = { 0x33, 0x0F, 0x0C, 0xCF, 0xFA, 0x04, 0x9C, 0x53, 0xE0, 0xC9, 0x7E, 0x13, 0x77, 0xFB, 0x97 }; ret = hid_set_output_report(*hid, PATH_IN, PATHLEN, PACKET4, SEND_PACKET_LEN4); if (ret != HID_RET_SUCCESS) { fprintf(stderr, "hid_set_output_report failed with return code %d\n", ret); } else { printf("\n\n----->Fourth sent: \n"); printHex(PACKET4, SEND_PACKET_LEN4); } char reply4[REPLY_PACKET_LENGTH4+1]; ret = hid_interrupt_read(*hid, EP_INTERRUPT_IN, reply4, REPLY_PACKET_LENGTH4, 100); if (ret != HID_RET_SUCCESS) { fprintf(stderr, "interrupt read failed with return code %d\n", ret); } else { printf("\n\n----->Fourth reply: \n", reply4); printHex(reply4, REPLY_PACKET_LENGTH4); } // TAG READ EPC MEMORY OPERATION unsigned int SEND_PACKET_LEN5 = 9; unsigned int REPLY_PACKET_LENGTH5 = 64; char PACKET5[] = { 0x37, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04 }; ret = hid_set_output_report(*hid, PATH_IN, PATHLEN, PACKET5, SEND_PACKET_LEN5); if (ret != HID_RET_SUCCESS) { fprintf(stderr, "hid_set_output_report failed with return code %d\n", ret); } else { printf("\n\n----->Fifth sent: \n"); printHex(PACKET5, SEND_PACKET_LEN5); } char reply5[REPLY_PACKET_LENGTH5+1]; ret = hid_interrupt_read(*hid, EP_INTERRUPT_IN, reply5, REPLY_PACKET_LENGTH5, 100); if (ret != HID_RET_SUCCESS) { fprintf(stderr, "interrupt read failed with return code %d\n", ret); } else { printf("\n\n----->Fifth reply: \n", reply5); printHex(reply5, REPLY_PACKET_LENGTH5); } }
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; }
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; }
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; }