]>
cvs.zerfleddert.de Git - proxmark3-svn/blob - client/cmddata.c
4b5cb0401e5ab431027ae2c8dab425e868d99518
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 //-----------------------------------------------------------------------------
15 #include "proxmark3.h"
19 #include "cmdparser.h"
24 uint8_t DemodBuffer
[ MAX_DEMOD_BUF_LEN
];
26 static int CmdHelp ( const char * Cmd
);
28 //set the demod buffer with given array of binary (one bit per byte)
30 void setDemodBuf ( uint8_t * buff
, int size
)
33 for (; i
< size
; ++ i
){
34 DemodBuffer
[ i
]= buff
[ i
];
44 int bitLen
= DemodBufferLen
;
46 PrintAndLog ( "no bits found in demod buffer" );
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" ,
73 int CmdAmp ( const char * Cmd
)
75 int i
, rising
, falling
;
76 int max
= INT_MIN
, min
= INT_MAX
;
78 for ( i
= 10 ; i
< GraphTraceLen
; ++ i
) {
79 if ( GraphBuffer
[ i
] > max
)
81 if ( GraphBuffer
[ i
] < min
)
87 for ( i
= 0 ; i
< GraphTraceLen
; ++ i
) {
88 if ( GraphBuffer
[ i
+ 1 ] < GraphBuffer
[ i
]) {
95 if ( GraphBuffer
[ i
+ 1 ] > GraphBuffer
[ i
]) {
104 RepaintGraphWindow ();
109 * Generic command to demodulate ASK.
111 * Argument is convention: positive or negative (High mod means zero
112 * or high mod means one)
114 * Updates the Graph trace with 0/1 values
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
)
123 int c
, high
= 0 , low
= 0 ;
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
);
129 /* Detect high and lows and clock */
131 for ( i
= 0 ; i
< GraphTraceLen
; ++ i
)
133 if ( GraphBuffer
[ i
] > high
)
134 high
= GraphBuffer
[ i
];
135 else if ( GraphBuffer
[ i
] < low
)
136 low
= GraphBuffer
[ i
];
140 if ( c
!= 0 && c
!= 1 ) {
141 PrintAndLog ( "Invalid argument: %s" , Cmd
);
145 if ( GraphBuffer
[ 0 ] > 0 ) {
146 GraphBuffer
[ 0 ] = 1 - c
;
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
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
))){
166 GraphBuffer
[ i
] = GraphBuffer
[ i
- 1 ];
169 RepaintGraphWindow ();
174 void printBitStream ( uint8_t BitStream
[], uint32_t bitLen
)
178 PrintAndLog ( "Too few bits found: %d" , bitLen
);
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" ,
204 void printEM410x ( uint64_t id
)
208 uint64_t id2lo
= 0 ; //id2hi=0,
211 for ( ii
= 5 ; ii
> 0 ; ii
--){
213 id2lo
=( id2lo
<< 1LL )|(( id
& ( iii
<<( i
+(( ii
- 1 )* 8 ))))>>( i
+(( ii
- 1 )* 8 )));
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 ));
231 int CmdEm410xDecode ( const char * Cmd
)
234 // uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
236 // i=getFromGraphBuf(BitStream);
237 id
= Em410xDecode ( DemodBuffer
, DemodBufferLen
);
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
)
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
);
259 int BitLen
= getFromGraphBuf ( BitStream
);
260 // PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);
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);
267 PrintAndLog ( " \n Using Clock: %d - Invert: %d - Bits Found: %d" , clk
, invert
, BitLen
);
271 PrintAndLog ( "# Errors during Demoding (shown as 77 in bit stream): %d" , errCnt
);
273 PrintAndLog ( "ASK/Manchester decoded bitstream:" );
274 // Now output the bitstream to the scrollback by line of 16 bits
275 setDemodBuf ( BitStream
, BitLen
);
278 lo
= Em410xDecode ( BitStream
, BitLen
);
280 //set GraphBuffer for clone or sim command
281 PrintAndLog ( "EM410x pattern found: " );
285 //if (BitLen>16) return 1;
291 //stricktly take 10 and 01 and convert to 0 and 1
292 int Cmdmandecoderaw ( const char * Cmd
)
297 uint8_t BitStream
[ MAX_GRAPH_TRACE_LEN
]={ 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
];
304 if ( high
> 1 || low
< 0 ){
305 PrintAndLog ( "Error: please raw demod the wave first then mancheseter raw decode" );
309 errCnt
= manrawdecode ( BitStream
,& bitnum
);
311 PrintAndLog ( "Too many errors: %d" , errCnt
);
314 PrintAndLog ( "Manchester Decoded - # errors:%d - data:" , errCnt
);
315 printBitStream ( BitStream
, bitnum
);
318 id
= Em410xDecode ( BitStream
, bitnum
);
319 if ( id
> 0 ) setDemodBuf ( BitStream
, bitnum
);
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
)
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
];
349 if ( high
> 1 || low
< 0 ){
350 PrintAndLog ( "Error: please raw demod the wave first then decode" );
354 errCnt
= BiphaseRawDecode ( BitStream
,& bitnum
, offset
);
356 PrintAndLog ( "Too many errors attempting to decode: %d" , errCnt
);
359 PrintAndLog ( "Biphase Decoded using offset: %d - # errors:%d - data:" , offset
, errCnt
);
360 printBitStream ( BitStream
, bitnum
);
361 PrintAndLog ( " \n if bitstream does not look right try offset=1" );
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
)
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
);
380 int BitLen
= getFromGraphBuf ( BitStream
);
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" );
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
);
394 PrintAndLog ( "# Errors during Demoding (shown as 77 in bit stream): %d" , errCnt
);
396 PrintAndLog ( "ASK demoded bitstream:" );
397 // Now output the bitstream to the scrollback by line of 16 bits
398 printBitStream ( BitStream
, BitLen
);
403 int CmdAutoCorr ( const char * Cmd
)
405 static int CorrelBuffer
[ MAX_GRAPH_TRACE_LEN
];
407 int window
= atoi ( Cmd
);
410 PrintAndLog ( "needs a window" );
413 if ( window
>= GraphTraceLen
) {
414 PrintAndLog ( "window must be smaller than trace (%d samples)" ,
419 PrintAndLog ( "performing %d correlations" , GraphTraceLen
- window
);
421 for ( int i
= 0 ; i
< GraphTraceLen
- window
; ++ i
) {
423 for ( int j
= 0 ; j
< window
; ++ j
) {
424 sum
+= ( GraphBuffer
[ j
]* GraphBuffer
[ i
+ j
]) / 256 ;
426 CorrelBuffer
[ i
] = sum
;
428 GraphTraceLen
= GraphTraceLen
- window
;
429 memcpy ( GraphBuffer
, CorrelBuffer
, GraphTraceLen
* sizeof ( int ));
431 RepaintGraphWindow ();
435 int CmdBitsamples ( const char * Cmd
)
440 GetFromBigBuf ( got
, sizeof ( got
), 0 );
441 WaitForResponse ( CMD_ACK
, NULL
);
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 ;
448 GraphBuffer
[ cnt
++] = 0 ;
453 RepaintGraphWindow ();
458 * Convert to a bitstream
460 int CmdBitstream ( const char * Cmd
)
468 int hithigh
, hitlow
, first
;
470 /* Detect high and lows and clock */
471 for ( i
= 0 ; i
< GraphTraceLen
; ++ i
)
473 if ( GraphBuffer
[ i
] > high
)
474 high
= GraphBuffer
[ i
];
475 else if ( GraphBuffer
[ i
] < low
)
476 low
= GraphBuffer
[ i
];
480 clock
= GetClock ( Cmd
, high
, 1 );
484 for ( i
= 0 ; i
< ( int )( gtl
/ clock
); ++ i
)
489 /* Find out if we hit both high and low peaks */
490 for ( j
= 0 ; j
< clock
; ++ j
)
492 if ( GraphBuffer
[( i
* clock
) + j
] == high
)
494 else if ( GraphBuffer
[( i
* clock
) + j
] == low
)
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 ;
503 if ( hithigh
&& hitlow
)
507 /* If we didn't hit both high and low peaks, we had a bit transition */
508 if (! hithigh
|| ! hitlow
)
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;
518 RepaintGraphWindow ();
522 int CmdBuffClear ( const char * Cmd
)
524 UsbCommand c
= { CMD_BUFF_CLEAR
};
530 int CmdDec ( const char * Cmd
)
532 for ( int i
= 0 ; i
< ( GraphTraceLen
/ 2 ); ++ i
)
533 GraphBuffer
[ i
] = GraphBuffer
[ i
* 2 ];
535 PrintAndLog ( "decimated by 2" );
536 RepaintGraphWindow ();
540 /* Print our clock rate */
541 // uses data from graphbuffer
542 int CmdDetectClockRate ( const char * Cmd
)
545 //int clock = DetectASKClock(0);
546 //PrintAndLog("Auto-detected clock rate: %d", clock);
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
)
556 //raw fsk demod no manchester decoding no start bit finding just get binary from wave
562 //set options from parameters entered with the command
563 sscanf ( Cmd
, "%i %i %i %i" , & rfLen
, & invert
, & fchigh
, & fclow
);
565 if ( strlen ( Cmd
)> 0 && strlen ( Cmd
)<= 2 ) {
566 //rfLen=param_get8(Cmd, 0); //if rfLen option only is used
568 invert
= 1 ; //if invert option only is used
570 } else if ( rfLen
== 0 ) rfLen
= 50 ;
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
);
577 PrintAndLog ( "FSK decoded bitstream:" );
578 setDemodBuf ( BitStream
, size
);
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
);
584 PrintAndLog ( "no FSK data found" );
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
)
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 ;
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
);
602 PrintAndLog ( "Error demoding fsk" );
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
);
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
616 uint32_t cardnum
= 0 ;
617 if ((( hi
>> 5 )& 1 )== 1 ){ //if bit 38 is set then < 37 bit format is used
619 lo2
=((( hi
& 15 ) << 12 ) | ( lo
>> 20 )); //get bits 21-37 to check for format len bit
621 while ( lo2
> 1 ){ //find last bit set to 1 (format len bit)
629 cardnum
= ( lo
>> 1 )& 0xFFFF ;
633 cardnum
= ( lo
>> 1 )& 0x7FFFF ;
634 fc
= (( hi
& 0xF )<< 12 )|( lo
>> 20 );
637 cardnum
= ( lo
>> 1 )& 0xFFFF ;
638 fc
= (( hi
& 1 )<< 15 )|( lo
>> 17 );
641 cardnum
= ( lo
>> 1 )& 0xFFFFF ;
642 fc
= (( hi
& 1 )<< 11 )|( lo
>> 21 );
645 else { //if bit 38 is not set then 37 bit format is used
650 cardnum
= ( lo
>> 1 )& 0x7FFFF ;
651 fc
= (( hi
& 0xF )<< 12 )|( lo
>> 20 );
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
);
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
)
668 //raw fsk demod no manchester decoding no start bit finding just get binary from wave
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
);
679 //PrintAndLog("Error demoding fsk");
682 // PrintAndLog("DEBUG: Got IOdemodFSK");
684 //PrintAndLog("IO Prox Data not found - FSK Data:");
685 //if (BitLen > 92) printBitStream(BitStream,92);
689 //0 10 20 30 40 50 60
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
695 //XSF(version)facility:codeone+codetwo (raw)
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 ]);
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
);
714 DemodBuffer
[ i
]= BitStream
[ idx
++];
719 int CmdFSKdemod ( const char * Cmd
) //old CmdFSKdemod needs updating
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
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 ,
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 ;
743 int minMark
= 0 , maxMark
= 0 ;
745 for ( i
= 0 ; i
< GraphTraceLen
- convLen
; ++ i
) {
746 int lowSum
= 0 , highSum
= 0 ;
748 for ( j
= 0 ; j
< lowLen
; ++ j
) {
749 lowSum
+= LowTone
[ j
]* GraphBuffer
[ i
+ j
];
751 for ( j
= 0 ; j
< highLen
; ++ j
) {
752 highSum
+= HighTone
[ j
] * GraphBuffer
[ i
+ j
];
754 lowSum
= abs ( 100 * lowSum
/ lowLen
);
755 highSum
= abs ( 100 * highSum
/ highLen
);
756 GraphBuffer
[ i
] = ( highSum
<< 16 ) | lowSum
;
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 );
765 for ( j
= 0 ; j
< 8 ; j
++) {
766 highTot
+= ( GraphBuffer
[ i
+ j
] >> 16 );
768 GraphBuffer
[ i
] = lowTot
- highTot
;
769 if ( GraphBuffer
[ i
] > maxMark
) maxMark
= GraphBuffer
[ i
];
770 if ( GraphBuffer
[ i
] < minMark
) minMark
= GraphBuffer
[ i
];
773 GraphTraceLen
-= ( convLen
+ 16 );
774 RepaintGraphWindow ();
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
) {
780 for ( j
= 0 ; j
< 3 * lowLen
; ++ j
) {
781 dec
-= GraphBuffer
[ i
+ j
];
783 for (; j
< 3 * ( lowLen
+ highLen
); ++ j
) {
784 dec
+= GraphBuffer
[ i
+ j
];
792 // place start of bit sync marker in graph
793 GraphBuffer
[ maxPos
] = maxMark
;
794 GraphBuffer
[ maxPos
+ 1 ] = minMark
;
798 // place end of bit sync marker in graph
799 GraphBuffer
[ maxPos
] = maxMark
;
800 GraphBuffer
[ maxPos
+ 1 ] = minMark
;
802 PrintAndLog ( "actual data bits start at sample %d" , maxPos
);
803 PrintAndLog ( "length %d/%d" , highLen
, lowLen
);
806 bits
[ sizeof ( bits
)- 1 ] = '\0' ;
808 // find bit pairs and manchester decode them
809 for ( i
= 0 ; i
< arraylen ( bits
) - 1 ; ++ i
) {
811 for ( j
= 0 ; j
< lowLen
; ++ j
) {
812 dec
-= GraphBuffer
[ maxPos
+ j
];
814 for (; j
< lowLen
+ highLen
; ++ j
) {
815 dec
+= GraphBuffer
[ maxPos
+ j
];
818 // place inter bit marker in graph
819 GraphBuffer
[ maxPos
] = maxMark
;
820 GraphBuffer
[ maxPos
+ 1 ] = minMark
;
822 // hi and lo form a 64 bit pair
823 hi
= ( hi
<< 1 ) | ( lo
>> 31 );
825 // store decoded bit as binary (in hi/lo) and text (in bits[])
833 PrintAndLog ( "bits: '%s'" , bits
);
834 PrintAndLog ( "hex: %08x %08x" , hi
, lo
);
838 int CmdDetectNRZpskClockRate ( const char * Cmd
)
840 GetNRZpskClock ( "" , 0 , 0 );
844 int PSKnrzDemod ( const char * Cmd
){
847 sscanf ( Cmd
, "%i %i" , & clk
, & invert
);
848 if ( invert
!= 0 && invert
!= 1 ) {
849 PrintAndLog ( "Invalid argument: %s" , Cmd
);
852 uint8_t BitStream
[ MAX_GRAPH_TRACE_LEN
]={ 0 };
853 int BitLen
= getFromGraphBuf ( BitStream
);
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);
860 PrintAndLog ( "Tried PSK/NRZ Demod using Clock: %d - invert: %d - Bits Found: %d" , clk
, invert
, BitLen
);
862 //prime demod buffer for output
863 setDemodBuf ( BitStream
, BitLen
);
866 // Indala 26 bit decode
868 // optional arguments - same as CmdpskNRZrawDemod (clock & invert)
869 int CmdIndalaDecode ( const char * Cmd
)
872 int ans
= PSKnrzDemod ( Cmd
);
874 PrintAndLog ( "Error1: %d" , ans
);
878 ans
= indala26decode ( DemodBuffer
, & DemodBufferLen
, & invert
);
880 PrintAndLog ( "Error2: %d" , ans
);
884 if ( invert
== 1 ) PrintAndLog ( "Had to invert bits" );
886 uint32_t uid1
, uid2
, uid3
, uid4
, uid5
, uid6
, uid7
;
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 ) {
903 PrintAndLog ( "Indala UID=%s (%x%08x)" , showbits
, uid1
, uid2
);
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 ) {
928 PrintAndLog ( "Indala UID=%s (%x%08x%08x%08x%08x%08x%08x)" , showbits
, uid1
, uid2
, uid3
, uid4
, uid5
, uid6
, uid7
);
934 //by marshmellow (attempt to get rid of high immediately after a low)
935 void pskCleanWave2(uint8_t *bitStream, int bitLen)
940 // int loopMax = 2048;
943 for (i=0; i<bitLen; ++i)
944 if (bitStream[i]<low) low=bitStream[i];
946 low = (int)(((low-128)*.80)+128);
947 PrintAndLog("low: %d",low);
948 for (i=0; i<bitLen; ++i){
957 if (bitStream[i]<=low) newLow=1;
962 int CmdPskClean ( const char * Cmd
)
964 uint8_t bitStream
[ MAX_GRAPH_TRACE_LEN
]={ 0 };
965 int bitLen
= getFromGraphBuf ( bitStream
);
966 pskCleanWave ( bitStream
, bitLen
);
967 setGraphBuf ( bitStream
, bitLen
);
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
)
977 int errCnt
= PSKnrzDemod ( Cmd
);
979 if ( errCnt
< 0 ) return 0 ;
981 PrintAndLog ( "# Errors during Demoding (shown as 77 in bit stream): %d" , errCnt
);
983 PrintAndLog ( "PSK or NRZ demoded bitstream:" );
984 // Now output the bitstream to the scrollback by line of 16 bits
992 int CmdGrid ( const char * Cmd
)
994 sscanf ( Cmd
, "%i %i" , & PlotGridX
, & PlotGridY
);
995 PlotGridXdefault
= PlotGridX
;
996 PlotGridYdefault
= PlotGridY
;
997 RepaintGraphWindow ();
1001 int CmdHexsamples ( const char * Cmd
)
1006 char string_buf
[ 25 ];
1007 char * string_ptr
= string_buf
;
1010 sscanf ( Cmd
, "%i %i" , & requested
, & offset
);
1012 /* if no args send something */
1013 if ( requested
== 0 ) {
1016 if ( offset
+ requested
> sizeof ( got
)) {
1017 PrintAndLog ( "Tried to read past end of buffer, <bytes> + <offset> > 40000" );
1021 GetFromBigBuf ( got
, requested
, offset
);
1022 WaitForResponse ( CMD_ACK
, NULL
);
1025 for ( j
= 0 ; j
< requested
; j
++) {
1027 string_ptr
+= sprintf ( string_ptr
, "%02x " , got
[ j
]);
1029 *( string_ptr
- 1 ) = '\0' ; // remove the trailing space
1030 PrintAndLog ( "%s" , string_buf
);
1031 string_buf
[ 0 ] = '\0' ;
1032 string_ptr
= string_buf
;
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' ;
1044 int CmdHide ( const char * Cmd
)
1050 int CmdHpf ( const char * Cmd
)
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
;
1061 RepaintGraphWindow ();
1065 int CmdSamples ( const char * Cmd
)
1071 n
= strtol ( Cmd
, NULL
, 0 );
1072 if ( n
== 0 ) n
= 6000 ;
1073 if ( n
> sizeof ( got
)) n
= sizeof ( got
);
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 ;
1082 PrintAndLog ( "Done! \n " );
1084 RepaintGraphWindow ();
1088 int CmdTuneSamples ( const char * Cmd
)
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 ;
1101 PrintAndLog ( "Done! Divisor 89 is 134khz, 95 is 125khz. \n " );
1104 RepaintGraphWindow ();
1108 int CmdLoad ( const char * Cmd
)
1110 FILE * f
= fopen ( Cmd
, "r" );
1112 PrintAndLog ( "couldn't open '%s'" , Cmd
);
1118 while ( fgets ( line
, sizeof ( line
), f
)) {
1119 GraphBuffer
[ GraphTraceLen
] = atoi ( line
);
1123 PrintAndLog ( "loaded %d samples" , GraphTraceLen
);
1124 RepaintGraphWindow ();
1128 int CmdLtrim ( const char * Cmd
)
1132 for ( int i
= ds
; i
< GraphTraceLen
; ++ i
)
1133 GraphBuffer
[ i
- ds
] = GraphBuffer
[ i
];
1134 GraphTraceLen
-= ds
;
1136 RepaintGraphWindow ();
1139 int CmdRtrim ( const char * Cmd
)
1145 RepaintGraphWindow ();
1150 * Manchester demodulate a bitstream. The bitstream needs to be already in
1151 * the GraphBuffer as 0 and 1 values
1153 * Give the clock rate as argument in order to help the sync - the algorithm
1154 * resyncs at each pulse anyway.
1156 * Not optimized by any means, this is the 1st time I'm writing this type of
1157 * routine, feel free to improve...
1159 * 1st argument: clock rate (as number of samples per clock rate)
1160 * Typical values can be 64, 32, 128...
1162 int CmdManchesterDemod ( const char * Cmd
)
1164 int i
, j
, invert
= 0 ;
1170 int hithigh
, hitlow
, first
;
1176 /* check if we're inverting output */
1179 PrintAndLog ( "Inverting output" );
1184 while (* Cmd
== ' ' ); // in case a 2nd argument was given
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]; */
1192 /* But it does not work if compiling on WIndows: therefore we just allocate a */
1194 uint8_t BitStream
[ MAX_GRAPH_TRACE_LEN
] = { 0 };
1196 /* Detect high and lows */
1197 for ( i
= 0 ; i
< GraphTraceLen
; i
++)
1199 if ( GraphBuffer
[ i
] > high
)
1200 high
= GraphBuffer
[ i
];
1201 else if ( GraphBuffer
[ i
] < low
)
1202 low
= GraphBuffer
[ i
];
1206 clock
= GetClock ( Cmd
, high
, 1 );
1208 int tolerance
= clock
/ 4 ;
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
)
1216 /* now look for the first low */
1217 for (; i
< GraphTraceLen
; i
++)
1219 if ( GraphBuffer
[ i
] == low
)
1226 /* If we're not working with 1/0s, demod based off clock */
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.
1233 for (; i
< ( int )( GraphTraceLen
/ clock
); i
++)
1239 /* Find out if we hit both high and low peaks */
1240 for ( j
= 0 ; j
< clock
; j
++)
1242 if ( GraphBuffer
[( i
* clock
) + j
] == high
)
1244 else if ( GraphBuffer
[( i
* clock
) + j
] == low
)
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 ;
1254 if ( hithigh
&& hitlow
)
1258 /* If we didn't hit both high and low peaks, we had a bit transition */
1259 if (! hithigh
|| ! hitlow
)
1262 BitStream
[ bit2idx
++] = bit
^ invert
;
1266 /* standard 1/0 bitstream */
1270 /* Then detect duration between 2 successive transitions */
1271 for ( bitidx
= 1 ; i
< GraphTraceLen
; i
++)
1273 if ( GraphBuffer
[ i
- 1 ] != GraphBuffer
[ i
])
1278 // Error check: if bitidx becomes too large, we do not
1279 // have a Manchester encoded bitstream or the clock is really
1281 if ( bitidx
> ( GraphTraceLen
* 2 / clock
+ 8 ) ) {
1282 PrintAndLog ( "Error: the clock you gave is probably wrong, aborting." );
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 ];
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)" );
1302 PrintAndLog ( "Error: too many detection errors, aborting." );
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
;
1318 // We cannot end up in this state, this means we are unsynchronized,
1322 PrintAndLog ( "Unsynchronized, resync..." );
1323 PrintAndLog ( "(too many of those messages mean the stream is not Manchester encoded)" );
1327 PrintAndLog ( "Error: too many decode errors, aborting." );
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" ,
1358 /* Modulate our data into manchester */
1359 int CmdManchesterMod ( const char * Cmd
)
1363 int bit
, lastbit
, wave
;
1366 clock
= GetClock ( Cmd
, 0 , 1 );
1370 for ( i
= 0 ; i
< ( int )( GraphTraceLen
/ clock
); i
++)
1372 bit
= GraphBuffer
[ i
* clock
] ^ 1 ;
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 ;
1379 /* Keep track of how we start our wave and if we changed or not this time */
1380 wave
^= bit
^ lastbit
;
1384 RepaintGraphWindow ();
1388 int CmdNorm ( const char * Cmd
)
1391 int max
= INT_MIN
, min
= INT_MAX
;
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
];
1401 for ( i
= 0 ; i
< GraphTraceLen
; ++ i
) {
1402 GraphBuffer
[ i
] = ( GraphBuffer
[ i
] - (( max
+ min
) / 2 )) * 256 /
1404 //marshmelow: adjusted *1000 to *256 to make +/- 128 so demod commands still work
1407 RepaintGraphWindow ();
1411 int CmdPlot ( const char * Cmd
)
1417 int CmdSave ( const char * Cmd
)
1419 FILE * f
= fopen ( Cmd
, "w" );
1421 PrintAndLog ( "couldn't open '%s'" , Cmd
);
1425 for ( i
= 0 ; i
< GraphTraceLen
; i
++) {
1426 fprintf ( f
, "%d \n " , GraphBuffer
[ i
]);
1429 PrintAndLog ( "saved to '%s'" , Cmd
);
1433 int CmdScale ( const char * Cmd
)
1435 CursorScaleFactor
= atoi ( Cmd
);
1436 if ( CursorScaleFactor
== 0 ) {
1437 PrintAndLog ( "bad, can't have zero scale" );
1438 CursorScaleFactor
= 1 ;
1440 RepaintGraphWindow ();
1444 int CmdThreshold ( const char * Cmd
)
1446 int threshold
= atoi ( Cmd
);
1448 for ( int i
= 0 ; i
< GraphTraceLen
; ++ i
) {
1449 if ( GraphBuffer
[ i
] >= threshold
)
1452 GraphBuffer
[ i
] = - 1 ;
1454 RepaintGraphWindow ();
1458 int CmdDirectionalThreshold ( const char * Cmd
)
1460 int8_t upThres
= param_get8 ( Cmd
, 0 );
1461 int8_t downThres
= param_get8 ( Cmd
, 1 );
1463 printf ( "Applying Up Threshold: %d, Down Threshold: %d \n " , upThres
, downThres
);
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.
1468 for ( int i
= 1 ; i
< GraphTraceLen
; ++ i
) {
1469 // Apply first threshold to samples heading up
1470 if ( GraphBuffer
[ i
] >= upThres
&& GraphBuffer
[ i
] > lastValue
)
1472 lastValue
= GraphBuffer
[ i
]; // Buffer last value as we overwrite it.
1475 // Apply second threshold to samples heading down
1476 else if ( GraphBuffer
[ i
] <= downThres
&& GraphBuffer
[ i
] < lastValue
)
1478 lastValue
= GraphBuffer
[ i
]; // Buffer last value as we overwrite it.
1479 GraphBuffer
[ i
] = - 1 ;
1483 lastValue
= GraphBuffer
[ i
]; // Buffer last value as we overwrite it.
1484 GraphBuffer
[ i
] = GraphBuffer
[ i
- 1 ];
1488 GraphBuffer
[ 0 ] = GraphBuffer
[ 1 ]; // Aline with first edited sample.
1489 RepaintGraphWindow ();
1493 int CmdZerocrossings ( const char * Cmd
)
1495 // Zero-crossings aren't meaningful unless the signal is zero-mean.
1502 for ( int i
= 0 ; i
< GraphTraceLen
; ++ i
) {
1503 if ( GraphBuffer
[ i
] * sign
>= 0 ) {
1504 // No change in sign, reproduce the previous sample count.
1506 GraphBuffer
[ i
] = lastZc
;
1508 // Change in sign, reset the sample count.
1510 GraphBuffer
[ i
] = lastZc
;
1518 RepaintGraphWindow ();
1522 static command_t CommandTable
[] =
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
}
1566 int CmdData ( const char * Cmd
)
1568 CmdsParse ( CommandTable
, Cmd
);
1572 int CmdHelp ( const char * Cmd
)
1574 CmdsHelp ( CommandTable
);