int stompbox_read_rom(usbDevice_t *dev, stompbox_rom_t *rom) { const int reportsize = 128; int romsize = 512; int report, len, err; for (report = 1, rom->size = 0; rom->size < romsize; report++, rom->size += reportsize) { len = reportsize; err = usbhidGetReport(dev, report, (char *) (rom->raw + rom->size), &len); if (0 != err || reportsize != len) { fprintf(stderr, "Error reading ROM at %d: %s\n", rom->size, (0 != err ? usbErrorMessage(err) : "reply is too short")); return -1; } } return 0; }
/************************************************************************************** Function Name : main Description : Read and Write the Password in the EEPROM Parameters : commandline arguments Return : NULL **************************************************************************************/ int main(int argc, char **argv) { usbDevice_t *dev; char buffer[129]; /* room for dummy report ID */ int err; if(argc < 2){ usage(argv[0]); exit(1); } if((dev = openDevice()) == NULL) exit(1); if(strcasecmp(argv[1], "read") == 0){ int len = sizeof(buffer); if((err = usbhidGetReport(dev, 0, buffer, &len)) != 0){ fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err)); }else{ hexdump(buffer + 1, sizeof(buffer) - 1); } }else if(strcasecmp(argv[1], "write") == 0){ memset(buffer, 0, sizeof(buffer)); int i = 1; while(*argv[2] != '\0'){ buffer[i] += *argv[2]++; i++; } if((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) /* add a dummy report ID */ fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err)); }else{ usage(argv[0]); exit(1); } usbhidCloseDevice(dev); return 0; }
uint8_t HIDwrite(usbDevice_t *dev, uint8_t reportId, uint8_t *buff, uint16_t size) { unsigned int i; int len; int err; ucp_request_t request; ucp_response_t response; for(i=0; i<size; i+= 8) { request.reportid = reportId; memcpy((void*)&request.data[0], (void*)&buff[i], sizeof(request.data)); if((err = usbhidSetReport(dev, (char*)&request, sizeof(request))) != 0) /* add a dummy report ID */ fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err)); len = sizeof(response); if((err = usbhidGetReport(dev, reportId, (char*)&response, &len)) != 0) { fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err)); } else { hexdump( (void*)&response.data[0], 8); } if(usleep(50000) < 0) // sleep 50 ms { fprintf( stderr, "sleep ERR\n"); } } return 0; }
int main(int argc, char **argv) { usbDevice_t *dev; char buffer[4]; /* room for dummy report ID */ int err; if(argc < 2){ usage(argv[0]); exit(1); } if((dev = openDevice()) == NULL) exit(1); if(strcasecmp(argv[1], "read") == 0){ int len = sizeof(buffer); if((err = usbhidGetReport(dev, 0, buffer, &len)) != 0){ fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err)); }else{ hexdump(buffer + 1, sizeof(buffer) - 1); } }else if(strcasecmp(argv[1], "write") == 0){ int i, pos; memset(buffer, 0, sizeof(buffer)); for(pos = 1, i = 2; i < argc && pos < sizeof(buffer); i++){ pos += hexread(buffer + pos, argv[i], sizeof(buffer) - pos); } if((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) /* add a dummy report ID */ fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err)); }else{ usage(argv[0]); exit(1); } usbhidCloseDevice(dev); return 0; }
// Read HID report static int d16_read_rep(USBDEVHANDLE dev, int reportnum, char raw_data[8+1]) { char buffer[10]; int err; int len = 8 + 1; /* report id 1 byte + 8 bytes data */ memset(buffer, 0, sizeof(buffer)); err = usbhidGetReport(dev, reportnum, buffer, &len); if ( err ) { printerr("error reading hid report: %s\n", usbErrorMessage(err)); return -1; } if ( len != 9 || buffer[0] != reportnum ) { printerr("ERROR: wrong HID report returned! %d\n", len); return -2; } if ( raw_data ) { /* copy raw report data */ memcpy(raw_data, buffer, len); } return 0; }
char* hidtool_read(usb_dev_handle *dev){ memset(readbuffer, 0, 5); int err; // convert r/w into struct. int len = sizeof(readbuffer); if((err = usbhidGetReport(dev, 0, readbuffer, &len)) != 0){ fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err)); } return readbuffer; }
void HIDDevice::GetReport(uint8_t* buffer, int report_size, uint8_t report_id) { log_str("-- into GetRep\n"); int buff_size = report_size + 1; char rcvBuff[buff_size]; int res = usbhidGetReport(hHIDDev, report_id, rcvBuff, &buff_size); if (res != USBOPEN_SUCCESS) { log_str("Unable to read data from programmer.\n"); throw std::string("Unable to read data from programmer"); } memcpy(buffer, rcvBuff + 1, report_size); log_str("-- GetRep "); for (int c = 0; c < report_size; ++c) log_str(int2hex(buffer[c]) + " "); log_str("\n"); log_str("-- out of GetRep\n"); }
uint8_t HIDread(usbDevice_t *dev, uint8_t reportId, uint8_t *buff, uint16_t size) { unsigned int i; int err; for(i=0; i<size; i+= 8) { ucp_response_t response; int len = sizeof(response); if((err = usbhidGetReport(dev, reportId, (char*)&response, &len)) != 0) { fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err)); } else { memcpy((void*)&buff[i], (void*)&response.data, sizeof(response.data)); hexdump( (void*)&buff[i], 8); } } return 0; }
int main(int argc, char **argv) { int option = 0; // For getopt temp option usbDevice_t *dev; ucp_cmd_t buffer; //room for dummy report ID int err; //Initialize globalArgs before we get to work globalArgs.rFlag = 0; //False globalArgs.iFlag = 0; //False globalArgs.wFlag = 0; //False globalArgs.fFlag = 0; //False globalArgs.pFlag = 0; //False globalArgs.hashFlag = 0; //False globalArgs.kFlag = 0; //False strncpy(globalArgs.pin,"0000",sizeof(globalArgs.pin)); //Default pin globalArgs.offset = 0; //Default globalArgs.size = 512; //Default globalArgs.fileName = NULL; globalArgs.file = NULL; //Check if no arguments at all if(argc==1) printUsage(argv[0]); //If there's some argument, parse them while((option = getopt(argc, argv, "rwif:o:p:Pk:s:h?")) !=-1){ //Check option flags switch(option){ case 'r': globalArgs.rFlag = 1; //True break; case 'w': globalArgs.wFlag = 1; //True break; case 'i': globalArgs.iFlag = 1; //True break; case 'f': globalArgs.fFlag = 1; //True globalArgs.fileName = optarg; printf("File: %s\n",globalArgs.fileName); break; case 'o': globalArgs.offset = atoi(optarg); break; case 'p': globalArgs.pFlag = 1; //True strncpy(globalArgs.pin,optarg, sizeof(globalArgs.pin)); break; case 'P': globalArgs.hashFlag=1; //True break; case 'k': globalArgs.kFlag = 1; //True globalArgs.keyboard = optarg; printf("Keyboard: %s\n", globalArgs.keyboard); case 's': globalArgs.size = atoi(optarg); break; case 'h': case '?': printUsage(argv[0]); break; //Unknown flag, don't know what to do default: //After getopt prints the error printUsage(argv[0]); break; } } //Check that only one action is done at a time if(globalArgs.rFlag + globalArgs.wFlag + globalArgs.iFlag > 1) printUsage(argv[0]); //Check that not set PIN and read HASH are given at a time if(globalArgs.pFlag + globalArgs.hashFlag > 1) printUsage(argv[0]); //Check that if write from file to device, we are given a file and a pin to encrypt! if(globalArgs.wFlag && !globalArgs.fFlag) printUsage(argv[0]); if(globalArgs.wFlag && !globalArgs.pFlag) printUsage(argv[0]); //Also check pin for read flag if(globalArgs.rFlag && !globalArgs.pFlag) printUsage(argv[0]); //Try to open the device, exit if no device present. if((dev = openDevice()) == NULL) exit(1); //Clean the buffer before working with it memset((void*)&buffer, 0, sizeof(buffer)); //Check and perform the desired commands if(globalArgs.rFlag){ //READ COMMAND buffer.cmd = UCP_CMD_READ; deviceRead.offset = globalArgs.offset; deviceRead.size = globalArgs.size; memcpy((void*)&buffer.buff, (void*)&deviceRead, sizeof(deviceRead)); //give some feedback fprintf(stderr,"Reading from the MemType: offset=%d bytes, size=%d bytes.\n",deviceRead.offset, deviceRead.size); }else if(globalArgs.wFlag){ //WRITE COMMAND buffer.cmd = UCP_CMD_WRITE; deviceRead.offset = globalArgs.offset; deviceRead.size = readXML(globalArgs.fileName); memcpy((void*)&buffer.buff, (void*)&deviceRead, sizeof(deviceRead)); //give some feedback fprintf(stderr,"Writing to the MemType: offset=%d bytes, size=%d bytes.\n",deviceRead.offset, deviceRead.size); }else if(globalArgs.iFlag){ //INFO COMMAND buffer.cmd = UCP_CMD_INFO; }else if(globalArgs.hashFlag){ //READ PIN HASH COMMAND buffer.cmd = UCP_CMD_READ_PIN; }else if(globalArgs.pFlag){ //SET PIN COMMAND buffer.cmd = UCP_CMD_SET_PIN; buffer.buff[0] = 16; //sizeof hash in bytes }else if(globalArgs.kFlag){ buffer.cmd = UCP_CMD_KEYBOARD; } //Add a dummy report ID and send data to device buffer.reportid = 2; if((err = usbhidSetReport(dev, (char*)&buffer, sizeof(buffer))) != 0) fprintf(stderr, "Error sending data to device: %s\n", usbErrorMessage(err)); //Read back report int len = sizeof(buffer); if((err = usbhidGetReport(dev, 2, (char*)&buffer, &len)) != 0) { //... if not OK, print error fprintf(stderr, "Error reading data from device: %s\n", usbErrorMessage(err)); } else //... if OK, do things :) { fprintf( stderr, "\nMemType CMD Response: "); hexdump( (void*)&buffer.cmd, sizeof(buffer.cmd)+sizeof(buffer.buff)); fprintf( stderr, "Received data from the device: \n"); switch(buffer.cmd) { case UCP_CMD_RESET: fprintf( stderr, "RESET\n"); break; case UCP_CMD_READ: fprintf( stderr, "READ\n"); cmdRead(dev, deviceRead.size); break; case UCP_CMD_WRITE: fprintf( stderr, "WRITE\n"); cmdWrite(dev, flashMemory, deviceRead.size); fprintf(stderr, "[ENCRYPTION TEST] only hexdump"); break; case UCP_CMD_SET_PIN: fprintf(stderr, "SET PIN\n"); cmdSetPin(dev); break; case UCP_CMD_READ_PIN: fprintf(stderr, "READ PIN HASH\n"); cmdReadPinHash(dev); break; case UCP_CMD_KEYBOARD: fprintf(stderr, "KEYBOARD\n"); cmdKeyboard(dev); break; case UCP_CMD_DATA: fprintf( stderr, "DATA\n"); break; case UCP_CMD_INFO: fprintf( stderr, "sizeof(info) -> %lu\n", sizeof(deviceInfo)); memcpy((void*)&deviceInfo, (void*)buffer.buff, sizeof(deviceInfo)); /* Call info */ cmdInfo(&deviceInfo); break; case UCP_CMD_ERROR: //Wait! the device returned one error! switch( (unsigned char) buffer.buff[0] ) { case UCP_ERR: fprintf( stderr, "GENERIC ERROR\n"); break; case UCP_ERR_PACKET: fprintf( stderr, "PACKET ERROR\n"); break; case UCP_ERR_CMD: fprintf( stderr, "CMD ERROR\n"); break; case UCP_ERR_ADDR: fprintf( stderr, "ADDR ERROR\n"); break; case UCP_ERR_SIZE: fprintf( stderr, "SIZE ERRROR\n"); break; case UCP_ERR_PROTOCOL: fprintf( stderr, "PROTOCOL ERROR\n"); break; case UCP_ERR_LOCKED: fprintf( stderr, "DEVICE LOCKED ERROR\n"); break; default: fprintf( stderr, "UNKNOWN ERROR\n"); } break; default: fprintf( stderr, "UNKNOWN CMD ERROR\n"); } } usbhidCloseDevice(dev); return 0; }
int main(int argc, char **argv) { usbDevice_t *dev; char buffer[REPORT_SIZE]; /* room for dummy report ID */ int err; if (argc < 2) { usage(argv[0]); exit(1); } if ((dev = openDevice()) == NULL) exit(1); if (strcasecmp(argv[1], "read") == 0) { int len = sizeof(buffer); if ((err = usbhidGetReport(dev, 0, buffer, &len)) != 0) { fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err)); } else { int16dump(buffer + 1, sizeof(buffer) - 1); } } else if (strcasecmp(argv[1], "write") == 0) { int i, pos; memset(buffer, 0, sizeof(buffer)); for (pos = 1, i = 2; i < argc && pos < sizeof(buffer); i++) { pos += int16read(buffer + pos, argv[i], sizeof(buffer) - pos); } if ((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) /* add a dummy report ID */ fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err)); } else if (strcasecmp(argv[1], "writeinput") == 0) { int i, pos; // read initial positions int len = sizeof(buffer); if ((err = usbhidGetReport(dev, 0, buffer, &len)) != 0) { fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err)); } // int16dump(buffer + 1, sizeof(buffer) - 1); char input[1000]; int scanfEof; do { scanfEof = scanf("%[^\n]%*c", input); // printf("[%i] %s\n", scanfEof, input); int16read(buffer + 1, input, sizeof(buffer) - 1); // int16dump(buffer + 1, sizeof(buffer) - 1); buffer[0] ++; int retry = 0; do { if ((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) { /* add a dummy report ID */ fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err)); } } while (err != 0 && retry ++ < 3); if (err != 0) { // try to reconnect usbhidCloseDevice(dev); dev = openDevice(); if ((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) { /* add a dummy report ID */ fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err)); } } //usleep(20000); } while (scanfEof > 0); // for (pos = 1, i = 2; i < argc && pos < sizeof(buffer); i++) { // pos += int16read(buffer + pos, argv[i], sizeof(buffer) - pos); // } // if ((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) /* add a dummy report ID */ // fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err)); } else { usage(argv[0]); exit(1); } usbhidCloseDevice(dev); return 0; }
/** * dun dun DUN */ int main(int argc, char **argv) { usbDevice_t *dev = NULL ; int err; // this needs to be a global int for getopt_long static int cmd = CMD_NONE; int16_t arg = 0; char addr = 0; //long color = 0; //int num = 1; int millis = 100; char file[255]; uint8_t buffer[65]; // room for dummy report ID (this will go away soon?) uint8_t cmdbuf[64]; // blinkm command buffer uint8_t recvbuf[64]; int len; memset(cmdbuf,0,sizeof(cmdbuf)); // zero out for debugging ease srand( time(0) ); // a good enough seeding for our purposes if(argc < 2){ usage(argv[0]); } // parse options int option_index = 0, opt; char* opt_str = "a:df:m:v"; static struct option loptions[] = { {"addr", required_argument, 0, 'a'}, {"debug", optional_argument, 0, 'd'}, {"file", required_argument, 0, 'f'}, {"millis", required_argument, 0, 'm'}, {"verbose", optional_argument, 0, 'v'}, {"linkmread", no_argument, &cmd, CMD_LINKM_READ }, {"linkmwrite", required_argument, &cmd, CMD_LINKM_WRITE }, {"linkmcmd", required_argument, &cmd, CMD_LINKM_CMD }, {"linkmversion",no_argument, &cmd, CMD_LINKM_VERSIONGET }, {"linkmeesave",no_argument, &cmd, CMD_LINKM_EESAVE }, {"linkmeeload",no_argument, &cmd, CMD_LINKM_EELOAD }, {"statled", required_argument, &cmd, CMD_LINKM_STATLEDSET }, {"i2cscan", no_argument, &cmd, CMD_LINKM_I2CSCAN }, {"i2cenable", required_argument, &cmd, CMD_LINKM_I2CENABLE }, {"i2cinit", no_argument, &cmd, CMD_LINKM_I2CINIT }, {"cmd", required_argument, &cmd, CMD_BLINKM_CMD }, {"off", no_argument, &cmd, CMD_BLINKM_OFF }, {"on", no_argument, &cmd, CMD_BLINKM_ON }, {"stop", no_argument, &cmd, CMD_BLINKM_STOP }, {"play", required_argument, &cmd, CMD_BLINKM_PLAY }, {"fadespeed", required_argument, &cmd, CMD_BLINKM_FADESPEED }, {"color", required_argument, &cmd, CMD_BLINKM_COLOR }, {"upload", required_argument, &cmd, CMD_BLINKM_UPLOAD }, {"download", required_argument, &cmd, CMD_BLINKM_DOWNLOAD }, {"readinputs", optional_argument, &cmd, CMD_BLINKM_READINPUTS }, {"random", required_argument, &cmd, CMD_BLINKM_RANDOM }, {"flash", optional_argument, &cmd, CMD_BLINKM_FLASH }, {"setaddr", required_argument, &cmd, CMD_BLINKM_SETADDR }, {"getversion", no_argument, &cmd, CMD_BLINKM_GETVERSION }, {"playset", required_argument, &cmd, CMD_LINKM_PLAYSET }, {"playget", no_argument, &cmd, CMD_LINKM_PLAYGET }, {"gobootload", no_argument, &cmd, CMD_LINKM_BOOTLOADGO }, #if ADDBOOTLOAD == 1 {"bootloadreset",no_argument, &cmd, CMD_LINKM_BOOTLOADRESET }, {"bootload", required_argument, &cmd, CMD_LINKM_BOOTLOAD }, #endif {NULL, 0, 0, 0} }; while(1) { opt = getopt_long (argc, argv, opt_str, loptions, &option_index); if (opt==-1) break; // parsed all the args switch (opt) { case 0: // deal with long opts that have no short opts switch(cmd) { case CMD_LINKM_PLAYSET: case CMD_LINKM_WRITE: case CMD_LINKM_CMD: case CMD_BLINKM_CMD: case CMD_BLINKM_COLOR: hexread(cmdbuf, optarg, sizeof(cmdbuf)); // cmd w/ hexlist arg break; case CMD_LINKM_STATLEDSET: case CMD_LINKM_I2CENABLE: case CMD_BLINKM_RANDOM: case CMD_BLINKM_FLASH: case CMD_BLINKM_SETADDR: case CMD_BLINKM_PLAY: case CMD_BLINKM_FADESPEED: case CMD_BLINKM_READINPUTS: if( optarg ) arg = strtol(optarg,NULL,0); // cmd w/ number arg break; case CMD_LINKM_BOOTLOAD: strcpy(file,optarg); break; } break; case 'a': addr = strtol(optarg,NULL,0); break; case 'f': strcpy(file,optarg); break; case 'm': millis = strtol(optarg,NULL,10); break; case 'v': case 'd': if( optarg==NULL ) debug++; else debug = strtol(optarg,NULL,0); default: break; } } if( cmd == CMD_NONE ) usage(argv[0]); // just in case linkm_debug = debug; #if ADDBOOTLOAD == 1 if( cmd == CMD_LINKM_BOOTLOAD ) { printf("linkmboot uploading firmware: %s\n",file); int rc = linkmboot_uploadFromFile(file, 0); if( rc == -1 ) { return 1; } if( rc == -2 ) { fprintf(stderr, "No data in input file, exiting.\n"); return 0; } else if( rc == -3 ) { fprintf(stderr,"error uploading\n"); } printf("Flashing done.\n"); return 1; } if( cmd == CMD_LINKM_BOOTLOADRESET ) { printf("linkmboot resetting bootloader:\n"); if( linkmboot_reset() ) { exit(1); } printf("reset done\n"); exit(0); } #endif // open up linkm, get back a 'dev' to pass around if( (err = linkm_open( &dev )) ) { fprintf(stderr, "Error opening LinkM: %s\n", linkm_error_msg(err)); exit(1); } if( cmd == CMD_LINKM_BOOTLOADGO ) { printf("linkm switching to bootloader:\n"); err = linkm_command(dev, LINKM_CMD_GOBOOTLOAD, 0, 0, NULL, NULL); //if( err ) { // fprintf(stderr,"error on linkm cmd: %s\n",linkm_error_msg(err)); //} printf("linkm is now in bootloader mode\n"); } else if( cmd == CMD_LINKM_VERSIONGET ) { printf("linkm version: "); err = linkm_command(dev, LINKM_CMD_VERSIONGET, 0, 2, NULL, recvbuf); if( err ) { fprintf(stderr,"error on linkm cmd: %s\n",linkm_error_msg(err)); } else { // success hexdump("", recvbuf, 2); } } else if( cmd == CMD_LINKM_PLAYSET ) { // control LinkM's state machine printf("linkm play set: "); err = linkm_command(dev, LINKM_CMD_PLAYSET, 7,0, cmdbuf, NULL); if( err ) { fprintf(stderr,"error on linkm cmd: %s\n",linkm_error_msg(err)); } printf("done\n"); } else if( cmd == CMD_LINKM_PLAYGET ) { // read LinkM's state machine printf("linkm play get: "); err = linkm_command(dev, LINKM_CMD_PLAYGET, 0,7, NULL, recvbuf); if( err ) { fprintf(stderr,"error on linkm cmd: %s\n",linkm_error_msg(err)); } else { // success hexdump("", recvbuf, 7); } } else if( cmd == CMD_LINKM_EESAVE ) { // tell linkm to save params to eeprom printf("linkm eeprom save: done\n"); err = linkm_command(dev, LINKM_CMD_EESAVE, 0,0, NULL, NULL); if( err ) { fprintf(stderr,"error on linkm cmd: %s\n",linkm_error_msg(err)); } } else if( cmd == CMD_LINKM_EELOAD ) { // tell linkm to load params to eeprom printf("linkm eeprom load: done\n"); err = linkm_command(dev, LINKM_CMD_EELOAD, 0,0, NULL, NULL); if( err ) { fprintf(stderr,"error on linkm cmd: %s\n",linkm_error_msg(err)); } } else if( cmd == CMD_LINKM_STATLEDSET ) { // control LinkM's status LED err = linkm_command(dev, LINKM_CMD_STATLEDSET, 1,0,(uint8_t*)&arg,NULL); if( err ) { fprintf(stderr,"error on linkm cmd: %s\n",linkm_error_msg(err)); } } else if( cmd == CMD_LINKM_I2CENABLE ) { // enable/disable i2c buffer err = linkm_command(dev, LINKM_CMD_I2CCONN, 1,0, (uint8_t*)&arg,NULL); if( err ) { fprintf(stderr,"error on linkm cmd: %s\n",linkm_error_msg(err)); } } else if( cmd == CMD_LINKM_I2CINIT ) { // restart LinkM's I2C software err = linkm_command(dev, LINKM_CMD_I2CINIT, 0,0, NULL,NULL); if( err ) { fprintf(stderr,"error on linkm cmd: %s\n",linkm_error_msg(err)); } } else if( cmd == CMD_LINKM_I2CSCAN ) { //if( addr == 0 ) addr = 1; printf("i2c scan from addresses %d - %d\n", 1, 113); int saddr = addr; for( int i=0; i < 7; i++ ) { saddr = i*16 + 1; cmdbuf[0] = saddr; // start address: 01 cmdbuf[1] = saddr+16; // end address: 16 // FIXME: allow arbitrary err = linkm_command(dev, LINKM_CMD_I2CSCAN, 2, 16, cmdbuf, recvbuf); if( err ) { fprintf(stderr,"error on i2c scan: %s\n",linkm_error_msg(err)); } else { if(debug) hexdump("recvbuf:", recvbuf, 16); int cnt = recvbuf[0]; if( cnt != 0 ) { for( int i=0; i< cnt; i++ ) { printf("device found at address %d\n",recvbuf[1+i]); } } } } // for } else if( cmd == CMD_BLINKM_CMD ) { // send arbitrary blinkm command printf("addr %d: sending cmd:%c,0x%02x,0x%02x,0x%02x\n",addr, cmdbuf[0],cmdbuf[1],cmdbuf[2],cmdbuf[3]); // fixme: check that 'b'yte array arg was used memmove( cmdbuf+1, cmdbuf, sizeof(cmdbuf)-1 ); // move over for addr cmdbuf[0] = addr; // do i2c transaction (0x01) with no recv err = linkm_command(dev, LINKM_CMD_I2CTRANS, 5,0, cmdbuf, NULL ); if( err ) { fprintf(stderr,"error on blinkm cmd: %s\n",linkm_error_msg(err)); } } else if( cmd == CMD_BLINKM_GETVERSION ) { if( addr == 0 ) { printf("Must specify non-zero address for download\n"); goto shutdown; } printf("addr:%d: getting version\n", addr ); cmdbuf[0] = addr; cmdbuf[1] = 'Z'; err = linkm_command(dev, LINKM_CMD_I2CTRANS, 2, 2, cmdbuf, recvbuf); if( err ) { fprintf(stderr,"error on getversion: %s\n",linkm_error_msg(err)); } else { printf("version: %c,%c\n", recvbuf[0],recvbuf[1]); } } else if( cmd == CMD_BLINKM_SETADDR ) { printf("setting addr from %d to %d\n", addr, arg ); cmdbuf[0] = addr; // send to old address (or zero for broadcast) cmdbuf[1] = 'A'; cmdbuf[2] = arg; // arg is new address cmdbuf[3] = 0xd0; cmdbuf[4] = 0x0d; cmdbuf[5] = arg; err = linkm_command(dev, LINKM_CMD_I2CTRANS, 6,0,cmdbuf, NULL); if( err ) { fprintf(stderr,"error on setatt cmd: %s\n",linkm_error_msg(err)); } } else if( cmd == CMD_BLINKM_COLOR ) { uint8_t r = cmdbuf[0]; // this is kind of dumb uint8_t g = cmdbuf[1]; uint8_t b = cmdbuf[2]; printf("addr %d: fading to color 0x%02x,0x%02x,0x%02x\n",addr,r,g,b); cmdbuf[0] = addr; cmdbuf[1] = 'c'; cmdbuf[2] = r; cmdbuf[3] = g; cmdbuf[4] = b; err = linkm_command(dev, LINKM_CMD_I2CTRANS, 5,0, cmdbuf, NULL ); if( err ) { fprintf(stderr,"error on color cmd: %s\n",linkm_error_msg(err)); } } else if( cmd == CMD_BLINKM_RANDOM ) { printf("addr %d: %d random every %d millis\n", addr,arg,millis); uint32_t start = stampstart(); for( int j=0; j< arg; j++ ) { uint8_t r = rand() % 255; // random() not avail on MinGWindows uint8_t g = rand() % 255; uint8_t b = rand() % 255; cmdbuf[0] = addr; cmdbuf[1] = 'n'; // go to color now cmdbuf[2] = r; cmdbuf[3] = g; cmdbuf[4] = b; err = linkm_command(dev, LINKM_CMD_I2CTRANS, 5,0, cmdbuf, NULL ); if( err ) { fprintf(stderr,"error on rand cmd: %s\n",linkm_error_msg(err)); break; } usleep(millis * 1000 ); // sleep milliseconds } stampstop(start); } else if( cmd == CMD_BLINKM_FLASH ) { printf("addr %d: %d flashing every %d millis\n", addr,arg,millis); uint8_t r,g,b; if( arg == 0 ) arg = 10000; for( int j=0; j< arg; j++ ) { r = 255; g = 255; b = 255; cmdbuf[0] = addr; cmdbuf[1] = 'n'; // go to color now cmdbuf[2] = r; cmdbuf[3] = g; cmdbuf[4] = b; err = linkm_command(dev, LINKM_CMD_I2CTRANS, 5,0, cmdbuf, NULL ); if( err ) { fprintf(stderr,"error on rand cmd: %s\n",linkm_error_msg(err)); break; } usleep(millis * 1000 ); // sleep milliseconds r = 0; g = 0; b = 0; cmdbuf[0] = addr; cmdbuf[1] = 'n'; // go to color now cmdbuf[2] = r; cmdbuf[3] = g; cmdbuf[4] = b; err = linkm_command(dev, LINKM_CMD_I2CTRANS, 5,0, cmdbuf, NULL ); if( err ) { fprintf(stderr,"error on rand cmd: %s\n",linkm_error_msg(err)); break; } usleep(millis * 1000 ); // sleep milliseconds } } else if( cmd == CMD_BLINKM_PLAY ) { printf("addr %d: playing script #%d\n", addr,arg); cmdbuf[0] = addr; cmdbuf[1] = 'p'; // play script cmdbuf[2] = arg; cmdbuf[3] = 0; cmdbuf[4] = 0; if( (err = linkm_command(dev, LINKM_CMD_I2CTRANS, 5,0, cmdbuf, NULL))) fprintf(stderr,"error on play: %s\n",linkm_error_msg(err)); } else if( cmd == CMD_BLINKM_STOP ) { printf("addr %d: stopping script\n", addr); cmdbuf[0] = addr; cmdbuf[1] = 'o'; // stop script if( (err = linkm_command(dev, LINKM_CMD_I2CTRANS, 2,0, cmdbuf, NULL))) fprintf(stderr,"error on stop: %s\n",linkm_error_msg(err)); } else if( cmd == CMD_BLINKM_OFF ) { printf("addr %d: turning off\n", addr); cmdbuf[0] = addr; cmdbuf[1] = 'o'; // stop script if( (err = linkm_command(dev, LINKM_CMD_I2CTRANS, 2,0, cmdbuf, NULL))) fprintf(stderr,"error on blinkmoff cmd: %s\n",linkm_error_msg(err)); cmdbuf[1] = 'n'; // set rgb color now now cmdbuf[2] = cmdbuf[3] = cmdbuf[4] = 0x00; // to zeros if( (err = linkm_command(dev, LINKM_CMD_I2CTRANS, 5,0, cmdbuf, NULL))) fprintf(stderr,"error on blinkmoff cmd: %s\n",linkm_error_msg(err)); } else if( cmd == CMD_BLINKM_ON ) { printf("addr %d: turning on\n", addr); cmdbuf[0] = addr; cmdbuf[1] = 'p'; // play script cmdbuf[2] = 0; cmdbuf[3] = 0; cmdbuf[4] = 0; if( (err = linkm_command(dev, LINKM_CMD_I2CTRANS, 5,0, cmdbuf, NULL))) fprintf(stderr,"error on play: %s\n",linkm_error_msg(err)); } else if( cmd == CMD_BLINKM_FADESPEED ) { printf("addr %d: setting fadespeed to %d\n", addr,arg); cmdbuf[0] = addr; cmdbuf[1] = 'f'; // set fadespeed cmdbuf[2] = arg; if( (err = linkm_command(dev, LINKM_CMD_I2CTRANS, 3,0, cmdbuf, NULL))) fprintf(stderr,"error on play: %s\n",linkm_error_msg(err)); } else if( cmd == CMD_BLINKM_DOWNLOAD ) { if( addr == 0 ) { printf("Must specify non-zero address for download\n"); goto shutdown; } printf("addr %d: downloading script %d\n", addr,arg); uint8_t pos = 0; while( pos < 49 ) { cmdbuf[0] = addr; cmdbuf[1] = 'R'; // go to color now cmdbuf[2] = arg; cmdbuf[3] = pos; err = linkm_command(dev, LINKM_CMD_I2CTRANS, 4,5, cmdbuf,recvbuf ); if( err ) { fprintf(stderr,"error on download cmd: %s\n", linkm_error_msg(err)); break; } else { hexdump("scriptline: ", recvbuf, 5); } pos++; } } else if( cmd == CMD_BLINKM_UPLOAD ) { printf("unsupported right now\n"); } else if( cmd == CMD_BLINKM_READINPUTS ) { if( addr == 0 ) { printf("Must specify non-zero address for readinputs\n"); goto shutdown; } arg = (arg==0) ? 1 : arg; for( uint8_t i = 0; i< arg; i++ ) { cmdbuf[0] = addr + i; cmdbuf[1] = 'i'; err = linkm_command(dev, LINKM_CMD_I2CTRANS, 2,4, cmdbuf, recvbuf ); if( err ) { fprintf(stderr,"error readinputs: %s\n",linkm_error_msg(err)); } else { hexdump("inputs: ", recvbuf, 5); } usleep(millis * 1000 ); // sleep milliseconds } } // low-level linkm cmd else if( cmd == CMD_LINKM_CMD ) { // low-level linkm command printf("linkm command:\n"); char cmdbyte = cmdbuf[0]; // this is kind of dumb char num_send = cmdbuf[1]; char num_recv = cmdbuf[2]; uint8_t* cmdbufp = cmdbuf + 3; // move along nothing to see here err = linkm_command(dev, cmdbyte, num_send,num_recv, cmdbufp,recvbuf); if( err ) { fprintf(stderr,"error on linkm cmd: %s\n",linkm_error_msg(err)); } else { // success if( num_recv ) hexdump("recv: ", recvbuf, 16); } } // low-level read else if( cmd == CMD_LINKM_READ ) { // low-level read linkm buffer printf("linkm read:\n"); memset( buffer, 0, sizeof(buffer)); len = sizeof(buffer); if((err = usbhidGetReport(dev, 0, (char*)buffer, &len)) != 0) { fprintf(stderr, "error reading data: %s\n", linkm_error_msg(err)); } else { hexdump("", buffer + 1, sizeof(buffer) - 1); } } // low-level write else if( cmd == CMD_LINKM_WRITE ) { // low-level write linkm buffer printf("linkm write:\n"); memset( buffer, 0, sizeof(buffer)); memcpy( buffer+1, cmdbuf, sizeof(cmdbuf) ); if(debug) hexdump("linkm write: ", buffer, 16); // print first bytes if((err = usbhidSetReport(dev, (char*)buffer, sizeof(buffer))) != 0) { fprintf(stderr, "error writing data: %s\n", linkm_error_msg(err)); } } shutdown: linkm_close(dev); return 0; }
int main(int argc, char **argv) { usbDevice_t *dev; char buffer[65]; /* room for dummy report ID */ int err; char quiet = 0; if ( argc < 2) { usage(argv[0]); exit(1); } if ( (dev = openDevice()) == NULL) exit(1); if ( strcasecmp(argv[1], "read") == 0) { int len = sizeof(buffer); if ( (err = usbhidGetReport(dev, 0, buffer, &len)) != 0) { fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err)); } else { hexdump(buffer + 1, sizeof(buffer) - 1); } } else if ( strcasecmp(argv[1], "write") == 0) { int i, pos; bzero(buffer, sizeof(buffer)); for ( pos = 1, i = 2; i < argc && pos < sizeof(buffer); i++) { pos += hexread(buffer + pos, argv[i], sizeof(buffer) - pos); } /* printf("%d\n",buffer[0]); printf("%d\n",buffer[1]); printf("%d\n",buffer[2]); printf("%d\n",buffer[3]); */ //if ( (err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) /* add a dummy report ID */ if ( (err = usbhidSetReport(dev, buffer, pos)) != 0) /* add a dummy report ID */ fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err)); } else if ( strcasecmp( argv[1], "interactive" ) == 0 ) { int t = 0; for ( t = 0; t < argc; t++ ) if ( strcasecmp(argv[t], "quiet") == 0 ) quiet = 1; char *help = "q = exit\nr = read\nw = write <Data separated by spaces as decimal or hex (8bit unsigned)>\n"; if ( !quiet ) printf("%s",help); char exit = 0; while ( exit != 1 ) { int nbytes = 350; if ( !quiet ) printf("> "); char *input; input = (char *) malloc (nbytes + 1); int cnt = getline(&input, &nbytes, stdin); if ( strncasecmp(input, "q", 1) == 0 ) { if ( !quiet ) printf("bye.\n"); exit = 1; } else if ( strncasecmp(input, "r", 1) == 0 ) { if ( !quiet ) printf("reading...\n"); int len = sizeof(buffer) ; if ( (err = usbhidGetReport(dev, 0, buffer, &len)) != 0) { fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err)); exit = 1; } else { hexdump(buffer + 1, sizeof(buffer) - 1); } } else if ( strncasecmp(input, "w ", 2) == 0 ) { int i, pos; input[0] = 32; // kommando durch leerzeichen ersetzen bzero(buffer, sizeof(buffer)); if ( !quiet ) printf("sending data... "); for ( pos = 1, i = 2; i < cnt -1 && pos < sizeof(buffer); i++) { //printf(">%c\n", input[i]); pos += hexread( buffer + pos, &input[i], sizeof(buffer) - pos); } if ( (err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) // add a dummy report ID { fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err)); usbhidCloseDevice(dev); if ( (dev = openDevice()) != NULL) printf("reconnect...\n"); else exit = 1; } else { if ( !quiet ) printf("ok.\n"); } } else printf("%s",help); } } else { usage(argv[0]); exit(1); } usbhidCloseDevice(dev); return 0; }