]>
git.zerfleddert.de Git - proxmark3-svn/blob - client/cmddata.c
1 //-----------------------------------------------------------------------------
2 // Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
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
7 //-----------------------------------------------------------------------------
8 // Data and Graph commands
9 //-----------------------------------------------------------------------------
14 //#include <inttypes.h>
16 #include "proxmark3.h"
20 #include "cmdparser.h"
26 static int CmdHelp ( const char * Cmd
);
28 int CmdAmp ( const char * Cmd
)
30 int i
, rising
, falling
;
31 int max
= INT_MIN
, min
= INT_MAX
;
33 for ( i
= 10 ; i
< GraphTraceLen
; ++ i
) {
34 if ( GraphBuffer
[ i
] > max
)
36 if ( GraphBuffer
[ i
] < min
)
42 for ( i
= 0 ; i
< GraphTraceLen
; ++ i
) {
43 if ( GraphBuffer
[ i
+ 1 ] < GraphBuffer
[ i
]) {
50 if ( GraphBuffer
[ i
+ 1 ] > GraphBuffer
[ i
]) {
64 * Generic command to demodulate ASK.
66 * Argument is convention: positive or negative (High mod means zero
67 * or high mod means one)
69 * Updates the Graph trace with 0/1 values
74 //this method is dependant on all highs and lows to be the same(or clipped) this creates issues[marshmellow] it also ignores the clock
75 int Cmdaskdemod ( const char * Cmd
)
78 int c
, high
= 0 , low
= 0 ;
80 // TODO: complain if we do not give 2 arguments here !
81 // (AL - this doesn't make sense! we're only using one argument!!!)
82 sscanf ( Cmd
, "%i" , & c
);
84 /* Detect high and lows and clock */
86 for ( i
= 0 ; i
< GraphTraceLen
; ++ i
)
88 if ( GraphBuffer
[ i
] > high
)
89 high
= GraphBuffer
[ i
];
90 else if ( GraphBuffer
[ i
] < low
)
95 if ( c
!= 0 && c
!= 1 ) {
96 PrintAndLog ( "Invalid argument: %s" , Cmd
);
100 if ( GraphBuffer
[ 0 ] > 0 ) {
101 GraphBuffer
[ 0 ] = 1 - c
;
105 for ( i
= 1 ; i
< GraphTraceLen
; ++ i
) {
106 /* Transitions are detected at each peak
107 * Transitions are either:
108 * - we're low: transition if we hit a high
109 * - we're high: transition if we hit a low
110 * (we need to do it this way because some tags keep high or
111 * low for long periods, others just reach the peak and go
114 //[marhsmellow] change == to >= for high and <= for low for fuzz
115 if (( GraphBuffer
[ i
] == high
) && ( GraphBuffer
[ i
- 1 ] == c
)) {
116 GraphBuffer
[ i
] = 1 - c
;
117 } else if (( GraphBuffer
[ i
] == low
) && ( GraphBuffer
[ i
- 1 ] == ( 1 - c
))){
121 GraphBuffer
[ i
] = GraphBuffer
[ i
- 1 ];
124 RepaintGraphWindow ();
128 void printBitStream ( uint8_t BitStream
[], uint32_t bitLen
){
131 PrintAndLog ( "Too few bits found: %d" , bitLen
);
134 if ( bitLen
> 512 ) bitLen
= 512 ;
135 for ( i
= 0 ; i
<= ( bitLen
- 16 ); i
+= 16 ) {
136 PrintAndLog ( "%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i" ,
156 void printEM410x ( uint64_t id
)
160 uint64_t id2lo
= 0 ; //id2hi=0,
163 for ( ii
= 5 ; ii
> 0 ; ii
--){
165 id2lo
=( id2lo
<< 1LL )|(( id
& ( iii
<<( i
+(( ii
- 1 )* 8 ))))>>( i
+(( ii
- 1 )* 8 )));
169 PrintAndLog ( "EM TAG ID : %010llx" , id
);
170 PrintAndLog ( "Unique TAG ID: %010llx" , id2lo
); //id2hi,
171 PrintAndLog ( "DEZ 8 : %08lld" , id
& 0xFFFFFF );
172 PrintAndLog ( "DEZ 10 : %010lld" , id
& 0xFFFFFF );
173 PrintAndLog ( "DEZ 5.5 : %05lld.%05lld" ,( id
>> 16LL ) & 0xFFFF ,( id
& 0xFFFF ));
174 PrintAndLog ( "DEZ 3.5A : %03lld.%05lld" ,( id
>> 32ll ),( id
& 0xFFFF ));
175 PrintAndLog ( "DEZ 14/IK2 : %014lld" , id
);
176 PrintAndLog ( "DEZ 15/IK3 : %015lld" , id2lo
);
177 PrintAndLog ( "Other : %05lld_%03lld_%08lld" ,( id
& 0xFFFF ),(( id
>> 16LL ) & 0xFF ),( id
& 0xFFFFFF ));
182 int CmdEm410xDecode ( const char * Cmd
)
185 uint8_t BitStream
[ MAX_GRAPH_TRACE_LEN
]={ 0 };
187 for ( i
= 0 ; i
< GraphTraceLen
;++ i
){
188 BitStream
[ i
]=( uint8_t )( GraphBuffer
[ i
]+ 128 );
190 id
= Em410xDecode ( BitStream
, i
);
195 int getFromGraphBuf ( uint8_t * buff
)
198 for ( i
= 0 ; i
< GraphTraceLen
;++ i
)
199 buff
[ i
]=( uint8_t )( GraphBuffer
[ i
]+ 128 );
204 //takes 2 arguments - clock and invert both as integers
205 //attempts to demodulate ask while decoding manchester
206 //prints binary found and saves in graphbuffer for further commands
207 int Cmdaskmandemod ( const char * Cmd
)
211 uint8_t BitStream
[ MAX_GRAPH_TRACE_LEN
]={ 0 };
212 sscanf ( Cmd
, "%i %i" , & clk
, & invert
);
213 if ( invert
!= 0 && invert
!= 1 ) {
214 PrintAndLog ( "Invalid argument: %s" , Cmd
);
217 uint32_t BitLen
= getFromGraphBuf ( BitStream
);
220 errCnt
= askmandemod ( BitStream
, & BitLen
,& clk
,& invert
);
221 if ( errCnt
==- 1 ){ //if fatal error (or -1)
222 PrintAndLog ( "no data found" );
225 PrintAndLog ( "Using Clock: %d and invert=%d" , clk
, invert
);
226 //PrintAndLog("Data start pos:%d, lastBit:%d, stop pos:%d, numBits:%d",iii,lastBit,i,bitnum);
227 //move BitStream back to GraphBuffer
230 for (i=0; i < bitnum; ++i){
231 GraphBuffer[i]=BitStream[i];
233 GraphTraceLen=bitnum;
234 RepaintGraphWindow();
238 PrintAndLog ( "# Errors during Demoding (shown as 77 in bit stream): %d" , errCnt
);
240 PrintAndLog ( "ASK/Manchester decoded bitstream:" );
241 // Now output the bitstream to the scrollback by line of 16 bits
242 printBitStream ( BitStream
, BitLen
);
244 lo
= Em410xDecode ( BitStream
, BitLen
);
251 //biphase demod = 10 (or 01)=1 / 00 (or 11)=0
256 //stricktly take 10 and 01 and convert to 0 and 1
257 int Cmdmandecoderaw ( const char * Cmd
)
262 uint8_t BitStream
[ MAX_GRAPH_TRACE_LEN
]={ 0 };
264 for (; i
< GraphTraceLen
;++ i
){
265 if ( GraphBuffer
[ i
]> high
) high
= GraphBuffer
[ i
];
266 else if ( GraphBuffer
[ i
]< low
) low
= GraphBuffer
[ i
];
267 BitStream
[ i
]= GraphBuffer
[ i
];
269 if ( high
> 1 || low
< 0 ){
270 PrintAndLog ( "Error: please raw demod the wave first then mancheseter raw decode" );
274 errCnt
= manrawdemod ( BitStream
,& bitnum
);
276 PrintAndLog ( "Too many errors: %d" , errCnt
);
279 PrintAndLog ( "Manchester Decoded - # errors:%d - data:" , errCnt
);
280 printBitStream ( BitStream
, bitnum
);
282 //put back in graphbuffer
284 for ( i
= 0 ; i
< bitnum
;++ i
){
285 GraphBuffer
[ i
]= BitStream
[ i
];
287 GraphTraceLen
= bitnum
;
288 RepaintGraphWindow ();
290 id
= Em410xDecode ( BitStream
, i
);
297 //takes 2 arguments - clock and invert both as integers
298 //attempts to demodulate ask only
299 //prints binary found and saves in graphbuffer for further commands
300 int Cmdaskrawdemod ( const char * Cmd
)
305 uint8_t BitStream
[ MAX_GRAPH_TRACE_LEN
]={ 0 };
306 sscanf ( Cmd
, "%i %i" , & clk
, & invert
);
307 if ( invert
!= 0 && invert
!= 1 ) {
308 PrintAndLog ( "Invalid argument: %s" , Cmd
);
311 int BitLen
= getFromGraphBuf ( BitStream
);
313 errCnt
= askrawdemod ( BitStream
, & BitLen
,& clk
,& invert
);
314 if ( errCnt
==- 1 ){ //throw away static - allow 1 and -1 (in case of threshold command first)
315 PrintAndLog ( "no data found" );
318 PrintAndLog ( "Using Clock: %d and invert=%d" , clk
, invert
);
319 //PrintAndLog("Data start pos:%d, lastBit:%d, stop pos:%d, numBits:%d",iii,lastBit,i,bitnum);
320 //move BitStream back to GraphBuffer
323 for ( i
= 0 ; i
< BitLen
; ++ i
){
324 GraphBuffer
[ i
]= BitStream
[ i
];
326 GraphTraceLen
= BitLen
;
327 RepaintGraphWindow ();
331 PrintAndLog ( "# Errors during Demoding (shown as 77 in bit stream): %d" , errCnt
);
333 PrintAndLog ( "ASK demoded bitstream:" );
334 // Now output the bitstream to the scrollback by line of 16 bits
335 printBitStream ( BitStream
, BitLen
);
340 int CmdAutoCorr ( const char * Cmd
)
342 static int CorrelBuffer
[ MAX_GRAPH_TRACE_LEN
];
344 int window
= atoi ( Cmd
);
347 PrintAndLog ( "needs a window" );
350 if ( window
>= GraphTraceLen
) {
351 PrintAndLog ( "window must be smaller than trace (%d samples)" ,
356 PrintAndLog ( "performing %d correlations" , GraphTraceLen
- window
);
358 for ( int i
= 0 ; i
< GraphTraceLen
- window
; ++ i
) {
360 for ( int j
= 0 ; j
< window
; ++ j
) {
361 sum
+= ( GraphBuffer
[ j
]* GraphBuffer
[ i
+ j
]) / 256 ;
363 CorrelBuffer
[ i
] = sum
;
365 GraphTraceLen
= GraphTraceLen
- window
;
366 memcpy ( GraphBuffer
, CorrelBuffer
, GraphTraceLen
* sizeof ( int ));
368 RepaintGraphWindow ();
372 int CmdBitsamples ( const char * Cmd
)
377 GetFromBigBuf ( got
, sizeof ( got
), 0 );
378 WaitForResponse ( CMD_ACK
, NULL
);
380 for ( int j
= 0 ; j
< sizeof ( got
); j
++) {
381 for ( int k
= 0 ; k
< 8 ; k
++) {
382 if ( got
[ j
] & ( 1 << ( 7 - k
))) {
383 GraphBuffer
[ cnt
++] = 1 ;
385 GraphBuffer
[ cnt
++] = 0 ;
390 RepaintGraphWindow ();
395 * Convert to a bitstream
397 int CmdBitstream ( const char * Cmd
)
405 int hithigh
, hitlow
, first
;
407 /* Detect high and lows and clock */
408 for ( i
= 0 ; i
< GraphTraceLen
; ++ i
)
410 if ( GraphBuffer
[ i
] > high
)
411 high
= GraphBuffer
[ i
];
412 else if ( GraphBuffer
[ i
] < low
)
413 low
= GraphBuffer
[ i
];
417 clock
= GetClock ( Cmd
, high
, 1 );
421 for ( i
= 0 ; i
< ( int )( gtl
/ clock
); ++ i
)
426 /* Find out if we hit both high and low peaks */
427 for ( j
= 0 ; j
< clock
; ++ j
)
429 if ( GraphBuffer
[( i
* clock
) + j
] == high
)
431 else if ( GraphBuffer
[( i
* clock
) + j
] == low
)
433 /* it doesn't count if it's the first part of our read
434 because it's really just trailing from the last sequence */
435 if ( first
&& ( hithigh
|| hitlow
))
436 hithigh
= hitlow
= 0 ;
440 if ( hithigh
&& hitlow
)
444 /* If we didn't hit both high and low peaks, we had a bit transition */
445 if (! hithigh
|| ! hitlow
)
448 AppendGraph ( 0 , clock
, bit
);
449 // for (j = 0; j < (int)(clock/2); j++)
450 // GraphBuffer[(i * clock) + j] = bit ^ 1;
451 // for (j = (int)(clock/2); j < clock; j++)
452 // GraphBuffer[(i * clock) + j] = bit;
455 RepaintGraphWindow ();
459 int CmdBuffClear ( const char * Cmd
)
461 UsbCommand c
= { CMD_BUFF_CLEAR
};
467 int CmdDec ( const char * Cmd
)
469 for ( int i
= 0 ; i
< ( GraphTraceLen
/ 2 ); ++ i
)
470 GraphBuffer
[ i
] = GraphBuffer
[ i
* 2 ];
472 PrintAndLog ( "decimated by 2" );
473 RepaintGraphWindow ();
477 /* Print our clock rate */
478 int CmdDetectClockRate ( const char * Cmd
)
480 int clock
= DetectClock ( 0 );
481 PrintAndLog ( "Auto-detected clock rate: %d" , clock
);
486 //fsk raw demod and print binary
487 //takes 2 arguments - Clock and invert
488 //defaults: clock = 50, invert=0
489 int CmdFSKrawdemod ( const char * Cmd
)
491 //raw fsk demod no manchester decoding no start bit finding just get binary from wave
495 //set options from parameters entered with the command
496 if ( strlen ( Cmd
)> 0 && strlen ( Cmd
)<= 2 ) {
497 rfLen
= param_get8 ( Cmd
, 0 ); //if rfLen option only is used
499 invert
= 1 ; //if invert option only is used
501 } else if ( rfLen
== 0 ) rfLen
= 50 ;
504 rfLen
= param_get8 ( Cmd
, 0 ); //if both options are used
505 invert
= param_get8 ( Cmd
, 1 );
507 PrintAndLog ( "Args invert: %d \n Clock:%d" , invert
, rfLen
);
509 uint8_t BitStream
[ MAX_GRAPH_TRACE_LEN
]={ 0 };
510 uint32_t BitLen
= getFromGraphBuf ( BitStream
);
511 int size
= fskdemod ( BitStream
, BitLen
, rfLen
, invert
);
513 PrintAndLog ( "FSK decoded bitstream:" );
515 for ( i
= 0 ; i
< size
;++ i
){
516 GraphBuffer
[ i
]= BitStream
[ i
];
519 RepaintGraphWindow ();
521 // Now output the bitstream to the scrollback by line of 16 bits
522 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
523 printBitStream ( BitStream
, size
);
527 //by marshmellow (based on existing demod + holiman's refactor)
528 //HID Prox demod - FSK RF/50 with preamble of 00011101 (then manchester encoded)
529 //print full HID Prox ID and some bit format details if found
530 int CmdFSKdemodHID ( const char * Cmd
)
532 //raw fsk demod no manchester decoding no start bit finding just get binary from wave
533 uint32_t hi2
= 0 , hi
= 0 , lo
= 0 ;
535 uint8_t BitStream
[ MAX_GRAPH_TRACE_LEN
]={ 0 };
536 uint32_t BitLen
= getFromGraphBuf ( BitStream
);
537 //get binary from fsk wave
538 size_t size
= HIDdemodFSK ( BitStream
, BitLen
,& hi2
,& hi
,& lo
);
540 PrintAndLog ( "Error demoding fsk" );
543 if ( hi2
!= 0 ){ //extra large HID tags
544 PrintAndLog ( "TAG ID: %x%08x%08x (%d)" ,
545 ( unsigned int ) hi2
, ( unsigned int ) hi
, ( unsigned int ) lo
, ( unsigned int ) ( lo
>> 1 ) & 0xFFFF );
547 else { //standard HID tags <38 bits
548 //Dbprintf("TAG ID: %x%08x (%d)",(unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); //old print cmd
551 uint32_t cardnum
= 0 ;
552 if ((( hi
>> 5 )& 1 )== 1 ){ //if bit 38 is set then < 37 bit format is used
554 lo2
=((( hi
& 15 ) << 12 ) | ( lo
>> 20 )); //get bits 21-37 to check for format len bit
556 while ( lo2
> 1 ){ //find last bit set to 1 (format len bit)
564 cardnum
= ( lo
>> 1 )& 0xFFFF ;
568 cardnum
= ( lo
>> 1 )& 0x7FFFF ;
569 fc
= (( hi
& 0xF )<< 12 )|( lo
>> 20 );
572 cardnum
= ( lo
>> 1 )& 0xFFFF ;
573 fc
= (( hi
& 1 )<< 15 )|( lo
>> 17 );
576 cardnum
= ( lo
>> 1 )& 0xFFFFF ;
577 fc
= (( hi
& 1 )<< 11 )|( lo
>> 21 );
580 else { //if bit 38 is not set then 37 bit format is used
585 cardnum
= ( lo
>> 1 )& 0x7FFFF ;
586 fc
= (( hi
& 0xF )<< 12 )|( lo
>> 20 );
589 PrintAndLog ( "TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d" ,
590 ( unsigned int ) hi
, ( unsigned int ) lo
, ( unsigned int ) ( lo
>> 1 ) & 0xFFFF ,
591 ( unsigned int ) bitlen
, ( unsigned int ) fc
, ( unsigned int ) cardnum
);
598 //IO-Prox demod - FSK RF/64 with preamble of 000000001
599 //print ioprox ID and some format details
600 int CmdFSKdemodIO ( const char * Cmd
)
602 //raw fsk demod no manchester decoding no start bit finding just get binary from wave
605 //test samples are not just noise
606 if ( GraphTraceLen
< 64 ) return 0 ;
607 uint8_t BitStream
[ MAX_GRAPH_TRACE_LEN
]={ 0 };
608 uint32_t BitLen
= getFromGraphBuf ( BitStream
);
609 //get binary from fsk wave
610 idx
= IOdemodFSK ( BitStream
, BitLen
);
612 PrintAndLog ( "Error demoding fsk" );
616 PrintAndLog ( "IO Prox Data not found - FSK Data:" );
617 printBitStream ( BitStream
, 92 );
620 //0 10 20 30 40 50 60
622 //01234567 8 90123456 7 89012345 6 78901234 5 67890123 4 56789012 3 45678901 23
623 //-----------------------------------------------------------------------------
624 //00000000 0 11110000 1 facility 1 version* 1 code*one 1 code*two 1 ???????? 11
626 //XSF(version)facility:codeone+codetwo (raw)
629 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 ]);
630 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 ]);
631 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 ]);
632 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 ]);
633 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 ]);
634 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 ]);
635 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 ]);
637 uint32_t code
= bytebits_to_byte ( BitStream
+ idx
, 32 );
638 uint32_t code2
= bytebits_to_byte ( BitStream
+ idx
+ 32 , 32 );
639 short version
= bytebits_to_byte ( BitStream
+ idx
+ 27 , 8 ); //14,4
640 uint8_t facilitycode
= bytebits_to_byte ( BitStream
+ idx
+ 19 , 8 ) ;
641 uint16_t number
= ( bytebits_to_byte ( BitStream
+ idx
+ 36 , 8 )<< 8 )|( bytebits_to_byte ( BitStream
+ idx
+ 45 , 8 )); //36,9
643 PrintAndLog ( "XSF(%02d)%02x:%d (%08x%08x)" , version
, facilitycode
, number
, code
, code2
);
646 int CmdFSKdemod ( const char * Cmd
) //old CmdFSKdemod needs updating
648 static const int LowTone
[] = {
649 1 , 1 , 1 , 1 , 1 , - 1 , - 1 , - 1 , - 1 , - 1 ,
650 1 , 1 , 1 , 1 , 1 , - 1 , - 1 , - 1 , - 1 , - 1 ,
651 1 , 1 , 1 , 1 , 1 , - 1 , - 1 , - 1 , - 1 , - 1 ,
652 1 , 1 , 1 , 1 , 1 , - 1 , - 1 , - 1 , - 1 , - 1 ,
653 1 , 1 , 1 , 1 , 1 , - 1 , - 1 , - 1 , - 1 , - 1
655 static const int HighTone
[] = {
656 1 , 1 , 1 , 1 , 1 , - 1 , - 1 , - 1 , - 1 ,
657 1 , 1 , 1 , 1 , - 1 , - 1 , - 1 , - 1 ,
658 1 , 1 , 1 , 1 , - 1 , - 1 , - 1 , - 1 ,
659 1 , 1 , 1 , 1 , - 1 , - 1 , - 1 , - 1 ,
660 1 , 1 , 1 , 1 , - 1 , - 1 , - 1 , - 1 ,
661 1 , 1 , 1 , 1 , - 1 , - 1 , - 1 , - 1 , - 1 ,
664 int lowLen
= sizeof ( LowTone
) / sizeof ( int );
665 int highLen
= sizeof ( HighTone
) / sizeof ( int );
666 int convLen
= ( highLen
> lowLen
) ? highLen
: lowLen
; //if highlen > lowLen then highlen else lowlen
667 uint32_t hi
= 0 , lo
= 0 ;
670 int minMark
= 0 , maxMark
= 0 ;
672 for ( i
= 0 ; i
< GraphTraceLen
- convLen
; ++ i
) {
673 int lowSum
= 0 , highSum
= 0 ;
675 for ( j
= 0 ; j
< lowLen
; ++ j
) {
676 lowSum
+= LowTone
[ j
]* GraphBuffer
[ i
+ j
];
678 for ( j
= 0 ; j
< highLen
; ++ j
) {
679 highSum
+= HighTone
[ j
] * GraphBuffer
[ i
+ j
];
681 lowSum
= abs ( 100 * lowSum
/ lowLen
);
682 highSum
= abs ( 100 * highSum
/ highLen
);
683 GraphBuffer
[ i
] = ( highSum
<< 16 ) | lowSum
;
686 for ( i
= 0 ; i
< GraphTraceLen
- convLen
- 16 ; ++ i
) {
687 int lowTot
= 0 , highTot
= 0 ;
688 // 10 and 8 are f_s divided by f_l and f_h, rounded
689 for ( j
= 0 ; j
< 10 ; ++ j
) {
690 lowTot
+= ( GraphBuffer
[ i
+ j
] & 0xffff );
692 for ( j
= 0 ; j
< 8 ; j
++) {
693 highTot
+= ( GraphBuffer
[ i
+ j
] >> 16 );
695 GraphBuffer
[ i
] = lowTot
- highTot
;
696 if ( GraphBuffer
[ i
] > maxMark
) maxMark
= GraphBuffer
[ i
];
697 if ( GraphBuffer
[ i
] < minMark
) minMark
= GraphBuffer
[ i
];
700 GraphTraceLen
-= ( convLen
+ 16 );
701 RepaintGraphWindow ();
703 // Find bit-sync (3 lo followed by 3 high) (HID ONLY)
704 int max
= 0 , maxPos
= 0 ;
705 for ( i
= 0 ; i
< 6000 ; ++ i
) {
707 for ( j
= 0 ; j
< 3 * lowLen
; ++ j
) {
708 dec
-= GraphBuffer
[ i
+ j
];
710 for (; j
< 3 * ( lowLen
+ highLen
); ++ j
) {
711 dec
+= GraphBuffer
[ i
+ j
];
719 // place start of bit sync marker in graph
720 GraphBuffer
[ maxPos
] = maxMark
;
721 GraphBuffer
[ maxPos
+ 1 ] = minMark
;
725 // place end of bit sync marker in graph
726 GraphBuffer
[ maxPos
] = maxMark
;
727 GraphBuffer
[ maxPos
+ 1 ] = minMark
;
729 PrintAndLog ( "actual data bits start at sample %d" , maxPos
);
730 PrintAndLog ( "length %d/%d" , highLen
, lowLen
);
733 bits
[ sizeof ( bits
)- 1 ] = '\0' ;
735 // find bit pairs and manchester decode them
736 for ( i
= 0 ; i
< arraylen ( bits
) - 1 ; ++ i
) {
738 for ( j
= 0 ; j
< lowLen
; ++ j
) {
739 dec
-= GraphBuffer
[ maxPos
+ j
];
741 for (; j
< lowLen
+ highLen
; ++ j
) {
742 dec
+= GraphBuffer
[ maxPos
+ j
];
745 // place inter bit marker in graph
746 GraphBuffer
[ maxPos
] = maxMark
;
747 GraphBuffer
[ maxPos
+ 1 ] = minMark
;
749 // hi and lo form a 64 bit pair
750 hi
= ( hi
<< 1 ) | ( lo
>> 31 );
752 // store decoded bit as binary (in hi/lo) and text (in bits[])
760 PrintAndLog ( "bits: '%s'" , bits
);
761 PrintAndLog ( "hex: %08x %08x" , hi
, lo
);
765 int CmdGrid ( const char * Cmd
)
767 sscanf ( Cmd
, "%i %i" , & PlotGridX
, & PlotGridY
);
768 PlotGridXdefault
= PlotGridX
;
769 PlotGridYdefault
= PlotGridY
;
770 RepaintGraphWindow ();
774 int CmdHexsamples ( const char * Cmd
)
780 char * string_ptr
= string_buf
;
783 sscanf ( Cmd
, "%i %i" , & requested
, & offset
);
785 /* if no args send something */
786 if ( requested
== 0 ) {
789 if ( offset
+ requested
> sizeof ( got
)) {
790 PrintAndLog ( "Tried to read past end of buffer, <bytes> + <offset> > 40000" );
794 GetFromBigBuf ( got
, requested
, offset
);
795 WaitForResponse ( CMD_ACK
, NULL
);
798 for ( j
= 0 ; j
< requested
; j
++) {
800 string_ptr
+= sprintf ( string_ptr
, "%02x " , got
[ j
]);
802 *( string_ptr
- 1 ) = '\0' ; // remove the trailing space
803 PrintAndLog ( "%s" , string_buf
);
804 string_buf
[ 0 ] = '\0' ;
805 string_ptr
= string_buf
;
808 if ( j
== requested
- 1 && string_buf
[ 0 ] != '\0' ) { // print any remaining bytes
809 *( string_ptr
- 1 ) = '\0' ;
810 PrintAndLog ( "%s" , string_buf
);
811 string_buf
[ 0 ] = '\0' ;
817 int CmdHide ( const char * Cmd
)
823 int CmdHpf ( const char * Cmd
)
828 for ( i
= 10 ; i
< GraphTraceLen
; ++ i
)
829 accum
+= GraphBuffer
[ i
];
830 accum
/= ( GraphTraceLen
- 10 );
831 for ( i
= 0 ; i
< GraphTraceLen
; ++ i
)
832 GraphBuffer
[ i
] -= accum
;
834 RepaintGraphWindow ();
838 int CmdSamples ( const char * Cmd
)
844 n
= strtol ( Cmd
, NULL
, 0 );
845 if ( n
== 0 ) n
= 6000 ;
846 if ( n
> sizeof ( got
)) n
= sizeof ( got
);
848 PrintAndLog ( "Reading %d samples \n " , n
);
849 GetFromBigBuf ( got
, n
, 0 );
850 WaitForResponse ( CMD_ACK
, NULL
);
851 for ( int j
= 0 ; j
< n
; j
++) {
852 GraphBuffer
[ cnt
++] = (( int ) got
[ j
]) - 128 ;
855 PrintAndLog ( "Done! \n " );
857 RepaintGraphWindow ();
861 int CmdTuneSamples ( const char * Cmd
)
867 PrintAndLog ( "Reading %d samples \n " , n
);
868 GetFromBigBuf ( got
, n
, 7256 ); // armsrc/apps.h: #define FREE_BUFFER_OFFSET 7256
869 WaitForResponse ( CMD_ACK
, NULL
);
870 for ( int j
= 0 ; j
< n
; j
++) {
871 GraphBuffer
[ cnt
++] = (( int ) got
[ j
]) - 128 ;
874 PrintAndLog ( "Done! Divisor 89 is 134khz, 95 is 125khz. \n " );
877 RepaintGraphWindow ();
881 int CmdLoad ( const char * Cmd
)
883 FILE * f
= fopen ( Cmd
, "r" );
885 PrintAndLog ( "couldn't open '%s'" , Cmd
);
891 while ( fgets ( line
, sizeof ( line
), f
)) {
892 GraphBuffer
[ GraphTraceLen
] = atoi ( line
);
896 PrintAndLog ( "loaded %d samples" , GraphTraceLen
);
897 RepaintGraphWindow ();
901 int CmdLtrim ( const char * Cmd
)
905 for ( int i
= ds
; i
< GraphTraceLen
; ++ i
)
906 GraphBuffer
[ i
- ds
] = GraphBuffer
[ i
];
909 RepaintGraphWindow ();
914 * Manchester demodulate a bitstream. The bitstream needs to be already in
915 * the GraphBuffer as 0 and 1 values
917 * Give the clock rate as argument in order to help the sync - the algorithm
918 * resyncs at each pulse anyway.
920 * Not optimized by any means, this is the 1st time I'm writing this type of
921 * routine, feel free to improve...
923 * 1st argument: clock rate (as number of samples per clock rate)
924 * Typical values can be 64, 32, 128...
926 int CmdManchesterDemod ( const char * Cmd
)
934 int hithigh
, hitlow
, first
;
940 /* check if we're inverting output */
943 PrintAndLog ( "Inverting output" );
948 while (* Cmd
== ' ' ); // in case a 2nd argument was given
951 /* Holds the decoded bitstream: each clock period contains 2 bits */
952 /* later simplified to 1 bit after manchester decoding. */
953 /* Add 10 bits to allow for noisy / uncertain traces without aborting */
954 /* int BitStream[GraphTraceLen*2/clock+10]; */
956 /* But it does not work if compiling on WIndows: therefore we just allocate a */
958 uint8_t BitStream
[ MAX_GRAPH_TRACE_LEN
] = { 0 };
960 /* Detect high and lows */
961 for ( i
= 0 ; i
< GraphTraceLen
; i
++)
963 if ( GraphBuffer
[ i
] > high
)
964 high
= GraphBuffer
[ i
];
965 else if ( GraphBuffer
[ i
] < low
)
966 low
= GraphBuffer
[ i
];
970 clock
= GetClock ( Cmd
, high
, 1 );
972 int tolerance
= clock
/ 4 ;
974 /* Detect first transition */
975 /* Lo-Hi (arbitrary) */
976 /* skip to the first high */
977 for ( i
= 0 ; i
< GraphTraceLen
; i
++)
978 if ( GraphBuffer
[ i
] == high
)
980 /* now look for the first low */
981 for (; i
< GraphTraceLen
; i
++)
983 if ( GraphBuffer
[ i
] == low
)
990 /* If we're not working with 1/0s, demod based off clock */
993 bit
= 0 ; /* We assume the 1st bit is zero, it may not be
994 * the case: this routine (I think) has an init problem.
997 for (; i
< ( int )( GraphTraceLen
/ clock
); i
++)
1003 /* Find out if we hit both high and low peaks */
1004 for ( j
= 0 ; j
< clock
; j
++)
1006 if ( GraphBuffer
[( i
* clock
) + j
] == high
)
1008 else if ( GraphBuffer
[( i
* clock
) + j
] == low
)
1011 /* it doesn't count if it's the first part of our read
1012 because it's really just trailing from the last sequence */
1013 if ( first
&& ( hithigh
|| hitlow
))
1014 hithigh
= hitlow
= 0 ;
1018 if ( hithigh
&& hitlow
)
1022 /* If we didn't hit both high and low peaks, we had a bit transition */
1023 if (! hithigh
|| ! hitlow
)
1026 BitStream
[ bit2idx
++] = bit
^ invert
;
1030 /* standard 1/0 bitstream */
1034 /* Then detect duration between 2 successive transitions */
1035 for ( bitidx
= 1 ; i
< GraphTraceLen
; i
++)
1037 if ( GraphBuffer
[ i
- 1 ] != GraphBuffer
[ i
])
1042 // Error check: if bitidx becomes too large, we do not
1043 // have a Manchester encoded bitstream or the clock is really
1045 if ( bitidx
> ( GraphTraceLen
* 2 / clock
+ 8 ) ) {
1046 PrintAndLog ( "Error: the clock you gave is probably wrong, aborting." );
1049 // Then switch depending on lc length:
1050 // Tolerance is 1/4 of clock rate (arbitrary)
1051 if ( abs ( lc
- clock
/ 2 ) < tolerance
) {
1052 // Short pulse : either "1" or "0"
1053 BitStream
[ bitidx
++]= GraphBuffer
[ i
- 1 ];
1054 } else if ( abs ( lc
- clock
) < tolerance
) {
1055 // Long pulse: either "11" or "00"
1056 BitStream
[ bitidx
++]= GraphBuffer
[ i
- 1 ];
1057 BitStream
[ bitidx
++]= GraphBuffer
[ i
- 1 ];
1061 PrintAndLog ( "Warning: Manchester decode error for pulse width detection." );
1062 PrintAndLog ( "(too many of those messages mean either the stream is not Manchester encoded, or clock is wrong)" );
1066 PrintAndLog ( "Error: too many detection errors, aborting." );
1073 // At this stage, we now have a bitstream of "01" ("1") or "10" ("0"), parse it into final decoded bitstream
1074 // Actually, we overwrite BitStream with the new decoded bitstream, we just need to be careful
1075 // to stop output at the final bitidx2 value, not bitidx
1076 for ( i
= 0 ; i
< bitidx
; i
+= 2 ) {
1077 if (( BitStream
[ i
] == 0 ) && ( BitStream
[ i
+ 1 ] == 1 )) {
1078 BitStream
[ bit2idx
++] = 1 ^ invert
;
1079 } else if (( BitStream
[ i
] == 1 ) && ( BitStream
[ i
+ 1 ] == 0 )) {
1080 BitStream
[ bit2idx
++] = 0 ^ invert
;
1082 // We cannot end up in this state, this means we are unsynchronized,
1086 PrintAndLog ( "Unsynchronized, resync..." );
1087 PrintAndLog ( "(too many of those messages mean the stream is not Manchester encoded)" );
1091 PrintAndLog ( "Error: too many decode errors, aborting." );
1098 PrintAndLog ( "Manchester decoded bitstream" );
1099 // Now output the bitstream to the scrollback by line of 16 bits
1100 for ( i
= 0 ; i
< ( bit2idx
- 16 ); i
+= 16 ) {
1101 PrintAndLog ( "%i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i" ,
1122 /* Modulate our data into manchester */
1123 int CmdManchesterMod ( const char * Cmd
)
1127 int bit
, lastbit
, wave
;
1130 clock
= GetClock ( Cmd
, 0 , 1 );
1134 for ( i
= 0 ; i
< ( int )( GraphTraceLen
/ clock
); i
++)
1136 bit
= GraphBuffer
[ i
* clock
] ^ 1 ;
1138 for ( j
= 0 ; j
< ( int )( clock
/ 2 ); j
++)
1139 GraphBuffer
[( i
* clock
) + j
] = bit
^ lastbit
^ wave
;
1140 for ( j
= ( int )( clock
/ 2 ); j
< clock
; j
++)
1141 GraphBuffer
[( i
* clock
) + j
] = bit
^ lastbit
^ wave
^ 1 ;
1143 /* Keep track of how we start our wave and if we changed or not this time */
1144 wave
^= bit
^ lastbit
;
1148 RepaintGraphWindow ();
1152 int CmdNorm ( const char * Cmd
)
1155 int max
= INT_MIN
, min
= INT_MAX
;
1157 for ( i
= 10 ; i
< GraphTraceLen
; ++ i
) {
1158 if ( GraphBuffer
[ i
] > max
)
1159 max
= GraphBuffer
[ i
];
1160 if ( GraphBuffer
[ i
] < min
)
1161 min
= GraphBuffer
[ i
];
1165 for ( i
= 0 ; i
< GraphTraceLen
; ++ i
) {
1166 GraphBuffer
[ i
] = ( GraphBuffer
[ i
] - (( max
+ min
) / 2 )) * 1000 /
1170 RepaintGraphWindow ();
1174 int CmdPlot ( const char * Cmd
)
1180 int CmdSave ( const char * Cmd
)
1182 FILE * f
= fopen ( Cmd
, "w" );
1184 PrintAndLog ( "couldn't open '%s'" , Cmd
);
1188 for ( i
= 0 ; i
< GraphTraceLen
; i
++) {
1189 fprintf ( f
, "%d \n " , GraphBuffer
[ i
]);
1192 PrintAndLog ( "saved to '%s'" , Cmd
);
1196 int CmdScale ( const char * Cmd
)
1198 CursorScaleFactor
= atoi ( Cmd
);
1199 if ( CursorScaleFactor
== 0 ) {
1200 PrintAndLog ( "bad, can't have zero scale" );
1201 CursorScaleFactor
= 1 ;
1203 RepaintGraphWindow ();
1207 int CmdThreshold ( const char * Cmd
)
1209 int threshold
= atoi ( Cmd
);
1211 for ( int i
= 0 ; i
< GraphTraceLen
; ++ i
) {
1212 if ( GraphBuffer
[ i
] >= threshold
)
1215 GraphBuffer
[ i
] = - 1 ;
1217 RepaintGraphWindow ();
1221 int CmdDirectionalThreshold ( const char * Cmd
)
1223 int8_t upThres
= param_get8 ( Cmd
, 0 );
1224 int8_t downThres
= param_get8 ( Cmd
, 1 );
1226 printf ( "Applying Up Threshold: %d, Down Threshold: %d \n " , upThres
, downThres
);
1228 int lastValue
= GraphBuffer
[ 0 ];
1229 GraphBuffer
[ 0 ] = 0 ; // Will be changed at the end, but init 0 as we adjust to last samples value if no threshold kicks in.
1231 for ( int i
= 1 ; i
< GraphTraceLen
; ++ i
) {
1232 // Apply first threshold to samples heading up
1233 if ( GraphBuffer
[ i
] >= upThres
&& GraphBuffer
[ i
] > lastValue
)
1235 lastValue
= GraphBuffer
[ i
]; // Buffer last value as we overwrite it.
1238 // Apply second threshold to samples heading down
1239 else if ( GraphBuffer
[ i
] <= downThres
&& GraphBuffer
[ i
] < lastValue
)
1241 lastValue
= GraphBuffer
[ i
]; // Buffer last value as we overwrite it.
1242 GraphBuffer
[ i
] = - 1 ;
1246 lastValue
= GraphBuffer
[ i
]; // Buffer last value as we overwrite it.
1247 GraphBuffer
[ i
] = GraphBuffer
[ i
- 1 ];
1251 GraphBuffer
[ 0 ] = GraphBuffer
[ 1 ]; // Aline with first edited sample.
1252 RepaintGraphWindow ();
1256 int CmdZerocrossings ( const char * Cmd
)
1258 // Zero-crossings aren't meaningful unless the signal is zero-mean.
1265 for ( int i
= 0 ; i
< GraphTraceLen
; ++ i
) {
1266 if ( GraphBuffer
[ i
] * sign
>= 0 ) {
1267 // No change in sign, reproduce the previous sample count.
1269 GraphBuffer
[ i
] = lastZc
;
1271 // Change in sign, reset the sample count.
1273 GraphBuffer
[ i
] = lastZc
;
1281 RepaintGraphWindow ();
1285 static command_t CommandTable
[] =
1287 { "help" , CmdHelp
, 1 , "This help" },
1288 { "amp" , CmdAmp
, 1 , "Amplify peaks" },
1289 { "askdemod" , Cmdaskdemod
, 1 , "<0 or 1> -- Attempt to demodulate simple ASK tags" },
1290 { "askmandemod" , Cmdaskmandemod
, 1 , "[clock] [invert<0 or 1>] -- Attempt to demodulate ASK/Manchester tags and output binary (args optional[clock will try Auto-detect])" },
1291 { "askrawdemod" , Cmdaskrawdemod
, 1 , "[clock] [invert<0 or 1>] -- Attempt to demodulate ASK tags and output binary (args optional[clock will try Auto-detect])" },
1292 { "autocorr" , CmdAutoCorr
, 1 , "<window length> -- Autocorrelation over window" },
1293 { "bitsamples" , CmdBitsamples
, 0 , "Get raw samples as bitstring" },
1294 { "bitstream" , CmdBitstream
, 1 , "[clock rate] -- Convert waveform into a bitstream" },
1295 { "buffclear" , CmdBuffClear
, 1 , "Clear sample buffer and graph window" },
1296 { "dec" , CmdDec
, 1 , "Decimate samples" },
1297 { "detectclock" , CmdDetectClockRate
, 1 , "Detect clock rate" },
1298 { "fskdemod" , CmdFSKdemod
, 1 , "Demodulate graph window as a HID FSK" },
1299 { "fskhiddemod" , CmdFSKdemodHID
, 1 , "Demodulate graph window as a HID FSK using raw" },
1300 { "fskiodemod" , CmdFSKdemodIO
, 1 , "Demodulate graph window as an IO Prox FSK using raw" },
1301 { "fskrawdemod" , CmdFSKrawdemod
, 1 , "[clock rate] [invert] Demodulate graph window from FSK to binary (clock = 64 or 50)(invert = 1 or 0)" },
1302 { "grid" , CmdGrid
, 1 , "<x> <y> -- overlay grid on graph window, use zero value to turn off either" },
1303 { "hexsamples" , CmdHexsamples
, 0 , "<bytes> [<offset>] -- Dump big buffer as hex bytes" },
1304 { "hide" , CmdHide
, 1 , "Hide graph window" },
1305 { "hpf" , CmdHpf
, 1 , "Remove DC offset from trace" },
1306 { "load" , CmdLoad
, 1 , "<filename> -- Load trace (to graph window" },
1307 { "ltrim" , CmdLtrim
, 1 , "<samples> -- Trim samples from left of trace" },
1308 { "mandemod" , CmdManchesterDemod
, 1 , "[i] [clock rate] -- Manchester demodulate binary stream (option 'i' to invert output)" },
1309 { "manrawdecode" , Cmdmandecoderaw
, 1 , "Manchester decode binary stream already in graph buffer" },
1310 { "manmod" , CmdManchesterMod
, 1 , "[clock rate] -- Manchester modulate a binary stream" },
1311 { "norm" , CmdNorm
, 1 , "Normalize max/min to +/-500" },
1312 { "plot" , CmdPlot
, 1 , "Show graph window (hit 'h' in window for keystroke help)" },
1313 { "samples" , CmdSamples
, 0 , "[512 - 40000] -- Get raw samples for graph window" },
1314 { "tune" , CmdTuneSamples
, 0 , "Get hw tune samples for graph window" },
1315 { "save" , CmdSave
, 1 , "<filename> -- Save trace (from graph window)" },
1316 { "scale" , CmdScale
, 1 , "<int> -- Set cursor display scale" },
1317 { "threshold" , CmdThreshold
, 1 , "<threshold> -- Maximize/minimize every value in the graph window depending on threshold" },
1318 { "zerocrossings" , CmdZerocrossings
, 1 , "Count time between zero-crossings" },
1319 { "dirthreshold" , CmdDirectionalThreshold
, 1 , "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev." },
1320 { NULL
, NULL
, 0 , NULL
}
1323 int CmdData ( const char * Cmd
)
1325 CmdsParse ( CommandTable
, Cmd
);
1329 int CmdHelp ( const char * Cmd
)
1331 CmdsHelp ( CommandTable
);