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