int
main(int ac, char **av)
{
int n, i;
int vflag = 0;
UCHAR key[32], IV[32];
int keysz, IVsz;
extern int keylen;
extern WORD K[];
if (ac == 2 && strcmp(av[1], "-test") == 0) {
test_s128(0);
return nerrors;
}
if (ac == 2 && strcmp(av[1], "-time") == 0) {
time_s128();
return 0;
}
if (ac >= 2 && strcmp(av[1], "-verbose") == 0) {
vflag = 1;
++av, --ac;
}
if (ac >= 2)
hexread(key, av[1], keysz = strlen(av[1]) / 2);
else
hexread(key, "0000000000000000", keysz = 8);
if (ac >= 3)
hexread(IV, av[2], IVsz = strlen(av[2]) / 2);
else
IVsz = 0;
sscanf(ac >= 4 ? av[3] : "1000000", "%d", &n);
if ((keysz | IVsz) & 0x3) {
fprintf(stderr, "Key and IV must be multiple of 4 bytes\n");
return 1;
}
s128_key(&ctx, key, keysz);
s128_IV(&ctx, IV, IVsz);
if (vflag) {
printLFSR("Initial LFSR", ctx.initR);
}
while (n > 0) {
i = sizeof bigbuf;
i = n > i ? i : n;
s128_stream(&ctx, bigbuf, i);
hexbulk(bigbuf, i);
n -= i;
}
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;
}
int main(int argc, char** argv)
{
int openall = 0;
int nogamma = 0;
int16_t arg=0;
static int vid,pid;
int rc;
char tmpstr[100];
uint16_t seed = time(NULL);
srand(seed);
memset( cmdbuf, 0, sizeof(cmdbuf));
static int cmd = CMD_NONE;
vid = blink1_vid(), pid = blink1_pid();
// parse options
int option_index = 0, opt;
char* opt_str = "aqvhm:t:d:U:u:gn:";
static struct option loptions[] = {
{"all", no_argument, 0, 'a'},
{"verbose", optional_argument, 0, 'v'},
{"quiet", optional_argument, 0, 'q'},
{"millis", required_argument, 0, 'm'},
{"delay", required_argument, 0, 't'},
{"id", required_argument, 0, 'd'},
{"num", required_argument, 0, 'n'},
{"nogamma", no_argument, 0, 'g'},
{"help", no_argument, 0, 'h'},
{"list", no_argument, &cmd, CMD_LIST },
{"hidread", no_argument, &cmd, CMD_HIDREAD },
{"hidwrite", required_argument, &cmd, CMD_HIDWRITE },
{"eeread", required_argument, &cmd, CMD_EEREAD },
{"eewrite", required_argument, &cmd, CMD_EEWRITE },
{"rgb", required_argument, &cmd, CMD_RGB },
{"savergb", required_argument, &cmd, CMD_SAVERGB },
{"readrgb", required_argument, &cmd, CMD_READRGB },
{"off", no_argument, &cmd, CMD_OFF },
{"on", no_argument, &cmd, CMD_ON },
{"red", no_argument, &cmd, CMD_RED },
{"green", no_argument, &cmd, CMD_GRN },
{"blue", no_argument, &cmd, CMD_BLU},
{"blink", required_argument, &cmd, CMD_BLINK},
{"play", required_argument, &cmd, CMD_PLAY},
{"random", required_argument, &cmd, CMD_RANDOM },
{"version", no_argument, &cmd, CMD_VERSION },
{"serialnumread", no_argument, &cmd, CMD_SERIALNUMREAD },
{"serialnumwrite",required_argument, &cmd,CMD_SERIALNUMWRITE },
{"servertickle", required_argument, &cmd, CMD_SERVERDOWN },
{"vid", required_argument, 0, 'U'}, // FIXME: This sucks
{"pid", required_argument, 0, 'u'},
{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_RGB:
hexread(rgbbuf, optarg, sizeof(rgbbuf));
break;
case CMD_HIDWRITE:
case CMD_EEREAD:
case CMD_EEWRITE:
case CMD_SAVERGB:
case CMD_READRGB:
case CMD_BLINK:
case CMD_PLAY:
hexread(cmdbuf, optarg, sizeof(cmdbuf)); // cmd w/ hexlist arg
break;
case CMD_RANDOM:
case CMD_SERVERDOWN:
if( optarg )
arg = strtol(optarg,NULL,0); // cmd w/ number arg
break;
case CMD_SERIALNUMWRITE:
strcpy(tmpstr, optarg);
break;
case CMD_ON:
rgbbuf[0] = 255; rgbbuf[1] = 255; rgbbuf[2] = 255;
break;
case CMD_OFF:
rgbbuf[0] = 0; rgbbuf[1] = 0; rgbbuf[2] = 0;
break;
case CMD_RED:
rgbbuf[0] = 255;
break;
case CMD_GRN:
rgbbuf[1] = 255;
break;
case CMD_BLU:
rgbbuf[2] = 255;
break;
} // switch(cmd)
break;
case 'g':
nogamma = 1;
case 'a':
openall = 1;
break;
case 'm':
millis = strtol(optarg,NULL,10);
break;
case 't':
delayMillis = strtol(optarg,NULL,10);
break;
case 'n':
ledn = strtol(optarg,NULL,10);
break;
case 'q':
if( optarg==NULL ) quiet++;
else quiet = strtol(optarg,NULL,0);
break;
case 'v':
if( optarg==NULL ) verbose++;
else verbose = strtol(optarg,NULL,0);
break;
case 'd':
if( strcmp(optarg,"all") == 0 ) {
numDevicesToUse = 0; //blink1_max_devices;
for( int i=0; i< blink1_max_devices; i++) {
deviceIds[i] = i;
}
} else {
numDevicesToUse = hexread(deviceIds,optarg,sizeof(deviceIds));
}
break;
case 'U':
vid = strtol(optarg,NULL,0);
break;
case 'u':
pid = strtol(optarg,NULL,0);
break;
case 'h':
usage( "blink1-tool" );
exit(1);
break;
}
}
if(argc < 2){
usage( "blink1-tool" );
exit(1);
}
//FIXME: confusing
if( nogamma ) {
if ( !quiet ) {
printf("disabling auto degamma\n");
}
blink1_disableDegamma();
}
// debug (not on Windows though, no getuid())
/*
if( 0 ) {
uid_t id = getuid();
printf("userid:%d\n",id);
wchar_t myser[10];
dev = blink1_open();
hid_get_serial_number_string(dev, myser, 10);
printf("ser:%ls\n",myser);
}
*/
// get a list of all devices and their paths
int count = blink1_enumerateByVidPid(vid,pid);
if( count == 0 ) {
if ( !quiet ) {
printf("no blink(1) devices found\n");
}
exit(1);
}
if( numDevicesToUse == 0 ) numDevicesToUse = count;
//if( !dev_serial )
// dev_serial = blink1_getCachedSerial( deviceIds[0] );
if( verbose && !quiet ) {
printf("deviceId[0] = %d\n", deviceIds[0]);
//printf("cached path = '%ls'\n", dev_serial);
for( int i=0; i< count; i++ ) {
printf("%d: serial: '%ls'\n", i,blink1_getCachedSerial(i) );
}
}
// actually open up the device to start talking to it
dev = blink1_openById( deviceIds[0] );
if( dev == NULL ) {
if ( !quiet ) {
printf("cannot open blink(1), bad serial number\n");
}
exit(1);
}
// an idea:
// blink1 mk2 does gamma correction in hardware
//if( blink1_getVersion() >= 200 ) {
// nogamma = 1;
//}
if( cmd == CMD_LIST ) {
printf("blink(1) list: \n");
for( int i=0; i< count; i++ ) {
printf("id:%d - serialnum:%ls\n", i, blink1_getCachedSerial(i) );
}
}
else if( cmd == CMD_HIDREAD ) {
printf("hidread: ");
int len = sizeof(cmdbuf);
if((rc = hid_get_feature_report(dev, cmdbuf, len)) == -1){
fprintf(stderr,"error reading data: %s\n",blink1_error_msg(rc));
} else {
hexdump(cmdbuf, sizeof(cmdbuf));
}
}
else if( cmd == CMD_HIDWRITE ) {
if ( !quiet ) {
printf("hidwrite: "); hexdump(cmdbuf,sizeof(cmdbuf));
}
if((rc = hid_send_feature_report(dev, cmdbuf, sizeof(cmdbuf))) == -1) {
fprintf(stderr,"error writing data: %d\n",rc);
}
}
else if( cmd == CMD_EEREAD ) { // FIXME
printf("eeread: addr 0x%2.2x = ", cmdbuf[0]);
uint8_t val = 0;
rc = blink1_eeread(dev, cmdbuf[0], &val );
if( rc==-1 ) { // on error
printf("error\n");
} else {
printf("%2.2x\n", val);
}
}
else if( cmd == CMD_EEWRITE ) { // FIXME
if ( !quiet ) { printf("eewrite: \n"); }
rc = blink1_eewrite(dev, cmdbuf[0], cmdbuf[1] );
if( rc==-1 && !quiet ) { // error
printf("error\n");
}
}
else if( cmd == CMD_VERSION ) {
printf("firmware version: ");
rc = blink1_getVersion(dev);
printf("%d\n", rc );
}
else if( cmd == CMD_RGB || cmd == CMD_ON || cmd == CMD_OFF ||
cmd == CMD_RED || cmd == CMD_BLU || cmd ==CMD_GRN ) {
blink1_close(dev); // close global device, open as needed
uint8_t r = rgbbuf[0];
uint8_t g = rgbbuf[1];
uint8_t b = rgbbuf[2];
for( int i=0; i< numDevicesToUse; i++ ) {
dev = blink1_openById( deviceIds[i] );
if( dev == NULL ) continue;
if ( !quiet ) {
printf("set dev:%d to rgb:0x%2.2x,0x%2.2x,0x%2.2x over %d msec\n",
deviceIds[i],r,g,b,millis);
}
if( ledn==0 ) {
rc = blink1_fadeToRGB(dev,millis, r,g,b);
} else {
rc = blink1_fadeToRGBN(dev,millis,r,g,b, ledn);
}
if( rc == -1 && !quiet ) { // on error, do something, anything. come on.
printf("error on fadeToRGB\n");
}
blink1_close( dev );
}
}
else if( cmd == CMD_PLAY ) {
uint8_t play = cmdbuf[0];
uint8_t pos = cmdbuf[1];
if ( !quiet ) { printf("%s color pattern at pos %d\n", ((play)?"playing":"stopping"),pos); }
rc = blink1_play(dev, play, pos);
if( rc == -1 && !quiet ) {
}
}
else if( cmd == CMD_SAVERGB ) {
uint8_t r = cmdbuf[0];
uint8_t g = cmdbuf[1];
uint8_t b = cmdbuf[2];
uint8_t p = cmdbuf[3];
if ( !quiet ) { printf("saving rgb: 0x%2.2x,0x%2.2x,0x%2.2x to pos %d\n", r,g,b,p ); }
rc = blink1_writePatternLine(dev, millis, r,g,b, p );
if( rc==-1 && !quiet ) {
printf("error on writePatternLine\n");
}
}
else if( cmd == CMD_READRGB ) {
uint8_t p = cmdbuf[0];
uint8_t r,g,b;
uint16_t msecs;
printf("reading rgb at pos %d: ", p );
rc = blink1_readPatternLine(dev, &msecs, &r,&g,&b, p );
if( rc==-1 && !quiet ) {
printf("error on writePatternLine\n");
}
printf("r,g,b = %x,%x,%x millis:%d\n", r,g,b, msecs);
}
else if( cmd == CMD_RANDOM ) {
int cnt = blink1_getCachedCount();
if( cnt>1 ) blink1_close(dev); // close global device, open as needed
if ( !quiet ) { printf("random %d times: \n", arg); }
for( int i=0; i<arg; i++ ) {
uint8_t r = rand()%255;
uint8_t g = rand()%255;
uint8_t b = rand()%255 ;
uint8_t id = rand() % blink1_getCachedCount();
if ( !quiet ) {
printf("%d: %d/%d : %2.2x,%2.2x,%2.2x \n",
i, id, blink1_getCachedCount(), r,g,b);
}
hid_device* mydev = dev;
if( cnt > 1 ) mydev = blink1_openById( id );
if( ledn == 0 ) {
rc = blink1_fadeToRGB(mydev, millis,r,g,b);
} else {
uint8_t n = 1 + rand() % ledn;
rc = blink1_fadeToRGBN(mydev, millis,r,g,b,n);
}
if( rc == -1 && !quiet ) { // on error, do something, anything. come on.
printf("error during random\n");
//break;
}
if( cnt > 1 ) blink1_close( mydev );
blink1_sleep(delayMillis);
}
}
else if( cmd == CMD_BLINK ) {
uint8_t n = cmdbuf[0];
uint8_t r = rgbbuf[0];
uint8_t g = rgbbuf[1];
uint8_t b = rgbbuf[2];
if( r == 0 && b == 0 && g == 0 ) {
r = g = b = 255;
}
if ( !quiet ) { printf("blink %d times rgb:%x,%x,%x: \n", n,r,g,b); }
for( int i=0; i<n; i++ ) {
rc = blink1_fadeToRGB(dev, millis,r,g,b);
blink1_sleep(delayMillis);
rc = blink1_fadeToRGB(dev, millis,0,0,0);
blink1_sleep(delayMillis);
}
}
else if( cmd == CMD_SERVERDOWN ) {
int on = arg;
if ( !quiet ) {
printf("setting serverdown %s (at %d millis)\n",
((on)?"ON":"OFF"), delayMillis);
}
blink1_serverdown( dev, on, delayMillis );
}
// use caution with this, could make your blink(1) unusable
// --serialnumwrite abcd1234
else if( cmd == CMD_SERIALNUMWRITE ) {
if ( !quiet ) { printf("serial number write: %s\n",tmpstr); }
//for( int i=0; i<4; i++) printf("%2.2X,",cmdbuf[i]);
//printf("\n");
if( (rc = blink1_serialnumwrite( dev, tmpstr)) == -1 ) {
fprintf(stderr,"error writing new serial number: %d\n",rc);
}
}
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)
{
int openall = 0;
int16_t arg=0;
int rc;
char serialnumstr[serialstrmax] = {'\0'};
uint16_t seed = time(NULL);
srand(seed);
memset( cmdbuf, 0, sizeof(cmdbuf));
static int cmd = CMD_NONE;
// parse options
int option_index = 0, opt;
char* opt_str = "aqvhm:t:d:U:u:l:";
static struct option loptions[] = {
{"all", no_argument, 0, 'a'},
{"verbose", optional_argument, 0, 'v'},
{"quiet", optional_argument, 0, 'q'},
{"millis", required_argument, 0, 'm'},
{"delay", required_argument, 0, 't'},
{"id", required_argument, 0, 'd'},
{"help", no_argument, 0, 'h'},
{"list", no_argument, &cmd, CMD_LIST },
{"version", no_argument, &cmd, CMD_VERSION },
{"settime", no_argument, &cmd, CMD_SETTIME },
{"settimeto", required_argument, &cmd, CMD_SETTIMETO },
{"buttons", no_argument, &cmd, CMD_BUTTONS },
{"send", required_argument, &cmd, CMD_SENDCHARS },
{"sendbytes", required_argument, &cmd, CMD_SENDBYTES },
{"get", no_argument, &cmd, CMD_GETCHAR },
{"getbyte", no_argument, &cmd, CMD_GETBYTE },
{"testtest", no_argument, &cmd, CMD_TESTTEST },
{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_SETTIMETO:
hexread(cmdbuf, optarg, sizeof(cmdbuf)); // cmd w/ hexlist arg
break;
case CMD_SENDCHARS:
strncpy((char*)cmdbuf, optarg, sizeof(cmdbuf));
cmdbuf[ strlen(optarg) ] = '\0';
break;
case CMD_SENDBYTES:
hexread(cmdbuf, optarg, sizeof(cmdbuf)); // cmd w/ hexlist arg
break;
} // switch(cmd)
break;
case 'a':
openall = 1;
break;
case 't':
delayMillis = strtol(optarg,NULL,10);
break;
case 'q':
if( optarg==NULL ) quiet++;
else quiet = strtol(optarg,NULL,0);
break;
case 'v':
if( optarg==NULL ) verbose++;
else verbose = strtol(optarg,NULL,0);
if( verbose > 3 ) {
fprintf(stderr,"going REALLY verbose\n");
}
break;
case 'd':
if( strcmp(optarg,"all") == 0 ) {
numDevicesToUse = 0; //cstbase_max_devices;
for( int i=0; i< cstbase_max_devices; i++) {
deviceIds[i] = i;
}
}
else if( strlen(optarg) == 8 ) { //
deviceIds[0] = strtol( optarg, NULL, 16);
numDevicesToUse = 1;
//sprintf( serialnumstr, "%s", optarg); // strcpy
}
else {
numDevicesToUse = hexread((uint8_t*)deviceIds,optarg,sizeof(deviceIds));
}
break;
case 'h':
usage( "cstbase-tool" );
exit(1);
break;
}
}
if(argc < 2){
usage( "cstbase-tool" );
exit(1);
}
// get a list of all devices and their paths
int count = cstbase_enumerate();
if( cmd == CMD_VERSION ) {
char verbuf[40] = "";
if( count ) {
dev = cstbase_openById( deviceIds[0] );
rc = cstbase_getVersion(dev);
cstbase_close(dev);
sprintf(verbuf, ", fw version: %d", rc);
}
msg("cstbase-tool version: %s %s\n",CSTBASE_TOOL_VERSION,verbuf);
exit(0);
}
if( count == 0 ) {
msg("no CST Base devices found\n");
exit(1);
}
if( numDevicesToUse == 0 ) numDevicesToUse = count;
if( verbose ) {
printf("deviceId[0] = %X\n", deviceIds[0]);
printf("cached list:\n");
for( int i=0; i< count; i++ ) {
printf("%d: serial: '%s' '%s'\n",
i, cstbase_getCachedSerial(i), cstbase_getCachedPath(i) );
}
}
// actually open up the device to start talking to it
if(verbose) printf("openById: %X\n", deviceIds[0]);
dev = cstbase_openById( deviceIds[0] );
if( dev == NULL ) {
msg("cannot open CST Base, bad id or serial number\n");
exit(1);
}
//
// begin command processing
//
if( cmd == CMD_LIST ) {
printf("CST Base list: \n");
for( int i=0; i< count; i++ ) {
printf("id:%d - serialnum:%s \n", i, cstbase_getCachedSerial(i) );
}
#ifdef USE_HIDDATA
printf("(Listing not supported in HIDDATA builds)\n");
#endif
}
else if( cmd == CMD_VERSION ) {
rc = cstbase_getVersion(dev);
msg("cstbase-tool: firmware version: ");
printf("%d\n",rc);
}
else if( cmd == CMD_SETTIME ) {
cstbase_close(dev); // close global device, open as needed
uint8_t h,m,s;
cstbase_getLocalTime(&h,&m,&s);
for( int i=0; i< numDevicesToUse; i++ ) {
dev = cstbase_openById( deviceIds[i] );
if( dev == NULL ) continue;
msg("set dev:%X to localtime %2.2d:%2.2d\n", deviceIds[i],h,m );
rc = cstbase_setTime(dev);
cstbase_close( dev );
}
}
else if( cmd == CMD_SETTIMETO ) {
// FIXME: not done yet
uint8_t hours = cmdbuf[0];
uint8_t mins = cmdbuf[1];
uint8_t secs = cmdbuf[2];
msg("setting time to ");
printf("%2.2d:%2.2d\n", hours, mins);
rc = cstbase_setTimeTo( dev, hours, mins, secs );
}
else if( cmd == CMD_BUTTONS ) {
rc = cstbase_getButtons(dev);
msg("cstbase-tool: button state: ");
printf("0x%x\n",rc);
}
else if( cmd == CMD_SENDCHARS ) {
msg("send: %s\n", cmdbuf);
rc = cstbase_sendBytesToWatch( dev, cmdbuf, strlen((char*)cmdbuf) );
}
else if( cmd == CMD_SENDBYTES ) {
msg("send bytes: %x\n", cmdbuf[0]);
rc = cstbase_sendBytesToWatch( dev, cmdbuf, 1 ); // FIXME: only sends 1st byte
}
else if( cmd == CMD_GETCHAR ) {
rc = cstbase_getByteFromWatch( dev );
msg("get char: %c", rc );
}
else if( cmd == CMD_GETBYTE ) {
rc = cstbase_getByteFromWatch( dev );
msg("get byte: ");
printf("0x%x\n",rc);
}
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;
}
