/**
* :call-seq:
* <span class="name">fade_to_rgbn</span> <span class="arguments">(fade_millis, r, g, b, n) -> integer</span>
*
* Fade a specific (blink(1) mk2) LED LED color to RGB in +fade_millis+.
*
* Return the actual number of bytes written and -1 on error.
*/
static VALUE rb_blink1_fadeToRGBN(VALUE self, VALUE fadeMillis, VALUE r, VALUE g, VALUE b, VALUE n) {
struct Blink1Instance *ins;
Data_Get_Struct(self, struct Blink1Instance, ins);
return INT2NUM(blink1_fadeToRGBN(ins->dev, FIX2UINT(fadeMillis), FIX2UINT(r), FIX2UINT(g), FIX2UINT(b), FIX2UINT(n)));
}
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;
}
