]> git.zerfleddert.de Git - proxmark3-svn/blame - client/cmddata.c
Called the OnSuccess() method for whatever reason that's there.
[proxmark3-svn] / client / cmddata.c
CommitLineData
a553f267 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
7fe9b0b7 11#include <stdio.h>
12#include <stdlib.h>
13#include <string.h>
14#include <limits.h>
902cb3c0 15#include "proxmark3.h"
7fe9b0b7 16#include "data.h"
17#include "ui.h"
18#include "graph.h"
19#include "cmdparser.h"
d51b2eda 20#include "util.h"
7fe9b0b7 21#include "cmdmain.h"
22#include "cmddata.h"
23
24static int CmdHelp(const char *Cmd);
25
26int 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 */
72int Cmdaskdemod(const char *Cmd)
73{
74 int i;
75 int c, high = 0, low = 0;
76
7fe9b0b7 77 sscanf(Cmd, "%i", &c);
78
f6c18637 79 if (c != 0 && c != 1) {
80 PrintAndLog("Invalid argument: %s", Cmd);
81 return 0;
82 }
83
84 /* Detect high and lows */
7fe9b0b7 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 }
f6c18637 92
7fe9b0b7 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
120int 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
152int CmdBitsamples(const char *Cmd)
153{
154 int cnt = 0;
90d74dc2 155 uint8_t got[12288];
156
157 GetFromBigBuf(got,sizeof(got),0);
158 WaitForResponse(CMD_ACK,NULL);
7fe9b0b7 159
90d74dc2 160 for (int j = 0; j < sizeof(got); j++) {
7fe9b0b7 161 for (int k = 0; k < 8; k++) {
90d74dc2 162 if(got[j] & (1 << (7 - k))) {
7fe9b0b7 163 GraphBuffer[cnt++] = 1;
164 } else {
165 GraphBuffer[cnt++] = 0;
166 }
167 }
7fe9b0b7 168 }
169 GraphTraceLen = cnt;
170 RepaintGraphWindow();
171 return 0;
172}
173
174/*
175 * Convert to a bitstream
176 */
177int 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
239int CmdBuffClear(const char *Cmd)
240{
241 UsbCommand c = {CMD_BUFF_CLEAR};
242 SendCommand(&c);
243 ClearGraph(true);
244 return 0;
245}
246
247int 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 */
258int CmdDetectClockRate(const char *Cmd)
259{
260 int clock = DetectClock(0);
261 PrintAndLog("Auto-detected clock rate: %d", clock);
262 return 0;
263}
264
265int 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
384int CmdGrid(const char *Cmd)
385{
386 sscanf(Cmd, "%i %i", &PlotGridX, &PlotGridY);
7ddb9900 387 PlotGridXdefault= PlotGridX;
388 PlotGridYdefault= PlotGridY;
7fe9b0b7 389 RepaintGraphWindow();
390 return 0;
391}
392
393int CmdHexsamples(const char *Cmd)
394{
4961e292 395 int i, j;
7fe9b0b7 396 int requested = 0;
397 int offset = 0;
4961e292 398 char string_buf[25];
399 char* string_ptr = string_buf;
90d74dc2 400 uint8_t got[40000];
4961e292 401
402 sscanf(Cmd, "%i %i", &requested, &offset);
90d74dc2 403
4961e292 404 /* if no args send something */
405 if (requested == 0) {
90d74dc2 406 requested = 8;
407 }
90d74dc2 408 if (offset + requested > sizeof(got)) {
409 PrintAndLog("Tried to read past end of buffer, <bytes> + <offset> > 40000");
4961e292 410 return 0;
411 }
90d74dc2 412
4961e292 413 GetFromBigBuf(got,requested,offset);
90d74dc2 414 WaitForResponse(CMD_ACK,NULL);
415
4961e292 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 }
7fe9b0b7 432 }
433 return 0;
434}
435
7fe9b0b7 436int CmdHide(const char *Cmd)
437{
438 HideGraphWindow();
439 return 0;
440}
441
442int 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
8d183c53 457int CmdSamples(const char *Cmd)
7fe9b0b7 458{
081151ea 459 uint8_t got[36440] = {0x00};
460
461 int n = strtol(Cmd, NULL, 0);
462 if (n == 0)
463 n = 512;
464 if (n > sizeof(got))
465 n = sizeof(got);
a2847518 466
081151ea 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[j] = ((int)got[j]) - 128;
472 }
473 GraphTraceLen = n;
474 RepaintGraphWindow();
475 return 0;
7fe9b0b7 476}
477
478int CmdLoad(const char *Cmd)
479{
c6f1fb9d 480 FILE *f = fopen(Cmd, "r");
7fe9b0b7 481 if (!f) {
c6f1fb9d 482 PrintAndLog("couldn't open '%s'", Cmd);
7fe9b0b7 483 return 0;
484 }
485
486 GraphTraceLen = 0;
487 char line[80];
488 while (fgets(line, sizeof (line), f)) {
489 GraphBuffer[GraphTraceLen] = atoi(line);
490 GraphTraceLen++;
491 }
492 fclose(f);
493 PrintAndLog("loaded %d samples", GraphTraceLen);
494 RepaintGraphWindow();
495 return 0;
496}
497
498int CmdLtrim(const char *Cmd)
499{
500 int ds = atoi(Cmd);
501
502 for (int i = ds; i < GraphTraceLen; ++i)
503 GraphBuffer[i-ds] = GraphBuffer[i];
504 GraphTraceLen -= ds;
505
506 RepaintGraphWindow();
507 return 0;
508}
509
510/*
511 * Manchester demodulate a bitstream. The bitstream needs to be already in
512 * the GraphBuffer as 0 and 1 values
513 *
514 * Give the clock rate as argument in order to help the sync - the algorithm
515 * resyncs at each pulse anyway.
516 *
517 * Not optimized by any means, this is the 1st time I'm writing this type of
518 * routine, feel free to improve...
519 *
520 * 1st argument: clock rate (as number of samples per clock rate)
521 * Typical values can be 64, 32, 128...
522 */
523int CmdManchesterDemod(const char *Cmd)
524{
525 int i, j, invert= 0;
526 int bit;
527 int clock;
fddf220a 528 int lastval = 0;
7fe9b0b7 529 int low = 0;
530 int high = 0;
531 int hithigh, hitlow, first;
532 int lc = 0;
533 int bitidx = 0;
534 int bit2idx = 0;
535 int warnings = 0;
536
537 /* check if we're inverting output */
c6f1fb9d 538 if (*Cmd == 'i')
7fe9b0b7 539 {
540 PrintAndLog("Inverting output");
541 invert = 1;
fffad860 542 ++Cmd;
7fe9b0b7 543 do
544 ++Cmd;
545 while(*Cmd == ' '); // in case a 2nd argument was given
546 }
547
548 /* Holds the decoded bitstream: each clock period contains 2 bits */
549 /* later simplified to 1 bit after manchester decoding. */
550 /* Add 10 bits to allow for noisy / uncertain traces without aborting */
551 /* int BitStream[GraphTraceLen*2/clock+10]; */
552
553 /* But it does not work if compiling on WIndows: therefore we just allocate a */
554 /* large array */
a61b4976 555 uint8_t BitStream[MAX_GRAPH_TRACE_LEN] = {0x00};
7fe9b0b7 556
557 /* Detect high and lows */
558 for (i = 0; i < GraphTraceLen; i++)
559 {
560 if (GraphBuffer[i] > high)
561 high = GraphBuffer[i];
562 else if (GraphBuffer[i] < low)
563 low = GraphBuffer[i];
564 }
565
566 /* Get our clock */
a61b4976 567 clock = GetClock(Cmd, high, 1);
7fe9b0b7 568 int tolerance = clock/4;
569
570 /* Detect first transition */
571 /* Lo-Hi (arbitrary) */
572 /* skip to the first high */
573 for (i= 0; i < GraphTraceLen; i++)
574 if (GraphBuffer[i] == high)
575 break;
576 /* now look for the first low */
577 for (; i < GraphTraceLen; i++)
578 {
579 if (GraphBuffer[i] == low)
580 {
581 lastval = i;
582 break;
583 }
584 }
b44e5233 585
7fe9b0b7 586 /* If we're not working with 1/0s, demod based off clock */
587 if (high != 1)
588 {
b44e5233 589 PrintAndLog("Entering path A");
7fe9b0b7 590 bit = 0; /* We assume the 1st bit is zero, it may not be
591 * the case: this routine (I think) has an init problem.
592 * Ed.
b44e5233 593 */
7fe9b0b7 594 for (; i < (int)(GraphTraceLen / clock); i++)
595 {
596 hithigh = 0;
597 hitlow = 0;
598 first = 1;
599
600 /* Find out if we hit both high and low peaks */
601 for (j = 0; j < clock; j++)
602 {
603 if (GraphBuffer[(i * clock) + j] == high)
604 hithigh = 1;
605 else if (GraphBuffer[(i * clock) + j] == low)
606 hitlow = 1;
607
608 /* it doesn't count if it's the first part of our read
609 because it's really just trailing from the last sequence */
610 if (first && (hithigh || hitlow))
611 hithigh = hitlow = 0;
612 else
613 first = 0;
614
615 if (hithigh && hitlow)
616 break;
617 }
618
619 /* If we didn't hit both high and low peaks, we had a bit transition */
620 if (!hithigh || !hitlow)
621 bit ^= 1;
622
623 BitStream[bit2idx++] = bit ^ invert;
624 }
625 }
626
627 /* standard 1/0 bitstream */
628 else
629 {
630
631 /* Then detect duration between 2 successive transitions */
632 for (bitidx = 1; i < GraphTraceLen; i++)
633 {
634 if (GraphBuffer[i-1] != GraphBuffer[i])
635 {
636 lc = i-lastval;
637 lastval = i;
638
639 // Error check: if bitidx becomes too large, we do not
640 // have a Manchester encoded bitstream or the clock is really
641 // wrong!
642 if (bitidx > (GraphTraceLen*2/clock+8) ) {
643 PrintAndLog("Error: the clock you gave is probably wrong, aborting.");
644 return 0;
645 }
646 // Then switch depending on lc length:
647 // Tolerance is 1/4 of clock rate (arbitrary)
648 if (abs(lc-clock/2) < tolerance) {
649 // Short pulse : either "1" or "0"
650 BitStream[bitidx++]=GraphBuffer[i-1];
651 } else if (abs(lc-clock) < tolerance) {
652 // Long pulse: either "11" or "00"
653 BitStream[bitidx++]=GraphBuffer[i-1];
654 BitStream[bitidx++]=GraphBuffer[i-1];
655 } else {
656 // Error
657 warnings++;
658 PrintAndLog("Warning: Manchester decode error for pulse width detection.");
659 PrintAndLog("(too many of those messages mean either the stream is not Manchester encoded, or clock is wrong)");
660
661 if (warnings > 10)
662 {
663 PrintAndLog("Error: too many detection errors, aborting.");
664 return 0;
665 }
666 }
667 }
668 }
669
670 // At this stage, we now have a bitstream of "01" ("1") or "10" ("0"), parse it into final decoded bitstream
671 // Actually, we overwrite BitStream with the new decoded bitstream, we just need to be careful
672 // to stop output at the final bitidx2 value, not bitidx
673 for (i = 0; i < bitidx; i += 2) {
674 if ((BitStream[i] == 0) && (BitStream[i+1] == 1)) {
675 BitStream[bit2idx++] = 1 ^ invert;
676 } else if ((BitStream[i] == 1) && (BitStream[i+1] == 0)) {
677 BitStream[bit2idx++] = 0 ^ invert;
678 } else {
679 // We cannot end up in this state, this means we are unsynchronized,
680 // move up 1 bit:
681 i++;
081151ea 682 warnings++;
7fe9b0b7 683 PrintAndLog("Unsynchronized, resync...");
684 PrintAndLog("(too many of those messages mean the stream is not Manchester encoded)");
685
686 if (warnings > 10)
687 {
688 PrintAndLog("Error: too many decode errors, aborting.");
689 return 0;
690 }
691 }
692 }
693 }
694
695 PrintAndLog("Manchester decoded bitstream");
696 // Now output the bitstream to the scrollback by line of 16 bits
697 for (i = 0; i < (bit2idx-16); i+=16) {
698 PrintAndLog("%i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i",
699 BitStream[i],
700 BitStream[i+1],
701 BitStream[i+2],
702 BitStream[i+3],
703 BitStream[i+4],
704 BitStream[i+5],
705 BitStream[i+6],
706 BitStream[i+7],
707 BitStream[i+8],
708 BitStream[i+9],
709 BitStream[i+10],
710 BitStream[i+11],
711 BitStream[i+12],
712 BitStream[i+13],
713 BitStream[i+14],
714 BitStream[i+15]);
715 }
716 return 0;
717}
718
719/* Modulate our data into manchester */
720int CmdManchesterMod(const char *Cmd)
721{
722 int i, j;
7fe9b0b7 723 int bit, lastbit, wave;
a61b4976 724 int clock = GetClock(Cmd, 0, 1);
725 int clock1 = GetT55x7Clock( GraphBuffer, GraphTraceLen, 0 );
726 PrintAndLog("MAN MOD CLOCKS: %d ice %d", clock,clock1);
727
728 int half = (int)(clock/2);
729
7fe9b0b7 730 wave = 0;
731 lastbit = 1;
732 for (i = 0; i < (int)(GraphTraceLen / clock); i++)
733 {
734 bit = GraphBuffer[i * clock] ^ 1;
735
a61b4976 736 for (j = 0; j < half; ++j)
7fe9b0b7 737 GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave;
a61b4976 738 for (j = half; j < clock; ++j)
7fe9b0b7 739 GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave ^ 1;
740
741 /* Keep track of how we start our wave and if we changed or not this time */
742 wave ^= bit ^ lastbit;
743 lastbit = bit;
744 }
745
746 RepaintGraphWindow();
747 return 0;
748}
749
750int CmdNorm(const char *Cmd)
751{
752 int i;
753 int max = INT_MIN, min = INT_MAX;
754
755 for (i = 10; i < GraphTraceLen; ++i) {
756 if (GraphBuffer[i] > max)
757 max = GraphBuffer[i];
758 if (GraphBuffer[i] < min)
759 min = GraphBuffer[i];
760 }
761
762 if (max != min) {
763 for (i = 0; i < GraphTraceLen; ++i) {
764 GraphBuffer[i] = (GraphBuffer[i] - ((max + min) / 2)) * 1000 /
765 (max - min);
766 }
767 }
768 RepaintGraphWindow();
769 return 0;
770}
771
772int CmdPlot(const char *Cmd)
773{
774 ShowGraphWindow();
775 return 0;
776}
777
778int CmdSave(const char *Cmd)
779{
780 FILE *f = fopen(Cmd, "w");
781 if(!f) {
782 PrintAndLog("couldn't open '%s'", Cmd);
783 return 0;
784 }
785 int i;
786 for (i = 0; i < GraphTraceLen; i++) {
787 fprintf(f, "%d\n", GraphBuffer[i]);
788 }
789 fclose(f);
790 PrintAndLog("saved to '%s'", Cmd);
791 return 0;
792}
793
794int CmdScale(const char *Cmd)
795{
796 CursorScaleFactor = atoi(Cmd);
797 if (CursorScaleFactor == 0) {
798 PrintAndLog("bad, can't have zero scale");
799 CursorScaleFactor = 1;
800 }
801 RepaintGraphWindow();
802 return 0;
803}
804
805int CmdThreshold(const char *Cmd)
806{
807 int threshold = atoi(Cmd);
808
809 for (int i = 0; i < GraphTraceLen; ++i) {
810 if (GraphBuffer[i] >= threshold)
811 GraphBuffer[i] = 1;
812 else
7bb9d33e 813 GraphBuffer[i] = -1;
7fe9b0b7 814 }
815 RepaintGraphWindow();
816 return 0;
817}
818
d51b2eda
MHS
819int CmdDirectionalThreshold(const char *Cmd)
820{
821 int8_t upThres = param_get8(Cmd, 0);
822 int8_t downThres = param_get8(Cmd, 1);
823
824 printf("Applying Up Threshold: %d, Down Threshold: %d\n", upThres, downThres);
825
826 int lastValue = GraphBuffer[0];
827 GraphBuffer[0] = 0; // Will be changed at the end, but init 0 as we adjust to last samples value if no threshold kicks in.
828
829 for (int i = 1; i < GraphTraceLen; ++i) {
830 // Apply first threshold to samples heading up
831 if (GraphBuffer[i] >= upThres && GraphBuffer[i] > lastValue)
832 {
833 lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
834 GraphBuffer[i] = 1;
835 }
836 // Apply second threshold to samples heading down
837 else if (GraphBuffer[i] <= downThres && GraphBuffer[i] < lastValue)
838 {
839 lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
840 GraphBuffer[i] = -1;
841 }
842 else
843 {
844 lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
845 GraphBuffer[i] = GraphBuffer[i-1];
846
847 }
848 }
849 GraphBuffer[0] = GraphBuffer[1]; // Aline with first edited sample.
850 RepaintGraphWindow();
851 return 0;
852}
853
7fe9b0b7 854int CmdZerocrossings(const char *Cmd)
855{
856 // Zero-crossings aren't meaningful unless the signal is zero-mean.
857 CmdHpf("");
858
859 int sign = 1;
860 int zc = 0;
861 int lastZc = 0;
862
863 for (int i = 0; i < GraphTraceLen; ++i) {
864 if (GraphBuffer[i] * sign >= 0) {
865 // No change in sign, reproduce the previous sample count.
866 zc++;
867 GraphBuffer[i] = lastZc;
868 } else {
869 // Change in sign, reset the sample count.
870 sign = -sign;
871 GraphBuffer[i] = lastZc;
872 if (sign > 0) {
873 lastZc = zc;
874 zc = 0;
875 }
876 }
877 }
878
879 RepaintGraphWindow();
880 return 0;
881}
882
883static command_t CommandTable[] =
884{
885 {"help", CmdHelp, 1, "This help"},
886 {"amp", CmdAmp, 1, "Amplify peaks"},
57c69556 887 {"askdemod", Cmdaskdemod, 1, "<0 or 1> -- Attempt to demodulate simple ASK tags"},
7fe9b0b7 888 {"autocorr", CmdAutoCorr, 1, "<window length> -- Autocorrelation over window"},
889 {"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"},
890 {"bitstream", CmdBitstream, 1, "[clock rate] -- Convert waveform into a bitstream"},
891 {"buffclear", CmdBuffClear, 1, "Clear sample buffer and graph window"},
892 {"dec", CmdDec, 1, "Decimate samples"},
893 {"detectclock", CmdDetectClockRate, 1, "Detect clock rate"},
894 {"fskdemod", CmdFSKdemod, 1, "Demodulate graph window as a HID FSK"},
895 {"grid", CmdGrid, 1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},
90d74dc2 896 {"hexsamples", CmdHexsamples, 0, "<bytes> [<offset>] -- Dump big buffer as hex bytes"},
7fe9b0b7 897 {"hide", CmdHide, 1, "Hide graph window"},
898 {"hpf", CmdHpf, 1, "Remove DC offset from trace"},
7fe9b0b7 899 {"load", CmdLoad, 1, "<filename> -- Load trace (to graph window"},
900 {"ltrim", CmdLtrim, 1, "<samples> -- Trim samples from left of trace"},
901 {"mandemod", CmdManchesterDemod, 1, "[i] [clock rate] -- Manchester demodulate binary stream (option 'i' to invert output)"},
902 {"manmod", CmdManchesterMod, 1, "[clock rate] -- Manchester modulate a binary stream"},
903 {"norm", CmdNorm, 1, "Normalize max/min to +/-500"},
7ddb9900 904 {"plot", CmdPlot, 1, "Show graph window (hit 'h' in window for keystroke help)"},
90d74dc2 905 {"samples", CmdSamples, 0, "[512 - 40000] -- Get raw samples for graph window"},
7fe9b0b7 906 {"save", CmdSave, 1, "<filename> -- Save trace (from graph window)"},
907 {"scale", CmdScale, 1, "<int> -- Set cursor display scale"},
dbf444a1 908 {"threshold", CmdThreshold, 1, "<threshold> -- Maximize/minimize every value in the graph window depending on threshold"},
7fe9b0b7 909 {"zerocrossings", CmdZerocrossings, 1, "Count time between zero-crossings"},
d51b2eda 910 {"dirthreshold", CmdDirectionalThreshold, 1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
7fe9b0b7 911 {NULL, NULL, 0, NULL}
912};
913
914int CmdData(const char *Cmd)
915{
916 CmdsParse(CommandTable, Cmd);
917 return 0;
918}
919
920int CmdHelp(const char *Cmd)
921{
922 CmdsHelp(CommandTable);
923 return 0;
924}
Impressum, Datenschutz