]> cvs.zerfleddert.de Git - proxmark3-svn/blob - client/cmddata.c
0a8bcd7a90c5b2ef992f8b9a22f2020cff1f476b
[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 #include "lfdemod.h"
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 //this method is dependant on all highs and lows to be the same(or clipped) this creates issues[marshmellow] it also ignores the clock
74 int Cmdaskdemod(const char *Cmd)
75 {
76 int i;
77 int c, high = 0, low = 0;
78
79 // TODO: complain if we do not give 2 arguments here !
80 // (AL - this doesn't make sense! we're only using one argument!!!)
81 sscanf(Cmd, "%i", &c);
82
83 /* Detect high and lows and clock */
84 // (AL - clock???)
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 high=abs(high*.75);
93 low=abs(low*.75);
94 if (c != 0 && c != 1) {
95 PrintAndLog("Invalid argument: %s", Cmd);
96 return 0;
97 }
98 //prime loop
99 if (GraphBuffer[0] > 0) {
100 GraphBuffer[0] = 1-c;
101 } else {
102 GraphBuffer[0] = c;
103 }
104 for (i = 1; i < GraphTraceLen; ++i) {
105 /* Transitions are detected at each peak
106 * Transitions are either:
107 * - we're low: transition if we hit a high
108 * - we're high: transition if we hit a low
109 * (we need to do it this way because some tags keep high or
110 * low for long periods, others just reach the peak and go
111 * down)
112 */
113 //[marhsmellow] change == to >= for high and <= for low for fuzz
114 if ((GraphBuffer[i] == high) && (GraphBuffer[i - 1] == c)) {
115 GraphBuffer[i] = 1 - c;
116 } else if ((GraphBuffer[i] == low) && (GraphBuffer[i - 1] == (1 - c))){
117 GraphBuffer[i] = c;
118 } else {
119 /* No transition */
120 GraphBuffer[i] = GraphBuffer[i - 1];
121 }
122 }
123 RepaintGraphWindow();
124 return 0;
125 }
126
127 //by marshmellow
128 void printBitStream(uint8_t BitStream[], uint32_t bitLen)
129 {
130 uint32_t i = 0;
131 if (bitLen<16) {
132 PrintAndLog("Too few bits found: %d",bitLen);
133 return;
134 }
135 if (bitLen>512) bitLen=512;
136 for (i = 0; i <= (bitLen-16); i+=16) {
137 PrintAndLog("%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i",
138 BitStream[i],
139 BitStream[i+1],
140 BitStream[i+2],
141 BitStream[i+3],
142 BitStream[i+4],
143 BitStream[i+5],
144 BitStream[i+6],
145 BitStream[i+7],
146 BitStream[i+8],
147 BitStream[i+9],
148 BitStream[i+10],
149 BitStream[i+11],
150 BitStream[i+12],
151 BitStream[i+13],
152 BitStream[i+14],
153 BitStream[i+15]);
154 }
155 return;
156 }
157 //by marshmellow
158 void printEM410x(uint64_t id)
159 {
160 if (id !=0){
161 uint64_t iii=1;
162 uint64_t id2lo=0; //id2hi=0,
163 uint32_t ii=0;
164 uint32_t i=0;
165 for (ii=5; ii>0;ii--){
166 for (i=0;i<8;i++){
167 id2lo=(id2lo<<1LL)|((id & (iii<<(i+((ii-1)*8))))>>(i+((ii-1)*8)));
168 }
169 }
170 //output em id
171 PrintAndLog("EM TAG ID : %010llx", id);
172 PrintAndLog("Unique TAG ID: %010llx", id2lo); //id2hi,
173 PrintAndLog("DEZ 8 : %08lld",id & 0xFFFFFF);
174 PrintAndLog("DEZ 10 : %010lld",id & 0xFFFFFF);
175 PrintAndLog("DEZ 5.5 : %05lld.%05lld",(id>>16LL) & 0xFFFF,(id & 0xFFFF));
176 PrintAndLog("DEZ 3.5A : %03lld.%05lld",(id>>32ll),(id & 0xFFFF));
177 PrintAndLog("DEZ 14/IK2 : %014lld",id);
178 PrintAndLog("DEZ 15/IK3 : %015lld",id2lo);
179 PrintAndLog("Other : %05lld_%03lld_%08lld",(id&0xFFFF),((id>>16LL) & 0xFF),(id & 0xFFFFFF));
180 }
181 return;
182 }
183
184 //by marshmellow
185 int CmdEm410xDecode(const char *Cmd)
186 {
187 uint64_t id=0;
188 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
189 uint32_t i=0;
190 i=getFromGraphBuf(BitStream);
191 id = Em410xDecode(BitStream,i);
192 printEM410x(id);
193 if (id>0) return 1;
194 return 0;
195 }
196
197 //by marshmellow
198 //takes 2 arguments - clock and invert both as integers
199 //attempts to demodulate ask while decoding manchester
200 //prints binary found and saves in graphbuffer for further commands
201 int Cmdaskmandemod(const char *Cmd)
202 {
203 int invert=0;
204 int clk=0;
205 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
206 sscanf(Cmd, "%i %i", &clk, &invert);
207 if (invert != 0 && invert != 1) {
208 PrintAndLog("Invalid argument: %s", Cmd);
209 return 0;
210 }
211 uint32_t BitLen = getFromGraphBuf(BitStream);
212
213 int errCnt=0;
214 errCnt = askmandemod(BitStream, &BitLen,&clk,&invert);
215 if (errCnt==-1){ //if fatal error (or -1)
216 //PrintAndLog("no data found");
217 return 0;
218 }
219 PrintAndLog("Using Clock: %d and invert=%d",clk,invert);
220 //no longer put BitStream back into GraphBuffer...
221 //PrintAndLog("Data start pos:%d, lastBit:%d, stop pos:%d, numBits:%d",iii,lastBit,i,bitnum);
222 //move BitStream back to GraphBuffer
223 /*
224 ClearGraph(0);
225 for (i=0; i < bitnum; ++i){
226 GraphBuffer[i]=BitStream[i];
227 }
228 GraphTraceLen=bitnum;
229 RepaintGraphWindow();
230 */
231 //output
232 if (errCnt>0){
233 PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
234 }
235 PrintAndLog("ASK/Manchester decoded bitstream:");
236 // Now output the bitstream to the scrollback by line of 16 bits
237 printBitStream(BitStream,BitLen);
238 uint64_t lo =0;
239 lo = Em410xDecode(BitStream,BitLen);
240 if (lo>0){
241 //set GraphBuffer for clone or sim command
242 setGraphBuf(BitStream,BitLen);
243 PrintAndLog("EM410x pattern found: ");
244 printEM410x(lo);
245 }
246 if (BitLen>16) return 1;
247 return 0;
248 }
249
250 //by marshmellow
251 //manchester decode
252 //stricktly take 10 and 01 and convert to 0 and 1
253 int Cmdmandecoderaw(const char *Cmd)
254 {
255 int i =0;
256 int errCnt=0;
257 int bitnum=0;
258 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
259 int high=0,low=0;
260 for (;i<GraphTraceLen;++i){
261 if (GraphBuffer[i]>high) high=GraphBuffer[i];
262 else if(GraphBuffer[i]<low) low=GraphBuffer[i];
263 BitStream[i]=GraphBuffer[i];
264 }
265 if (high>1 || low <0 ){
266 PrintAndLog("Error: please raw demod the wave first then mancheseter raw decode");
267 return 0;
268 }
269 bitnum=i;
270 errCnt=manrawdecode(BitStream,&bitnum);
271 if (errCnt>=20){
272 PrintAndLog("Too many errors: %d",errCnt);
273 return 0;
274 }
275 PrintAndLog("Manchester Decoded - # errors:%d - data:",errCnt);
276 printBitStream(BitStream,bitnum);
277 if (errCnt==0){
278 //put back in graphbuffer
279 ClearGraph(0);
280 for (i=0; i<bitnum;++i){
281 GraphBuffer[i]=BitStream[i];
282 }
283 GraphTraceLen=bitnum;
284 RepaintGraphWindow();
285 uint64_t id = 0;
286 id = Em410xDecode(BitStream,i);
287 printEM410x(id);
288 }
289 return 1;
290 }
291
292 //by marshmellow
293 //biphase decode
294 //take 01 or 10 = 0 and 11 or 00 = 1
295 //takes 1 argument "offset" default = 0 if 1 it will shift the decode by one bit
296 // since it is not like manchester and doesn't have an incorrect bit pattern we
297 // cannot determine if our decode is correct or if it should be shifted by one bit
298 // the argument offset allows us to manually shift if the output is incorrect
299 // (better would be to demod and decode at the same time so we can distinguish large
300 // width waves vs small width waves to help the decode positioning) or askbiphdemod
301 int CmdBiphaseDecodeRaw(const char *Cmd)
302 {
303 int i = 0;
304 int errCnt=0;
305 int bitnum=0;
306 int offset=0;
307 int high=0, low=0;
308 sscanf(Cmd, "%i", &offset);
309 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
310 //get graphbuffer & high and low
311 for (;i<GraphTraceLen;++i){
312 if(GraphBuffer[i]>high)high=GraphBuffer[i];
313 else if(GraphBuffer[i]<low)low=GraphBuffer[i];
314 BitStream[i]=GraphBuffer[i];
315 }
316 if (high>1 || low <0){
317 PrintAndLog("Error: please raw demod the wave first then decode");
318 return 0;
319 }
320 bitnum=i;
321 errCnt=BiphaseRawDecode(BitStream,&bitnum, offset);
322 if (errCnt>=20){
323 PrintAndLog("Too many errors attempting to decode: %d",errCnt);
324 return 0;
325 }
326 PrintAndLog("Biphase Decoded using offset: %d - # errors:%d - data:",offset,errCnt);
327 printBitStream(BitStream,bitnum);
328 PrintAndLog("\nif bitstream does not look right try offset=1");
329 return 1;
330 }
331
332
333 //by marshmellow
334 //takes 2 arguments - clock and invert both as integers
335 //attempts to demodulate ask only
336 //prints binary found and saves in graphbuffer for further commands
337 int Cmdaskrawdemod(const char *Cmd)
338 {
339 uint32_t i;
340 int invert=0;
341 int clk=0;
342 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
343 sscanf(Cmd, "%i %i", &clk, &invert);
344 if (invert != 0 && invert != 1) {
345 PrintAndLog("Invalid argument: %s", Cmd);
346 return 0;
347 }
348 int BitLen = getFromGraphBuf(BitStream);
349 int errCnt=0;
350 errCnt = askrawdemod(BitStream, &BitLen,&clk,&invert);
351 if (errCnt==-1){ //throw away static - allow 1 and -1 (in case of threshold command first)
352 PrintAndLog("no data found");
353 return 0;
354 }
355 PrintAndLog("Using Clock: %d and invert=%d",clk,invert);
356 //PrintAndLog("Data start pos:%d, lastBit:%d, stop pos:%d, numBits:%d",iii,lastBit,i,bitnum);
357 //move BitStream back to GraphBuffer
358
359 ClearGraph(0);
360 for (i=0; i < BitLen; ++i){
361 GraphBuffer[i]=BitStream[i];
362 }
363 GraphTraceLen=BitLen;
364 RepaintGraphWindow();
365
366 //output
367 if (errCnt>0){
368 PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
369 }
370 PrintAndLog("ASK demoded bitstream:");
371 // Now output the bitstream to the scrollback by line of 16 bits
372 printBitStream(BitStream,BitLen);
373
374 return 0;
375 }
376
377 int CmdAutoCorr(const char *Cmd)
378 {
379 static int CorrelBuffer[MAX_GRAPH_TRACE_LEN];
380
381 int window = atoi(Cmd);
382
383 if (window == 0) {
384 PrintAndLog("needs a window");
385 return 0;
386 }
387 if (window >= GraphTraceLen) {
388 PrintAndLog("window must be smaller than trace (%d samples)",
389 GraphTraceLen);
390 return 0;
391 }
392
393 PrintAndLog("performing %d correlations", GraphTraceLen - window);
394
395 for (int i = 0; i < GraphTraceLen - window; ++i) {
396 int sum = 0;
397 for (int j = 0; j < window; ++j) {
398 sum += (GraphBuffer[j]*GraphBuffer[i + j]) / 256;
399 }
400 CorrelBuffer[i] = sum;
401 }
402 GraphTraceLen = GraphTraceLen - window;
403 memcpy(GraphBuffer, CorrelBuffer, GraphTraceLen * sizeof (int));
404
405 RepaintGraphWindow();
406 return 0;
407 }
408
409 int CmdBitsamples(const char *Cmd)
410 {
411 int cnt = 0;
412 uint8_t got[12288];
413
414 GetFromBigBuf(got,sizeof(got),0);
415 WaitForResponse(CMD_ACK,NULL);
416
417 for (int j = 0; j < sizeof(got); j++) {
418 for (int k = 0; k < 8; k++) {
419 if(got[j] & (1 << (7 - k))) {
420 GraphBuffer[cnt++] = 1;
421 } else {
422 GraphBuffer[cnt++] = 0;
423 }
424 }
425 }
426 GraphTraceLen = cnt;
427 RepaintGraphWindow();
428 return 0;
429 }
430
431 /*
432 * Convert to a bitstream
433 */
434 int CmdBitstream(const char *Cmd)
435 {
436 int i, j;
437 int bit;
438 int gtl;
439 int clock;
440 int low = 0;
441 int high = 0;
442 int hithigh, hitlow, first;
443
444 /* Detect high and lows and clock */
445 for (i = 0; i < GraphTraceLen; ++i)
446 {
447 if (GraphBuffer[i] > high)
448 high = GraphBuffer[i];
449 else if (GraphBuffer[i] < low)
450 low = GraphBuffer[i];
451 }
452
453 /* Get our clock */
454 clock = GetClock(Cmd, high, 1);
455 gtl = ClearGraph(0);
456
457 bit = 0;
458 for (i = 0; i < (int)(gtl / clock); ++i)
459 {
460 hithigh = 0;
461 hitlow = 0;
462 first = 1;
463 /* Find out if we hit both high and low peaks */
464 for (j = 0; j < clock; ++j)
465 {
466 if (GraphBuffer[(i * clock) + j] == high)
467 hithigh = 1;
468 else if (GraphBuffer[(i * clock) + j] == low)
469 hitlow = 1;
470 /* it doesn't count if it's the first part of our read
471 because it's really just trailing from the last sequence */
472 if (first && (hithigh || hitlow))
473 hithigh = hitlow = 0;
474 else
475 first = 0;
476
477 if (hithigh && hitlow)
478 break;
479 }
480
481 /* If we didn't hit both high and low peaks, we had a bit transition */
482 if (!hithigh || !hitlow)
483 bit ^= 1;
484
485 AppendGraph(0, clock, bit);
486 // for (j = 0; j < (int)(clock/2); j++)
487 // GraphBuffer[(i * clock) + j] = bit ^ 1;
488 // for (j = (int)(clock/2); j < clock; j++)
489 // GraphBuffer[(i * clock) + j] = bit;
490 }
491
492 RepaintGraphWindow();
493 return 0;
494 }
495
496 int CmdBuffClear(const char *Cmd)
497 {
498 UsbCommand c = {CMD_BUFF_CLEAR};
499 SendCommand(&c);
500 ClearGraph(true);
501 return 0;
502 }
503
504 int CmdDec(const char *Cmd)
505 {
506 for (int i = 0; i < (GraphTraceLen / 2); ++i)
507 GraphBuffer[i] = GraphBuffer[i * 2];
508 GraphTraceLen /= 2;
509 PrintAndLog("decimated by 2");
510 RepaintGraphWindow();
511 return 0;
512 }
513
514 /* Print our clock rate */
515 // uses data from graphbuffer
516 int CmdDetectClockRate(const char *Cmd)
517 {
518 GetClock("",0,0);
519 //int clock = DetectASKClock(0);
520 //PrintAndLog("Auto-detected clock rate: %d", clock);
521 return 0;
522 }
523
524 //by marshmellow
525 //fsk raw demod and print binary
526 //takes 2 arguments - Clock and invert
527 //defaults: clock = 50, invert=0
528 int CmdFSKrawdemod(const char *Cmd)
529 {
530 //raw fsk demod no manchester decoding no start bit finding just get binary from wave
531 //set defaults
532 uint8_t rfLen = 50;
533 uint8_t invert=0;
534 //set options from parameters entered with the command
535 if (strlen(Cmd)>0 && strlen(Cmd)<=2) {
536 rfLen=param_get8(Cmd, 0); //if rfLen option only is used
537 if (rfLen==1){
538 invert=1; //if invert option only is used
539 rfLen = 50;
540 } else if(rfLen==0) rfLen=50;
541 }
542 if (strlen(Cmd)>2) {
543 rfLen=param_get8(Cmd, 0); //if both options are used
544 invert=param_get8(Cmd,1);
545 }
546 PrintAndLog("Args invert: %d \nClock:%d",invert,rfLen);
547 uint32_t i=0;
548 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
549 uint32_t BitLen = getFromGraphBuf(BitStream);
550 int size = fskdemod(BitStream,BitLen,rfLen,invert);
551 if (size>0){
552 PrintAndLog("FSK decoded bitstream:");
553 ClearGraph(0);
554 for (i=0;i<size;++i){
555 GraphBuffer[i]=BitStream[i];
556 }
557 GraphTraceLen=size;
558 RepaintGraphWindow();
559
560 // Now output the bitstream to the scrollback by line of 16 bits
561 if(size > (8*32)+2) size = (8*32)+2; //only output a max of 8 blocks of 32 bits most tags will have full bit stream inside that sample size
562 printBitStream(BitStream,size);
563 } else{
564 PrintAndLog("no FSK data found");
565 }
566 return 0;
567 }
568
569 //by marshmellow (based on existing demod + holiman's refactor)
570 //HID Prox demod - FSK RF/50 with preamble of 00011101 (then manchester encoded)
571 //print full HID Prox ID and some bit format details if found
572 int CmdFSKdemodHID(const char *Cmd)
573 {
574 //raw fsk demod no manchester decoding no start bit finding just get binary from wave
575 uint32_t hi2=0, hi=0, lo=0;
576
577 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
578 uint32_t BitLen = getFromGraphBuf(BitStream);
579 //get binary from fsk wave
580 size_t size = HIDdemodFSK(BitStream,BitLen,&hi2,&hi,&lo);
581 if (size<0){
582 PrintAndLog("Error demoding fsk");
583 return 0;
584 }
585 if (hi2==0 && hi==0 && lo==0) return 0;
586 if (hi2 != 0){ //extra large HID tags
587 PrintAndLog("TAG ID: %x%08x%08x (%d)",
588 (unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
589 setGraphBuf(BitStream,BitLen);
590 return 1;
591 }
592 else { //standard HID tags <38 bits
593 //Dbprintf("TAG ID: %x%08x (%d)",(unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); //old print cmd
594 uint8_t fmtLen = 0;
595 uint32_t fc = 0;
596 uint32_t cardnum = 0;
597 if (((hi>>5)&1)==1){//if bit 38 is set then < 37 bit format is used
598 uint32_t lo2=0;
599 lo2=(((hi & 15) << 12) | (lo>>20)); //get bits 21-37 to check for format len bit
600 uint8_t idx3 = 1;
601 while(lo2>1){ //find last bit set to 1 (format len bit)
602 lo2=lo2>>1;
603 idx3++;
604 }
605 fmtLen =idx3+19;
606 fc =0;
607 cardnum=0;
608 if(fmtLen==26){
609 cardnum = (lo>>1)&0xFFFF;
610 fc = (lo>>17)&0xFF;
611 }
612 if(fmtLen==37){
613 cardnum = (lo>>1)&0x7FFFF;
614 fc = ((hi&0xF)<<12)|(lo>>20);
615 }
616 if(fmtLen==34){
617 cardnum = (lo>>1)&0xFFFF;
618 fc= ((hi&1)<<15)|(lo>>17);
619 }
620 if(fmtLen==35){
621 cardnum = (lo>>1)&0xFFFFF;
622 fc = ((hi&1)<<11)|(lo>>21);
623 }
624 }
625 else { //if bit 38 is not set then 37 bit format is used
626 fmtLen= 37;
627 fc =0;
628 cardnum=0;
629 if(fmtLen==37){
630 cardnum = (lo>>1)&0x7FFFF;
631 fc = ((hi&0xF)<<12)|(lo>>20);
632 }
633 }
634 PrintAndLog("TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d",
635 (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF,
636 (unsigned int) fmtLen, (unsigned int) fc, (unsigned int) cardnum);
637 setGraphBuf(BitStream,BitLen);
638 return 1;
639 }
640 return 0;
641 }
642
643 //by marshmellow
644 //IO-Prox demod - FSK RF/64 with preamble of 000000001
645 //print ioprox ID and some format details
646 int CmdFSKdemodIO(const char *Cmd)
647 {
648 //raw fsk demod no manchester decoding no start bit finding just get binary from wave
649 //set defaults
650 int idx=0;
651 //something in graphbuffer
652 if (GraphTraceLen < 65) return 0;
653 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
654 uint32_t BitLen = getFromGraphBuf(BitStream);
655 //get binary from fsk wave
656 // PrintAndLog("DEBUG: got buff");
657 idx = IOdemodFSK(BitStream,BitLen);
658 if (idx<0){
659 //PrintAndLog("Error demoding fsk");
660 return 0;
661 }
662 // PrintAndLog("DEBUG: Got IOdemodFSK");
663 if (idx==0){
664 //PrintAndLog("IO Prox Data not found - FSK Data:");
665 //if (BitLen > 92) printBitStream(BitStream,92);
666 return 0;
667 }
668 //Index map
669 //0 10 20 30 40 50 60
670 //| | | | | | |
671 //01234567 8 90123456 7 89012345 6 78901234 5 67890123 4 56789012 3 45678901 23
672 //-----------------------------------------------------------------------------
673 //00000000 0 11110000 1 facility 1 version* 1 code*one 1 code*two 1 ???????? 11
674 //
675 //XSF(version)facility:codeone+codetwo (raw)
676 //Handle the data
677 if (idx+64>BitLen) return 0;
678 PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx], BitStream[idx+1], BitStream[idx+2], BitStream[idx+3], BitStream[idx+4], BitStream[idx+5], BitStream[idx+6], BitStream[idx+7], BitStream[idx+8]);
679 PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx+9], BitStream[idx+10], BitStream[idx+11],BitStream[idx+12],BitStream[idx+13],BitStream[idx+14],BitStream[idx+15],BitStream[idx+16],BitStream[idx+17]);
680 PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx+18], BitStream[idx+19], BitStream[idx+20],BitStream[idx+21],BitStream[idx+22],BitStream[idx+23],BitStream[idx+24],BitStream[idx+25],BitStream[idx+26]);
681 PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx+27], BitStream[idx+28], BitStream[idx+29],BitStream[idx+30],BitStream[idx+31],BitStream[idx+32],BitStream[idx+33],BitStream[idx+34],BitStream[idx+35]);
682 PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx+36], BitStream[idx+37], BitStream[idx+38],BitStream[idx+39],BitStream[idx+40],BitStream[idx+41],BitStream[idx+42],BitStream[idx+43],BitStream[idx+44]);
683 PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx+45], BitStream[idx+46], BitStream[idx+47],BitStream[idx+48],BitStream[idx+49],BitStream[idx+50],BitStream[idx+51],BitStream[idx+52],BitStream[idx+53]);
684 PrintAndLog("%d%d%d%d%d%d%d%d %d%d",BitStream[idx+54],BitStream[idx+55],BitStream[idx+56],BitStream[idx+57],BitStream[idx+58],BitStream[idx+59],BitStream[idx+60],BitStream[idx+61],BitStream[idx+62],BitStream[idx+63]);
685
686 uint32_t code = bytebits_to_byte(BitStream+idx,32);
687 uint32_t code2 = bytebits_to_byte(BitStream+idx+32,32);
688 short version = bytebits_to_byte(BitStream+idx+27,8); //14,4
689 uint8_t facilitycode = bytebits_to_byte(BitStream+idx+19,8) ;
690 uint16_t number = (bytebits_to_byte(BitStream+idx+36,8)<<8)|(bytebits_to_byte(BitStream+idx+45,8)); //36,9
691
692 PrintAndLog("XSF(%02d)%02x:%d (%08x%08x)",version,facilitycode,number,code,code2);
693 setGraphBuf(BitStream,BitLen);
694 return 1;
695 }
696 int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating
697 {
698 static const int LowTone[] = {
699 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,
700 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,
701 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,
702 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,
703 1, 1, 1, 1, 1, -1, -1, -1, -1, -1
704 };
705 static const int HighTone[] = {
706 1, 1, 1, 1, 1, -1, -1, -1, -1,
707 1, 1, 1, 1, -1, -1, -1, -1,
708 1, 1, 1, 1, -1, -1, -1, -1,
709 1, 1, 1, 1, -1, -1, -1, -1,
710 1, 1, 1, 1, -1, -1, -1, -1,
711 1, 1, 1, 1, -1, -1, -1, -1, -1,
712 };
713
714 int lowLen = sizeof (LowTone) / sizeof (int);
715 int highLen = sizeof (HighTone) / sizeof (int);
716 int convLen = (highLen > lowLen) ? highLen : lowLen; //if highlen > lowLen then highlen else lowlen
717 uint32_t hi = 0, lo = 0;
718
719 int i, j;
720 int minMark = 0, maxMark = 0;
721
722 for (i = 0; i < GraphTraceLen - convLen; ++i) {
723 int lowSum = 0, highSum = 0;
724
725 for (j = 0; j < lowLen; ++j) {
726 lowSum += LowTone[j]*GraphBuffer[i+j];
727 }
728 for (j = 0; j < highLen; ++j) {
729 highSum += HighTone[j] * GraphBuffer[i + j];
730 }
731 lowSum = abs(100 * lowSum / lowLen);
732 highSum = abs(100 * highSum / highLen);
733 GraphBuffer[i] = (highSum << 16) | lowSum;
734 }
735
736 for(i = 0; i < GraphTraceLen - convLen - 16; ++i) {
737 int lowTot = 0, highTot = 0;
738 // 10 and 8 are f_s divided by f_l and f_h, rounded
739 for (j = 0; j < 10; ++j) {
740 lowTot += (GraphBuffer[i+j] & 0xffff);
741 }
742 for (j = 0; j < 8; j++) {
743 highTot += (GraphBuffer[i + j] >> 16);
744 }
745 GraphBuffer[i] = lowTot - highTot;
746 if (GraphBuffer[i] > maxMark) maxMark = GraphBuffer[i];
747 if (GraphBuffer[i] < minMark) minMark = GraphBuffer[i];
748 }
749
750 GraphTraceLen -= (convLen + 16);
751 RepaintGraphWindow();
752
753 // Find bit-sync (3 lo followed by 3 high) (HID ONLY)
754 int max = 0, maxPos = 0;
755 for (i = 0; i < 6000; ++i) {
756 int dec = 0;
757 for (j = 0; j < 3 * lowLen; ++j) {
758 dec -= GraphBuffer[i + j];
759 }
760 for (; j < 3 * (lowLen + highLen ); ++j) {
761 dec += GraphBuffer[i + j];
762 }
763 if (dec > max) {
764 max = dec;
765 maxPos = i;
766 }
767 }
768
769 // place start of bit sync marker in graph
770 GraphBuffer[maxPos] = maxMark;
771 GraphBuffer[maxPos + 1] = minMark;
772
773 maxPos += j;
774
775 // place end of bit sync marker in graph
776 GraphBuffer[maxPos] = maxMark;
777 GraphBuffer[maxPos+1] = minMark;
778
779 PrintAndLog("actual data bits start at sample %d", maxPos);
780 PrintAndLog("length %d/%d", highLen, lowLen);
781
782 uint8_t bits[46];
783 bits[sizeof(bits)-1] = '\0';
784
785 // find bit pairs and manchester decode them
786 for (i = 0; i < arraylen(bits) - 1; ++i) {
787 int dec = 0;
788 for (j = 0; j < lowLen; ++j) {
789 dec -= GraphBuffer[maxPos + j];
790 }
791 for (; j < lowLen + highLen; ++j) {
792 dec += GraphBuffer[maxPos + j];
793 }
794 maxPos += j;
795 // place inter bit marker in graph
796 GraphBuffer[maxPos] = maxMark;
797 GraphBuffer[maxPos + 1] = minMark;
798
799 // hi and lo form a 64 bit pair
800 hi = (hi << 1) | (lo >> 31);
801 lo = (lo << 1);
802 // store decoded bit as binary (in hi/lo) and text (in bits[])
803 if(dec < 0) {
804 bits[i] = '1';
805 lo |= 1;
806 } else {
807 bits[i] = '0';
808 }
809 }
810 PrintAndLog("bits: '%s'", bits);
811 PrintAndLog("hex: %08x %08x", hi, lo);
812 return 0;
813 }
814
815 int CmdGrid(const char *Cmd)
816 {
817 sscanf(Cmd, "%i %i", &PlotGridX, &PlotGridY);
818 PlotGridXdefault= PlotGridX;
819 PlotGridYdefault= PlotGridY;
820 RepaintGraphWindow();
821 return 0;
822 }
823
824 int CmdHexsamples(const char *Cmd)
825 {
826 int i, j;
827 int requested = 0;
828 int offset = 0;
829 char string_buf[25];
830 char* string_ptr = string_buf;
831 uint8_t got[40000];
832
833 sscanf(Cmd, "%i %i", &requested, &offset);
834
835 /* if no args send something */
836 if (requested == 0) {
837 requested = 8;
838 }
839 if (offset + requested > sizeof(got)) {
840 PrintAndLog("Tried to read past end of buffer, <bytes> + <offset> > 40000");
841 return 0;
842 }
843
844 GetFromBigBuf(got,requested,offset);
845 WaitForResponse(CMD_ACK,NULL);
846
847 i = 0;
848 for (j = 0; j < requested; j++) {
849 i++;
850 string_ptr += sprintf(string_ptr, "%02x ", got[j]);
851 if (i == 8) {
852 *(string_ptr - 1) = '\0'; // remove the trailing space
853 PrintAndLog("%s", string_buf);
854 string_buf[0] = '\0';
855 string_ptr = string_buf;
856 i = 0;
857 }
858 if (j == requested - 1 && string_buf[0] != '\0') { // print any remaining bytes
859 *(string_ptr - 1) = '\0';
860 PrintAndLog("%s", string_buf);
861 string_buf[0] = '\0';
862 }
863 }
864 return 0;
865 }
866
867 int CmdHide(const char *Cmd)
868 {
869 HideGraphWindow();
870 return 0;
871 }
872
873 int CmdHpf(const char *Cmd)
874 {
875 int i;
876 int accum = 0;
877
878 for (i = 10; i < GraphTraceLen; ++i)
879 accum += GraphBuffer[i];
880 accum /= (GraphTraceLen - 10);
881 for (i = 0; i < GraphTraceLen; ++i)
882 GraphBuffer[i] -= accum;
883
884 RepaintGraphWindow();
885 return 0;
886 }
887
888 int CmdSamples(const char *Cmd)
889 {
890 int cnt = 0;
891 int n;
892 uint8_t got[40000];
893
894 n = strtol(Cmd, NULL, 0);
895 if (n == 0) n = 6000;
896 if (n > sizeof(got)) n = sizeof(got);
897
898 PrintAndLog("Reading %d samples\n", n);
899 GetFromBigBuf(got,n,0);
900 WaitForResponse(CMD_ACK,NULL);
901 for (int j = 0; j < n; j++) {
902 GraphBuffer[cnt++] = ((int)got[j]) - 128;
903 }
904
905 PrintAndLog("Done!\n");
906 GraphTraceLen = n;
907 RepaintGraphWindow();
908 return 0;
909 }
910
911 int CmdTuneSamples(const char *Cmd)
912 {
913 int cnt = 0;
914 int n = 255;
915 uint8_t got[255];
916
917 PrintAndLog("Reading %d samples\n", n);
918 GetFromBigBuf(got,n,7256); // armsrc/apps.h: #define FREE_BUFFER_OFFSET 7256
919 WaitForResponse(CMD_ACK,NULL);
920 for (int j = 0; j < n; j++) {
921 GraphBuffer[cnt++] = ((int)got[j]) - 128;
922 }
923
924 PrintAndLog("Done! Divisor 89 is 134khz, 95 is 125khz.\n");
925 PrintAndLog("\n");
926 GraphTraceLen = n;
927 RepaintGraphWindow();
928 return 0;
929 }
930
931 int CmdLoad(const char *Cmd)
932 {
933 FILE *f = fopen(Cmd, "r");
934 if (!f) {
935 PrintAndLog("couldn't open '%s'", Cmd);
936 return 0;
937 }
938
939 GraphTraceLen = 0;
940 char line[80];
941 while (fgets(line, sizeof (line), f)) {
942 GraphBuffer[GraphTraceLen] = atoi(line);
943 GraphTraceLen++;
944 }
945 fclose(f);
946 PrintAndLog("loaded %d samples", GraphTraceLen);
947 RepaintGraphWindow();
948 return 0;
949 }
950
951 int CmdLtrim(const char *Cmd)
952 {
953 int ds = atoi(Cmd);
954
955 for (int i = ds; i < GraphTraceLen; ++i)
956 GraphBuffer[i-ds] = GraphBuffer[i];
957 GraphTraceLen -= ds;
958
959 RepaintGraphWindow();
960 return 0;
961 }
962
963 /*
964 * Manchester demodulate a bitstream. The bitstream needs to be already in
965 * the GraphBuffer as 0 and 1 values
966 *
967 * Give the clock rate as argument in order to help the sync - the algorithm
968 * resyncs at each pulse anyway.
969 *
970 * Not optimized by any means, this is the 1st time I'm writing this type of
971 * routine, feel free to improve...
972 *
973 * 1st argument: clock rate (as number of samples per clock rate)
974 * Typical values can be 64, 32, 128...
975 */
976 int CmdManchesterDemod(const char *Cmd)
977 {
978 int i, j, invert= 0;
979 int bit;
980 int clock;
981 int lastval = 0;
982 int low = 0;
983 int high = 0;
984 int hithigh, hitlow, first;
985 int lc = 0;
986 int bitidx = 0;
987 int bit2idx = 0;
988 int warnings = 0;
989
990 /* check if we're inverting output */
991 if (*Cmd == 'i')
992 {
993 PrintAndLog("Inverting output");
994 invert = 1;
995 ++Cmd;
996 do
997 ++Cmd;
998 while(*Cmd == ' '); // in case a 2nd argument was given
999 }
1000
1001 /* Holds the decoded bitstream: each clock period contains 2 bits */
1002 /* later simplified to 1 bit after manchester decoding. */
1003 /* Add 10 bits to allow for noisy / uncertain traces without aborting */
1004 /* int BitStream[GraphTraceLen*2/clock+10]; */
1005
1006 /* But it does not work if compiling on WIndows: therefore we just allocate a */
1007 /* large array */
1008 uint8_t BitStream[MAX_GRAPH_TRACE_LEN] = {0};
1009
1010 /* Detect high and lows */
1011 for (i = 0; i < GraphTraceLen; i++)
1012 {
1013 if (GraphBuffer[i] > high)
1014 high = GraphBuffer[i];
1015 else if (GraphBuffer[i] < low)
1016 low = GraphBuffer[i];
1017 }
1018
1019 /* Get our clock */
1020 clock = GetClock(Cmd, high, 1);
1021
1022 int tolerance = clock/4;
1023
1024 /* Detect first transition */
1025 /* Lo-Hi (arbitrary) */
1026 /* skip to the first high */
1027 for (i= 0; i < GraphTraceLen; i++)
1028 if (GraphBuffer[i] == high)
1029 break;
1030 /* now look for the first low */
1031 for (; i < GraphTraceLen; i++)
1032 {
1033 if (GraphBuffer[i] == low)
1034 {
1035 lastval = i;
1036 break;
1037 }
1038 }
1039
1040 /* If we're not working with 1/0s, demod based off clock */
1041 if (high != 1)
1042 {
1043 bit = 0; /* We assume the 1st bit is zero, it may not be
1044 * the case: this routine (I think) has an init problem.
1045 * Ed.
1046 */
1047 for (; i < (int)(GraphTraceLen / clock); i++)
1048 {
1049 hithigh = 0;
1050 hitlow = 0;
1051 first = 1;
1052
1053 /* Find out if we hit both high and low peaks */
1054 for (j = 0; j < clock; j++)
1055 {
1056 if (GraphBuffer[(i * clock) + j] == high)
1057 hithigh = 1;
1058 else if (GraphBuffer[(i * clock) + j] == low)
1059 hitlow = 1;
1060
1061 /* it doesn't count if it's the first part of our read
1062 because it's really just trailing from the last sequence */
1063 if (first && (hithigh || hitlow))
1064 hithigh = hitlow = 0;
1065 else
1066 first = 0;
1067
1068 if (hithigh && hitlow)
1069 break;
1070 }
1071
1072 /* If we didn't hit both high and low peaks, we had a bit transition */
1073 if (!hithigh || !hitlow)
1074 bit ^= 1;
1075
1076 BitStream[bit2idx++] = bit ^ invert;
1077 }
1078 }
1079
1080 /* standard 1/0 bitstream */
1081 else
1082 {
1083
1084 /* Then detect duration between 2 successive transitions */
1085 for (bitidx = 1; i < GraphTraceLen; i++)
1086 {
1087 if (GraphBuffer[i-1] != GraphBuffer[i])
1088 {
1089 lc = i-lastval;
1090 lastval = i;
1091
1092 // Error check: if bitidx becomes too large, we do not
1093 // have a Manchester encoded bitstream or the clock is really
1094 // wrong!
1095 if (bitidx > (GraphTraceLen*2/clock+8) ) {
1096 PrintAndLog("Error: the clock you gave is probably wrong, aborting.");
1097 return 0;
1098 }
1099 // Then switch depending on lc length:
1100 // Tolerance is 1/4 of clock rate (arbitrary)
1101 if (abs(lc-clock/2) < tolerance) {
1102 // Short pulse : either "1" or "0"
1103 BitStream[bitidx++]=GraphBuffer[i-1];
1104 } else if (abs(lc-clock) < tolerance) {
1105 // Long pulse: either "11" or "00"
1106 BitStream[bitidx++]=GraphBuffer[i-1];
1107 BitStream[bitidx++]=GraphBuffer[i-1];
1108 } else {
1109 // Error
1110 warnings++;
1111 PrintAndLog("Warning: Manchester decode error for pulse width detection.");
1112 PrintAndLog("(too many of those messages mean either the stream is not Manchester encoded, or clock is wrong)");
1113
1114 if (warnings > 10)
1115 {
1116 PrintAndLog("Error: too many detection errors, aborting.");
1117 return 0;
1118 }
1119 }
1120 }
1121 }
1122
1123 // At this stage, we now have a bitstream of "01" ("1") or "10" ("0"), parse it into final decoded bitstream
1124 // Actually, we overwrite BitStream with the new decoded bitstream, we just need to be careful
1125 // to stop output at the final bitidx2 value, not bitidx
1126 for (i = 0; i < bitidx; i += 2) {
1127 if ((BitStream[i] == 0) && (BitStream[i+1] == 1)) {
1128 BitStream[bit2idx++] = 1 ^ invert;
1129 } else if ((BitStream[i] == 1) && (BitStream[i+1] == 0)) {
1130 BitStream[bit2idx++] = 0 ^ invert;
1131 } else {
1132 // We cannot end up in this state, this means we are unsynchronized,
1133 // move up 1 bit:
1134 i++;
1135 warnings++;
1136 PrintAndLog("Unsynchronized, resync...");
1137 PrintAndLog("(too many of those messages mean the stream is not Manchester encoded)");
1138
1139 if (warnings > 10)
1140 {
1141 PrintAndLog("Error: too many decode errors, aborting.");
1142 return 0;
1143 }
1144 }
1145 }
1146 }
1147
1148 PrintAndLog("Manchester decoded bitstream");
1149 // Now output the bitstream to the scrollback by line of 16 bits
1150 for (i = 0; i < (bit2idx-16); i+=16) {
1151 PrintAndLog("%i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i",
1152 BitStream[i],
1153 BitStream[i+1],
1154 BitStream[i+2],
1155 BitStream[i+3],
1156 BitStream[i+4],
1157 BitStream[i+5],
1158 BitStream[i+6],
1159 BitStream[i+7],
1160 BitStream[i+8],
1161 BitStream[i+9],
1162 BitStream[i+10],
1163 BitStream[i+11],
1164 BitStream[i+12],
1165 BitStream[i+13],
1166 BitStream[i+14],
1167 BitStream[i+15]);
1168 }
1169 return 0;
1170 }
1171
1172 /* Modulate our data into manchester */
1173 int CmdManchesterMod(const char *Cmd)
1174 {
1175 int i, j;
1176 int clock;
1177 int bit, lastbit, wave;
1178
1179 /* Get our clock */
1180 clock = GetClock(Cmd, 0, 1);
1181
1182 wave = 0;
1183 lastbit = 1;
1184 for (i = 0; i < (int)(GraphTraceLen / clock); i++)
1185 {
1186 bit = GraphBuffer[i * clock] ^ 1;
1187
1188 for (j = 0; j < (int)(clock/2); j++)
1189 GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave;
1190 for (j = (int)(clock/2); j < clock; j++)
1191 GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave ^ 1;
1192
1193 /* Keep track of how we start our wave and if we changed or not this time */
1194 wave ^= bit ^ lastbit;
1195 lastbit = bit;
1196 }
1197
1198 RepaintGraphWindow();
1199 return 0;
1200 }
1201
1202 int CmdNorm(const char *Cmd)
1203 {
1204 int i;
1205 int max = INT_MIN, min = INT_MAX;
1206
1207 for (i = 10; i < GraphTraceLen; ++i) {
1208 if (GraphBuffer[i] > max)
1209 max = GraphBuffer[i];
1210 if (GraphBuffer[i] < min)
1211 min = GraphBuffer[i];
1212 }
1213
1214 if (max != min) {
1215 for (i = 0; i < GraphTraceLen; ++i) {
1216 GraphBuffer[i] = (GraphBuffer[i] - ((max + min) / 2)) * 1000 /
1217 (max - min);
1218 }
1219 }
1220 RepaintGraphWindow();
1221 return 0;
1222 }
1223
1224 int CmdPlot(const char *Cmd)
1225 {
1226 ShowGraphWindow();
1227 return 0;
1228 }
1229
1230 int CmdSave(const char *Cmd)
1231 {
1232 FILE *f = fopen(Cmd, "w");
1233 if(!f) {
1234 PrintAndLog("couldn't open '%s'", Cmd);
1235 return 0;
1236 }
1237 int i;
1238 for (i = 0; i < GraphTraceLen; i++) {
1239 fprintf(f, "%d\n", GraphBuffer[i]);
1240 }
1241 fclose(f);
1242 PrintAndLog("saved to '%s'", Cmd);
1243 return 0;
1244 }
1245
1246 int CmdScale(const char *Cmd)
1247 {
1248 CursorScaleFactor = atoi(Cmd);
1249 if (CursorScaleFactor == 0) {
1250 PrintAndLog("bad, can't have zero scale");
1251 CursorScaleFactor = 1;
1252 }
1253 RepaintGraphWindow();
1254 return 0;
1255 }
1256
1257 int CmdThreshold(const char *Cmd)
1258 {
1259 int threshold = atoi(Cmd);
1260
1261 for (int i = 0; i < GraphTraceLen; ++i) {
1262 if (GraphBuffer[i] >= threshold)
1263 GraphBuffer[i] = 1;
1264 else
1265 GraphBuffer[i] = -1;
1266 }
1267 RepaintGraphWindow();
1268 return 0;
1269 }
1270
1271 int CmdDirectionalThreshold(const char *Cmd)
1272 {
1273 int8_t upThres = param_get8(Cmd, 0);
1274 int8_t downThres = param_get8(Cmd, 1);
1275
1276 printf("Applying Up Threshold: %d, Down Threshold: %d\n", upThres, downThres);
1277
1278 int lastValue = GraphBuffer[0];
1279 GraphBuffer[0] = 0; // Will be changed at the end, but init 0 as we adjust to last samples value if no threshold kicks in.
1280
1281 for (int i = 1; i < GraphTraceLen; ++i) {
1282 // Apply first threshold to samples heading up
1283 if (GraphBuffer[i] >= upThres && GraphBuffer[i] > lastValue)
1284 {
1285 lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
1286 GraphBuffer[i] = 1;
1287 }
1288 // Apply second threshold to samples heading down
1289 else if (GraphBuffer[i] <= downThres && GraphBuffer[i] < lastValue)
1290 {
1291 lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
1292 GraphBuffer[i] = -1;
1293 }
1294 else
1295 {
1296 lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
1297 GraphBuffer[i] = GraphBuffer[i-1];
1298
1299 }
1300 }
1301 GraphBuffer[0] = GraphBuffer[1]; // Aline with first edited sample.
1302 RepaintGraphWindow();
1303 return 0;
1304 }
1305
1306 int CmdZerocrossings(const char *Cmd)
1307 {
1308 // Zero-crossings aren't meaningful unless the signal is zero-mean.
1309 CmdHpf("");
1310
1311 int sign = 1;
1312 int zc = 0;
1313 int lastZc = 0;
1314
1315 for (int i = 0; i < GraphTraceLen; ++i) {
1316 if (GraphBuffer[i] * sign >= 0) {
1317 // No change in sign, reproduce the previous sample count.
1318 zc++;
1319 GraphBuffer[i] = lastZc;
1320 } else {
1321 // Change in sign, reset the sample count.
1322 sign = -sign;
1323 GraphBuffer[i] = lastZc;
1324 if (sign > 0) {
1325 lastZc = zc;
1326 zc = 0;
1327 }
1328 }
1329 }
1330
1331 RepaintGraphWindow();
1332 return 0;
1333 }
1334
1335 static command_t CommandTable[] =
1336 {
1337 {"help", CmdHelp, 1, "This help"},
1338 {"amp", CmdAmp, 1, "Amplify peaks"},
1339 {"askdemod", Cmdaskdemod, 1, "<0 or 1> -- Attempt to demodulate simple ASK tags"},
1340 {"askmandemod", Cmdaskmandemod, 1, "[clock] [invert<0 or 1>] -- Attempt to demodulate ASK/Manchester tags and output binary (args optional[clock will try Auto-detect])"},
1341 {"askrawdemod", Cmdaskrawdemod, 1, "[clock] [invert<0 or 1>] -- Attempt to demodulate ASK tags and output binary (args optional[clock will try Auto-detect])"},
1342 {"autocorr", CmdAutoCorr, 1, "<window length> -- Autocorrelation over window"},
1343 {"biphaserawdecode",CmdBiphaseDecodeRaw,1,"[offset] Biphase decode binary stream already in graph buffer (offset = bit to start decode from)"},
1344 {"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"},
1345 {"bitstream", CmdBitstream, 1, "[clock rate] -- Convert waveform into a bitstream"},
1346 {"buffclear", CmdBuffClear, 1, "Clear sample buffer and graph window"},
1347 {"dec", CmdDec, 1, "Decimate samples"},
1348 {"detectaskclock",CmdDetectClockRate, 1, "Detect ASK clock rate"},
1349 {"fskdemod", CmdFSKdemod, 1, "Demodulate graph window as a HID FSK"},
1350 {"fskhiddemod", CmdFSKdemodHID, 1, "Demodulate graph window as a HID FSK using raw"},
1351 {"fskiodemod", CmdFSKdemodIO, 1, "Demodulate graph window as an IO Prox FSK using raw"},
1352 {"fskrawdemod", CmdFSKrawdemod, 1, "[clock rate] [invert] Demodulate graph window from FSK to binary (clock = 64 or 50)(invert = 1 or 0)"},
1353 {"grid", CmdGrid, 1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},
1354 {"hexsamples", CmdHexsamples, 0, "<bytes> [<offset>] -- Dump big buffer as hex bytes"},
1355 {"hide", CmdHide, 1, "Hide graph window"},
1356 {"hpf", CmdHpf, 1, "Remove DC offset from trace"},
1357 {"load", CmdLoad, 1, "<filename> -- Load trace (to graph window"},
1358 {"ltrim", CmdLtrim, 1, "<samples> -- Trim samples from left of trace"},
1359 {"mandemod", CmdManchesterDemod, 1, "[i] [clock rate] -- Manchester demodulate binary stream (option 'i' to invert output)"},
1360 {"manrawdecode", Cmdmandecoderaw, 1, "Manchester decode binary stream already in graph buffer"},
1361 {"manmod", CmdManchesterMod, 1, "[clock rate] -- Manchester modulate a binary stream"},
1362 {"norm", CmdNorm, 1, "Normalize max/min to +/-500"},
1363 {"plot", CmdPlot, 1, "Show graph window (hit 'h' in window for keystroke help)"},
1364 {"samples", CmdSamples, 0, "[512 - 40000] -- Get raw samples for graph window"},
1365 {"tune", CmdTuneSamples, 0, "Get hw tune samples for graph window"},
1366 {"save", CmdSave, 1, "<filename> -- Save trace (from graph window)"},
1367 {"scale", CmdScale, 1, "<int> -- Set cursor display scale"},
1368 {"threshold", CmdThreshold, 1, "<threshold> -- Maximize/minimize every value in the graph window depending on threshold"},
1369 {"zerocrossings", CmdZerocrossings, 1, "Count time between zero-crossings"},
1370 {"dirthreshold", CmdDirectionalThreshold, 1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
1371 {NULL, NULL, 0, NULL}
1372 };
1373
1374 int CmdData(const char *Cmd)
1375 {
1376 CmdsParse(CommandTable, Cmd);
1377 return 0;
1378 }
1379
1380 int CmdHelp(const char *Cmd)
1381 {
1382 CmdsHelp(CommandTable);
1383 return 0;
1384 }
Impressum, Datenschutz