// listen for advertisement packets
bool BTLE::listen(int timeout) {
radio->startListening();
delay(timeout);
if (!radio->available())
return false;
uint8_t total_size = 0;
uint8_t* inbuf = (uint8_t*)&buffer;
while (radio->available()) {
// fetch the payload, and check if there are more left
radio->read( inbuf, sizeof(buffer) );
// decode: swap bit order, un-whiten
swapbuf( sizeof(buffer) );
whiten( sizeof(buffer) );
// size is w/o header+CRC -> add 2 bytes header
total_size = inbuf[1]+2;
uint8_t in_crc[3];
// calculate & compare CRC
crc( total_size, in_crc );
for (uint8_t i = 0; i < 3; i++)
if (inbuf[total_size+i] != in_crc[i])
return false;
}
return true;
}
// Broadcast an advertisement packet with a specific data type
// Standardized data types can be seen here:
// https://www.bluetooth.org/en-us/specification/assigned-numbers/generic-access-profile
bool BTLE::advertise( uint8_t data_type, void* buf, uint8_t buflen ) {
// name & total payload size
uint8_t namelen = strlen(name);
uint8_t pls = 0;
// insert pseudo-random MAC address
buffer.mac[0] = ((__TIME__[6]-0x30) << 4) | (__TIME__[7]-0x30);
buffer.mac[1] = ((__TIME__[3]-0x30) << 4) | (__TIME__[4]-0x30);
buffer.mac[2] = ((__TIME__[0]-0x30) << 4) | (__TIME__[1]-0x30);
buffer.mac[3] = ((__DATE__[4]-0x30) << 4) | (__DATE__[5]-0x30);
buffer.mac[4] = month(__DATE__);
buffer.mac[5] = ((__DATE__[9]-0x30) << 4) | (__DATE__[10]-0x30) | 0xC0; // static random address should have two topmost bits set
// add device descriptor chunk
chunk(buffer,pls)->size = 0x02; // chunk size: 2
chunk(buffer,pls)->type = 0x01; // chunk type: device flags
chunk(buffer,pls)->data[0]= 0x05; // flags: LE-only, limited discovery mode
pls += 3;
// add "complete name" chunk
chunk(buffer,pls)->size = namelen+1; // chunk size
chunk(buffer,pls)->type = 0x09; // chunk type
for (uint8_t i = 0; i < namelen; i++)
chunk(buffer,pls)->data[i] = name[i];
pls += namelen+2;
// add custom data, if applicable
if (buflen > 0) {
chunk(buffer,pls)->size = buflen+1; // chunk size
chunk(buffer,pls)->type = data_type; // chunk type
for (uint8_t i = 0; i < buflen; i++)
chunk(buffer,pls)->data[i] = ((uint8_t*)buf)[i];
pls += buflen+2;
}
// total payload size must be 21 bytes or less
if (pls > 21)
return false;
// assemble header
buffer.pdu_type = 0x42; // PDU type: ADV_NONCONN_IND, TX address is random
buffer.pl_size = pls+6; // set final payload size in header incl. MAC
// calculate CRC over header+MAC+payload, append after payload
uint8_t* outbuf = (uint8_t*)&buffer;
crc( pls+8, outbuf+pls+8);
// whiten header+MAC+payload+CRC, swap bit order
whiten( pls+11 );
swapbuf( pls+11 );
// flush buffers and send
radio->stopListening();
radio->write( outbuf, pls+11 );
return true;
}
void run_unit_test_whiten()
{
int M = 4;
int N = 12;
Mda X(M, N);
for (int n = 0; n < N; n++) {
for (int m = 0; m < M; m++) {
X.set(sin(sin(m) + sin(n) + sin(m + n)), m, n);
}
}
QString path1 = "tmp_ut1.mda";
QString path2 = "tmp_ut2.mda";
X.write32(path1);
whiten(path1, path2);
Mda Y;
Y.read(path2);
printf("\nY:\n");
matrix_print(Y);
}
void testwhiten()
{
int letter,row,column,white[31],unwhite[31],histo[256],i,x,y,z,inx;
char boxes[4960],triples[12][3];
char teststr[]="PACK@MY@BOX@WITH@FIVE@DOZEN@LIQUOR@JUGS@";
memset(boxes,0,sizeof(boxes));
memset(histo,0,sizeof(histo));
for (row=i=0;row<32;row++)
{
for (column=0;column<31;column++)
{
letter=teststr[i];
if (!letter)
letter=teststr[i=0];
i++;
white[column]=whiten(letter,row,column);
unwhite[column]=unwhiten(white[column],row,column);
}
for (column=0;column<31;column++)
putchar(white[column]);
putchar(' ');
for (column=0;column<31;column++)
putchar(unwhite[column]);
putchar('\n');
}
for (i=row=0;i<4096;i++)
if (invletters[i]&0x8000)
{
putchar(((invletters[i]) &31)+'@');
putchar(((invletters[i]>>5) &31)+'@');
putchar(((invletters[i]>>10)&31)+'@');
triples[row][0]=((invletters[i]) &31);
triples[row][1]=((invletters[i]>>5) &31);
triples[row][2]=((invletters[i]>>10)&31);
row++;
putchar('\n');
}
void
Sprite::Render(Video* video, DWORD flags)
{
if (shade < 0.001 || hidden || !visible || !video)
return;
if (blend_mode == 2 && !(flags & Graphic::RENDER_ALPHA))
return;
if (blend_mode == 4 && !(flags & Graphic::RENDER_ADDITIVE))
return;
if (life > 0 || loop) {
const Camera* camera = video->GetCamera();
Matrix orient(camera->Orientation());
Vec3 nrm(camera->vpn() * -1);
ColorValue white((float) shade, (float) shade, (float) shade, (float) shade);
ColorValue whiten((float) shade/3, (float) shade/3, (float) shade/3, (float) shade/3);
DWORD diff = white.ToColor().Value();
orient.Roll(angle);
Vec3 vx = Vec3((float) orient(0,0),
(float) orient(0,1),
(float) orient(0,2)) * (float) (w/2.0f);
Vec3 vy = Vec3((float) orient(1,0),
(float) orient(1,1),
(float) orient(1,2)) * (float) (h/2.0f);
vset.loc[0] = loc - vx + vy;
vset.nrm[0] = nrm;
vset.diffuse[0] = diff;
vset.loc[1] = loc + vx + vy;
vset.nrm[1] = nrm;
vset.diffuse[1] = diff;
vset.loc[2] = loc + vx - vy;
vset.nrm[2] = nrm;
vset.diffuse[2] = diff;
vset.loc[3] = loc - vx - vy;
vset.nrm[3] = nrm;
vset.diffuse[3] = diff;
if (luminous) {
mtl.Ka = Color::Black;
mtl.Kd = Color::Black;
mtl.Ks = Color::Black;
mtl.Ke = white;
mtl.tex_diffuse = Frame();
mtl.tex_emissive = Frame();
mtl.blend = blend_mode;
mtl.luminous = luminous;
}
else {
mtl.Ka = white;
mtl.Kd = white;
mtl.Ks = Color::Black;
mtl.Ke = whiten; //Color::Black;
mtl.tex_diffuse = Frame();
mtl.tex_emissive = Frame(); //0;
mtl.blend = blend_mode;
mtl.luminous = luminous;
}
video->DrawPolys(1, &poly);
}
memset(&screen_rect, 0, sizeof(Rect));
}
int main(int argc,char *argv[]) {
QCoreApplication app(argc,argv); //important for qApp->applicationDirPath() in processtracker
// test_armadillo();
// test_pca_2();
// return 0;
CLParams CLP;
QStringList required;
CLP=get_command_line_params(argc,argv,required);
ProcessTracker PT;
register_processors(PT);
if (CLP.unnamed_parameters.count()>1) {
printf("Only one command parameter may be specified.\n");
return -1;
}
QString command=CLP.unnamed_parameters.value(0);
if (command.isEmpty()) {
printf("\nmountainsort processors:\n");
for (int i=0; i<PT.processorCount(); i++) {
QString cmd=PT.processor(i).command;
printf("%s ",cmd.toLatin1().data());
}
printf("\n\n");
return -1;
}
PTProcessor PP=PT.findProcessor(command);
printf("%s version %s\n",PP.command.toLatin1().data(),PP.version.toLatin1().data());
if (!CLP.named_parameters.value("force").toInt()) {
if (PT.processAlreadyCompleted(CLP)) {
printf("Process already completed.\n");
return 0;
}
}
CLP.named_parameters.remove("force");
QTime timer; timer.start();
if (command=="extract") {
QString input_path=CLP.named_parameters["input"];
QString output_path=CLP.named_parameters["output"];
int num_channels=CLP.named_parameters["num_channels"].toInt();
long t1=CLP.named_parameters["t1"].toLong();
long t2=CLP.named_parameters["t2"].toLong();
QStringList channels_str=CLP.named_parameters["channels"].split(",");
int M=channels_str.count();
int channels[M];
for (int m=0; m<M; m++) channels[m]=channels_str[m].toInt();
if ((input_path.isEmpty())||(output_path.isEmpty())) {extract_usage(); return -1;}
if (M==0) {extract_usage(); return -1;}
if (!extract(input_path.toLatin1().data(),output_path.toLatin1().data(),num_channels,M,channels,t1,t2)) {
printf("Error in extract.\n");
return -1;
}
}
else if (command=="bandpass_filter") {
QString input_path=CLP.named_parameters["input"];
QString output_path=CLP.named_parameters["output"];
double samplefreq=CLP.named_parameters["samplefreq"].toDouble();
double freq_min=CLP.named_parameters["freq_min"].toDouble();
double freq_max=CLP.named_parameters["freq_max"].toDouble();
double outlier_threshold=CLP.named_parameters["outlier_threshold"].toDouble();
if ((input_path.isEmpty())||(output_path.isEmpty())) {bandpass_filter_usage(); return -1;}
if ((samplefreq==0)||(freq_min==0)||(freq_max==0)) {bandpass_filter_usage(); return -1;}
if (!bandpass_filter(input_path.toLatin1().data(),output_path.toLatin1().data(),samplefreq,freq_min,freq_max,outlier_threshold)) {
printf("Error in bandpass_filter.\n");
return -1;
}
}
else if (command=="normalize_channels") {
QString input_path=CLP.named_parameters["input"];
QString output_path=CLP.named_parameters["output"];
if ((input_path.isEmpty())||(output_path.isEmpty())) {normalize_channels_usage(); return -1;}
if (!normalize_channels(input_path.toLatin1().data(),output_path.toLatin1().data())) {
printf("Error in normalize_channels.\n");
return -1;
}
}
else if (command=="whiten") {
QString input_path=CLP.named_parameters["input"];
QString output_path=CLP.named_parameters["output"];
int ncomp=CLP.named_parameters["ncomp"].toInt();
if ((input_path.isEmpty())||(output_path.isEmpty())) {whiten_usage(); return -1;}
if (ncomp==0) {whiten_usage(); return -1;}
if (!whiten(input_path.toLatin1().data(),output_path.toLatin1().data(),ncomp)) {
printf("Error in whiten.\n");
return -1;
}
}
else if (command=="detect") {
QString input_path=CLP.named_parameters["input"];
QString output_path=CLP.named_parameters["output"];
int inner_window_width=CLP.named_parameters["inner_window_width"].toInt();
int outer_window_width=CLP.named_parameters["outer_window_width"].toInt();
float threshold=CLP.named_parameters["threshold"].toFloat();
if ((input_path.isEmpty())||(output_path.isEmpty())) {detect_usage(); return -1;}
if (inner_window_width==0) {detect_usage(); return -1;}
if (outer_window_width==0) {detect_usage(); return -1;}
if (threshold==0) {detect_usage(); return -1;}
if (!detect(input_path.toLatin1().data(),output_path.toLatin1().data(),inner_window_width,outer_window_width,threshold)) {
printf("Error in detect.\n");
return -1;
}
}
else if (command=="features") {
QString input_path=CLP.named_parameters["input"];
QString detect_path=CLP.named_parameters["detect"];
QString adjacency_path=CLP.named_parameters["adjacency"];
QString output_path=CLP.named_parameters["output"];
int num_features=CLP.named_parameters["num_features"].toInt();
int clip_size=CLP.named_parameters["clip_size"].toInt();
if ((input_path.isEmpty())||(detect_path.isEmpty())||(adjacency_path.isEmpty())||(output_path.isEmpty())) {features_usage(); return -1;}
if (num_features==0) {features_usage(); return -1;}
if (clip_size==0) {features_usage(); return -1;}
if (!features(input_path.toLatin1().data(),detect_path.toLatin1().data(),adjacency_path.toLatin1().data(),output_path.toLatin1().data(),num_features,clip_size)) {
printf("Error in features.\n");
return -1;
}
}
else if (command=="cluster") {
QString input_path=CLP.named_parameters["input"];
QString output_path=CLP.named_parameters["output"];
if ((input_path.isEmpty())||(output_path.isEmpty())) {cluster_usage(); return -1;}
if (!cluster(input_path.toLatin1().data(),output_path.toLatin1().data())) {
printf("Error in cluster.\n");
return -1;
}
}
else if (command=="split_clusters") {
QString input_path=CLP.named_parameters["input"];
QString cluster_path=CLP.named_parameters["cluster"];
QString output_path=CLP.named_parameters["output"];
int num_features=CLP.named_parameters["num_features"].toInt();
int clip_size=CLP.named_parameters["clip_size"].toInt();
if ((input_path.isEmpty())||(cluster_path.isEmpty())||(output_path.isEmpty())) {cluster_usage(); return -1;}
if (num_features==0) {cluster_usage(); return -1;}
if (clip_size==0) {cluster_usage(); return -1;}
if (!split_clusters(input_path.toLatin1().data(),cluster_path.toLatin1().data(),output_path.toLatin1().data(),num_features,clip_size)) {
printf("Error in cluster.\n");
return -1;
}
}
else if (command=="templates") {
QString input_path=CLP.named_parameters["input"];
QString cluster_path=CLP.named_parameters["cluster"];
QString output_path=CLP.named_parameters["output"];
int clip_size=CLP.named_parameters["clip_size"].toInt();
if ((input_path.isEmpty())||(output_path.isEmpty())) {templates_usage(); return -1;}
if (clip_size==0) {templates_usage(); return -1;}
if (!templates(input_path.toLatin1().data(),cluster_path.toLatin1().data(),output_path.toLatin1().data(),clip_size)) {
printf("Error in templates.\n");
return -1;
}
}
else if (command=="consolidate") {
QString cluster_path=CLP.named_parameters["cluster"];
QString templates_path=CLP.named_parameters["templates"];
QString cluster_out_path=CLP.named_parameters["cluster_out"];
QString templates_out_path=CLP.named_parameters["templates_out"];
QString load_channels_out_path=CLP.named_parameters["load_channels_out"];
if ((cluster_path.isEmpty())||(templates_path.isEmpty())) {consolidate_usage(); return -1;}
if ((cluster_out_path.isEmpty())||(templates_out_path.isEmpty())) {consolidate_usage(); return -1;}
if (load_channels_out_path.isEmpty()) {consolidate_usage(); return -1;}
if (!consolidate(cluster_path.toLatin1().data(),templates_path.toLatin1().data(),cluster_out_path.toLatin1().data(),templates_out_path.toLatin1().data(),load_channels_out_path.toLatin1().data())) {
printf("Error in consolidate.\n");
return -1;
}
}
else if (command=="fit") {
QString input_path=CLP.named_parameters["input"];
QString cluster_path=CLP.named_parameters["cluster"];
QString templates_path=CLP.named_parameters["templates"];
QString cluster_out_path=CLP.named_parameters["cluster_out"];
if ((input_path.isEmpty())||(cluster_path.isEmpty())||(templates_path.isEmpty())) {fit_usage(); return -1;}
if ((cluster_out_path.isEmpty())) {fit_usage(); return -1;}
if (!fit(input_path.toLatin1().data(),templates_path.toLatin1().data(),cluster_path.toLatin1().data(),cluster_out_path.toLatin1().data())) {
printf("Error in fit.\n");
return -1;
}
}
else if (command=="extract_clips") {
QString input_path=CLP.named_parameters["input"];
QString cluster_path=CLP.named_parameters["cluster"];
QString output_path=CLP.named_parameters["output"];
QString index_out_path=CLP.named_parameters["index_out"];
int clip_size=CLP.named_parameters["clip_size"].toInt();
if ((input_path.isEmpty())||(cluster_path.isEmpty())) {extract_usage(); return -1;}
if ((output_path.isEmpty())||(index_out_path.isEmpty())) {extract_usage(); return -1;}
if (!extract_clips(input_path.toLatin1().data(),cluster_path.toLatin1().data(),output_path.toLatin1().data(),index_out_path.toLatin1().data(),clip_size)) {
printf("Error in extract_clips.\n");
return -1;
}
}
else {
printf("Unknown command: %s\n",command.toLatin1().data());
return -1;
}
PT.reportProcessCompleted(CLP);
printf("Elapsed time for %s: %.2f seconds\n",command.toLatin1().data(),timer.elapsed()*1.0/1000);
return 0;
}
