cvs.zerfleddert.de Git - proxmark3-svn/blob - client/cmddata.c

   1 //-----------------------------------------------------------------------------
   2 // Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
   3 //
   4 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
   5 // at your option, any later version. See the LICENSE.txt file for the text of
   6 // the license.
   7 //-----------------------------------------------------------------------------
   8 // Data and Graph commands
   9 //-----------------------------------------------------------------------------
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <limits.h>
  15 #include "proxmark3.h"
  16 #include "data.h"
  17 #include "ui.h"
  18 #include "graph.h"
  19 #include "cmdparser.h"
  20 #include "util.h"
  21 #include "cmdmain.h"
  22 #include "cmddata.h"
  23
  24 static int CmdHelp(const char *Cmd);
  25
  26 int CmdAmp(const char *Cmd)
  27 {
  28   int i, rising, falling;
  29   int max = INT_MIN, min = INT_MAX;
  30
  31   for (i = 10; i < GraphTraceLen; ++i) {
  32     if (GraphBuffer[i] > max)
  33       max = GraphBuffer[i];
  34     if (GraphBuffer[i] < min)
  35       min = GraphBuffer[i];
  36   }
  37
  38   if (max != min) {
  39     rising = falling= 0;
  40     for (i = 0; i < GraphTraceLen; ++i) {
  41       if (GraphBuffer[i + 1] < GraphBuffer[i]) {
  42         if (rising) {
  43           GraphBuffer[i] = max;
  44           rising = 0;
  45         }
  46         falling = 1;
  47       }
  48       if (GraphBuffer[i + 1] > GraphBuffer[i]) {
  49         if (falling) {
  50           GraphBuffer[i] = min;
  51           falling = 0;
  52         }
  53         rising= 1;
  54       }
  55     }
  56   }
  57   RepaintGraphWindow();
  58   return 0;
  59 }
  60
  61 /*
  62  * Generic command to demodulate ASK.
  63  *
  64  * Argument is convention: positive or negative (High mod means zero
  65  * or high mod means one)
  66  *
  67  * Updates the Graph trace with 0/1 values
  68  *
  69  * Arguments:
  70  * c : 0 or 1
  71  */
  72 int Cmdaskdemod(const char *Cmd)
  73 {
  74   int i;
  75   int c, high = 0, low = 0;
  76
  77   sscanf(Cmd, "%i", &c);
  78
  79   if (c != 0 && c != 1) {
  80     PrintAndLog("Invalid argument: %s", Cmd);
  81     return 0;
  82   }
  83
  84   /* Detect high and lows */
  85   for (i = 0; i < GraphTraceLen; ++i)
  86   {
  87     if (GraphBuffer[i] > high)
  88       high = GraphBuffer[i];
  89     else if (GraphBuffer[i] < low)
  90       low = GraphBuffer[i];
  91   }
  92
  93   if (GraphBuffer[0] > 0) {
  94     GraphBuffer[0] = 1-c;
  95   } else {
  96     GraphBuffer[0] = c;
  97   }
  98   for (i = 1; i < GraphTraceLen; ++i) {
  99     /* Transitions are detected at each peak
 100      * Transitions are either:
 101      * - we're low: transition if we hit a high
 102      * - we're high: transition if we hit a low
 103      * (we need to do it this way because some tags keep high or
 104      * low for long periods, others just reach the peak and go
 105      * down)
 106      */
 107     if ((GraphBuffer[i] == high) && (GraphBuffer[i - 1] == c)) {
 108       GraphBuffer[i] = 1 - c;
 109     } else if ((GraphBuffer[i] == low) && (GraphBuffer[i - 1] == (1 - c))){
 110       GraphBuffer[i] = c;
 111     } else {
 112       /* No transition */
 113       GraphBuffer[i] = GraphBuffer[i - 1];
 114     }
 115   }
 116   RepaintGraphWindow();
 117   return 0;
 118 }
 119
 120 int CmdAutoCorr(const char *Cmd)
 121 {
 122   static int CorrelBuffer[MAX_GRAPH_TRACE_LEN];
 123
 124   int window = atoi(Cmd);
 125
 126   if (window == 0) {
 127     PrintAndLog("needs a window");
 128     return 0;
 129   }
 130   if (window >= GraphTraceLen) {
 131     PrintAndLog("window must be smaller than trace (%d samples)",
 132       GraphTraceLen);
 133     return 0;
 134   }
 135
 136   PrintAndLog("performing %d correlations", GraphTraceLen - window);
 137
 138   for (int i = 0; i < GraphTraceLen - window; ++i) {
 139     int sum = 0;
 140     for (int j = 0; j < window; ++j) {
 141       sum += (GraphBuffer[j]*GraphBuffer[i + j]) / 256;
 142     }
 143     CorrelBuffer[i] = sum;
 144   }
 145   GraphTraceLen = GraphTraceLen - window;
 146   memcpy(GraphBuffer, CorrelBuffer, GraphTraceLen * sizeof (int));
 147
 148   RepaintGraphWindow();
 149   return 0;
 150 }
 151
 152 int CmdBitsamples(const char *Cmd)
 153 {
 154   int cnt = 0;
 155   uint8_t got[12288];
 156
 157   GetFromBigBuf(got,sizeof(got),0);
 158   WaitForResponse(CMD_ACK,NULL);
 159
 160     for (int j = 0; j < sizeof(got); j++) {
 161       for (int k = 0; k < 8; k++) {
 162         if(got[j] & (1 << (7 - k))) {
 163           GraphBuffer[cnt++] = 1;
 164         } else {
 165           GraphBuffer[cnt++] = 0;
 166         }
 167       }
 168   }
 169   GraphTraceLen = cnt;
 170   RepaintGraphWindow();
 171   return 0;
 172 }
 173
 174 /*
 175  * Convert to a bitstream
 176  */
 177 int CmdBitstream(const char *Cmd)
 178 {
 179   int i, j;
 180   int bit;
 181   int gtl;
 182   int clock;
 183   int low = 0;
 184   int high = 0;
 185   int hithigh, hitlow, first;
 186
 187   /* Detect high and lows and clock */
 188   for (i = 0; i < GraphTraceLen; ++i)
 189   {
 190     if (GraphBuffer[i] > high)
 191       high = GraphBuffer[i];
 192     else if (GraphBuffer[i] < low)
 193       low = GraphBuffer[i];
 194   }
 195
 196   /* Get our clock */
 197   clock = GetClock(Cmd, high, 1);
 198   gtl = ClearGraph(0);
 199
 200   bit = 0;
 201   for (i = 0; i < (int)(gtl / clock); ++i)
 202   {
 203     hithigh = 0;
 204     hitlow = 0;
 205     first = 1;
 206     /* Find out if we hit both high and low peaks */
 207     for (j = 0; j < clock; ++j)
 208     {
 209       if (GraphBuffer[(i * clock) + j] == high)
 210         hithigh = 1;
 211       else if (GraphBuffer[(i * clock) + j] == low)
 212         hitlow = 1;
 213       /* it doesn't count if it's the first part of our read
 214          because it's really just trailing from the last sequence */
 215       if (first && (hithigh || hitlow))
 216         hithigh = hitlow = 0;
 217       else
 218         first = 0;
 219
 220       if (hithigh && hitlow)
 221         break;
 222     }
 223
 224     /* If we didn't hit both high and low peaks, we had a bit transition */
 225     if (!hithigh || !hitlow)
 226       bit ^= 1;
 227
 228     AppendGraph(0, clock, bit);
 229 //    for (j = 0; j < (int)(clock/2); j++)
 230 //      GraphBuffer[(i * clock) + j] = bit ^ 1;
 231 //    for (j = (int)(clock/2); j < clock; j++)
 232 //      GraphBuffer[(i * clock) + j] = bit;
 233   }
 234
 235   RepaintGraphWindow();
 236   return 0;
 237 }
 238
 239 int CmdBuffClear(const char *Cmd)
 240 {
 241   UsbCommand c = {CMD_BUFF_CLEAR};
 242   SendCommand(&c);
 243   ClearGraph(true);
 244   return 0;
 245 }
 246
 247 int CmdDec(const char *Cmd)
 248 {
 249   for (int i = 0; i < (GraphTraceLen / 2); ++i)
 250     GraphBuffer[i] = GraphBuffer[i * 2];
 251   GraphTraceLen /= 2;
 252   PrintAndLog("decimated by 2");
 253   RepaintGraphWindow();
 254   return 0;
 255 }
 256
 257 /* Print our clock rate */
 258 int CmdDetectClockRate(const char *Cmd)
 259 {
 260   int clock = DetectClock(0);
 261   PrintAndLog("Auto-detected clock rate: %d", clock);
 262   return 0;
 263 }
 264
 265 int CmdFSKdemod(const char *Cmd)
 266 {
 267   static const int LowTone[]  = {
 268     1,  1,  1,  1,  1, -1, -1, -1, -1, -1,
 269     1,  1,  1,  1,  1, -1, -1, -1, -1, -1,
 270     1,  1,  1,  1,  1, -1, -1, -1, -1, -1,
 271     1,  1,  1,  1,  1, -1, -1, -1, -1, -1,
 272     1,  1,  1,  1,  1, -1, -1, -1, -1, -1
 273   };
 274   static const int HighTone[] = {
 275     1,  1,  1,  1,  1,     -1, -1, -1, -1,
 276     1,  1,  1,  1,         -1, -1, -1, -1,
 277     1,  1,  1,  1,         -1, -1, -1, -1,
 278     1,  1,  1,  1,         -1, -1, -1, -1,
 279     1,  1,  1,  1,         -1, -1, -1, -1,
 280     1,  1,  1,  1,     -1, -1, -1, -1, -1,
 281   };
 282
 283   int lowLen = sizeof (LowTone) / sizeof (int);
 284   int highLen = sizeof (HighTone) / sizeof (int);
 285   int convLen = (highLen > lowLen) ? highLen : lowLen;
 286   uint32_t hi = 0, lo = 0;
 287
 288   int i, j;
 289   int minMark = 0, maxMark = 0;
 290
 291   for (i = 0; i < GraphTraceLen - convLen; ++i) {
 292     int lowSum = 0, highSum = 0;
 293
 294     for (j = 0; j < lowLen; ++j) {
 295       lowSum += LowTone[j]*GraphBuffer[i+j];
 296     }
 297     for (j = 0; j < highLen; ++j) {
 298       highSum += HighTone[j] * GraphBuffer[i + j];
 299     }
 300     lowSum = abs(100 * lowSum / lowLen);
 301     highSum = abs(100 * highSum / highLen);
 302     GraphBuffer[i] = (highSum << 16) | lowSum;
 303   }
 304
 305   for(i = 0; i < GraphTraceLen - convLen - 16; ++i) {
 306     int lowTot = 0, highTot = 0;
 307     // 10 and 8 are f_s divided by f_l and f_h, rounded
 308     for (j = 0; j < 10; ++j) {
 309       lowTot += (GraphBuffer[i+j] & 0xffff);
 310     }
 311     for (j = 0; j < 8; j++) {
 312       highTot += (GraphBuffer[i + j] >> 16);
 313     }
 314     GraphBuffer[i] = lowTot - highTot;
 315     if (GraphBuffer[i] > maxMark) maxMark = GraphBuffer[i];
 316     if (GraphBuffer[i] < minMark) minMark = GraphBuffer[i];
 317   }
 318
 319   GraphTraceLen -= (convLen + 16);
 320   RepaintGraphWindow();
 321
 322   // Find bit-sync (3 lo followed by 3 high)
 323   int max = 0, maxPos = 0;
 324   for (i = 0; i < 6000; ++i) {
 325     int dec = 0;
 326     for (j = 0; j < 3 * lowLen; ++j) {
 327       dec -= GraphBuffer[i + j];
 328     }
 329     for (; j < 3 * (lowLen + highLen ); ++j) {
 330       dec += GraphBuffer[i + j];
 331     }
 332     if (dec > max) {
 333       max = dec;
 334       maxPos = i;
 335     }
 336   }
 337
 338   // place start of bit sync marker in graph
 339   GraphBuffer[maxPos] = maxMark;
 340   GraphBuffer[maxPos + 1] = minMark;
 341
 342   maxPos += j;
 343
 344   // place end of bit sync marker in graph
 345   GraphBuffer[maxPos] = maxMark;
 346   GraphBuffer[maxPos+1] = minMark;
 347
 348   PrintAndLog("actual data bits start at sample %d", maxPos);
 349   PrintAndLog("length %d/%d", highLen, lowLen);
 350
 351   uint8_t bits[46];
 352   bits[sizeof(bits)-1] = '\0';
 353
 354   // find bit pairs and manchester decode them
 355   for (i = 0; i < arraylen(bits) - 1; ++i) {
 356     int dec = 0;
 357     for (j = 0; j < lowLen; ++j) {
 358       dec -= GraphBuffer[maxPos + j];
 359     }
 360     for (; j < lowLen + highLen; ++j) {
 361       dec += GraphBuffer[maxPos + j];
 362     }
 363     maxPos += j;
 364     // place inter bit marker in graph
 365     GraphBuffer[maxPos] = maxMark;
 366     GraphBuffer[maxPos + 1] = minMark;
 367
 368     // hi and lo form a 64 bit pair
 369     hi = (hi << 1) | (lo >> 31);
 370     lo = (lo << 1);
 371     // store decoded bit as binary (in hi/lo) and text (in bits[])
 372     if(dec < 0) {
 373       bits[i] = '1';
 374       lo |= 1;
 375     } else {
 376       bits[i] = '0';
 377     }
 378   }
 379   PrintAndLog("bits: '%s'", bits);
 380   PrintAndLog("hex: %08x %08x", hi, lo);
 381   return 0;
 382 }
 383
 384 int CmdGrid(const char *Cmd)
 385 {
 386   sscanf(Cmd, "%i %i", &PlotGridX, &PlotGridY);
 387   PlotGridXdefault= PlotGridX;
 388   PlotGridYdefault= PlotGridY;
 389   RepaintGraphWindow();
 390   return 0;
 391 }
 392
 393 int CmdHexsamples(const char *Cmd)
 394 {
 395   int i, j;
 396   int requested = 0;
 397   int offset = 0;
 398   char string_buf[25];
 399   char* string_ptr = string_buf;
 400   uint8_t got[40000];
 401
 402   sscanf(Cmd, "%i %i", &requested, &offset);
 403
 404   /* if no args send something */
 405   if (requested == 0) {
 406     requested = 8;
 407   }
 408   if (offset + requested > sizeof(got)) {
 409     PrintAndLog("Tried to read past end of buffer, <bytes> + <offset> > 40000");
 410     return 0;
 411   }
 412
 413   GetFromBigBuf(got,requested,offset);
 414   WaitForResponse(CMD_ACK,NULL);
 415
 416   i = 0;
 417   for (j = 0; j < requested; j++) {
 418     i++;
 419     string_ptr += sprintf(string_ptr, "%02x ", got[j]);
 420     if (i == 8) {
 421       *(string_ptr - 1) = '\0';    // remove the trailing space
 422       PrintAndLog("%s", string_buf);
 423       string_buf[0] = '\0';
 424       string_ptr = string_buf;
 425       i = 0;
 426     }
 427     if (j == requested - 1 && string_buf[0] != '\0') { // print any remaining bytes
 428       *(string_ptr - 1) = '\0';
 429       PrintAndLog("%s", string_buf);
 430       string_buf[0] = '\0';
 431     }
 432   }
 433   return 0;
 434 }
 435
 436 int CmdHide(const char *Cmd)
 437 {
 438   HideGraphWindow();
 439   return 0;
 440 }
 441
 442 int CmdHpf(const char *Cmd)
 443 {
 444   int i;
 445   int accum = 0;
 446
 447   for (i = 10; i < GraphTraceLen; ++i)
 448     accum += GraphBuffer[i];
 449   accum /= (GraphTraceLen - 10);
 450   for (i = 0; i < GraphTraceLen; ++i)
 451     GraphBuffer[i] -= accum;
 452
 453   RepaintGraphWindow();
 454   return 0;
 455 }
 456
 457 int CmdSamples(const char *Cmd)
 458 {
 459   int cnt = 0;
 460   int n;
 461   uint8_t got[40000];
 462
 463   n = strtol(Cmd, NULL, 0);
 464   if (n == 0) n = 512;
 465   if (n > sizeof(got)) n = sizeof(got);
 466
 467   PrintAndLog("Reading %d samples from device memory\n", n);
 468   GetFromBigBuf(got,n,3560);
 469   WaitForResponse(CMD_ACK,NULL);
 470   for (int j = 0; j < n; j++) {
 471     GraphBuffer[cnt++] = ((int)got[j]) - 128;
 472   }
 473
 474   PrintAndLog("Done!\n");
 475   GraphTraceLen = n;
 476   RepaintGraphWindow();
 477   return 0;
 478 }
 479
 480 int CmdLoad(const char *Cmd)
 481 {
 482   FILE *f = fopen(Cmd, "r");
 483   if (!f) {
 484     PrintAndLog("couldn't open '%s'", Cmd);
 485     return 0;
 486   }
 487
 488   GraphTraceLen = 0;
 489   char line[80];
 490   while (fgets(line, sizeof (line), f)) {
 491     GraphBuffer[GraphTraceLen] = atoi(line);
 492     GraphTraceLen++;
 493   }
 494   fclose(f);
 495   PrintAndLog("loaded %d samples", GraphTraceLen);
 496   RepaintGraphWindow();
 497   return 0;
 498 }
 499
 500 int CmdLtrim(const char *Cmd)
 501 {
 502   int ds = atoi(Cmd);
 503
 504   for (int i = ds; i < GraphTraceLen; ++i)
 505     GraphBuffer[i-ds] = GraphBuffer[i];
 506   GraphTraceLen -= ds;
 507
 508   RepaintGraphWindow();
 509   return 0;
 510 }
 511
 512 /*
 513  * Manchester demodulate a bitstream. The bitstream needs to be already in
 514  * the GraphBuffer as 0 and 1 values
 515  *
 516  * Give the clock rate as argument in order to help the sync - the algorithm
 517  * resyncs at each pulse anyway.
 518  *
 519  * Not optimized by any means, this is the 1st time I'm writing this type of
 520  * routine, feel free to improve...
 521  *
 522  * 1st argument: clock rate (as number of samples per clock rate)
 523  *               Typical values can be 64, 32, 128...
 524  */
 525 int CmdManchesterDemod(const char *Cmd)
 526 {
 527   int i, j, invert= 0;
 528   int bit;
 529   int clock;
 530   int lastval = 0;
 531   int low = 0;
 532   int high = 0;
 533   int hithigh, hitlow, first;
 534   int lc = 0;
 535   int bitidx = 0;
 536   int bit2idx = 0;
 537   int warnings = 0;
 538
 539   /* check if we're inverting output */
 540   if (*Cmd == 'i')
 541   {
 542     PrintAndLog("Inverting output");
 543     invert = 1;
 544     ++Cmd;
 545     do
 546       ++Cmd;
 547     while(*Cmd == ' '); // in case a 2nd argument was given
 548   }
 549
 550   /* Holds the decoded bitstream: each clock period contains 2 bits       */
 551   /* later simplified to 1 bit after manchester decoding.                 */
 552   /* Add 10 bits to allow for noisy / uncertain traces without aborting   */
 553   /* int BitStream[GraphTraceLen*2/clock+10]; */
 554
 555   /* But it does not work if compiling on WIndows: therefore we just allocate a */
 556   /* large array */
 557   uint8_t BitStream[MAX_GRAPH_TRACE_LEN];
 558
 559   /* Detect high and lows */
 560   for (i = 0; i < GraphTraceLen; i++)
 561   {
 562     if (GraphBuffer[i] > high)
 563       high = GraphBuffer[i];
 564     else if (GraphBuffer[i] < low)
 565       low = GraphBuffer[i];
 566   }
 567
 568   /* Get our clock */
 569   clock = GetClock(Cmd, high, 1);
 570
 571   int tolerance = clock/4;
 572
 573   /* Detect first transition */
 574   /* Lo-Hi (arbitrary)       */
 575   /* skip to the first high */
 576   for (i= 0; i < GraphTraceLen; i++)
 577     if (GraphBuffer[i] == high)
 578       break;
 579   /* now look for the first low */
 580   for (; i < GraphTraceLen; i++)
 581   {
 582     if (GraphBuffer[i] == low)
 583     {
 584       lastval = i;
 585       break;
 586     }
 587   }
 588
 589   PrintAndLog("Clock:  %d", clock);
 590
 591   /* If we're not working with 1/0s, demod based off clock */
 592   if (high != 1)
 593   {
 594         PrintAndLog("Entering path A");
 595     bit = 0; /* We assume the 1st bit is zero, it may not be
 596               * the case: this routine (I think) has an init problem.
 597               * Ed.
 598                           */
 599     for (; i < (int)(GraphTraceLen / clock); i++)
 600     {
 601       hithigh = 0;
 602       hitlow = 0;
 603       first = 1;
 604
 605       /* Find out if we hit both high and low peaks */
 606       for (j = 0; j < clock; j++)
 607       {
 608         if (GraphBuffer[(i * clock) + j] == high)
 609           hithigh = 1;
 610         else if (GraphBuffer[(i * clock) + j] == low)
 611           hitlow = 1;
 612
 613         /* it doesn't count if it's the first part of our read
 614            because it's really just trailing from the last sequence */
 615         if (first && (hithigh || hitlow))
 616           hithigh = hitlow = 0;
 617         else
 618           first = 0;
 619
 620         if (hithigh && hitlow)
 621           break;
 622       }
 623
 624       /* If we didn't hit both high and low peaks, we had a bit transition */
 625       if (!hithigh || !hitlow)
 626         bit ^= 1;
 627
 628       BitStream[bit2idx++] = bit ^ invert;
 629     }
 630   }
 631
 632   /* standard 1/0 bitstream */
 633   else
 634   {
 635
 636     /* Then detect duration between 2 successive transitions */
 637     for (bitidx = 1; i < GraphTraceLen; i++)
 638     {
 639       if (GraphBuffer[i-1] != GraphBuffer[i])
 640       {
 641       lc = i-lastval;
 642       lastval = i;
 643
 644       // Error check: if bitidx becomes too large, we do not
 645       // have a Manchester encoded bitstream or the clock is really
 646       // wrong!
 647       if (bitidx > (GraphTraceLen*2/clock+8) ) {
 648         PrintAndLog("Error: the clock you gave is probably wrong, aborting.");
 649         return 0;
 650       }
 651       // Then switch depending on lc length:
 652       // Tolerance is 1/4 of clock rate (arbitrary)
 653       if (abs(lc-clock/2) < tolerance) {
 654         // Short pulse : either "1" or "0"
 655         BitStream[bitidx++]=GraphBuffer[i-1];
 656       } else if (abs(lc-clock) < tolerance) {
 657         // Long pulse: either "11" or "00"
 658         BitStream[bitidx++]=GraphBuffer[i-1];
 659         BitStream[bitidx++]=GraphBuffer[i-1];
 660       } else {
 661         // Error
 662           warnings++;
 663         PrintAndLog("Warning: Manchester decode error for pulse width detection.");
 664         PrintAndLog("(too many of those messages mean either the stream is not Manchester encoded, or clock is wrong)");
 665
 666           if (warnings > 10)
 667           {
 668             PrintAndLog("Error: too many detection errors, aborting.");
 669             return 0;
 670           }
 671         }
 672       }
 673     }
 674
 675     // At this stage, we now have a bitstream of "01" ("1") or "10" ("0"), parse it into final decoded bitstream
 676     // Actually, we overwrite BitStream with the new decoded bitstream, we just need to be careful
 677     // to stop output at the final bitidx2 value, not bitidx
 678     for (i = 0; i < bitidx; i += 2) {
 679       if ((BitStream[i] == 0) && (BitStream[i+1] == 1)) {
 680         BitStream[bit2idx++] = 1 ^ invert;
 681     } else if ((BitStream[i] == 1) && (BitStream[i+1] == 0)) {
 682       BitStream[bit2idx++] = 0 ^ invert;
 683     } else {
 684       // We cannot end up in this state, this means we are unsynchronized,
 685       // move up 1 bit:
 686       i++;
 687         warnings++;
 688       PrintAndLog("Unsynchronized, resync...");
 689       PrintAndLog("(too many of those messages mean the stream is not Manchester encoded)");
 690
 691         if (warnings > 10)
 692         {
 693           PrintAndLog("Error: too many decode errors, aborting.");
 694           return 0;
 695         }
 696       }
 697     }
 698   }
 699
 700   PrintAndLog("Manchester decoded bitstream");
 701   // Now output the bitstream to the scrollback by line of 16 bits
 702   for (i = 0; i < (bit2idx-16); i+=16) {
 703     PrintAndLog("%i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i",
 704       BitStream[i],
 705       BitStream[i+1],
 706       BitStream[i+2],
 707       BitStream[i+3],
 708       BitStream[i+4],
 709       BitStream[i+5],
 710       BitStream[i+6],
 711       BitStream[i+7],
 712       BitStream[i+8],
 713       BitStream[i+9],
 714       BitStream[i+10],
 715       BitStream[i+11],
 716       BitStream[i+12],
 717       BitStream[i+13],
 718       BitStream[i+14],
 719       BitStream[i+15]);
 720   }
 721   return 0;
 722 }
 723
 724 /* Modulate our data into manchester */
 725 int CmdManchesterMod(const char *Cmd)
 726 {
 727   int i, j;
 728   int clock;
 729   int bit, lastbit, wave;
 730
 731   /* Get our clock */
 732   clock = GetClock(Cmd, 0, 1);
 733
 734   wave = 0;
 735   lastbit = 1;
 736   for (i = 0; i < (int)(GraphTraceLen / clock); i++)
 737   {
 738     bit = GraphBuffer[i * clock] ^ 1;
 739
 740     for (j = 0; j < (int)(clock/2); j++)
 741       GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave;
 742     for (j = (int)(clock/2); j < clock; j++)
 743       GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave ^ 1;
 744
 745     /* Keep track of how we start our wave and if we changed or not this time */
 746     wave ^= bit ^ lastbit;
 747     lastbit = bit;
 748   }
 749
 750   RepaintGraphWindow();
 751   return 0;
 752 }
 753
 754 int CmdNorm(const char *Cmd)
 755 {
 756   int i;
 757   int max = INT_MIN, min = INT_MAX;
 758
 759   for (i = 10; i < GraphTraceLen; ++i) {
 760     if (GraphBuffer[i] > max)
 761       max = GraphBuffer[i];
 762     if (GraphBuffer[i] < min)
 763       min = GraphBuffer[i];
 764   }
 765
 766   if (max != min) {
 767     for (i = 0; i < GraphTraceLen; ++i) {
 768       GraphBuffer[i] = (GraphBuffer[i] - ((max + min) / 2)) * 1000 /
 769         (max - min);
 770     }
 771   }
 772   RepaintGraphWindow();
 773   return 0;
 774 }
 775
 776 int CmdPlot(const char *Cmd)
 777 {
 778   ShowGraphWindow();
 779   return 0;
 780 }
 781
 782 int CmdSave(const char *Cmd)
 783 {
 784   FILE *f = fopen(Cmd, "w");
 785   if(!f) {
 786     PrintAndLog("couldn't open '%s'", Cmd);
 787     return 0;
 788   }
 789   int i;
 790   for (i = 0; i < GraphTraceLen; i++) {
 791     fprintf(f, "%d\n", GraphBuffer[i]);
 792   }
 793   fclose(f);
 794   PrintAndLog("saved to '%s'", Cmd);
 795   return 0;
 796 }
 797
 798 int CmdScale(const char *Cmd)
 799 {
 800   CursorScaleFactor = atoi(Cmd);
 801   if (CursorScaleFactor == 0) {
 802     PrintAndLog("bad, can't have zero scale");
 803     CursorScaleFactor = 1;
 804   }
 805   RepaintGraphWindow();
 806   return 0;
 807 }
 808
 809 int CmdThreshold(const char *Cmd)
 810 {
 811   int threshold = atoi(Cmd);
 812
 813   for (int i = 0; i < GraphTraceLen; ++i) {
 814     if (GraphBuffer[i] >= threshold)
 815       GraphBuffer[i] = 1;
 816     else
 817       GraphBuffer[i] = -1;
 818   }
 819   RepaintGraphWindow();
 820   return 0;
 821 }
 822
 823 int CmdDirectionalThreshold(const char *Cmd)
 824 {
 825         int8_t upThres = param_get8(Cmd, 0);
 826         int8_t downThres = param_get8(Cmd, 1);
 827
 828   printf("Applying Up Threshold: %d, Down Threshold: %d\n", upThres, downThres);
 829
 830   int lastValue = GraphBuffer[0];
 831   GraphBuffer[0] = 0; // Will be changed at the end, but init 0 as we adjust to last samples value if no threshold kicks in.
 832
 833   for (int i = 1; i < GraphTraceLen; ++i) {
 834     // Apply first threshold to samples heading up
 835     if (GraphBuffer[i] >= upThres && GraphBuffer[i] > lastValue)
 836     {
 837       lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
 838       GraphBuffer[i] = 1;
 839     }
 840     // Apply second threshold to samples heading down
 841     else if (GraphBuffer[i] <= downThres && GraphBuffer[i] < lastValue)
 842     {
 843       lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
 844       GraphBuffer[i] = -1;
 845     }
 846     else
 847     {
 848       lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
 849       GraphBuffer[i] = GraphBuffer[i-1];
 850
 851     }
 852   }
 853   GraphBuffer[0] = GraphBuffer[1]; // Aline with first edited sample.
 854   RepaintGraphWindow();
 855   return 0;
 856 }
 857
 858 int CmdZerocrossings(const char *Cmd)
 859 {
 860   // Zero-crossings aren't meaningful unless the signal is zero-mean.
 861   CmdHpf("");
 862
 863   int sign = 1;
 864   int zc = 0;
 865   int lastZc = 0;
 866
 867   for (int i = 0; i < GraphTraceLen; ++i) {
 868     if (GraphBuffer[i] * sign >= 0) {
 869       // No change in sign, reproduce the previous sample count.
 870       zc++;
 871       GraphBuffer[i] = lastZc;
 872     } else {
 873       // Change in sign, reset the sample count.
 874       sign = -sign;
 875       GraphBuffer[i] = lastZc;
 876       if (sign > 0) {
 877         lastZc = zc;
 878         zc = 0;
 879       }
 880     }
 881   }
 882
 883   RepaintGraphWindow();
 884   return 0;
 885 }
 886
 887 static command_t CommandTable[] =
 888 {
 889   {"help",          CmdHelp,            1, "This help"},
 890   {"amp",           CmdAmp,             1, "Amplify peaks"},
 891   {"askdemod",      Cmdaskdemod,        1, "<0 or 1> -- Attempt to demodulate simple ASK tags"},
 892   {"autocorr",      CmdAutoCorr,        1, "<window length> -- Autocorrelation over window"},
 893   {"bitsamples",    CmdBitsamples,      0, "Get raw samples as bitstring"},
 894   {"bitstream",     CmdBitstream,       1, "[clock rate] -- Convert waveform into a bitstream"},
 895   {"buffclear",     CmdBuffClear,       1, "Clear sample buffer and graph window"},
 896   {"dec",           CmdDec,             1, "Decimate samples"},
 897   {"detectclock",   CmdDetectClockRate, 1, "Detect clock rate"},
 898   {"fskdemod",      CmdFSKdemod,        1, "Demodulate graph window as a HID FSK"},
 899   {"grid",          CmdGrid,            1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},
 900   {"hexsamples",    CmdHexsamples,      0, "<bytes> [<offset>] -- Dump big buffer as hex bytes"},
 901   {"hide",          CmdHide,            1, "Hide graph window"},
 902   {"hpf",           CmdHpf,             1, "Remove DC offset from trace"},
 903   {"load",          CmdLoad,            1, "<filename> -- Load trace (to graph window"},
 904   {"ltrim",         CmdLtrim,           1, "<samples> -- Trim samples from left of trace"},
 905   {"mandemod",      CmdManchesterDemod, 1, "[i] [clock rate] -- Manchester demodulate binary stream (option 'i' to invert output)"},
 906   {"manmod",        CmdManchesterMod,   1, "[clock rate] -- Manchester modulate a binary stream"},
 907   {"norm",          CmdNorm,            1, "Normalize max/min to +/-500"},
 908   {"plot",          CmdPlot,            1, "Show graph window (hit 'h' in window for keystroke help)"},
 909   {"samples",       CmdSamples,         0, "[512 - 40000] -- Get raw samples for graph window"},
 910   {"save",          CmdSave,            1, "<filename> -- Save trace (from graph window)"},
 911   {"scale",         CmdScale,           1, "<int> -- Set cursor display scale"},
 912   {"threshold",     CmdThreshold,       1, "<threshold> -- Maximize/minimize every value in the graph window depending on threshold"},
 913   {"zerocrossings", CmdZerocrossings,   1, "Count time between zero-crossings"},
 914   {"dirthreshold",  CmdDirectionalThreshold,   1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
 915   {NULL, NULL, 0, NULL}
 916 };
 917
 918 int CmdData(const char *Cmd)
 919 {
 920   CmdsParse(CommandTable, Cmd);
 921   return 0;
 922 }
 923
 924 int CmdHelp(const char *Cmd)
 925 {
 926   CmdsHelp(CommandTable);
 927   return 0;
 928 }