mirrors
/
blink1-tool
mirror of https://github.com/todbot/blink1-tool.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
blink1-tool/blink1-lib.c

912 lines
24 KiB
C
Raw Permalink Blame History

/**
* blink(1) C library -- aka "blink1-lib"
*
* Part of the blink(1) open source hardware project
* See https://github.com/todbot/blink1 for details
*
* 2012-2022, Tod Kurt, http://todbot.com/blog/ , http://thingm.com/
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <ctype.h> // for toupper()
#include <unistd.h>
#ifdef _WIN32
#include <windows.h>
#define swprintf _snwprintf
#else
//#include <unistd.h> // for usleep()
#endif
#include "blink1-lib.h"
int msg_quiet = 0;
// blink1 copy of some hid_device_info and other bits.
// this seems kinda dumb, though. is there a better way?
typedef struct blink1_info_ {
blink1_device* dev; // device, if opened, NULL otherwise
char path[pathstrmax]; // platform-specific device path
char serial[serialstrmax];
int type; // from blink1types
} blink1_info;
static blink1_info blink1_infos[cache_max];
static int blink1_cached_count = 0; // number of cached entities
static int blink1_enable_degamma = 1;
int blink1_lib_verbose = 0;
// set in Makefile to debug HIDAPI stuff
#ifdef DEBUG_PRINTF
#define LOG(...) fprintf(stderr, __VA_ARGS__)
#else
#define LOG(...) { if(blink1_lib_verbose) { fprintf(stderr, __VA_ARGS__); } }
#endif
// addresses in EEPROM for mk1 blink(1) devices
#define blink1_eeaddr_osccal 0
#define blink1_eeaddr_bootmode 1
#define blink1_eeaddr_serialnum 2
#define blink1_serialnum_len 4
#define blink1_eeaddr_patternstart (blink1_eeaddr_serialnum + blink1_serialnum_len)
void blink1_sortCache(void);
const char * const deviceTypeStrings[] =
{
"unknown",
"mk1", "mk2", "mk3"
};
//----------------------------------------------------------------------------
// implementation-varying code
#if USE_HIDDATA
#include "blink1-lib-lowlevel-hiddata.h"
#else
//#if USE_HIDAPI
#include "blink1-lib-lowlevel-hidapi.h"
#endif
// default to USE_HIDAPI unless specifically told otherwise
// -------------------------------------------------------------------------
// everything below here doesn't need to know about USB details
// except for a "blink1_device*"
// -------------------------------------------------------------------------
//
// blink1 hardware api
//
//
int blink1_getCachedCount(void)
{
return blink1_cached_count;
}
//
const char* blink1_getCachedPath(int i)
{
if( i > blink1_getCachedCount()-1 ) return NULL;
return blink1_infos[i].path;
}
//
const char* blink1_getCachedSerial(int i)
{
if( i > blink1_getCachedCount()-1 ) return NULL;
return blink1_infos[i].serial;
}
int blink1_getCacheIndexByPath( const char* path )
{
for( int i=0; i< cache_max; i++ ) {
if( strcmp( blink1_infos[i].path, (const char*) path ) == 0 ) return i;
}
return -1;
}
int blink1_getCacheIndexById( uint32_t i )
{
if( i > blink1_max_devices ) { // then i is a serial number not an array index
char serialstr[serialstrmax];
snprintf(serialstr, sizeof(serialstr), "%X", i); // convert to wchar_t*
return blink1_getCacheIndexBySerial( serialstr );
}
return i;
}
int blink1_getCacheIndexBySerial( const char* serial )
{
for( int i=0; i< cache_max; i++ ) {
if( strcasecmp( blink1_infos[i].serial, serial ) == 0 ) return i;
}
return -1;
}
int blink1_getCacheIndexByDev( blink1_device* dev )
{
for( int i=0; i< cache_max; i++ ) {
if( blink1_infos[i].dev == dev ) return i;
}
return -1;
}
const char* blink1_getSerialForDev(blink1_device* dev)
{
int i = blink1_getCacheIndexByDev( dev );
if( i>=0 ) return blink1_infos[i].serial;
return NULL;
}
int blink1_clearCacheDev( blink1_device* dev )
{
int i = blink1_getCacheIndexByDev( dev );
if( i>=0 ) blink1_infos[i].dev = NULL; // FIXME: hmmmm
return i;
}
blink1Type_t blink1_deviceTypeById( int i )
{
return blink1_infos[i].type;
}
// returns BLINK1_MK2, BLINK1_MK3, or BLINK1
blink1Type_t blink1_deviceType( blink1_device* dev )
{
return blink1_deviceTypeById( blink1_getCacheIndexByDev(dev) );
}
const char* blink1_deviceTypeToStr(blink1Type_t t)
{
return deviceTypeStrings[t];
}
int blink1_isMk2ById( int i )
{
if( i>=0 && blink1_infos[i].type == BLINK1_MK2 ) return 1;
return 0;
}
int blink1_isMk2( blink1_device* dev )
{
return blink1_isMk2ById( blink1_getCacheIndexByDev(dev) );
}
//
int blink1_getVersion(blink1_device *dev)
{
char buf[blink1_buf_size] = {blink1_report_id, 'v' };
int len = sizeof(buf);
int rc = blink1_read(dev, buf, len);
if( rc != -1 ) // also no error
rc = ((buf[3]-'0') * 100) + (buf[4]-'0');
// rc is now version number or error
// FIXME: we don't know vals of errcodes
return rc;
}
// mk1 only, not supported on mk2
int blink1_eeread(blink1_device *dev, uint16_t addr, uint8_t* val)
{
char buf[blink1_buf_size] = {blink1_report_id, 'e', addr };
int len = sizeof(buf);
int rc = blink1_write(dev, buf, len );
blink1_sleep( 50 ); // FIXME:
if( rc != -1 ) // no error
rc = blink1_read(dev, buf, len );
if( rc != -1 )
*val = buf[3];
return rc;
}
// mk1 only, not supported on mk2
int blink1_eewrite(blink1_device *dev, uint16_t addr, uint8_t val)
{
char buf[blink1_buf_size] = {blink1_report_id, 'E', addr, val };
int rc = blink1_write(dev, buf, sizeof(buf) );
return rc;
}
// FIXME: this doesn't work, use hidapi info instead
int blink1_serialnumread(blink1_device *dev, uint8_t** serialnum)
{
int rc = -1;
for( int i=0; i<blink1_serialnum_len; i++ ) { // serial num is 8 chars long
//blink1_eeread( dev, blink1_eeaddr_serialnum+i, (serialnum+i) );
}
return rc;
}
//
static uint8_t parseHex(char c)
{
c = toupper(c);
if (c >= '0' && c <= '9') return (c - '0');
if (c >= 'A' && c <= 'F') return (c - 'A')+10;
return 0;
}
// serialnum comes in as an ascii set of 8 characters representing
// 4-bytes
int blink1_serialnumwrite(blink1_device *dev, uint8_t* serialnumstr)
{
uint8_t serialnum[4];
serialnum[0] = parseHex( serialnumstr[0] )*16 + parseHex( serialnumstr[1] );
serialnum[1] = parseHex( serialnumstr[2] )*16 + parseHex( serialnumstr[3] );
serialnum[2] = parseHex( serialnumstr[4] )*16 + parseHex( serialnumstr[5] );
serialnum[3] = parseHex( serialnumstr[6] )*16 + parseHex( serialnumstr[7] );
int rc = 0;
for( int i=0; i<blink1_serialnum_len; i++ ) { // serialnum is 4 chars long
blink1_sleep(50); //FIXME:
uint8_t v = serialnum[i];
int rc = blink1_eewrite( dev, blink1_eeaddr_serialnum+i, v);
if( rc == -1 ) { // try again
LOG("blink1_serialwrite: oops, trying again on char %d\n",i);
rc = blink1_eewrite(dev,blink1_eeaddr_serialnum+i, v);
if( rc == -1 ) {
LOG("blink1_serialwrite: error on try again\n");
break;
}
}
}
return rc;
}
int blink1_fadeToRGBN(blink1_device *dev, uint16_t fadeMillis,
uint8_t r, uint8_t g, uint8_t b, uint8_t n)
{
int dms = fadeMillis/10; // millis_divided_by_10
char buf[blink1_buf_size];
buf[0] = blink1_report_id; // report id
buf[1] = 'c'; // command code for 'fade to rgb'
buf[2] = ((blink1_enable_degamma) ? blink1_degamma(r) : r );
buf[3] = ((blink1_enable_degamma) ? blink1_degamma(g) : g );
buf[4] = ((blink1_enable_degamma) ? blink1_degamma(b) : b );
buf[5] = (dms >> 8);
buf[6] = dms & 0xff;
buf[7] = n;
int rc = blink1_write(dev, buf, sizeof(buf) );
return rc;
}
//
int blink1_fadeToRGB(blink1_device *dev, uint16_t fadeMillis,
uint8_t r, uint8_t g, uint8_t b)
{
int dms = fadeMillis/10; // millis_divided_by_10
uint8_t buf[9];
buf[0] = blink1_report_id; // report id
buf[1] = 'c'; // command code for 'fade to rgb'
buf[2] = ((blink1_enable_degamma) ? blink1_degamma(r) : r );
buf[3] = ((blink1_enable_degamma) ? blink1_degamma(g) : g );
buf[4] = ((blink1_enable_degamma) ? blink1_degamma(b) : b );
buf[5] = (dms >> 8);
buf[6] = dms & 0xff;
buf[7] = 0;
int rc = blink1_write(dev, buf, sizeof(buf) );
return rc;
}
//
int blink1_setRGB(blink1_device *dev, uint8_t r, uint8_t g, uint8_t b )
{
uint8_t buf[blink1_buf_size];
buf[0] = blink1_report_id; // report id
buf[1] = 'n'; // command code for "set rgb now"
buf[2] = ((blink1_enable_degamma) ? blink1_degamma(r) : r ); // red
buf[3] = ((blink1_enable_degamma) ? blink1_degamma(g) : g ); // grn
buf[4] = ((blink1_enable_degamma) ? blink1_degamma(b) : b ); // blu
buf[5] = 0;
buf[6] = 0;
buf[7] = 0;
int rc = blink1_write(dev, buf, sizeof(buf) );
return rc;
}
// mk2 devices only
int blink1_readRGB(blink1_device *dev, uint16_t* fadeMillis,
uint8_t* r, uint8_t* g, uint8_t* b,
uint8_t ledn)
{
if( ! blink1_isMk2(dev) ) {
return blink1_readRGB_mk1( dev, fadeMillis, r,g,b);
}
uint8_t buf[blink1_buf_size] = { blink1_report_id, 'r', 0,0,0, 0,0,ledn };
int rc = blink1_read(dev, buf, sizeof(buf) );
if( rc != -1 ) {
*r = buf[2];
*g = buf[3];
*b = buf[4];
*fadeMillis = ((buf[5]<<8) + (buf[6] &0xff)) * 10;
}
return rc;
}
//
// args:
// - on == 1 or 0, enable or disable
// - millis == milliseconds to wait until triggering
// - st == 1 or 0, stay lit or set off() (mk2 firmware only)
// FIXME: bug in firmware? yes in v204 devices, max time is 62 secs
// - millis = 100000 => dms = 10000, dms_hi = 39, dms_lo = 16 :: real time = 34 secs
// - millis = 50000 => dms = 5000, dms_hi = 19, dms_lo = 136 :: real time = 50 secs
// - millis = 652800 => dms = 65280, dms_hi = 255, dms_lo = 0 :: real time = 62 secs
// - millis = 62000 => dms = 6200, dms_hi = 24, dms_lo = 56 :: real time = 62 secs
//
int blink1_serverdown(blink1_device *dev, uint8_t on, uint32_t millis, uint8_t st,
uint8_t startpos, uint8_t endpos)
{
uint16_t dms = millis / 10; // millis_divided_by_10
// printf("serverdown: millis: %u, dms: %d = %d / %d\n", millis, dms, (dms>>8), (dms % 0xff) );
uint8_t buf[blink1_buf_size];
buf[0] = blink1_report_id;
buf[1] = 'D';
buf[2] = on;
buf[3] = (dms>>8);
buf[4] = (dms & 0xff);
buf[5] = st; // mk2 only
buf[6] = startpos;
buf[7] = endpos;
int rc = blink1_write(dev, buf, sizeof(buf) );
return rc;
}
//
int blink1_play(blink1_device *dev, uint8_t play, uint8_t startpos)
{
return blink1_playloop(dev, play, startpos, 0,0);
}
// mk2 devices only
int blink1_playloop(blink1_device *dev, uint8_t play, uint8_t startpos,uint8_t endpos, uint8_t count)
{
uint8_t buf[blink1_buf_size];
buf[0] = blink1_report_id;
buf[1] = 'p';
buf[2] = play;
buf[3] = startpos;
buf[4] = endpos;
buf[5] = count;
buf[6] = 0;
buf[7] = 0;
int rc = blink1_write(dev, buf, sizeof(buf) );
return rc;
}
// mk2 devices only
int blink1_readPlayState(blink1_device *dev, uint8_t* playing,
uint8_t* playstart, uint8_t* playend,
uint8_t* playcount, uint8_t* playpos)
{
uint8_t buf[blink1_buf_size] = { blink1_report_id, 'S', 0,0,0, 0,0,0 };
int rc = blink1_read(dev, buf, sizeof(buf) );
if( rc != -1 ) {
*playing = buf[2];
*playstart = buf[3];
*playend = buf[4];
*playcount = buf[5];
*playpos = buf[6];
}
return rc;
}
//
int blink1_writePatternLine(blink1_device *dev, uint16_t fadeMillis,
uint8_t r, uint8_t g, uint8_t b,
uint8_t pos)
{
int dms = fadeMillis/10; // millis_divided_by_10
r = (blink1_enable_degamma) ? blink1_degamma(r) : r ;
g = (blink1_enable_degamma) ? blink1_degamma(g) : g ;
b = (blink1_enable_degamma) ? blink1_degamma(b) : b ;
uint8_t buf[blink1_buf_size] =
{blink1_report_id, 'P', r,g,b, (dms>>8), (dms & 0xff), pos };
int rc = blink1_write(dev, buf, sizeof(buf) );
return rc;
}
//
int blink1_readPatternLine(blink1_device *dev, uint16_t* fadeMillis,
uint8_t* r, uint8_t* g, uint8_t* b,
uint8_t pos)
{
uint8_t ledn;
return blink1_readPatternLineN( dev, fadeMillis, r,g,b, &ledn, pos);
}
int blink1_readPatternLineN(blink1_device *dev, uint16_t* fadeMillis,
uint8_t* r, uint8_t* g, uint8_t* b, uint8_t* ledn,
uint8_t pos)
{
uint8_t buf[blink1_buf_size] = { blink1_report_id, 'R', 0,0,0, 0,0, pos };
int rc = blink1_read(dev, buf, sizeof(buf) );
if( rc != -1 ) {
*r = buf[2];
*g = buf[3];
*b = buf[4];
*fadeMillis = ((buf[5]<<8) + (buf[6] &0xff)) * 10;
*ledn = buf[7];
}
return rc;
}
// mk2 devices only, mk1 devices save on each writePatternLine()
int blink1_savePattern( blink1_device *dev )
{
uint8_t buf[blink1_buf_size];
buf[0] = blink1_report_id; // report id
buf[1] = 'W'; // command code for "write pattern to flash"
buf[2] = 0xBE;
buf[3] = 0xEF;
buf[4] = 0xCA;
buf[5] = 0xFE;
buf[6] = 0x00;
buf[7] = 0x00;
int rc = blink1_write(dev, buf, sizeof(buf) );
rc = 0; // assume success
// note rc will always return -1
// because of issue with flash programming timing out USB
return rc;
}
// only for devcies with fw val 204+
int blink1_setLEDN( blink1_device* dev, uint8_t ledn)
{
uint8_t buf[blink1_buf_size];
buf[0] = blink1_report_id; // report id
buf[1] = 'l'; // command code for "set ledn"
buf[2] = ledn;
int rc = blink1_write(dev, buf, sizeof(buf) );
return rc;
}
// only for devices with fw val 206+ or mk3
int blink1_getStartupParams( blink1_device* dev, uint8_t* bootmode,
uint8_t* playstart, uint8_t* playend, uint8_t* playcount)
{
uint8_t buf[blink1_buf_size] = { blink1_report_id, 'b', 0,0,0, 0,0, 0 };
int rc = blink1_read(dev, buf, sizeof(buf) );
if( rc != -1 ) {
*bootmode = buf[2];
*playstart = buf[3];
*playend = buf[4];
*playcount = buf[5];
}
return rc;
}
// only for devices with fw val 206+ or mk3
// FIXME: make 'params' a struct
int blink1_setStartupParams( blink1_device* dev, uint8_t bootmode,
uint8_t playstart, uint8_t playend, uint8_t playcount)
{
uint8_t buf[blink1_buf_size];
buf[0] = blink1_report_id;
buf[1] = 'B';
buf[2] = bootmode; // (0=normal, 1=play, 2=off)
buf[3] = playstart;
buf[4] = playend;
buf[5] = playcount;
buf[6] = 0; // unused1
buf[7] = 0; // unused2
int rc = blink1_write(dev, buf, sizeof(buf) );
return rc;
}
// only for mk3
int blink1_writeNote( blink1_device* dev, uint8_t noteid, const uint8_t* notebuf)
{
uint8_t buf[blink1_buf2_size] = { blink1_report2_id, 'F', noteid };
memcpy( buf+3, notebuf, blink1_note_size ); // FIXME: notes are 100 bytes
//hexdump(stdout, (char*)notebuf, 15);
//hexdump(stdout, buf, 15);
int rc = blink1_write(dev, buf, sizeof(buf));
if( rc == -1 ) {
printf("blink1_writeNote: oops error\n");
}
return rc;
}
// only for mk3
int blink1_readNote( blink1_device* dev, uint8_t noteid, uint8_t** notebuf)
{
uint8_t buf[blink1_buf2_size] = { blink1_report2_id, 'f', noteid };
int rc = blink1_read(dev, buf, sizeof(buf) );
//int rc = blink1_write(dev, buf, sizeof(buf)-1 ); // why does this need to be one shorter?
//rc = blink1_read_nosend(dev, buf, sizeof(buf) );
uint8_t* notedata = buf+3;
memcpy( *notebuf, notedata, blink1_note_size); // skip over report id, cmd FIXME: harccoded 100
return rc;
}
// only for mk3
int blink1_bootloaderGo( blink1_device* dev )
{
uint8_t buf[blink1_buf2_size] = { blink1_report2_id, 'G', 'o','B','o','o','t',0 };
int rc = blink1_read(dev, buf, sizeof(buf));
if( rc == -1 ) {
printf("blink1_bootloaderLock: oops error\n");
}
else {
printf("blink1 response: '%s'\n", buf);
if( strncmp("GOBOOT", (char*)buf+1, 6) != 0 ) {
printf("blink1_bootloaderLock: bootloader is locked\n");
rc = 01; // fail
}
}
return rc; // >0 on good completion
}
// only for mk3
int blink1_bootloaderLock( blink1_device* dev )
{
uint8_t buf[blink1_buf2_size] = { blink1_report2_id, 'L', 'o','c','k','B','o','o','t','l','o','a','d' };
int rc = blink1_read(dev, buf, sizeof(buf));
if( rc == -1 ) {
printf("blink1_bootlaoderLock: oops error\n");
}
else {
printf("blink1 response: %s\n", buf+1);
if( strncmp("LOCKED", (char*)buf+1, 6) != 0 ) {
rc = -1;
}
}
return rc;
}
// only for mk3
// idbuf must be at least blink1_report2_size-2 big
//
int blink1_getId( blink1_device *dev, uint8_t** idbuf )
{
uint8_t buf[blink1_report2_size] = { blink1_report2_id, 'U', 0,0,0, 0,0,0 };
int rc = blink1_read(dev, buf, sizeof(buf));
if( rc != -1 ) {
memcpy( idbuf, buf+2, blink1_report2_size-2); // skip over report id & cmd
}
else {
printf("getId: read error: rc=%d\n", rc);
}
return rc;
}
//
int blink1_testtest( blink1_device *dev, uint8_t reportid )
{
uint8_t count = (reportid==1) ? blink1_buf_size : blink1_buf2_size;
uint8_t buf[blink1_report2_size] = { reportid, '!', 0,0,0, 0,0,0 };
int rc = blink1_write(dev, buf, count );
blink1_sleep( 50 ); //FIXME:
if( rc != -1 ) { // no error
rc = blink1_read(dev, buf, count);
for( int i=0; i<count; i++ ) {
printf("%2.2x,",(uint8_t)buf[i]);
}
printf("\n");
}
else {
printf("testtest error: rc=%d\n", rc);
}
return rc;
}
/* ------------------------------------------------------------------------- */
void blink1_enableDegamma()
{
blink1_enable_degamma = 1;
}
void blink1_disableDegamma()
{
blink1_enable_degamma = 0;
}
/**
* Using a brightness value, update an r,g,b triplet
* Modifies r,g,b in place
*/
void blink1_adjustBrightness( uint8_t brightness, uint8_t* r, uint8_t* g, uint8_t* b)
{
if( brightness ) {
*r = (*r * brightness) >> 8;
*g = (*g * brightness) >> 8;
*b = (*b * brightness) >> 8;
}
}
#if 0
// a simple logarithmic -> linear mapping as a sort of gamma correction
// maps from 0-255 to 0-255
static int blink1_degamma_log2lin( int n )
{
//return (int)(1.0* (n * 0.707 )); // 1/sqrt(2)
return (((1<<(n/32))-1) + ((1<<(n/32))*((n%32)+1)+15)/32);
}
#endif
// from http://rgb-123.com/ws2812-color-output/
// GammaE=255*(res/255).^(1/.45)
//
uint8_t GammaE[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5,
6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 11, 11,
11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18,
19, 19, 20, 21, 21, 22, 22, 23, 23, 24, 25, 25, 26, 27, 27, 28,
29, 29, 30, 31, 31, 32, 33, 34, 34, 35, 36, 37, 37, 38, 39, 40,
40, 41, 42, 43, 44, 45, 46, 46, 47, 48, 49, 50, 51, 52, 53, 54,
55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
71, 72, 73, 74, 76, 77, 78, 79, 80, 81, 83, 84, 85, 86, 88, 89,
90, 91, 93, 94, 95, 96, 98, 99,100,102,103,104,106,107,109,110,
111,113,114,116,117,119,120,121,123,124,126,128,129,131,132,134,
135,137,138,140,142,143,145,146,148,150,151,153,155,157,158,160,
162,163,165,167,169,170,172,174,176,178,179,181,183,185,187,189,
191,193,194,196,198,200,202,204,206,208,210,212,214,216,218,220,
222,224,227,229,231,233,235,237,239,241,244,246,248,250,252,255};
//
static int blink1_degamma_better( int n )
{
return GammaE[n];
}
//
int blink1_degamma( int n )
{
//return blink1_degamma_log2lin(n);
return blink1_degamma_better(n);
}
// qsort char* string comparison function
int cmp_blink1_info_serial(const void *a, const void *b)
{
blink1_info* bia = (blink1_info*) a;
blink1_info* bib = (blink1_info*) b;
return strncmp( bia->serial,
bib->serial,
serialstrmax);
}
void blink1_sortCache(void)
{
size_t elemsize = sizeof( blink1_info ); //
qsort( blink1_infos,
blink1_cached_count,
elemsize,
cmp_blink1_info_serial);
}
//
int blink1_vid(void)
{
//uint8_t rawVid[2] = {USB_CFG_VENDOR_ID};
//int vid = rawVid[0] + 256 * rawVid[1];
return BLINK1_VENDOR_ID;
}
//
int blink1_pid(void)
{
//uint8_t rawPid[2] = {USB_CFG_DEVICE_ID};
//int pid = rawPid[0] + 256 * rawPid[1];
return BLINK1_DEVICE_ID;
}
// simple cross-platform millis sleep func
void blink1_sleep(uint32_t millis)
{
#ifdef WIN32
Sleep(millis);
#else
usleep( millis * 1000);
#endif
}
//
// blink1 utility api
//
// take an array of bytes and spit them out as a hex string
void hexdump(FILE* fp, uint8_t *buffer, int len)
{
int i;
//FILE *fp = stdout;
for(i = 0; i < len; i++){
if(i != 0){
if(i % 16 == 0){
fprintf(fp, "\n");
}else{
fprintf(fp, " ");
}
}
fprintf(fp, "0x%02x", buffer[i] & 0xff);
}
if(i != 0)
fprintf(fp, "\n");
}
// parse a comma-delimited string containing numbers (dec,hex) into a byte arr
int hexread(uint8_t *buffer, char *string, int buflen)
{
char *s;
int pos = 0;
if( string==NULL ) return -1;
memset(buffer,0,buflen); // bzero() not defined on Win32?
while((s = strtok(string, ", ")) != NULL && pos < buflen){
string = NULL;
buffer[pos++] = (char)strtol(s, NULL, 0);
}
return pos;
}
// integer-only hsbtorgb
// from: http://web.mit.edu/storborg/Public/hsvtorgb.c
void hsbtorgb( rgb_t* rgb, uint8_t* hsb )
{
uint8_t h = hsb[0];
uint8_t s = hsb[1];
uint8_t v = hsb[2];
unsigned char region, fpart, p, q, t;
uint8_t r,g,b;
if(s == 0) { // color is grayscale
r = g = b = v;
return;
}
region = h / 43; // make hue 0-5
fpart = (h - (region * 43)) * 6; // find remainder part, make it from 0-255
// calculate temp vars, doing integer multiplication
p = (v * (255 - s)) >> 8;
q = (v * (255 - ((s * fpart) >> 8))) >> 8;
t = (v * (255 - ((s * (255 - fpart)) >> 8))) >> 8;
// assign temp vars based on color cone region
switch(region) {
case 0: r = v; g = t; b = p; break;
case 1: r = q; g = v; b = p; break;
case 2: r = p; g = v; b = t; break;
case 3: r = p; g = q; b = v; break;
case 4: r = t; g = p; b = v; break;
default: r = v; g = p; b = q; break;
}
rgb->r=r;
rgb->g=g;
rgb->b=b;
}
void remove_whitespace(char *str)
{
char *p;
size_t len = strlen(str);
for(p = str; *p; p ++, len --) {
while(isspace(*p)) memmove(p, p+1, len--);
}
}
// parse a color in form either "#ff00ff" or "FF00FF"
// or "255,0,255" or "0xff,0x00,0xff"
void parsecolor(rgb_t* color, char* colorstr)
{
// parse hex color code like "#FF00FF" or "FF00FF"
if( strchr(colorstr,',')==NULL && (colorstr[0] == '#' || strlen(colorstr)==6) ) {
colorstr = (colorstr[0] == '#') ? colorstr+1 : colorstr;
uint32_t colorint = strtol(colorstr, NULL, 16);
color->r = (colorint >> 16) & 0xff;
color->g = (colorint >> 8) & 0xff;
color->b = (colorint >> 0) & 0xff;
} else { // else it's a list like "0xff,0x00,0xff" or "255,0,255"
hexread((uint8_t*)color, colorstr, 3); // FIXME: hardcoded size
}
}
//
// Parse pattern into an array of patternlines
// - number repeats
// - pattern array (contains {color,millis,ledn}
// - pattern length
int parsePattern( char* str, int* repeats, patternline_t* pattern )
{
remove_whitespace(str);
char* s;
s = strtok( str, ", ");
if( s != NULL ) {
*repeats = strtol(s,NULL,0);
}
int i=0;
s = strtok(NULL, ","); // prep next parse
while( s != NULL ) {
//printf("s:'%s'\n",s);
parsecolor( &pattern[i].color, s );
s = strtok(NULL, ",");
if( s == NULL ) { msg("bad pattern: no millis\n"); break; }
pattern[i].millis = atof(s) * 1000;
s = strtok(NULL, ",");
if( s == NULL ) { msg("bad pattern: no led\n"); break; }
pattern[i].ledn = strtol(s,NULL,0);
i++;
s = strtok(NULL, ",");
if( s == NULL ) break;
}
int pattlen = i;
return pattlen;
}
/**
* printf that can be shut up
*/
void msg(char* fmt, ...)
{
va_list args;
va_start(args,fmt);
if( !msg_quiet ) {
vprintf(fmt,args);
}
va_end(args);
}
/**
* set the level of quiet for msg FIXME:
*/
void msg_setquiet(int q)
{
msg_quiet = q;
}
Reference in New Issue View Git Blame Copy Permalink