Ejemplo n.º 1
0
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;
}
Ejemplo n.º 2
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;
}
Ejemplo n.º 3
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;
}
Ejemplo n.º 4
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;
}
Ejemplo n.º 6
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;
}
Ejemplo n.º 7
0
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");
}
Ejemplo n.º 8
0
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;
}
Ejemplo n.º 9
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;
}
Ejemplo n.º 10
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;
}
Ejemplo n.º 11
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;
}
Ejemplo n.º 12
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;
}