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