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