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;
}
