]> cvs.zerfleddert.de Git - proxmark3-svn/commitdiff
FIX: a shot at fixing the "_" underscore problem in fileutils.c. This one uses _ifde...
authoriceman1001 <iceman@iuse.se>
Sun, 4 Jan 2015 21:49:54 +0000 (22:49 +0100)
committericeman1001 <iceman@iuse.se>
Sun, 4 Jan 2015 21:49:54 +0000 (22:49 +0100)
FIX: changed the DetectASKClock in lfdemod.c to correct detect all clocks in the array.
CHG: I like code with more spaces inside of it and tried change some stuff according to our codestyle in HACKING.txt
ADD: some zero checks and overflows, god knows where it was.

The T55XX commands will be rewritten to use Marshmellows lfdemod.c instead.
CHG: Made the graph window smaller.
CHG: lf read  now does a "data samples" also.  (less writing commands)
CHG: data samples now defaults to samples size of 20000

12 files changed:
armsrc/desfire_crypto.c
armsrc/lfops.c
client/cmddata.c
client/cmdlf.c
client/cmdlfem4x.c
client/cmdlft55xx.c
client/graph.c
client/graph.h
client/loclass/fileutils.c
client/proxguiqt.cpp
client/ui.c
common/lfdemod.c

index b77ad8ef9141c05cb0e42c52e9e51da04c0d2aaf..9ea07371f9d2fa84d5e13abfbbd304a2e84674e6 100644 (file)
@@ -321,7 +321,7 @@ void* mifare_cryto_postprocess_data (desfiretag_t tag, void *data, ssize_t *nbyt
                     *nbytes = -1;
                     res = NULL;
 #ifdef WITH_DEBUG
-                    printf ("No room for MAC!");
+                    Dbprintf ("No room for MAC!");
 #endif
                     break;
                 }
@@ -336,7 +336,7 @@ void* mifare_cryto_postprocess_data (desfiretag_t tag, void *data, ssize_t *nbyt
 
                 if (0 != memcmp ((uint8_t *)data + *nbytes - 1, (uint8_t *)edata + edl - 8, 4)) {
 #ifdef WITH_DEBUG
-                    printf ("MACing not verified");
+                    Dbprintf ("MACing not verified");
                     hexdump ((uint8_t *)data + *nbytes - 1, key_macing_length (key), "Expect ", 0);
                     hexdump ((uint8_t *)edata + edl - 8, key_macing_length (key), "Actual ", 0);
 #endif
@@ -366,7 +366,7 @@ void* mifare_cryto_postprocess_data (desfiretag_t tag, void *data, ssize_t *nbyt
                 ((uint8_t *)data)[*nbytes - 9] = first_cmac_byte;
                 if (0 != memcmp (DESFIRE (tag)->cmac, (uint8_t *)data + *nbytes - 9, 8)) {
 #ifdef WITH_DEBUG
-                    printf ("CMAC NOT verified :-(");
+                    Dbprintf ("CMAC NOT verified :-(");
                     hexdump ((uint8_t *)data + *nbytes - 9, 8, "Expect ", 0);
                     hexdump (DESFIRE (tag)->cmac, 8, "Actual ", 0);
 #endif
index ea2b0c44be2d3c7cccc49eed1cf9a856de231052..cc9814be645654b7eaa6178507303cb55e678dde 100644 (file)
@@ -64,9 +64,9 @@ void SnoopLFRawAdcSamples(int divisor, int trigger_threshold)
 // split into two routines so we can avoid timing issues after sending commands //
 void DoAcquisition125k_internal(int trigger_threshold, bool silent)
 {
-       uint8_t *dest = get_bigbufptr_recvrespbuf();
+       uint8_t *dest = (uint8_t *)BigBuf;
        uint16_t i = 0;
-       memset(dest, 0x00, FREE_BUFFER_SIZE);
+       memset(dest, 0x00, BIGBUF_SIZE);
 
        for(;;) {
                if (AT91C_BASE_SSC->SSC_SR & AT91C_SSC_TXRDY) {
@@ -80,7 +80,7 @@ void DoAcquisition125k_internal(int trigger_threshold, bool silent)
                                continue;
                        else
                                trigger_threshold = -1;
-                       if (++i >= FREE_BUFFER_SIZE) break;
+                       if (++i >= BIGBUF_SIZE) break;
                }
        }
        if (!silent){
@@ -161,8 +161,6 @@ void ReadTItag(void)
 
        signed char *dest = (signed char *)BigBuf;
        int n = sizeof(BigBuf);
-//     int *dest = GraphBuffer;
-//     int n = GraphTraceLen;
 
        // 128 bit shift register [shift3:shift2:shift1:shift0]
        uint32_t shift3 = 0, shift2 = 0, shift1 = 0, shift0 = 0;
@@ -569,8 +567,6 @@ void SimulateTagLowFrequency( uint16_t period, uint32_t gap, uint8_t ledcontrol)
 
 void SimulateTagLowFrequencyA(int len, int gap)
 {
-       //Dbprintf("LEN %d || Gap %d",len, gap);
-
        uint8_t *buf = (uint8_t *)BigBuf;
 
        FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
@@ -624,7 +620,7 @@ static void fc(int c, uint16_t *n) {
        int idx;
 
        // for when we want an fc8 pattern every 4 logical bits
-       if(c==0) {
+       if(c == 0) {
                dest[((*n)++)]=1;
                dest[((*n)++)]=1;
                dest[((*n)++)]=0;
@@ -635,7 +631,7 @@ static void fc(int c, uint16_t *n) {
                dest[((*n)++)]=0;
        }
        //      an fc/8  encoded bit is a bit pattern of  11000000  x6 = 48 samples
-       if(c==8) {
+       if(c == 8) {
                for (idx=0; idx<6; idx++) {
                        dest[((*n)++)]=1;
                        dest[((*n)++)]=1;
@@ -649,8 +645,8 @@ static void fc(int c, uint16_t *n) {
        }
 
        //      an fc/10 encoded bit is a bit pattern of 1110000000 x5 = 50 samples
-       if(c==10) {
-               for (idx=0; idx<5; idx++) {
+       if(c == 10) {
+               for (idx = 0; idx < 5; idx++) {
                        dest[((*n)++)]=1;
                        dest[((*n)++)]=1;
                        dest[((*n)++)]=1;
@@ -669,7 +665,7 @@ static void fc(int c, uint16_t *n) {
 // simulate a HID tag until the button is pressed
 void CmdHIDsimTAG(int hi, int lo, uint8_t ledcontrol)
 {
-       uint16_t n=0, i=0;
+       uint16_t n = 0, i = 0;
        /*
         HID tag bitstream format
         The tag contains a 44bit unique code. This is sent out MSB first in sets of 4 bits
@@ -680,11 +676,11 @@ void CmdHIDsimTAG(int hi, int lo, uint8_t ledcontrol)
         nor 1 bits, they are special patterns (a = set of 12 fc8 and b = set of 10 fc10)
        */
 
-       if (hi>0xFFF) {
+       if (hi > 0xFFF) {
                DbpString("Tags can only have 44 bits.");
                return;
        }
-       fc(0,&n);
+       fc(0, &n);
        // special start of frame marker containing invalid bit sequences
        fc(8,  &n);     fc(8,  &n);     // invalid
        fc(8,  &n);     fc(10, &n); // logical 0
@@ -693,9 +689,9 @@ void CmdHIDsimTAG(int hi, int lo, uint8_t ledcontrol)
 
        WDT_HIT();
        // manchester encode bits 43 to 32
-       for (i=11; i>=0; i--) {
-               if ((i%4)==3) fc(0,&n);
-               if ((hi>>i)&1) {
+       for (i = 11; i >= 0; i--) {
+               if ((i % 4) == 3) fc(0, &n);
+               if ((hi >> i) & 1) {
                        fc(10, &n);     fc(8,  &n);             // low-high transition
                } else {
                        fc(8,  &n);     fc(10, &n);             // high-low transition
@@ -704,9 +700,9 @@ void CmdHIDsimTAG(int hi, int lo, uint8_t ledcontrol)
 
        WDT_HIT();
        // manchester encode bits 31 to 0
-       for (i=31; i>=0; i--) {
-               if ((i%4)==3) fc(0,&n);
-               if ((lo>>i)&1) {
+       for (i = 31; i >= 0; i--) {
+               if ((i % 4 ) == 3) fc(0, &n);
+               if ((lo >> i ) & 1) {
                        fc(10, &n);     fc(8,  &n);             // low-high transition
                } else {
                        fc(8,  &n);     fc(10, &n);             // high-low transition
@@ -725,10 +721,8 @@ void CmdHIDsimTAG(int hi, int lo, uint8_t ledcontrol)
 // loop to get raw HID waveform then FSK demodulate the TAG ID from it
 void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
 {
-       uint8_t *dest = get_bigbufptr_recvrespbuf();
-
-       size_t size=0; //, found=0;
-       uint32_t hi2=0, hi=0, lo=0;
+       uint8_t *dest = (uint8_t *)BigBuf;
+       uint32_t hi2 = 0, hi = 0, lo = 0;
 
        // Configure to go in 125Khz listen mode
        LFSetupFPGAForADC(0, true);
@@ -739,77 +733,84 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
                if (ledcontrol) LED_A_ON();
 
                DoAcquisition125k_internal(-1,true);
-               size  = sizeof(BigBuf);
-    if (size < 2000) continue; 
-               // FSK demodulator
 
-               int bitLen = HIDdemodFSK(dest,size,&hi2,&hi,&lo);
+               // FSK demodulator
+               int bitLen = HIDdemodFSK(dest,BIGBUF_SIZE,&hi2,&hi,&lo);
 
                WDT_HIT();
 
-               if (bitLen>0 && lo>0){
+               if (bitLen > 0 && lo > 0){
+
                // final loop, go over previously decoded manchester data and decode into usable tag ID
                // 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
-                                               if (hi2 != 0){ //extra large HID tags
-                                                       Dbprintf("TAG ID: %x%08x%08x (%d)",
-                                                                (unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
-                       }else {  //standard HID tags <38 bits
-                                                       //Dbprintf("TAG ID: %x%08x (%d)",(unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); //old print cmd
-                                                       uint8_t bitlen = 0;
-                                                       uint32_t fc = 0;
-                                                       uint32_t cardnum = 0;
-                                                       if (((hi>>5)&1)==1){//if bit 38 is set then < 37 bit format is used
-                                                               uint32_t lo2=0;
-                                                               lo2=(((hi & 31) << 12) | (lo>>20)); //get bits 21-37 to check for format len bit
-                                                               uint8_t idx3 = 1;
-                                                               while(lo2>1){ //find last bit set to 1 (format len bit)
-                                                                       lo2=lo2>>1;
-                                                                       idx3++;
-                                                               }
-                                                               bitlen =idx3+19;  
-                                                               fc =0;
-                                                               cardnum=0;
-                                                               if(bitlen==26){
-                                                                       cardnum = (lo>>1)&0xFFFF;
-                                                                       fc = (lo>>17)&0xFF;
-                                                               }
-                                                               if(bitlen==37){
-                                                                       cardnum = (lo>>1)&0x7FFFF;
-                                                                       fc = ((hi&0xF)<<12)|(lo>>20);
-                                                               }
-                                                               if(bitlen==34){
-                                                                       cardnum = (lo>>1)&0xFFFF;
-                                                                       fc= ((hi&1)<<15)|(lo>>17);
-                                                               }
-                                                               if(bitlen==35){
-                                                                       cardnum = (lo>>1)&0xFFFFF;
-                                                                       fc = ((hi&1)<<11)|(lo>>21);
-                                                               }
-                                                       }
-                                                       else { //if bit 38 is not set then 37 bit format is used
-                                                               bitlen= 37;
-                                                               fc =0;
-                                                               cardnum=0;
-                                                               if(bitlen==37){
-                                                                       cardnum = (lo>>1)&0x7FFFF;
-                                                                       fc = ((hi&0xF)<<12)|(lo>>20);
-                                                               }
-                                                       }
-                                                                       //Dbprintf("TAG ID: %x%08x (%d)",
-                                                       // (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);                              
-                                                       Dbprintf("TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d",
-                                                               (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF,
-                                                               (unsigned int) bitlen, (unsigned int) fc, (unsigned int) cardnum);
-                                               }
-                                               if (findone){
-                                                       if (ledcontrol) LED_A_OFF();
-                                                       return;
+
+                       if (hi2 != 0){ 
+                               //extra large HID tags
+                               Dbprintf("TAG ID: %x%08x%08x (%d)",
+                                        (unsigned int) hi2,
+                                        (unsigned int) hi,
+                                        (unsigned int) lo,
+                                        (unsigned int) (lo >> 1) & 0xFFFF);
+                                        
+                       } else {
+                               //standard HID tags <38 bits
+                               uint8_t bitlen = 0;
+                               uint32_t fc = 0;
+                               uint32_t cardnum = 0;
+
+                               if ((( hi >> 5 ) & 1) ==1){//if bit 38 is set then < 37 bit format is used
+                                       uint32_t lo2 = 0;
+                                       lo2 = (((hi & 31) << 12) | (lo >> 20)); //get bits 21-37 to check for format len bit                                    
+                                       uint8_t idx3 = 1;
+                                       while(lo2 > 1){ //find last bit set to 1 (format len bit)
+                                               lo2 = lo2 >> 1;
+                                               idx3++;
+                                       }
+                                       bitlen =idx3 + 19;  
+                                       fc = 0;
+                                       cardnum = 0;
+                                       if(bitlen == 26){
+                                               cardnum = (lo >> 1) & 0xFFFF;
+                                               fc = (lo >> 17) & 0xFF;
+                                       }
+                                       if(bitlen == 37){
+                                               cardnum = (lo >> 1) & 0x7FFFF;
+                                               fc = ((hi & 0xF) << 12)|( lo >> 20);
+                                       }
+                                       if(bitlen == 34){
+                                               cardnum = (lo >> 1) & 0xFFFF;
+                                               fc = ((hi & 1) << 15) | (lo >> 17);
+                                       }
+                                       if(bitlen == 35){
+                                               cardnum = (lo >> 1 ) & 0xFFFFF;
+                                               fc = ((hi & 1) << 11 ) | ( lo >> 21);
+                                       }
+                               }
+                               else { //if bit 38 is not set then 37 bit format is used
+                                       bitlen = 37;
+                                       fc = 0;
+                                       cardnum = 0;
+                                       if(bitlen == 37){
+                                               cardnum = ( lo >> 1) & 0x7FFFF;
+                                               fc = ((hi & 0xF) << 12 ) |(lo >> 20);
+                                       }
                                }
-                               // reset
-                               hi2 = hi = lo = 0;
+                               Dbprintf("TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d",
+                                       (unsigned int) hi,
+                                       (unsigned int) lo,
+                                       (unsigned int) (lo >> 1) & 0xFFFF,
+                                       (unsigned int) bitlen,
+                                       (unsigned int) fc,
+                                       (unsigned int) cardnum);
+                       }
+                       if (findone){
+                               if (ledcontrol) LED_A_OFF();
+                               return;
+                       }
+                       // reset
+                       hi2 = hi = lo = 0;
                }
                WDT_HIT();
-               //SpinDelay(50);
        }       
        DbpString("Stopped");
        if (ledcontrol) LED_A_OFF();
@@ -818,13 +819,12 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
 void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
 {
        uint8_t *dest = (uint8_t *)BigBuf;
-
-       size_t size=0; //, found=0;
-       uint32_t bitLen=0;
-       int clk=0, invert=0, errCnt=0;
-       uint64_t lo=0;
+       uint32_t bitLen = 0;
+       int clk = 0, invert = 0, errCnt  = 0;
+       uint64_t lo = 0;
+       
        // Configure to go in 125Khz listen mode
-       LFSetupFPGAForADC(95, true);
+       LFSetupFPGAForADC(0, true);
 
        while(!BUTTON_PRESS()) {
 
@@ -832,37 +832,33 @@ void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
                if (ledcontrol) LED_A_ON();
 
                DoAcquisition125k_internal(-1,true);
-               size  = sizeof(BigBuf);
-    if (size < 2000) continue; 
+       
                // FSK demodulator
-     //int askmandemod(uint8_t *BinStream,uint32_t *BitLen,int *clk, int *invert);
-    bitLen=size;
-    //Dbprintf("DEBUG: Buffer got");
-    errCnt = askmandemod(dest,&bitLen,&clk,&invert); //HIDdemodFSK(dest,size,&hi2,&hi,&lo);
-               //Dbprintf("DEBUG: ASK Got");
-               WDT_HIT();
+               bitLen = BIGBUF_SIZE;
+               errCnt = askmandemod(dest,&bitLen,&clk,&invert); 
+               if ( errCnt < 0 ) continue;
 
-               if (errCnt>=0){
-                       lo = Em410xDecode(dest,bitLen);
-                       //Dbprintf("DEBUG: EM GOT");
-               //printEM410x(lo);
-               if (lo>0){
-               Dbprintf("EM TAG ID: %02x%08x - (%05d_%03d_%08d)",(uint32_t)(lo>>32),(uint32_t)lo,(uint32_t)(lo&0xFFFF),(uint32_t)((lo>>16LL) & 0xFF),(uint32_t)(lo & 0xFFFFFF));
-       }
-                       if (findone){
-                               if (ledcontrol) LED_A_OFF();
+               WDT_HIT();
+               
+               lo = Em410xDecode(dest,bitLen);
+               
+               if ( lo <= 0) continue;
+                               
+               Dbprintf("EM TAG ID: %02x%08x - (%05d_%03d_%08d)",
+                       (uint32_t)(lo >> 32),
+                       (uint32_t)lo,
+                       (uint32_t)(lo & 0xFFFF),
+                       (uint32_t)((lo >> 16LL) & 0xFF),
+                       (uint32_t)(lo & 0xFFFFFF)
+               );
+
+               if (findone){
+                       if (ledcontrol) LED_A_OFF();
                                return;
-                       }
-                       } else {
-                       //Dbprintf("DEBUG: No Tag");
                }
+               
                WDT_HIT();
-               lo = 0;
-               clk=0;
-    invert=0;
-               errCnt=0;
-               size=0;
-               //SpinDelay(50);
+               lo = clk = invert = errCnt = 0;
        }
        DbpString("Stopped");
        if (ledcontrol) LED_A_OFF();
@@ -871,30 +867,27 @@ void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
 void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol)
 {
        uint8_t *dest = (uint8_t *)BigBuf;
-       size_t size=0;
-       int idx=0;
-       uint32_t code=0, code2=0;
-  uint8_t version=0;
-  uint8_t facilitycode=0;
-  uint16_t number=0;
-       // Configure to go in 125Khz listen mode
+       int idx = 0;
+       uint32_t code = 0, code2 = 0;
+       uint8_t version = 0;
+       uint8_t facilitycode = 0;
+       uint16_t number = 0;
+
        LFSetupFPGAForADC(0, true);
 
        while(!BUTTON_PRESS()) {
 
                WDT_HIT();
-               
                if (ledcontrol) LED_A_ON();
 
-               DoAcquisition125k_internal(-1,true);
-               size  = sizeof(BigBuf);
-               //make sure buffer has data
-               if (size < 2000) continue;
-               //fskdemod and get start index
-                       WDT_HIT();
-               idx = IOdemodFSK(dest,size);
-               if (idx>0){
-                       //valid tag found
+               DoAcquisition125k_internal(-1, true);
+
+               idx = IOdemodFSK(dest, BIGBUF_SIZE);
+               
+               if ( idx < 0 )
+                       continue;
+                       
+               WDT_HIT();
 
                //Index map
                //0 10 20 30 40 50 60
@@ -905,34 +898,34 @@ void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol)
                //
                //XSF(version)facility:codeone+codetwo
                //Handle the data
-                               if(findone){ //only print binary if we are doing one
-                                       Dbprintf("%d%d%d%d%d%d%d%d %d",dest[idx], dest[idx+1], dest[idx+2],dest[idx+3],dest[idx+4],dest[idx+5],dest[idx+6],dest[idx+7],dest[idx+8]);
-                                       Dbprintf("%d%d%d%d%d%d%d%d %d",dest[idx+9], dest[idx+10],dest[idx+11],dest[idx+12],dest[idx+13],dest[idx+14],dest[idx+15],dest[idx+16],dest[idx+17]);
-                                       Dbprintf("%d%d%d%d%d%d%d%d %d",dest[idx+18],dest[idx+19],dest[idx+20],dest[idx+21],dest[idx+22],dest[idx+23],dest[idx+24],dest[idx+25],dest[idx+26]);
-                                       Dbprintf("%d%d%d%d%d%d%d%d %d",dest[idx+27],dest[idx+28],dest[idx+29],dest[idx+30],dest[idx+31],dest[idx+32],dest[idx+33],dest[idx+34],dest[idx+35]);
-                                       Dbprintf("%d%d%d%d%d%d%d%d %d",dest[idx+36],dest[idx+37],dest[idx+38],dest[idx+39],dest[idx+40],dest[idx+41],dest[idx+42],dest[idx+43],dest[idx+44]);
-                                       Dbprintf("%d%d%d%d%d%d%d%d %d",dest[idx+45],dest[idx+46],dest[idx+47],dest[idx+48],dest[idx+49],dest[idx+50],dest[idx+51],dest[idx+52],dest[idx+53]);
-                                       Dbprintf("%d%d%d%d%d%d%d%d %d%d",dest[idx+54],dest[idx+55],dest[idx+56],dest[idx+57],dest[idx+58],dest[idx+59],dest[idx+60],dest[idx+61],dest[idx+62],dest[idx+63]);
-                               }
-                               code = bytebits_to_byte(dest+idx,32);
-                               code2 = bytebits_to_byte(dest+idx+32,32);
-           version = bytebits_to_byte(dest+idx+27,8); //14,4
-           facilitycode = bytebits_to_byte(dest+idx+18,8) ;
-           number = (bytebits_to_byte(dest+idx+36,8)<<8)|(bytebits_to_byte(dest+idx+45,8)); //36,9
-
-           Dbprintf("XSF(%02d)%02x:%05d (%08x%08x)",version,facilitycode,number,code,code2);                   
-                               // if we're only looking for one tag
-                               if (findone){
-                                       if (ledcontrol) LED_A_OFF();
+
+               if(findone){ //only print binary if we are doing one
+                       Dbprintf("%d%d%d%d%d%d%d%d %d",dest[idx], dest[idx+1], dest[idx+2],dest[idx+3],dest[idx+4],dest[idx+5],dest[idx+6],dest[idx+7],dest[idx+8]);
+                       Dbprintf("%d%d%d%d%d%d%d%d %d",dest[idx+9], dest[idx+10],dest[idx+11],dest[idx+12],dest[idx+13],dest[idx+14],dest[idx+15],dest[idx+16],dest[idx+17]);
+                       Dbprintf("%d%d%d%d%d%d%d%d %d",dest[idx+18],dest[idx+19],dest[idx+20],dest[idx+21],dest[idx+22],dest[idx+23],dest[idx+24],dest[idx+25],dest[idx+26]);
+                       Dbprintf("%d%d%d%d%d%d%d%d %d",dest[idx+27],dest[idx+28],dest[idx+29],dest[idx+30],dest[idx+31],dest[idx+32],dest[idx+33],dest[idx+34],dest[idx+35]);
+                       Dbprintf("%d%d%d%d%d%d%d%d %d",dest[idx+36],dest[idx+37],dest[idx+38],dest[idx+39],dest[idx+40],dest[idx+41],dest[idx+42],dest[idx+43],dest[idx+44]);
+                       Dbprintf("%d%d%d%d%d%d%d%d %d",dest[idx+45],dest[idx+46],dest[idx+47],dest[idx+48],dest[idx+49],dest[idx+50],dest[idx+51],dest[idx+52],dest[idx+53]);
+                       Dbprintf("%d%d%d%d%d%d%d%d %d%d",dest[idx+54],dest[idx+55],dest[idx+56],dest[idx+57],dest[idx+58],dest[idx+59],dest[idx+60],dest[idx+61],dest[idx+62],dest[idx+63]);
+               }
+
+               code = bytebits_to_byte(dest+idx,32);
+               code2 = bytebits_to_byte(dest+idx+32,32);
+               version = bytebits_to_byte(dest+idx+27,8); //14,4
+               facilitycode = bytebits_to_byte(dest+idx+18,8) ;
+               number = (bytebits_to_byte(dest+idx+36,8)<<8)|(bytebits_to_byte(dest+idx+45,8)); //36,9
+
+               Dbprintf("XSF(%02d)%02x:%05d (%08x%08x)", version, facilitycode, number, code, code2);                  
+               if (findone){
+                       if (ledcontrol) LED_A_OFF();
                                return;
-                       }
-                       code=code2=0;
-                       version=facilitycode=0;
-                       number=0;
-                       idx=0;
                }
-               WDT_HIT();
+               code = code2 = 0;
+               version = facilitycode = 0;
+               number = 0;
+               idx = 0;
        }
+
        DbpString("Stopped");
        if (ledcontrol) LED_A_OFF();
 }
index de564a69c94b387abb59a2b328ca389a451b7e28..e9499ed8dccd94e7317848eb94d0f9d1d09e6414 100644 (file)
@@ -26,37 +26,33 @@ static int CmdHelp(const char *Cmd);
 
 int CmdAmp(const char *Cmd)
 {
-  int i, rising, falling;
-  int max = INT_MIN, min = INT_MAX;
-
-  for (i = 10; i < GraphTraceLen; ++i) {
-    if (GraphBuffer[i] > max)
-      max = GraphBuffer[i];
-    if (GraphBuffer[i] < min)
-      min = GraphBuffer[i];
-  }
-
-  if (max != min) {
-    rising = falling= 0;
-    for (i = 0; i < GraphTraceLen; ++i) {
-      if (GraphBuffer[i + 1] < GraphBuffer[i]) {
-        if (rising) {
-          GraphBuffer[i] = max;
-          rising = 0;
-        }
-        falling = 1;
-      }
-      if (GraphBuffer[i + 1] > GraphBuffer[i]) {
-        if (falling) {
-          GraphBuffer[i] = min;
-          falling = 0;
-        }
-        rising= 1;
-      }
-    }
-  }
-  RepaintGraphWindow();
-  return 0;
+       int i, rising, falling;
+       int max = INT_MIN, min = INT_MAX;
+
+       DetectHighLowInGraph( &max, &min, FALSE);
+
+       if (max != min) {
+               rising = falling = 0;
+               
+               for (i = 0; i < GraphTraceLen; ++i) {
+                       if (GraphBuffer[i + 1] < GraphBuffer[i]) {
+                               if (rising) {
+                                       GraphBuffer[i] = max;
+                                       rising = 0;
+                               }
+                               falling = 1;
+                       }
+                       if (GraphBuffer[i + 1] > GraphBuffer[i]) {
+                               if (falling) {
+                                       GraphBuffer[i] = min;
+                                       falling = 0;
+                               }
+                               rising= 1;
+                       }
+               }
+       }
+       RepaintGraphWindow();
+       return 0;
 }
 
 /*
@@ -73,118 +69,122 @@ int CmdAmp(const char *Cmd)
  //this method is dependant on all highs and lows to be the same(or clipped)  this creates issues[marshmellow] it also ignores the clock
 int Cmdaskdemod(const char *Cmd)
 {
-  int i;
-  int c, high = 0, low = 0;
+       int i;
+       int c, high = 0, low = 0;
 
-  sscanf(Cmd, "%i", &c);
+       sscanf(Cmd, "%i", &c);
 
-  /* Detect high and lows and clock */
-  // (AL - clock???) 
-  for (i = 0; i < GraphTraceLen; ++i)
-  {
-    if (GraphBuffer[i] > high)
-      high = GraphBuffer[i];
-    else if (GraphBuffer[i] < low)
-      low = GraphBuffer[i];
-  }
-  high=abs(high*.75);
-  low=abs(low*.75);
-  if (c != 0 && c != 1) {
-    PrintAndLog("Invalid argument: %s", Cmd);
-    return 0;
-  }
-  //prime loop
-  if (GraphBuffer[0] > 0) {
-    GraphBuffer[0] = 1-c;
-  } else {
-    GraphBuffer[0] = c;
-  }
-  for (i = 1; i < GraphTraceLen; ++i) {
-    /* Transitions are detected at each peak
-     * Transitions are either:
-     * - we're low: transition if we hit a high
-     * - we're high: transition if we hit a low
-     * (we need to do it this way because some tags keep high or
-     * low for long periods, others just reach the peak and go
-     * down)
-     */
-    if ((GraphBuffer[i] == high) && (GraphBuffer[i - 1] == c)) {
-      GraphBuffer[i] = 1 - c;
-    } else if ((GraphBuffer[i] == low) && (GraphBuffer[i - 1] == (1 - c))){
-      GraphBuffer[i] = c;
-    } else {
-      /* No transition */
-      GraphBuffer[i] = GraphBuffer[i - 1];
-    }
-  }
+       if (c != 0 && c != 1) {
+               PrintAndLog("Invalid argument: %s", Cmd);
+               return 0;
+       }
+
+       DetectHighLowInGraph( &high, &low, FALSE);
+
+       high = abs(high * .75);
+       low = abs(low * .75);
+
+       //prime loop
+       if (GraphBuffer[0] > 0) {
+               GraphBuffer[0] = 1-c;
+       } else {
+               GraphBuffer[0] = c;
+       }
+       
+       for (i = 1; i < GraphTraceLen; ++i) {
+               /* Transitions are detected at each peak
+                * Transitions are either:
+                * - we're low: transition if we hit a high
+                * - we're high: transition if we hit a low
+                * (we need to do it this way because some tags keep high or
+                * low for long periods, others just reach the peak and go
+                * down)
+                */
+               if ((GraphBuffer[i] == high) && (GraphBuffer[i - 1] == c)) {
+                 GraphBuffer[i] = 1 - c;
+               } else if ((GraphBuffer[i] == low) && (GraphBuffer[i - 1] == (1 - c))){
+                 GraphBuffer[i] = c;
+               } else {
+                 /* No transition */
+                 GraphBuffer[i] = GraphBuffer[i - 1];
+               }
+       }
   RepaintGraphWindow();
   return 0;
 }
 
-void printBitStream(uint8_t BitStream[], uint32_t bitLen){
-  uint32_t i = 0;
-  if (bitLen<16) {
-    PrintAndLog("Too few bits found: %d",bitLen);
-    return;
-  }
-  if (bitLen>512) bitLen=512;
-   for (i = 0; i <= (bitLen-16); i+=16) {
-    PrintAndLog("%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i",
-      BitStream[i],
-      BitStream[i+1],
-      BitStream[i+2],
-      BitStream[i+3],
-      BitStream[i+4],
-      BitStream[i+5],
-      BitStream[i+6],
-      BitStream[i+7],
-      BitStream[i+8],
-      BitStream[i+9],
-      BitStream[i+10],
-      BitStream[i+11],
-      BitStream[i+12],
-      BitStream[i+13],
-      BitStream[i+14],
-      BitStream[i+15]);
-  }
+void printBitStream(uint8_t bits[], uint32_t bitLen){
+
+       uint32_t i = 0;
+       if (bitLen < 16) {
+               PrintAndLog("Too few bits found: %d",bitLen);
+               return;
+       }
+       if (bitLen > 512) 
+               bitLen = 512;
+               
+       if ( ( bitLen % 16 ) > 0) {
+               bitLen = ((bitLen / 16) * 16);
+               PrintAndLog("ICE: equally divided with 16 = %d",bitLen);
+       }
+       
+       for (i = 0; i <= ( bitLen - 16); i += 16) {
+               PrintAndLog("%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i",
+                       bits[i],
+                       bits[i+1],
+                       bits[i+2],
+                       bits[i+3],
+                       bits[i+4],
+                       bits[i+5],
+                       bits[i+6],
+                       bits[i+7],
+                       bits[i+8],
+                       bits[i+9],
+                       bits[i+10],
+                       bits[i+11],
+                       bits[i+12],
+                       bits[i+13],
+                       bits[i+14],
+                       bits[i+15]);
+       }
   return; 
 }
-void printEM410x(uint64_t id)
-{
-  if (id !=0){
-      uint64_t iii=1;
-      uint64_t id2lo=0; //id2hi=0,
-      uint32_t ii=0;
-      uint32_t i=0;
-      for (ii=5; ii>0;ii--){
-      for (i=0;i<8;i++){
-          id2lo=(id2lo<<1LL)|((id & (iii<<(i+((ii-1)*8))))>>(i+((ii-1)*8)));
-        }
-      }
-      //output em id
-      PrintAndLog("EM TAG ID    : %010llx", id);
-      PrintAndLog("Unique TAG ID: %010llx",  id2lo); //id2hi,
-      PrintAndLog("DEZ 8        : %08lld",id & 0xFFFFFF);
-      PrintAndLog("DEZ 10       : %010lld",id & 0xFFFFFF);
-      PrintAndLog("DEZ 5.5      : %05lld.%05lld",(id>>16LL) & 0xFFFF,(id & 0xFFFF));
-      PrintAndLog("DEZ 3.5A     : %03lld.%05lld",(id>>32ll),(id & 0xFFFF));
-      PrintAndLog("DEZ 14/IK2   : %014lld",id);
-      PrintAndLog("DEZ 15/IK3   : %015lld",id2lo);
-      PrintAndLog("Other        : %05lld_%03lld_%08lld",(id&0xFFFF),((id>>16LL) & 0xFF),(id & 0xFFFFFF));
-    }  
-    return;
+
+void printEM410x(uint64_t id) {
+
+       if ( id <= 0 ) return;
+       
+       uint64_t id2lo = 0; 
+       uint32_t i,j;
+       i = j = 0;
+       
+       for (j = 5; j > 0; j--){
+               for (i = 0; i < 8; i++){
+                       id2lo = ( id2lo << 1LL)|((id & ( 1 << ( i +( ( j-1 ) * 8 )))) >> ( i + (( j-1) *8 )));
+               }
+       }
+       //output em id
+       PrintAndLog("EM TAG ID    : %010llx", id);
+       PrintAndLog("Unique TAG ID: %010llx", id2lo);
+       PrintAndLog("DEZ 8        : %08lld", id & 0xFFFFFF);
+       PrintAndLog("DEZ 10       : %010lld", id & 0xFFFFFF);
+       PrintAndLog("DEZ 5.5      : %05lld.%05lld", (id>>16LL) & 0xFFFF, (id & 0xFFFF));
+       PrintAndLog("DEZ 3.5A     : %03lld.%05lld", (id>>32ll), (id & 0xFFFF));
+       PrintAndLog("DEZ 14/IK2   : %014lld", id);
+       PrintAndLog("DEZ 15/IK3   : %015lld", id2lo);
+       PrintAndLog("Other        : %05lld_%03lld_%08lld", (id & 0xFFFF), (( id >> 16LL) & 0xFF), (id & 0xFFFFFF));
 }
 
 int CmdEm410xDecode(const char *Cmd)
 {
-  uint64_t id=0;
-  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
-  uint32_t i=0;
-  i=getFromGraphBuf(BitStream);
-  id = Em410xDecode(BitStream,i);
-  printEM410x(id);
-  if (id>0) return 1;
-      return 0;
+       uint64_t id = 0;
+       uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
+       uint32_t len = GetFromGraphBuf(bits);
+       id = Em410xDecode(bits, len);
+       printEM410x(id);
+       if ( id > 0 ) 
+               return 1;
+       return 0;
 }
 
 //by marshmellow
@@ -193,41 +193,42 @@ int CmdEm410xDecode(const char *Cmd)
 //prints binary found and saves in graphbuffer for further commands
 int Cmdaskmandemod(const char *Cmd)
 {
-  int invert=0; 
-  int clk=0; 
-  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
-  sscanf(Cmd, "%i %i", &clk, &invert);    
-  if (invert != 0 && invert != 1) {
-    PrintAndLog("Invalid argument: %s", Cmd);
-    return 0;
-  }
-  uint32_t BitLen = getFromGraphBuf(BitStream);
+       int invert = 0; 
+       int clk = 0; 
 
-  int errCnt=0;
-   errCnt = askmandemod(BitStream, &BitLen,&clk,&invert);
-  if (errCnt<0){  //if fatal error (or -1)
-    // PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk); 
-    return 0;
-  } 
-  if (BitLen<16) return 0;
-  PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,BitLen);
+       sscanf(Cmd, "%i %i", &clk, &invert);    
 
-  if (errCnt>0){
-    PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
-  }
-  PrintAndLog("ASK/Manchester decoded bitstream:");
-  // Now output the bitstream to the scrollback by line of 16 bits
-  printBitStream(BitStream,BitLen);
-  uint64_t lo =0;
-  lo = Em410xDecode(BitStream,BitLen);
-  if (lo>0){
-    //set GraphBuffer for clone or sim command
-    setGraphBuf(BitStream,BitLen); 
-    PrintAndLog("EM410x pattern found: ");
-  printEM410x(lo);
-  }
-  //if (BitLen>16) return 1;
-  return 0;
+       if (invert != 0 && invert != 1) {
+               PrintAndLog("Invalid argument: %s", Cmd);
+               return 0;
+       }
+  
+       uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
+       uint32_t len = GetFromGraphBuf(bits);
+
+       int errCnt = askmandemod(bits, &len, &clk, &invert);
+
+       if (errCnt < 0) return 0;
+       if (len < 16) return 0;
+  
+       PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,len);
+
+       if (errCnt > 0){
+               PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
+       }
+  
+       PrintAndLog("ASK/Manchester decoded bitstream:");
+
+       printBitStream(bits, len);
+       uint64_t lo = Em410xDecode(bits, len);
+
+       if (lo > 0){
+               SetGraphBuf(bits,len); 
+               PrintAndLog("EM410x pattern found: ");
+               printEM410x(lo);
+               return 1;
+       }
+       return 0;
 }
 
 //by marshmellow
@@ -235,41 +236,42 @@ int Cmdaskmandemod(const char *Cmd)
 //stricktly take 10 and 01 and convert to 0 and 1
 int Cmdmandecoderaw(const char *Cmd)
 {
-  int i =0;
-  int errCnt=0;
-  int bitnum=0;
-  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
-  int high = 0, low = 0;
-  for (;i<GraphTraceLen;++i){
-    if (GraphBuffer[i]>high) high=GraphBuffer[i];
-    else if(GraphBuffer[i]<low) low=GraphBuffer[i];
-    BitStream[i]=GraphBuffer[i];
-  }
-  if (high>1 || low <0 ){
-    PrintAndLog("Error: please raw demod the wave first then mancheseter raw decode");
-    return 0;
-  }
-  bitnum=i;
-  errCnt=manrawdecode(BitStream,&bitnum);
-  if (errCnt>=20){
-    PrintAndLog("Too many errors: %d",errCnt);
-    return 0;
-  }
-  PrintAndLog("Manchester Decoded - # errors:%d - data:",errCnt);
-  printBitStream(BitStream,bitnum);
-  if (errCnt==0){
-    //put back in graphbuffer
-    ClearGraph(0);
-    for (i=0; i < bitnum; ++i){
-      GraphBuffer[i]=BitStream[i];
-    }
-    GraphTraceLen=bitnum;
-    RepaintGraphWindow();
-    uint64_t id = 0; 
-    id = Em410xDecode(BitStream,i);
-    printEM410x(id);     
-  }
-  return 1;
+       int i = 0;
+       int errCnt = 0;
+       int bitnum = 0;
+       uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
+       int high = 0, low = 0;
+
+       for (; i < GraphTraceLen; ++i){
+               if (GraphBuffer[i] > high) high = GraphBuffer[i];
+               else if (GraphBuffer[i] < low) low = GraphBuffer[i];
+               bits[i] = GraphBuffer[i];
+       }
+       
+       if (high > 1 || low < 0 ){
+               PrintAndLog("Error: please raw demod the wave first then mancheseter raw decode");
+               return 0;
+       }
+
+       bitnum = i;
+       errCnt = manrawdecode(bits, &bitnum);
+
+       if (errCnt>=20){
+               PrintAndLog("Too many errors: %d",errCnt);
+               return 0;
+       }
+       
+       PrintAndLog("Manchester Decoded - # errors:%d - data:",errCnt);
+       printBitStream(bits,bitnum);
+
+       if (errCnt==0){
+       //put back in graphbuffer
+       SetGraphBuf(bits, bitnum);
+
+       uint64_t id = Em410xDecode(bits,i);
+       printEM410x(id);     
+       }
+       return 1;
 }
 
 //by marshmellow
@@ -283,33 +285,35 @@ int Cmdmandecoderaw(const char *Cmd)
 //    width waves vs small width waves to help the decode positioning) or askbiphdemod
 int CmdBiphaseDecodeRaw(const char *Cmd)
 {
-  int i = 0;
-  int errCnt=0;
-  int bitnum=0;
-  int offset=0;
-  int high=0, low=0;
-  sscanf(Cmd, "%i", &offset);    
-  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
-  //get graphbuffer & high and low
-  for (;i<GraphTraceLen;++i){
-    if(GraphBuffer[i]>high)high=GraphBuffer[i];
-    else if(GraphBuffer[i]<low)low=GraphBuffer[i];
-    BitStream[i]=GraphBuffer[i];
-  }
-  if (high>1 || low <0){
-    PrintAndLog("Error: please raw demod the wave first then decode");
-  return 0;
-}
-  bitnum=i;
-  errCnt=BiphaseRawDecode(BitStream,&bitnum, offset);
-  if (errCnt>=20){
-    PrintAndLog("Too many errors attempting to decode: %d",errCnt);
-    return 0;
-  }
-  PrintAndLog("Biphase Decoded using offset: %d - # errors:%d - data:",offset,errCnt);
-  printBitStream(BitStream,bitnum);
-  PrintAndLog("\nif bitstream does not look right try offset=1");
-  return 1;
+       int i = 0;
+       int errCnt = 0;
+       int bitnum = 0;
+       int offset = 0;
+       int high = 0, low = 0;
+       sscanf(Cmd, "%i", &offset);    
+
+       uint8_t bits[MAX_GRAPH_TRACE_LEN]={0};
+
+       //get graphbuffer & high and low
+       for (; i<GraphTraceLen; ++i){
+               if (GraphBuffer[i] > high) high = GraphBuffer[i];
+               else if (GraphBuffer[i] < low) low = GraphBuffer[i];
+               bits[i] = GraphBuffer[i];
+       }
+       if (high > 1 || low < 0){
+               PrintAndLog("Error: please raw demod the wave first then decode");
+               return 0;
+       }
+       bitnum = i;
+       errCnt = BiphaseRawDecode(bits, &bitnum, offset);
+       if (errCnt >= 20){
+               PrintAndLog("Too many errors attempting to decode: %d", errCnt);
+               return 0;
+       }
+       PrintAndLog("Biphase Decoded using offset: %d - # errors:%d - data:", offset, errCnt);
+       printBitStream(bits, bitnum);
+       PrintAndLog("\nif bitstream does not look right try offset=1");
+       return 1;
 }
 
 
@@ -319,43 +323,49 @@ int CmdBiphaseDecodeRaw(const char *Cmd)
 //prints binary found and saves in graphbuffer for further commands
 int Cmdaskrawdemod(const char *Cmd)
 {
-  uint32_t i;
-  int invert=0; 
-  int clk=0; 
-  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
-  sscanf(Cmd, "%i %i", &clk, &invert);    
-  if (invert != 0 && invert != 1) {
-    PrintAndLog("Invalid argument: %s", Cmd);
-    return 0;
-  }
-  int BitLen = getFromGraphBuf(BitStream);
-  int errCnt=0;
-  errCnt = askrawdemod(BitStream, &BitLen,&clk,&invert);
-  if (errCnt==-1){  //throw away static - allow 1 and -1 (in case of threshold command first)
-    PrintAndLog("no data found"); 
-    return 0;
-  } 
-  if (BitLen<16) return 0;
-  PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen);
-    //PrintAndLog("Data start pos:%d, lastBit:%d, stop pos:%d, numBits:%d",iii,lastBit,i,bitnum);
-    //move BitStream back to GraphBuffer
-    
-  ClearGraph(0);
-  for (i=0; i < BitLen; ++i){
-    GraphBuffer[i]=BitStream[i];
-  }
-  GraphTraceLen=BitLen;
-  RepaintGraphWindow();
-    
-    //output
-    if (errCnt>0){
-      PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
-    }
-  PrintAndLog("ASK demoded bitstream:");
-    // Now output the bitstream to the scrollback by line of 16 bits
-  printBitStream(BitStream,BitLen);
-  
-  return 1;
+       int invert = 0; 
+       int clk = 0; 
+
+       sscanf(Cmd, "%i %i", &clk, &invert);
+
+       if (invert != 0 && invert != 1 ) {
+               PrintAndLog("Invalid argument: %s", Cmd);
+               return 0;
+       }
+       
+       if ( clock < 0 ) {
+               PrintAndLog("Wrong clock argument");
+               return 0;
+       }
+
+       uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
+       int len = GetFromGraphBuf(bits);
+       int errCnt = 0;
+
+       errCnt = askrawdemod(bits, &len, &clk, &invert);
+       
+       //throw away static - allow 1 and -1 (in case of threshold command first)
+       if (errCnt == -1) {  
+               PrintAndLog("no data found"); 
+               return 0;
+       } 
+
+       if (len < 16) return 0;
+       
+       PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d",clk,invert,len);
+
+       //move BitStream back to GraphBuffer
+       SetGraphBuf(bits, len);
+       
+       if (errCnt > 0){
+         PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
+       }
+
+       PrintAndLog("ASK demoded bitstream:");
+       
+       // Now output the bitstream to the scrollback by line of 16 bits
+       printBitStream(bits,len);
+       return 1;
 }
 
 int CmdAutoCorr(const char *Cmd)
@@ -393,7 +403,7 @@ int CmdAutoCorr(const char *Cmd)
 int CmdBitsamples(const char *Cmd)
 {
   int cnt = 0;
-  uint8_t got[12288];
+  uint8_t got[10000];
   
   GetFromBigBuf(got,sizeof(got),0);
   WaitForResponse(CMD_ACK,NULL);
@@ -426,16 +436,10 @@ int CmdBitstream(const char *Cmd)
   int hithigh, hitlow, first;
 
   /* Detect high and lows and clock */
-  for (i = 0; i < GraphTraceLen; ++i)
-  {
-    if (GraphBuffer[i] > high)
-      high = GraphBuffer[i];
-    else if (GraphBuffer[i] < low)
-      low = GraphBuffer[i];
-  }
+  DetectHighLowInGraph( &high, &low, FALSE); 
 
   /* Get our clock */
-  clock = GetClock(Cmd, high, 1);
+  clock = GetClock(Cmd, 0);
   gtl = ClearGraph(0);
 
   bit = 0;
@@ -467,10 +471,6 @@ int CmdBitstream(const char *Cmd)
       bit ^= 1;
 
     AppendGraph(0, clock, bit);
-//    for (j = 0; j < (int)(clock/2); j++)
-//      GraphBuffer[(i * clock) + j] = bit ^ 1;
-//    for (j = (int)(clock/2); j < clock; j++)
-//      GraphBuffer[(i * clock) + j] = bit;
   }
 
   RepaintGraphWindow();
@@ -499,7 +499,7 @@ int CmdDec(const char *Cmd)
 // uses data from graphbuffer 
 int CmdDetectClockRate(const char *Cmd)
 {
-  GetClock("",0,0);
+  GetClock("",1);
   return 0;
 }
 
@@ -509,43 +509,48 @@ int CmdDetectClockRate(const char *Cmd)
 //defaults: clock = 50, invert=0, rchigh=10, rclow=8 (RF/10 RF/8 (fsk2a))
 int CmdFSKrawdemod(const char *Cmd)
 {
-  //raw fsk demod no manchester decoding no start bit finding just get binary from wave
-  //set defaults
-  int rfLen = 50;
-  int invert=0;
-  int fchigh=10;
-  int fclow=8;
-  //set options from parameters entered with the command
-  sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow);    
+       //raw fsk demod no manchester decoding no start bit finding just get binary from wave
+       int rfLen = 50;
+       int invert = 0;
+       int fchigh = 10;
+       int fclow = 8;
+
+       //set options from parameters entered with the command
+       sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow);    
   
-  if (strlen(Cmd)>0 && strlen(Cmd)<=2) {
-     //rfLen=param_get8(Cmd, 0); //if rfLen option only is used
-     if (rfLen==1){
-      invert=1;   //if invert option only is used
-      rfLen = 50;
-     } else if(rfLen==0) rfLen=50;
-  } 
-  PrintAndLog("Args invert: %d - Clock:%d - fchigh:%d - fclow: %d",invert,rfLen,fchigh, fclow);
-  uint32_t i=0;
-  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
-  uint32_t BitLen = getFromGraphBuf(BitStream);
-  int size  = fskdemod(BitStream,BitLen,(uint8_t)rfLen,(uint8_t)invert,(uint8_t)fchigh,(uint8_t)fclow); 
-  if (size>0){
-  PrintAndLog("FSK decoded bitstream:");
-  ClearGraph(0);
-  for (i=0;i<size;++i){
-    GraphBuffer[i]=BitStream[i];
-  }
-  GraphTraceLen=size;
-  RepaintGraphWindow();
+       // A lots of checks if chigh, clow is out-of bounds.
   
-  // Now output the bitstream to the scrollback by line of 16 bits
-  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
-  printBitStream(BitStream,size);
-  } else{
-    PrintAndLog("no FSK data found");
-  }
-  return 0;
+       if (strlen(Cmd)>0 && strlen(Cmd)<=2) {
+               
+               rfLen = 50;
+               
+               //if invert option only is used
+               if (rfLen == 1){
+                       invert=1;   
+               }
+       } 
+       
+       PrintAndLog("Args invert: %d - Clock:%d - FC high:%d - FC low: %d",invert,rfLen,fchigh, fclow);
+
+       uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
+       uint32_t len = GetFromGraphBuf(bits);
+
+       int size  = fskdemod(bits, len,(uint8_t)rfLen, (uint8_t)invert, (uint8_t)fchigh, (uint8_t)fclow); 
+
+       if (size > 0) {
+               PrintAndLog("FSK decoded bitstream:");
+               
+               SetGraphBuf(bits, size);
+  
+               // Now output the bitstream to the scrollback by line of 16 bits
+               // only output a max of 8 blocks of 32 bits  most tags will have full bit stream inside that sample size
+               if(size > (8*32)+2)
+                       size = (8*32)+2; 
+               printBitStream(bits,size);
+       } else {
+               PrintAndLog("no FSK data found");
+       }
+       return 0;
 }
 
 //by marshmellow (based on existing demod + holiman's refactor)
@@ -553,70 +558,89 @@ int CmdFSKrawdemod(const char *Cmd)
 //print full HID Prox ID and some bit format details if found
 int CmdFSKdemodHID(const char *Cmd)
 {
-  //raw fsk demod no manchester decoding no start bit finding just get binary from wave
-  uint32_t hi2=0, hi=0, lo=0;
-
-  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
-  uint32_t BitLen = getFromGraphBuf(BitStream);
-  //get binary from fsk wave
-  size_t size  = HIDdemodFSK(BitStream,BitLen,&hi2,&hi,&lo); 
-  if (size<0){
-    PrintAndLog("Error demoding fsk");
-    return 0;
-      }
-  if (hi2==0 && hi==0 && lo==0) return 0;
-          if (hi2 != 0){ //extra large HID tags
-            PrintAndLog("TAG ID: %x%08x%08x (%d)",
-               (unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
-    setGraphBuf(BitStream,BitLen);
-    return 1;
-          }
-          else {  //standard HID tags <38 bits
-            //Dbprintf("TAG ID: %x%08x (%d)",(unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); //old print cmd
-    uint8_t fmtLen = 0;
-            uint32_t fc = 0;
-            uint32_t cardnum = 0;
-            if (((hi>>5)&1)==1){//if bit 38 is set then < 37 bit format is used
-              uint32_t lo2=0;
-              lo2=(((hi & 15) << 12) | (lo>>20)); //get bits 21-37 to check for format len bit
-              uint8_t idx3 = 1;
-              while(lo2>1){ //find last bit set to 1 (format len bit)
-                lo2=lo2>>1;
-                idx3++;
-              }
-      fmtLen =idx3+19;  
-              fc =0;
-              cardnum=0;
-      if(fmtLen==26){
-                cardnum = (lo>>1)&0xFFFF;
-                fc = (lo>>17)&0xFF;
-              }
-      if(fmtLen==37){
+       //raw fsk demod no manchester decoding no start bit finding just get binary from wave
+       uint32_t hi2=0, hi=0, lo=0;
+
+       uint8_t BitStream[MAX_GRAPH_TRACE_LEN] = {0x00};
+       uint32_t BitLen = GetFromGraphBuf(BitStream);
+
+       //get binary from fsk wave
+       size_t size  = HIDdemodFSK(BitStream,BitLen,&hi2,&hi,&lo); 
+
+       if (size < 0){
+               PrintAndLog("Error demoding fsk");
+               return 0;
+       }
+       
+       if (hi2==0 && hi==0 && lo==0) return 0;
+
+       //extra large HID tags  
+       if (hi2 != 0){
+               PrintAndLog("TAG ID: %x%08x%08x (%d)",
+                                               (unsigned int) hi2,
+                                               (unsigned int) hi,
+                                               (unsigned int) lo,
+                                               (unsigned int) (lo>>1) & 0xFFFF);
+               SetGraphBuf(BitStream,BitLen);
+               return 1;
+       } else {  
+               //standard HID tags <38 bits
+               uint8_t fmtLen = 0;
+               uint32_t fc = 0;
+               uint32_t cardnum = 0;
+               
+               //if bit 38 is set then < 37 bit format is used
+               if (((hi>>5) & 1)==1){
+                       uint32_t lo2 = 0;
+                       
+                        //get bits 21-37 to check for format len bit
+                       lo2 = (((hi & 15) << 12) | (lo>>20));
+                       uint8_t idx3 = 1;
+
+                       //find last bit set to 1 (format len bit)
+                       while( lo2 > 1){ 
+                               lo2=lo2>>1;
+                               idx3++;
+                       }
+                       fmtLen = idx3 + 19;  
+                       fc = 0;
+                       cardnum = 0;
+                       
+                       if(fmtLen==26){
+                               cardnum = (lo>>1)&0xFFFF;
+                               fc = (lo>>17)&0xFF;
+                       }
+                       if(fmtLen==37){
                 cardnum = (lo>>1)&0x7FFFF;
                 fc = ((hi&0xF)<<12)|(lo>>20);
               }
-      if(fmtLen==34){
+                       if(fmtLen==34){
                 cardnum = (lo>>1)&0xFFFF;
                 fc= ((hi&1)<<15)|(lo>>17);
-              }
-      if(fmtLen==35){
+                       }
+                       if(fmtLen==35){
                 cardnum = (lo>>1)&0xFFFFF;
                 fc = ((hi&1)<<11)|(lo>>21);
+                       }
+               } else { 
+                       //if bit 38 is not set then 37 bit format is used
+                       fmtLen= 37;
+                       fc =0;
+                       cardnum=0;
+                       
+                       if (fmtLen==37){
+                cardnum = (lo>>1) & 0x7FFFF;
+                fc = ((hi&0xF) << 12) | (lo >> 20);
               }
-            }
-            else { //if bit 38 is not set then 37 bit format is used
-      fmtLen= 37;
-              fc =0;
-              cardnum=0;
-      if(fmtLen==37){
-                cardnum = (lo>>1)&0x7FFFF;
-                fc = ((hi&0xF)<<12)|(lo>>20);
-              }
-            }
-            PrintAndLog("TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d",
-              (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF,
-      (unsigned int) fmtLen, (unsigned int) fc, (unsigned int) cardnum);
-    setGraphBuf(BitStream,BitLen);
+               }
+               PrintAndLog("TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d",
+                                               (unsigned int) hi,
+                                               (unsigned int) lo,
+                                               (unsigned int) (lo>>1) & 0xFFFF,
+                                               (unsigned int) fmtLen, 
+                                               (unsigned int) fc, 
+                                               (unsigned int) cardnum);
+    SetGraphBuf(BitStream,BitLen);
     return 1;
           }
   return 0;
@@ -627,51 +651,65 @@ int CmdFSKdemodHID(const char *Cmd)
 //print ioprox ID and some format details
 int CmdFSKdemodIO(const char *Cmd)
 {
-  //raw fsk demod no manchester decoding no start bit finding just get binary from wave
-  //set defaults
-  int idx=0; 
-  //something in graphbuffer
-  if (GraphTraceLen < 65) return 0;
-  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
-  uint32_t BitLen = getFromGraphBuf(BitStream);
-  //get binary from fsk wave
-  idx = IOdemodFSK(BitStream,BitLen); 
-  if (idx<0){
-    //PrintAndLog("Error demoding fsk");
-    return 0;
-  }
-  if (idx==0){
-    //PrintAndLog("IO Prox Data not found - FSK Data:");
-    //if (BitLen > 92) printBitStream(BitStream,92);
-    return 0;
-  }
-    //Index map
-    //0           10          20          30          40          50          60
-    //|           |           |           |           |           |           |
-    //01234567 8 90123456 7 89012345 6 78901234 5 67890123 4 56789012 3 45678901 23
-    //-----------------------------------------------------------------------------
-    //00000000 0 11110000 1 facility 1 version* 1 code*one 1 code*two 1 ???????? 11
-    //
-    //XSF(version)facility:codeone+codetwo (raw)
-    //Handle the data
-  if (idx+64>BitLen) return 0;
-  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]);
-  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]);       
-  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]);
-  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]);
-  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]);
-  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]);
-  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]);
-
-  uint32_t code = bytebits_to_byte(BitStream+idx,32);
-  uint32_t code2 = bytebits_to_byte(BitStream+idx+32,32); 
-  uint8_t version = bytebits_to_byte(BitStream+idx+27,8); //14,4
-  uint8_t facilitycode = bytebits_to_byte(BitStream+idx+18,8) ;
-  uint16_t number = (bytebits_to_byte(BitStream+idx+36,8)<<8)|(bytebits_to_byte(BitStream+idx+45,8)); //36,9
-          
-  PrintAndLog("XSF(%02d)%02x:%05d (%08x%08x)",version,facilitycode,number,code,code2);    
-  setGraphBuf(BitStream,BitLen);
-  return 1;
+       if (GraphTraceLen < 65) {
+               PrintAndLog("data samples size is too small");
+               return 0;
+       }
+
+       //raw fsk demod no manchester decoding no start bit finding just get binary from wave
+       //set defaults
+       int idx = 0; 
+       uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
+       uint32_t bitlen = GetFromGraphBuf(bits);
+
+       //get binary from fsk wave
+       idx = IOdemodFSK(bits, bitlen); 
+  
+       if (idx == 0) {
+               return 0;
+       }
+       if (idx == -1) {
+               PrintAndLog("data samples size is too small");
+               return 0;
+       }
+       if (idx == -2) {
+               PrintAndLog("Data samples has too much noice");
+               return 0;
+       }
+       if (idx == -3){
+               PrintAndLog("No good demod");
+               return 0;
+       }
+  
+       if (idx+64 > bitlen) return 0;
+  
+       //Index map
+       //0           10          20          30          40          50          60
+       //|           |           |           |           |           |           |
+       //01234567 8 90123456 7 89012345 6 78901234 5 67890123 4 56789012 3 45678901 23
+       //-----------------------------------------------------------------------------
+       //00000000 0 11110000 1 facility 1 version* 1 code*one 1 code*two 1 ???????? 11
+       //
+       //XSF(version)facility:codeone+codetwo (raw)
+       //Handle the data
+
+       PrintAndLog("%d%d%d%d%d%d%d%d %d",                      bits[idx]   , bits[idx+1],  bits[idx+2], bits[idx+3], bits[idx+4], bits[idx+5], bits[idx+6], bits[idx+7], bits[idx+8]);
+       PrintAndLog("%d%d%d%d%d%d%d%d %d",                      bits[idx+9] , bits[idx+10], bits[idx+11], bits[idx+12], bits[idx+13], bits[idx+14], bits[idx+15], bits[idx+16], bits[idx+17]);       
+       PrintAndLog("%d%d%d%d%d%d%d%d %d facility", bits[idx+18], bits[idx+19], bits[idx+20], bits[idx+21], bits[idx+22], bits[idx+23], bits[idx+24], bits[idx+25], bits[idx+26]);
+       PrintAndLog("%d%d%d%d%d%d%d%d %d version",      bits[idx+27], bits[idx+28], bits[idx+29], bits[idx+30], bits[idx+31], bits[idx+32], bits[idx+33], bits[idx+34], bits[idx+35]);
+       PrintAndLog("%d%d%d%d%d%d%d%d %d code1",        bits[idx+36], bits[idx+37], bits[idx+38], bits[idx+39], bits[idx+40], bits[idx+41], bits[idx+42], bits[idx+43], bits[idx+44]);
+       PrintAndLog("%d%d%d%d%d%d%d%d %d code2",        bits[idx+45], bits[idx+46], bits[idx+47], bits[idx+48], bits[idx+49], bits[idx+50], bits[idx+51], bits[idx+52], bits[idx+53]);
+       PrintAndLog("%d%d%d%d%d%d%d%d %d%d checksum", bits[idx+54], bits[idx+55], bits[idx+56], bits[idx+57], bits[idx+58], bits[idx+59], bits[idx+60], bits[idx+61], bits[idx+62], bits[idx+63]);
+
+       uint32_t code = bytebits_to_byte(bits+idx,32);
+       uint32_t code2 = bytebits_to_byte(bits+idx+32,32); 
+       uint8_t version = bytebits_to_byte(bits+idx+27,8); //14,4
+       uint8_t facilitycode = bytebits_to_byte(bits+idx+18,8) ;
+       uint16_t number = (bytebits_to_byte(bits+idx+36,8)<<8)|(bytebits_to_byte(bits+idx+45,8)); //36,9
+                 
+       PrintAndLog("XSF(%02d)%02x:%05d (%08x%08x)", version, facilitycode, number, code, code2);    
+       SetGraphBuf(bits, bitlen);
+       return 1;
 }
 
 int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating
@@ -760,8 +798,7 @@ int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating
   PrintAndLog("actual data bits start at sample %d", maxPos);
   PrintAndLog("length %d/%d", highLen, lowLen);
 
-  uint8_t bits[46];
-  bits[sizeof(bits)-1] = '\0';
+  uint8_t bits[46] = {0x00};
 
   // find bit pairs and manchester decode them
   for (i = 0; i < arraylen(bits) - 1; ++i) {
@@ -868,16 +905,17 @@ int CmdHpf(const char *Cmd)
 
 int CmdSamples(const char *Cmd)
 {
-       uint8_t got[36440] = {0x00};
-       
+       uint8_t got[40000] = {0x00};
+
        int n = strtol(Cmd, NULL, 0);
        if (n == 0) 
                n = 20000;
+               
        if (n > sizeof(got)) 
                n = sizeof(got);
   
        PrintAndLog("Reading %d samples from device memory\n", n);
-       GetFromBigBuf(got,n,3560);
+       GetFromBigBuf(got,n,0);
        WaitForResponse(CMD_ACK,NULL);
        for (int j = 0; j < n; ++j) {
                GraphBuffer[j] = ((int)got[j]) - 128;
@@ -1034,16 +1072,10 @@ int CmdManchesterDemod(const char *Cmd)
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN] = {0x00};
 
   /* Detect high and lows */
-  for (i = 0; i < GraphTraceLen; i++)
-  {
-    if (GraphBuffer[i] > high)
-      high = GraphBuffer[i];
-    else if (GraphBuffer[i] < low)
-      low = GraphBuffer[i];
-  }
-
+  DetectHighLowInGraph( &high, &low, TRUE);
+  
   /* Get our clock */
-  clock = GetClock(Cmd, high, 1); 
+  clock = GetClock(Cmd, 0); 
   int tolerance = clock/4;
 
   /* Detect first transition */
@@ -1201,10 +1233,8 @@ int CmdManchesterMod(const char *Cmd)
 {
   int i, j;
   int bit, lastbit, wave;
-  int clock = GetClock(Cmd, 0, 1);
-  int clock1 = GetT55x7Clock( GraphBuffer, GraphTraceLen, 0 );
-  PrintAndLog("MAN MOD CLOCKS:  %d  ice %d", clock,clock1);
-  
+  int clock = GetClock(Cmd, 0);
   int half = (int)(clock/2);
   
   wave = 0;
@@ -1373,8 +1403,8 @@ static command_t CommandTable[] =
   {"help",          CmdHelp,            1, "This help"},
   {"amp",           CmdAmp,             1, "Amplify peaks"},
   {"askdemod",      Cmdaskdemod,        1, "<0 or 1> -- Attempt to demodulate simple ASK tags"},
-  {"askmandemod",   Cmdaskmandemod,     1, "[clock] [invert<0 or 1>] -- Attempt to demodulate ASK/Manchester tags and output binary (args optional[clock will try Auto-detect])"},
-  {"askrawdemod",   Cmdaskrawdemod,     1, "[clock] [invert<0 or 1>] -- Attempt to demodulate ASK tags and output binary (args optional[clock will try Auto-detect])"},
+  {"askmandemod",   Cmdaskmandemod,     1, "[clock] [invert <0|1>] -- Attempt to demodulate ASK/Manchester tags and output binary"},
+  {"askrawdemod",   Cmdaskrawdemod,     1, "[clock] [invert <0|1>] -- Attempt to demodulate ASK tags and output binary"},
   {"autocorr",      CmdAutoCorr,        1, "<window length> -- Autocorrelation over window"},
   {"biphaserawdecode",CmdBiphaseDecodeRaw,1,"[offset] Biphase decode binary stream already in graph buffer (offset = bit to start decode from)"},
   {"bitsamples",    CmdBitsamples,      0, "Get raw samples as bitstring"},
@@ -1383,6 +1413,7 @@ static command_t CommandTable[] =
   {"dec",           CmdDec,             1, "Decimate samples"},
   {"detectaskclock",CmdDetectClockRate, 1, "Detect ASK clock rate"},
   {"dirthreshold",  CmdDirectionalThreshold,   1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
+  {"em4xdecode",    CmdEm410xDecode,    1, "decode em4x from graph buffer"},
   {"fskdemod",      CmdFSKdemod,        1, "Demodulate graph window as a HID FSK"},
   {"fskhiddemod",   CmdFSKdemodHID,     1, "Demodulate graph window as a HID FSK using raw"},
   {"fskiodemod",    CmdFSKdemodIO,      1, "Demodulate graph window as an IO Prox FSK using raw"},
index 8257a5b392abeb66a42395630e277d6909de503c..e445b47bae7e94fb794f57ff5b6fddd55fd5478a 100644 (file)
@@ -375,6 +375,8 @@ int CmdLFRead(const char *Cmd)
   
   // load samples 
   CmdSamples("");
+  // show plot
+  ShowGraphWindow();
   return 0;
 }
 
@@ -460,36 +462,38 @@ int CmdLFSimManchester(const char *Cmd)
 
 int CmdLFSnoop(const char *Cmd)
 {
-  UsbCommand c = {CMD_LF_SNOOP_RAW_ADC_SAMPLES};
-  // 'h' means higher-low-frequency, 134 kHz
-  c.arg[0] = 0;
-  c.arg[1] = -1;
-  if (*Cmd == 0) {
-    // empty
-  } else if (*Cmd == 'l') {
-    sscanf(Cmd, "l %"lli, &c.arg[1]);
-  } else if(*Cmd == 'h') {
-    c.arg[0] = 1;
-    sscanf(Cmd, "h %"lli, &c.arg[1]);
-  } else if (sscanf(Cmd, "%"lli" %"lli, &c.arg[0], &c.arg[1]) < 1) {
-    PrintAndLog("use 'snoop' or 'snoop {l,h} [trigger threshold]', or 'snoop <divisor> [trigger threshold]'");
-    return 0;
-  }
-  SendCommand(&c);
-  WaitForResponse(CMD_ACK,NULL);
-  
-  size_t BUFF_SIZE = 8000;
-  uint8_t data[BUFF_SIZE];
+       UsbCommand c = {CMD_LF_SNOOP_RAW_ADC_SAMPLES};
+
+       // 'h' means higher-low-frequency, 134 kHz
+       c.arg[0] = 0;
+       c.arg[1] = -1;
+
+       if (*Cmd == 'l') {
+               sscanf(Cmd, "l %"lli, &c.arg[1]);
+       } else if (*Cmd == 'h') {
+               c.arg[0] = 1;
+               sscanf(Cmd, "h %"lli, &c.arg[1]);
+       } else if (sscanf(Cmd, "%"lli" %"lli, &c.arg[0], &c.arg[1]) < 1) {
+               PrintAndLog("use 'snoop' or 'snoop {l,h} [trigger threshold]', or 'snoop <divisor> [trigger threshold]'");
+               return 0;
+       }
+
+       SendCommand(&c);
+       WaitForResponse(CMD_ACK,NULL);
 
-  GetFromBigBuf(data,BUFF_SIZE,3560);  //3560 -- should be offset..
-  WaitForResponseTimeout(CMD_ACK,NULL, 1500);
+       size_t BUFF_SIZE = 8000;
+       uint8_t data[BUFF_SIZE];
+
+       GetFromBigBuf(data,BUFF_SIZE,0);  //3560 -- should be offset..
+       WaitForResponseTimeout(CMD_ACK,NULL, 1500);
 
        for (int j = 0; j < BUFF_SIZE; j++) {
                GraphBuffer[j] = ((int)data[j]);
        }
+
        GraphTraceLen = BUFF_SIZE;
-  
-  return 0;
+
+       return 0;
 }
 
 int CmdVchDemod(const char *Cmd)
@@ -575,8 +579,8 @@ int CmdLFfind(const char *Cmd)
        char cmdp = param_getchar(Cmd, 0);
        
        if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') {
-               PrintAndLog("Usage:  lf search [use data from Graphbuffer]");
-               PrintAndLog("     [use data from Graphbuffer], if not set, try reading data from tag.");
+               PrintAndLog("Usage:  lf search <0|1>");
+               PrintAndLog("     <use data from Graphbuffer>, if not set, try reading data from tag.");
                PrintAndLog("");
                PrintAndLog("    sample: lf search");
                PrintAndLog("          : lf search 1");
@@ -585,7 +589,7 @@ int CmdLFfind(const char *Cmd)
 
        if (!offline || (cmdp != '1') ){
                ans = CmdLFRead("");
-       } else if (GraphTraceLen<1000) {
+       } else if (GraphTraceLen < 1000) {
                PrintAndLog("Data in Graphbuffer was too small.");
                return 0;
        }
index 6567ee41014698b15f6b21ec9b7fed73cf588544..a0cd87caaeef47a89d5987a8ae072addfa7804f7 100644 (file)
@@ -28,20 +28,16 @@ char *global_em410xId;
 
 static int CmdHelp(const char *Cmd);
 
-
-
 int CmdEMdemodASK(const char *Cmd)
 {
-  int findone=0;
-  UsbCommand c={CMD_EM410X_DEMOD};
-  if(Cmd[0]=='1') findone=1;
-  c.arg[0]=findone;
-  SendCommand(&c);
-  return 0;
+       char cmdp = param_getchar(Cmd, 0);
+       int findone = (cmdp == '1') ? 1 : 0;    
+       UsbCommand c = { CMD_EM410X_DEMOD };
+       c.arg[0] = findone;
+       SendCommand(&c);
+       return 0;
 }
 
-
-
 /* Read the ID of an EM410x tag.
  * Format:
  *   1111 1111 1           <-- standard non-repeatable header
@@ -54,29 +50,25 @@ int CmdEM410xRead(const char *Cmd)
 {
   int i, j, clock, header, rows, bit, hithigh, hitlow, first, bit2idx, high, low;
   int parity[4];
-  char id[11];
-  char id2[11];
+  char id[11] = {0x00};
+  char id2[11] = {0x00};
   int retested = 0;
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN];
   high = low = 0;
 
-  /* Detect high and lows and clock */
-  for (i = 0; i < GraphTraceLen; i++)
-  {
-    if (GraphBuffer[i] > high)
-      high = GraphBuffer[i];
-    else if (GraphBuffer[i] < low)
-      low = GraphBuffer[i];
-  }
+  // get clock 
+  clock = GetClock(Cmd, 0);
+  
+  // Detect high and lows and clock 
+  DetectHighLowInGraph( &high, &low, TRUE);
 
-  /* get clock */
-  clock = GetClock(Cmd, high, 0);
-   
-  /* parity for our 4 columns */
+  PrintAndLog("NUMNUM");
+  
+  // parity for our 4 columns
   parity[0] = parity[1] = parity[2] = parity[3] = 0;
   header = rows = 0;
 
-  /* manchester demodulate */
+  // manchester demodulate
   bit = bit2idx = 0;
   for (i = 0; i < (int)(GraphTraceLen / clock); i++)
   {
@@ -87,9 +79,9 @@ int CmdEM410xRead(const char *Cmd)
     /* Find out if we hit both high and low peaks */
     for (j = 0; j < clock; j++)
     {
-      if (GraphBuffer[(i * clock) + j] == high)
+      if (GraphBuffer[(i * clock) + j] >= high)
         hithigh = 1;
-      else if (GraphBuffer[(i * clock) + j] == low)
+      else if (GraphBuffer[(i * clock) + j] <= low)
         hitlow = 1;
 
       /* it doesn't count if it's the first part of our read
@@ -109,7 +101,7 @@ int CmdEM410xRead(const char *Cmd)
 
     BitStream[bit2idx++] = bit;
   }
-
+  
 retest:
   /* We go till 5 before the graph ends because we'll get that far below */
   for (i = 0; i < bit2idx - 5; i++)
@@ -189,13 +181,14 @@ retest:
   }
 
   /* if we've already retested after flipping bits, return */
-  if (retested++){
-    return 0;
+       if (retested++){
+               PrintAndLog("Failed to decode");
+               return 0;
        }
 
   /* if this didn't work, try flipping bits */
-  for (i = 0; i < bit2idx; i++)
-    BitStream[i] ^= 1;
+       for (i = 0; i < bit2idx; i++)
+               BitStream[i] ^= 1;
 
   goto retest;
 }
@@ -290,7 +283,8 @@ int CmdEM410xSim(const char *Cmd)
 */
 int CmdEM410xWatch(const char *Cmd)
 {
-       int read_h = (*Cmd == 'h');
+       char cmdp = param_getchar(Cmd, 0);
+       int read_h = (cmdp == 'h');
        do
        {
                if (ukbhit()) {
@@ -551,7 +545,7 @@ int CmdReadWord(const char *Cmd)
 
        uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};
 
-       GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,3560);  //3560 -- should be offset..
+       GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,0);  //3560 -- should be offset..
        WaitForResponseTimeout(CMD_ACK,NULL, 1500);
 
        for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {
@@ -591,7 +585,7 @@ int CmdReadWordPWD(const char *Cmd)
                
        uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};
 
-       GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,3560);  //3560 -- should be offset..
+       GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,0);  //3560 -- should be offset..
        WaitForResponseTimeout(CMD_ACK,NULL, 1500);
 
        for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {
index 6ea9d2d3a575beff7868050ab5a298284abc01b6..6f1ada7c9492fca4900bcbe3ca67b4a9bcb42758 100644 (file)
@@ -22,7 +22,7 @@
 #include "data.h"\r
 \r
 \r
-#define LF_TRACE_BUFF_SIZE 12000 // 32 x 32 x 10  (32 bit times numofblock (7), times clock skip..)\r
+#define LF_TRACE_BUFF_SIZE 20000 // 32 x 32 x 10  (32 bit times numofblock (7), times clock skip..)\r
 #define LF_BITSSTREAM_LEN 1000 // more then 1000 bits shouldn't happend..  8block * 4 bytes * 8bits = \r
 static int CmdHelp(const char *Cmd);\r
 \r
@@ -48,7 +48,7 @@ int CmdReadBlk(const char *Cmd)
        \r
        uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};\r
        \r
-       GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,3560);  //3560 -- should be offset..\r
+       GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,0);  //3560 -- should be offset..\r
        WaitForResponseTimeout(CMD_ACK,NULL, 1500);\r
 \r
        for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {\r
@@ -85,7 +85,7 @@ int CmdReadBlkPWD(const char *Cmd)
                \r
        uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};\r
 \r
-       GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,3560);  //3560 -- should be offset..\r
+       GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,0);  //3560 -- should be offset..\r
        WaitForResponseTimeout(CMD_ACK,NULL, 1500);\r
 \r
        for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {\r
@@ -166,7 +166,7 @@ int CmdReadTrace(const char *Cmd)
 \r
                uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};\r
 \r
-               GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,3560);  //3560 -- should be offset..\r
+               GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,0);  //3560 -- should be offset..\r
                WaitForResponseTimeout(CMD_ACK,NULL, 1500);\r
 \r
                for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {\r
@@ -249,32 +249,31 @@ int CmdInfo(const char *Cmd){
                return 0;\r
        }\r
 \r
-       if ( strlen(Cmd)==0){\r
+       if ( strlen(Cmd) == 0 ){\r
                CmdReadBlk("0");\r
        }       \r
 \r
        uint8_t bits[LF_BITSSTREAM_LEN] = {0x00};\r
-       uint8_t * bitstream = bits;\r
-       \r
-       manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN);\r
+\r
+       manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bits, LF_BITSSTREAM_LEN);\r
        \r
        uint8_t si = 5;\r
-       uint32_t bl0      = PackBits(si, 32, bitstream);\r
+       uint32_t bl0      = PackBits(si, 32, bits);\r
        \r
-       uint32_t safer    = PackBits(si, 4, bitstream); si += 4;        \r
-       uint32_t resv     = PackBits(si, 7, bitstream); si += 7;\r
-       uint32_t dbr      = PackBits(si, 3, bitstream); si += 3;\r
-       uint32_t extend   = PackBits(si, 1, bitstream); si += 1;\r
-       uint32_t datamodulation   = PackBits(si, 5, bitstream); si += 5;\r
-       uint32_t pskcf    = PackBits(si, 2, bitstream); si += 2;\r
-       uint32_t aor      = PackBits(si, 1, bitstream); si += 1;        \r
-       uint32_t otp      = PackBits(si, 1, bitstream); si += 1;        \r
-       uint32_t maxblk   = PackBits(si, 3, bitstream); si += 3;\r
-       uint32_t pwd      = PackBits(si, 1, bitstream); si += 1;        \r
-       uint32_t sst      = PackBits(si, 1, bitstream); si += 1;        \r
-       uint32_t fw       = PackBits(si, 1, bitstream); si += 1;\r
-       uint32_t inv      = PackBits(si, 1, bitstream); si += 1;        \r
-       uint32_t por      = PackBits(si, 1, bitstream); si += 1;\r
+       uint32_t safer    = PackBits(si, 4, bits); si += 4;     \r
+       uint32_t resv     = PackBits(si, 7, bits); si += 7;\r
+       uint32_t dbr      = PackBits(si, 3, bits); si += 3;\r
+       uint32_t extend   = PackBits(si, 1, bits); si += 1;\r
+       uint32_t datamodulation   = PackBits(si, 5, bits); si += 5;\r
+       uint32_t pskcf    = PackBits(si, 2, bits); si += 2;\r
+       uint32_t aor      = PackBits(si, 1, bits); si += 1;     \r
+       uint32_t otp      = PackBits(si, 1, bits); si += 1;     \r
+       uint32_t maxblk   = PackBits(si, 3, bits); si += 3;\r
+       uint32_t pwd      = PackBits(si, 1, bits); si += 1;     \r
+       uint32_t sst      = PackBits(si, 1, bits); si += 1;     \r
+       uint32_t fw       = PackBits(si, 1, bits); si += 1;\r
+       uint32_t inv      = PackBits(si, 1, bits); si += 1;     \r
+       uint32_t por      = PackBits(si, 1, bits); si += 1;\r
                \r
        PrintAndLog("");\r
        PrintAndLog("-- T55xx Configuration --------------------------------------");\r
@@ -295,7 +294,7 @@ int CmdInfo(const char *Cmd){
        PrintAndLog(" POR-Delay                 : %s", (por) ? "Yes":"No");\r
        PrintAndLog("-------------------------------------------------------------");\r
        PrintAndLog(" Raw Data - Page 0");\r
-       PrintAndLog("     Block 0  : 0x%08X  %s", bl0, sprint_bin(bitstream+5,32) );\r
+       PrintAndLog("     Block 0  : 0x%08X  %s", bl0, sprint_bin(bits+5,32) );\r
        PrintAndLog("-------------------------------------------------------------");\r
        \r
        return 0;\r
@@ -357,8 +356,10 @@ int ManchesterDemod(int blockNum){
        uint8_t  bits[LF_BITSSTREAM_LEN] = {0x00};\r
        uint8_t * bitstream = bits;\r
        \r
-       manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN);       \r
-    blockData = PackBits(offset, sizebyte, bitstream);\r
+       //manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN);     \r
+       manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bits, LF_BITSSTREAM_LEN);    \r
+    //blockData = PackBits(offset, sizebyte, bitstream);\r
+       blockData = PackBits(offset, sizebyte, bits);\r
 \r
        if ( blockNum < 0)\r
                PrintAndLog(" Decoded     : 0x%08X  %s", blockData, sprint_bin(bitstream+offset,sizebyte) );\r
index ff5a02e43160800a061bee57312b74f56bc71ce5..d0f6fe74fce36b1f1e6a2fd1a9ae73f14c82f6ef 100644 (file)
@@ -49,151 +49,69 @@ int ClearGraph(int redraw)
   return gtl;
 }
 
-/*
- * Detect clock rate
- */
- //decommissioned - has difficulty detecting rf/32 
-/*
-int DetectClockOld(int peak)
+void SetGraphBuf(uint8_t *buff, int size) 
 {
-  int i;
-  int clock = 0xFFFF;
-  int lastpeak = 0;
-
-  // Detect peak if we don't have one 
-  if (!peak)
-    for (i = 0; i < GraphTraceLen; ++i)
-      if (GraphBuffer[i] > peak)
-        peak = GraphBuffer[i];
-
- // peak=(int)(peak*.75);
-  for (i = 1; i < GraphTraceLen; ++i)
-  {
-    // If this is the beginning of a peak 
-    if (GraphBuffer[i - 1] != GraphBuffer[i] && GraphBuffer[i] >= peak)
-    {
-      // Find lowest difference between peaks 
-      if (lastpeak && i - lastpeak < clock)
-        clock = i - lastpeak;
-      lastpeak = i;
-    }
-  }
+       if ( buff == NULL ) return;
        
-               return clock;
-}
-*/
-/*
-NOW IN LFDEMOD.C
-
-// by marshmellow
-// not perfect especially with lower clocks or VERY good antennas (heavy wave clipping)
-// maybe somehow adjust peak trimming value based on samples to fix?
-int DetectASKClock(int peak)
-       {
-  int i=0;
-  int low=0;
-  int clk[]={16,32,40,50,64,100,128,256};
-  int loopCnt = 256;
-  if (GraphTraceLen<loopCnt) loopCnt = GraphTraceLen;
-  if (!peak){
-    for (i=0;i<loopCnt;++i){
-      if(GraphBuffer[i]>peak){
-        peak = GraphBuffer[i]; 
-      }
-      if(GraphBuffer[i]<low){
-        low = GraphBuffer[i];
-      }
-    }
-    peak=(int)(peak*.75);
-    low= (int)(low*.75);
-  }
-  int ii;
-  int clkCnt;
-  int tol = 0;
-  int bestErr=1000;
-  int errCnt[]={0,0,0,0,0,0,0,0};
-  for(clkCnt=0; clkCnt<6;++clkCnt){
-    if (clk[clkCnt]==32){
-      tol=1;
-    }else{
-      tol=0;
-    }
-    bestErr=1000;
-    for (ii=0; ii<loopCnt; ++ii){
-      if ((GraphBuffer[ii]>=peak) || (GraphBuffer[ii]<=low)){
-        errCnt[clkCnt]=0;
-        for (i=0; i<((int)(GraphTraceLen/clk[clkCnt])-1); ++i){
-          if (GraphBuffer[ii+(i*clk[clkCnt])]>=peak || GraphBuffer[ii+(i*clk[clkCnt])]<=low){
-          }else if(GraphBuffer[ii+(i*clk[clkCnt])-tol]>=peak || GraphBuffer[ii+(i*clk[clkCnt])-tol]<=low){
-          }else if(GraphBuffer[ii+(i*clk[clkCnt])+tol]>=peak || GraphBuffer[ii+(i*clk[clkCnt])+tol]<=low){
-          }else{  //error no peak detected
-            errCnt[clkCnt]++;
-          }    
-        }
-        if(errCnt[clkCnt]==0) return clk[clkCnt];
-        if(errCnt[clkCnt]<bestErr) bestErr=errCnt[clkCnt];
-      }
-    } 
-  }
-  int iii=0;
-  int best=0;
-  for (iii=0; iii<6;++iii){
-    if (errCnt[iii]<errCnt[best]){
-      best = iii;
-    }
-  }
-  // PrintAndLog("DEBUG: clkCnt: %d, ii: %d, i: %d peak: %d, low: %d, errcnt: %d, errCnt64: %d",clkCnt,ii,i,peak,low,errCnt[best],errCnt[4]);
-  return clk[best];
-}
-*/
-void setGraphBuf(uint8_t *buff,int size) 
-{
-  int i=0;
-  ClearGraph(0);
-  for (; i < size; ++i){
-    GraphBuffer[i]=buff[i];
-  }
-  GraphTraceLen=size;
-  RepaintGraphWindow();
-  return;
+       uint16_t i = 0;  
+       if ( size > MAX_GRAPH_TRACE_LEN )
+               size = MAX_GRAPH_TRACE_LEN;
+       ClearGraph(0);
+       for (; i < size; ++i){
+               GraphBuffer[i] = buff[i];
+       }
+       GraphTraceLen = size;
+       RepaintGraphWindow();
+       return;
 }
-int getFromGraphBuf(uint8_t *buff)
+
+// Copies grahpbuff to buff. 
+// while triming values to the range -127 -- 127.
+int GetFromGraphBuf(uint8_t *buff)
 {
-  uint32_t i;
-  for (i=0;i<GraphTraceLen;++i){
-    if (GraphBuffer[i]>127) GraphBuffer[i]=127; //trim
-    if (GraphBuffer[i]<-127) GraphBuffer[i]=-127; //trim
-    buff[i]=(uint8_t)(GraphBuffer[i]+128);
-  }
-  return i;
+       if ( buff == NULL ) return -1;
+       uint32_t i = 0;
+       
+       for (; i < GraphTraceLen; ++i){
+       
+               // trim upper and lower values.
+               if (GraphBuffer[i] > 127) 
+                       GraphBuffer[i] = 127;
+               else if (GraphBuffer[i] < -127)
+                       GraphBuffer[i] = -127;
+                       
+               buff[i] = (uint8_t)(GraphBuffer[i] + 128);
+       }
+       return i;
 }
 /* Get or auto-detect clock rate */
-int GetClock(const char *str, int peak, int verbose)
+int GetClock(const char *str, int verbose)
 {
-  int clock;
-
-  sscanf(str, "%i", &clock);
-  if (!strcmp(str, ""))
-    clock = 0;
-
-  /* Auto-detect clock */
-  if (!clock)
-  {
-    uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};
-    int size = getFromGraphBuf(grph);
-    clock = DetectASKClock(grph,size,0);
-    //clock2 = DetectClock2(peak);
-    /* Only print this message if we're not looping something */
-    if (!verbose)
-      PrintAndLog("Auto-detected clock rate: %d", clock);
-  }
-
-  return clock;
+       int clock;
+
+       sscanf(str, "%i", &clock);
+       if (!strcmp(str, ""))
+               clock = 0;
+
+       /* Auto-detect clock */
+       if (!clock) {
+
+               uint8_t grph[MAX_GRAPH_TRACE_LEN] = {0x00};
+               int size = GetFromGraphBuf(grph);
+               if ( size < 0 ) {
+                       PrintAndLog("Failed to copy from graphbuffer");
+                       return -1;
+               }
+               clock = DetectASKClock(grph, size, 0);
+
+               /* Only print this message if we're not looping something */
+               if (verbose)
+                       PrintAndLog("Auto-detected clock rate: %d", clock);
+               }
+       return clock;
 }
 
-
-/* A simple test to see if there is any data inside Graphbuffer. 
-*/
+// A simple test to see if there is any data inside Graphbuffer. 
 bool HasGraphData(){
 
        if ( GraphTraceLen <= 0) {
@@ -201,4 +119,26 @@ bool HasGraphData(){
                return false;
        }
        return true;    
+}
+
+// Detect high and lows in Grapbuffer.
+// Only loops the first 256 values. 
+void DetectHighLowInGraph(int *high, int *low, bool addFuzz) {
+
+       uint8_t loopMax = 255;
+       if ( loopMax > GraphTraceLen)
+               loopMax = GraphTraceLen;
+  
+       for (uint8_t i = 0; i < loopMax; ++i) {
+               if (GraphBuffer[i] > *high)
+                       *high = GraphBuffer[i];
+               else if (GraphBuffer[i] < *low)
+                       *low = GraphBuffer[i];
+       }
+       
+       //12% fuzz in case highs and lows aren't clipped
+       if (addFuzz) {
+               *high = (int)(*high * .88);
+               *low  = (int)(*low  * .88);
+       }
 }
\ No newline at end of file
index afe23686cd251b9098abed43063909d60a89814e..c745270d4118e24c4a033d72471d7ad5152da556 100644 (file)
 
 void AppendGraph(int redraw, int clock, int bit);
 int ClearGraph(int redraw);
-//int DetectClock(int peak);
-int getFromGraphBuf(uint8_t *buff);
-int GetClock(const char *str, int peak, int verbose);
-void setGraphBuf(uint8_t *buff,int size);
+int GetFromGraphBuf(uint8_t *buff);
+int GetClock(const char *str, int verbose);
+void SetGraphBuf(uint8_t *buff,int size);
 bool HasGraphData();
+void DetectHighLowInGraph(int *high, int *low, bool addFuzz); 
 
 #define MAX_GRAPH_TRACE_LEN (1024*128)
 extern int GraphBuffer[MAX_GRAPH_TRACE_LEN];
index deab3137a5704d798374430725f48661c3b07ff8..74c36a4dc52c94b57603ab12bf22199e91b0d539 100644 (file)
  * @return
  */
 int fileExists(const char *filename) {
+
+#ifdef _WIN32
        struct _stat fileStat;
        int result = _stat(filename, &fileStat);
+#else
+       struct stat fileStat;
+       int result = stat(filename, &fileStat);
+#endif
        return result == 0;
 }
 
index a820fe419d44f0ba604cc3c323667b1e07101e2a..3e9bdfd5f7add82182a3675c015f560e44e84313 100644 (file)
@@ -280,7 +280,7 @@ void ProxWidget::paintEvent(QPaintEvent *event)
 
 ProxWidget::ProxWidget(QWidget *parent) : QWidget(parent), GraphStart(0), GraphPixelsPerPoint(1)
 {
-       resize(600, 500);
+       resize(600, 300);
 
        QPalette palette(QColor(0,0,0,0));
        palette.setColor(QPalette::WindowText, QColor(255,255,255));
index 5111e2952b993c21664e04bea6c153843878356c..e464a533c193bc0cfc2c181752a985f5d6460c88 100644 (file)
 #include "ui.h"
 #include "cmdmain.h"
 #include "cmddata.h"
+#include "graph.h"
 //#include <liquid/liquid.h>
 #define M_PI 3.14159265358979323846264338327
 
 double CursorScaleFactor;
 int PlotGridX, PlotGridY, PlotGridXdefault= 64, PlotGridYdefault= 64;
 int offline;
-int flushAfterWrite = 0;  //buzzy
+int flushAfterWrite = 0;
 extern pthread_mutex_t print_lock;
 
 static char *logfilename = "proxmark3.log";
@@ -37,13 +38,13 @@ void PrintAndLog(char *fmt, ...)
        int saved_point;
        va_list argptr, argptr2;
        static FILE *logfile = NULL;
-       static int logging=1;
+       static int logging = 1;
 
        // lock this section to avoid interlacing prints from different threats
        pthread_mutex_lock(&print_lock);
   
        if (logging && !logfile) {
-               logfile=fopen(logfilename, "a");
+               logfile = fopen(logfilename, "a");
                if (!logfile) {
                        fprintf(stderr, "Can't open logfile, logging disabled!\n");
                        logging=0;
@@ -82,8 +83,7 @@ void PrintAndLog(char *fmt, ...)
        }
        va_end(argptr2);
 
-       if (flushAfterWrite == 1)  //buzzy
-       {
+       if (flushAfterWrite == 1) {
                fflush(NULL);
        }
        //release lock
@@ -98,74 +98,35 @@ void SetLogFilename(char *fn)
 int manchester_decode( int * data, const size_t len, uint8_t * dataout,  size_t dataoutlen){
        
        int bitlength = 0;
-       int i, clock, high, low, startindex;
+       int clock, high, low, startindex;
        low = startindex = 0;
        high = 1;
        uint8_t * bitStream =  (uint8_t* ) malloc(sizeof(uint8_t) * dataoutlen);        
        memset(bitStream, 0x00, dataoutlen);    
        
        /* Detect high and lows */
-       for (i = 0; i < len; i++) {
-               if (data[i] > high)
-                       high = data[i];
-               else if (data[i] < low)
-                       low = data[i];
-       }
-       
+       DetectHighLowInGraph(&high, &low, TRUE); 
+
        /* get clock */
-       clock = GetT55x7Clock( data, len, high );       
+       clock = GetClock("", 0);        
+
        startindex = DetectFirstTransition(data, len, high);
   
-       //PrintAndLog(" Clock       : %d", clock);
-
        if (high != 1)
+               // decode "raw"
                bitlength = ManchesterConvertFrom255(data, len, bitStream, dataoutlen, high, low, clock, startindex);
        else
-               bitlength= ManchesterConvertFrom1(data, len, bitStream, dataoutlen, clock, startindex);
+               // decode manchester
+               bitlength = ManchesterConvertFrom1(data, len, bitStream, dataoutlen, clock, startindex);
 
        memcpy(dataout, bitStream, bitlength);
        free(bitStream);
        return bitlength;
 }
-
- int GetT55x7Clock( const int * data, const size_t len, int peak ){ 
-       int i,lastpeak,clock;
-       clock = 0xFFFF;
-       lastpeak = 0;
-       
-       /* Detect peak if we don't have one */
-       if (!peak) {
-               for (i = 0; i < len; ++i) {
-                       if (data[i] > peak) {
-                               peak = data[i];
-                       }
-               }
-       }
-       
-       for (i = 1; i < len; ++i) {
-               /* if this is the beginning of a peak */
-               if ( data[i-1] != data[i] &&  data[i] == peak) {
-                 /* find lowest difference between peaks */
-                       if (lastpeak && i - lastpeak < clock)
-                               clock = i - lastpeak;
-                       lastpeak = i;
-               }
-       }
-       
-       // When detected clock is 31 or 33 then then return 
-       int clockmod = clock%8;
-       if ( clockmod == 0) return clock;
-       
-       if ( clockmod == 7 ) clock += 1;
-       else if ( clockmod == 1 ) clock -= 1;
-       
-       return clock;
- }
  
  int DetectFirstTransition(const int * data, const size_t len, int threshold){
 
-       int i =0;
+       int i = 0;
        /* now look for the first threshold */
        for (; i < len; ++i) {
                if (data[i] == threshold) {
index d30262f36693843a1893ec227d0bf63fc99ac758..5ab5e03ae30973417b792c653397cfaa41a33843 100644 (file)
 // Low frequency commands
 //-----------------------------------------------------------------------------
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lfdemod.h"
 
 //by marshmellow
 //takes 1s and 0s and searches for EM410x format - output EM ID
-uint64_t Em410xDecode(uint8_t *BitStream,uint32_t BitLen)
+uint64_t Em410xDecode(uint8_t *BitStream, uint32_t BitLen)
 {
-  //no arguments needed - built this way in case we want this to be a direct call from "data " cmds in the future
-  //  otherwise could be a void with no arguments
-  //set defaults
-  int high=0, low=128;
-  uint64_t lo=0; //hi=0,
+       //no arguments needed - built this way in case we want this to be a direct call from "data " cmds in the future
+       //  otherwise could be a void with no arguments
+       //set defaults
+       int high = 0, low = 128;
+       uint64_t lo = 0; 
+       uint32_t i = 0;
+       uint32_t initLoopMax = 65;
+
+       if (initLoopMax > BitLen) 
+               initLoopMax = BitLen;
+
+       for (; i < initLoopMax; ++i) //65 samples should be plenty to find high and low values
+       {
+               if (BitStream[i] > high)
+                       high = BitStream[i];
+               else if (BitStream[i] < low)
+                       low = BitStream[i];
+       }
 
-  uint32_t i = 0;
-  uint32_t initLoopMax = 65;
-  if (initLoopMax>BitLen) initLoopMax=BitLen;
+       if (((high !=1)||(low !=0))){  //allow only 1s and 0s 
+               return 0;
+       }
+
+       uint8_t parityTest = 0;
+       // 111111111 bit pattern represent start of frame
+       uint8_t frame_marker_mask[] = {1,1,1,1,1,1,1,1,1};
+       uint32_t idx = 0;
+       uint32_t j = 0;
+       uint8_t resetCnt = 0;
+       while( (idx + 64) < BitLen) {
+
+       restart:
 
-  for (;i < initLoopMax; ++i) //65 samples should be plenty to find high and low values
-  {
-    if (BitStream[i] > high)
-      high = BitStream[i];
-    else if (BitStream[i] < low)
-      low = BitStream[i];
-  }
-  if (((high !=1)||(low !=0))){  //allow only 1s and 0s 
-   // PrintAndLog("no data found"); 
-    return 0;
-  }
-  uint8_t parityTest=0;
-   // 111111111 bit pattern represent start of frame
-  uint8_t frame_marker_mask[] = {1,1,1,1,1,1,1,1,1};
-  uint32_t idx = 0;
-  uint32_t ii=0;
-  uint8_t resetCnt = 0;
-  while( (idx + 64) < BitLen) {
- restart:
     // search for a start of frame marker
-    if ( memcmp(BitStream+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
-    { // frame marker found
-      idx+=9;//sizeof(frame_marker_mask);
-      for (i=0; i<10;i++){
-        for(ii=0; ii<5; ++ii){
-          parityTest += BitStream[(i*5)+ii+idx];        
-        }
-        if (parityTest== ((parityTest>>1)<<1)){
-          parityTest=0;
-          for (ii=0; ii<4;++ii){
-            //hi = (hi<<1)|(lo>>31);
-            lo=(lo<<1LL)|(BitStream[(i*5)+ii+idx]);
-          }
-          //PrintAndLog("DEBUG: EM parity passed parity val: %d, i:%d, ii:%d,idx:%d, Buffer: %d%d%d%d%d,lo: %d",parityTest,i,ii,idx,BitStream[idx+ii+(i*5)-5],BitStream[idx+ii+(i*5)-4],BitStream[idx+ii+(i*5)-3],BitStream[idx+ii+(i*5)-2],BitStream[idx+ii+(i*5)-1],lo);          
-        }else {//parity failed
-          //PrintAndLog("DEBUG: EM parity failed parity val: %d, i:%d, ii:%d,idx:%d, Buffer: %d%d%d%d%d",parityTest,i,ii,idx,BitStream[idx+ii+(i*5)-5],BitStream[idx+ii+(i*5)-4],BitStream[idx+ii+(i*5)-3],BitStream[idx+ii+(i*5)-2],BitStream[idx+ii+(i*5)-1]);
-          parityTest=0;
-          idx-=8;
-          if (resetCnt>5)return 0;
-          resetCnt++;
-          goto restart;//continue;
-        }
-      }
-      //skip last 5 bit parity test for simplicity.
-      return lo;
-    }else{
-      idx++;
-    }
-  }
-  return 0;
+    if ( memcmp(BitStream+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0) {
+               // frame marker found
+               idx += 9;//sizeof(frame_marker_mask);
+               for ( i = 0; i < 10; ++i){
+                       for( j = 0; j < 5; ++j){
+                               parityTest += BitStream[(i*5) + j + idx];        
+                       }
+                       if (parityTest == ( (parityTest >> 1) << 1)){
+                               parityTest = 0;
+                               for (j = 0; j < 4; ++j){
+                                       lo = ( lo << 1LL)|( BitStream[( i * 5 ) + j + idx]);
+                               }
+                       } else {
+                               //parity failed
+                               parityTest = 0;
+                               idx -= 8;
+                               if (resetCnt > 5) return 0;
+                               resetCnt++;
+                               goto restart;//continue;
+                       }
+               }
+               //skip last 5 bit parity test for simplicity.
+               return lo;
+               } else {
+                       idx++;
+               }
+       }       
+       return 0;
 }
 
 //by marshmellow
 //takes 2 arguments - clock and invert both as integers
 //attempts to demodulate ask while decoding manchester 
 //prints binary found and saves in graphbuffer for further commands
-int askmandemod(uint8_t * BinStream,uint32_t *BitLen,int *clk, int *invert)
+int askmandemod(uint8_t *BinStream, uint32_t *BitLen, int *clk, int *invert)
 {
-  int i;
-  int high = 0, low = 128;
-  *clk=DetectASKClock(BinStream,(size_t)*BitLen,*clk); //clock default
-
-  if (*clk<8) *clk =64;
-  if (*clk<32) *clk=32;
-  if (*invert != 1) *invert=0;
+       int i;
+       int high = 0, low = 128;
+       *clk = DetectASKClock(BinStream, (size_t)*BitLen, *clk); //clock default
+       
+       if (*clk < 8 )    *clk = 64;
+       if (*clk < 32 )   *clk = 32;
+       if (*invert != 1) *invert = 0;
+       
+       uint32_t initLoopMax = 200;
+       if (initLoopMax > *BitLen) 
+               initLoopMax = *BitLen;
   
-  uint32_t initLoopMax = 200;
-  if (initLoopMax>*BitLen) initLoopMax=*BitLen;
+       // Detect high and lows 
+       // 200 samples should be enough to find high and low values
+       for (i = 0; i < initLoopMax; ++i) {
+               if (BinStream[i] > high)
+                       high = BinStream[i];
+               else if (BinStream[i] < low)
+                       low = BinStream[i];
+       }
   
-  // Detect high and lows 
-  for (i = 0; i < initLoopMax; ++i) //200 samples should be enough to find high and low values
-  {
-    if (BinStream[i] > high)
-      high = BinStream[i];
-    else if (BinStream[i] < low)
-      low = BinStream[i];
-  }
-  if ((high < 158) ){  //throw away static 
-    return -2;
-  }
-  //25% fuzz in case highs and lows aren't clipped [marshmellow]
-  high=(int)((high-128)*.75)+128;
-  low= (int)((low-128)*.75)+128;
+       //throw away static 
+       if ((high < 158) )
+               return -2;
+
+       //25% fuzz in case highs and lows aren't clipped [marshmellow]
+       high = (int)(high * .75);
+       low  = (int)(low+128 * .25);
  
-  //PrintAndLog("DEBUG - valid high: %d - valid low: %d",high,low);
-  int lastBit = 0;  //set first clock check
-  uint32_t bitnum = 0;     //output counter
-  int tol = 0;  //clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave
-  if (*clk==32)tol=1;    //clock tolerance may not be needed anymore currently set to + or - 1 but could be increased for poor waves or removed entirely 
-  int iii = 0;
-  uint32_t gLen = *BitLen;
-  if (gLen > 3000) gLen=3000;
-  uint8_t errCnt =0;
-  uint32_t bestStart = *BitLen;
-  uint32_t bestErrCnt = (*BitLen/1000);
-  uint32_t maxErr = (*BitLen/1000);
+       int lastBit = 0;      // set first clock check
+       uint32_t bitnum = 0;  // output counter
+
+       // clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave
+       //clock tolerance may not be needed anymore currently set to + or - 1 but could be increased for poor waves or removed entirely 
+       int tol = ( *clk == 32 ) ? 1 : 0;  
+
+       int j = 0;
+       uint32_t gLen = *BitLen;
+
+       if (gLen > 3000) gLen = 3000;
+
+       uint8_t errCnt = 0;
+       uint32_t bestStart = *BitLen;
+       uint32_t bestErrCnt = (*BitLen/1000);
+       uint32_t maxErr = bestErrCnt;
 
   //loop to find first wave that works
-  for (iii=0; iii < gLen; ++iii){
-    if ((BinStream[iii]>=high)||(BinStream[iii]<=low)){
-      lastBit=iii-*clk;    
-      errCnt=0;
+       for (j=0; j < gLen; ++j){
+  
+               if ((BinStream[j] >= high)||(BinStream[j] <= low)){
+                 lastBit = j - *clk;    
+                 errCnt = 0;
+         
       //loop through to see if this start location works
-      for (i = iii; i < *BitLen; ++i) {   
+      for (i = j; i < *BitLen; ++i) {   
         if ((BinStream[i] >= high) && ((i-lastBit)>(*clk-tol))){
-          lastBit+=*clk;
+          lastBit += *clk;
         } else if ((BinStream[i] <= low) && ((i-lastBit)>(*clk-tol))){
           //low found and we are expecting a bar
-          lastBit+=*clk;
+          lastBit += *clk;
         } else {
           //mid value found or no bar supposed to be here
-          if ((i-lastBit)>(*clk+tol)){
+          if ((i-lastBit) > (*clk + tol)){
             //should have hit a high or low based on clock!!
            
             errCnt++;
-            lastBit+=*clk;//skip over until hit too many errors
-            if (errCnt>(maxErr)) break;  //allow 1 error for every 1000 samples else start over
+            lastBit += *clk;//skip over until hit too many errors
+            if (errCnt > maxErr) break;  //allow 1 error for every 1000 samples else start over
           }
         }
-        if ((i-iii) >(400 * *clk)) break; //got plenty of bits
+        if ((i-j) >(400 * *clk)) break; //got plenty of bits
       }
       //we got more than 64 good bits and not all errors
-      if ((((i-iii)/ *clk) > (64+errCnt)) && (errCnt<maxErr)) {
+      if ((((i-j)/ *clk) > (64 + errCnt)) && (errCnt < maxErr)) {
         //possible good read
-        if (errCnt==0){
-                       bestStart=iii;
-                       bestErrCnt=errCnt;
+        if (errCnt == 0){
+                       bestStart = j;
+                       bestErrCnt = errCnt;
                        break;  //great read - finish
         } 
-        if (errCnt<bestErrCnt){  //set this as new best run
-          bestErrCnt=errCnt;
-          bestStart = iii;
+        if (errCnt < bestErrCnt){  //set this as new best run
+          bestErrCnt = errCnt;
+          bestStart = j;
         }
       }
     }
   }
-  if (bestErrCnt<maxErr){
+  if (bestErrCnt < maxErr){
        //best run is good enough set to best run and set overwrite BinStream
-       iii=bestStart;
-       lastBit=bestStart-*clk;
-       bitnum=0;
-    for (i = iii; i < *BitLen; ++i) {   
-      if ((BinStream[i] >= high) && ((i-lastBit)>(*clk-tol))){
-        lastBit+=*clk;
-        BinStream[bitnum] =  *invert;
-        bitnum++;
-      } else if ((BinStream[i] <= low) && ((i-lastBit)>(*clk-tol))){
-        //low found and we are expecting a bar
-        lastBit+=*clk;
-        BinStream[bitnum] = 1-*invert; 
-        bitnum++;
-      } else {
-        //mid value found or no bar supposed to be here
-        if ((i-lastBit)>(*clk+tol)){
-          //should have hit a high or low based on clock!!
-
-          if (bitnum > 0){
-            BinStream[bitnum]=77;
-            bitnum++;
-          }
-          
-          lastBit+=*clk;//skip over error
-        }
-      }
-      if (bitnum >=400) break;
-    }
-    *BitLen=bitnum;
-       } else{
-       *invert=bestStart;
-       *clk=iii;
-       return -1; 
-  }    
+       j = bestStart;
+       lastBit = bestStart - *clk;
+       bitnum = 0;
+    for (i = j; i < *BitLen; ++i) {   
+               if ((BinStream[i] >= high) && ((i-lastBit)>(*clk-tol))){
+                       lastBit += *clk;
+                       BinStream[bitnum] = *invert;
+                       bitnum++;
+               } else if ((BinStream[i] <= low) && ((i-lastBit)>(*clk-tol))){
+                       //low found and we are expecting a bar
+                       lastBit += *clk;
+                       BinStream[bitnum] = 1 - *invert; 
+                       bitnum++;
+               } else {
+                       //mid value found or no bar supposed to be here
+                       if ((i-lastBit) > (*clk+tol)){
+                               //should have hit a high or low based on clock!!
+                               if (bitnum > 0){
+                                       BinStream[bitnum] = 77;
+                                       bitnum++;
+                               }
+                               lastBit += *clk;//skip over error
+                       }
+               }
+               if (bitnum >= 400) break;
+               }
+               *BitLen = bitnum;
+       } else {
+               *invert = bestStart;
+               *clk = j;
+               return -1; 
+       }       
   return bestErrCnt;
 }
 
 //by marshmellow
 //take 10 and 01 and manchester decode
 //run through 2 times and take least errCnt
-int manrawdecode(uint8_t * BitStream, int *bitLen)
+int manrawdecode(uint8_t * bits, int *bitlen)
 {
-  int bitnum=0;
-  int errCnt =0;
-  int i=1;
+  int bitnum = 0;
+  int errCnt = 0;
   int bestErr = 1000;
   int bestRun = 0;
-  int ii=1;
-  for (ii=1;ii<3;++ii){
-       i=1;
-               for (i=i+ii;i<*bitLen-2;i+=2){
-                 if(BitStream[i]==1 && (BitStream[i+1]==0)){
-                 } else if((BitStream[i]==0)&& BitStream[i+1]==1){
-           } else {
-                     errCnt++;
-           }
-           if(bitnum>300) break;
+  int i = 1;
+  int j = 1;
+
+       for (; j < 3; ++j){
+               i = 1;
+               for ( i = i + j; i < *bitlen-2; i += 2){
+                       if ( bits[i]==1 && (bits[i+1]==0)){
+                       } else if ((bits[i]==0)&& bits[i+1]==1){
+                       } else {
+                               errCnt++;
+                       }
+                       if(bitnum > 300) break;
                }
-               if (bestErr>errCnt){
-                 bestErr=errCnt;
-                 bestRun=ii;
+               if (bestErr > errCnt){
+                       bestErr = errCnt;
+                       bestRun = j;
                }       
-               errCnt=0;
-  }
-  errCnt=bestErr;
-  if (errCnt<20){
-       ii=bestRun;
-       i=1;
-               for (i=i+ii;i<*bitLen-2;i+=2){
-                 if(BitStream[i]==1 && (BitStream[i+1]==0)){
-                   BitStream[bitnum++]=0;
-                 } else if((BitStream[i]==0)&& BitStream[i+1]==1){
-                   BitStream[bitnum++]=1;
-           } else {
-             BitStream[bitnum++]=77;
-                     //errCnt++;
-           }
-           if(bitnum>300) break;
+               errCnt = 0;
+       }
+       errCnt = bestErr;
+       if (errCnt < 20){
+               j = bestRun;
+               i = 1;
+               for ( i = i+j; i < *bitlen-2; i += 2){
+                       if ( bits[i] == 1 && bits[i + 1] == 0 ){
+                                       bits[bitnum++] = 0;
+                       } else if ( bits[i] == 0 && bits[i + 1] == 1 ){
+                                       bits[bitnum++] = 1;
+                       } else {
+                               bits[bitnum++] = 77;
+                       }
+                       if ( bitnum > 300 ) break;
                }
-       *bitLen=bitnum;
+               *bitlen = bitnum;
        }   
-  return errCnt;
+       return errCnt;
 }
 
 
 //by marshmellow
 //take 01 or 10 = 0 and 11 or 00 = 1
-int BiphaseRawDecode(uint8_t * BitStream, int *bitLen, int offset)
+int BiphaseRawDecode(uint8_t * bits, int *bitlen, int offset)
 {
-  uint8_t bitnum = 0;
-  uint32_t errCnt = 0;
-  uint32_t i = 1;
-  i=offset;
-       for (;i<*bitLen-2;i+=2){
-         if((BitStream[i]==1 && BitStream[i+1]==0)||(BitStream[i]==0 && BitStream[i+1]==1)){
-           BitStream[bitnum++]=1;
-         } else if((BitStream[i]==0 && BitStream[i+1]==0)||(BitStream[i]==1 && BitStream[i+1]==1)){
-           BitStream[bitnum++]=0;
-    } else {
-           BitStream[bitnum++]=77;
-      errCnt++;
-    }
-    if(bitnum>250) break;
+       uint8_t bitnum = 0;
+       uint32_t errCnt = 0;
+       uint32_t i = offset;
+       
+       for (; i < *bitlen-2; i += 2 ){
+               if ( (bits[i]==1 && bits[i+1]==0)||
+                        (bits[i]==0 && bits[i+1]==1)){
+                       bits[bitnum++] = 1;
+               } else if ( (bits[i]==0 && bits[i+1]==0)||
+                                       (bits[i]==1 && bits[i+1]==1)){
+                       bits[bitnum++] = 0;
+               } else {
+                       bits[bitnum++] = 77;
+                       errCnt++;
+               }
+               if ( bitnum > 250) break;
        }  
-  *bitLen=bitnum;
-  return errCnt;
+       *bitlen = bitnum;
+       return errCnt;
 }
 
 //by marshmellow
 //takes 2 arguments - clock and invert both as integers
 //attempts to demodulate ask only
 //prints binary found and saves in graphbuffer for further commands
-int askrawdemod(uint8_t *BinStream, int *bitLen,int *clk, int *invert)
+int askrawdemod(uint8_t *BinStream, int *bitLen, int *clk, int *invert)
 {
   uint32_t i;
- // int invert=0;  //invert default
+  uint32_t initLoopMax = 200;
   int high = 0, low = 128;
-  *clk=DetectASKClock(BinStream,*bitLen,*clk); //clock default
-  uint8_t BitStream[502] = {0};
-
-  if (*clk<8) *clk =64;
-  if (*clk<32) *clk=32;
+  uint8_t BitStream[502] = {0x00};
+  
+  *clk = DetectASKClock(BinStream, *bitLen, *clk); //clock default
+  
+  if (*clk < 8)                *clk = 64;      
+  if (*clk < 32)       *clk = 32;      
   if (*invert != 1) *invert = 0;
+
+  if (initLoopMax > *bitLen) 
+       initLoopMax = *bitLen;
   
-  uint32_t initLoopMax = 200;
-  if (initLoopMax>*bitLen) initLoopMax=*bitLen;
   // Detect high and lows 
   for (i = 0; i < initLoopMax; ++i) //200 samples should be plenty to find high and low values
   {
     if (BinStream[i] > high)
-      high = BinStream[i];
+               high = BinStream[i];
     else if (BinStream[i] < low)
-      low = BinStream[i];
+               low = BinStream[i];
   }
-  if ((high < 158)){  //throw away static
-    return -2;
-  }
-  //25% fuzz in case highs and lows aren't clipped [marshmellow]
-  high=(int)((high-128)*.75)+128;
-  low= (int)((low-128)*.75)+128;
-
-  int lastBit = 0;  //set first clock check
-  uint32_t bitnum = 0;     //output counter
-  uint8_t tol = 0;  //clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave
-  if (*clk==32) tol=1;    //clock tolerance may not be needed anymore currently set to + or - 1 but could be increased for poor waves or removed entirely 
-  uint32_t iii = 0;
+  
+  //throw away static
+       if ((high < 158)){  
+               return -2;
+       }
+  
+       //25% fuzz in case highs and lows aren't clipped [marshmellow]
+       high = (int)(high * .75);
+       low  = (int)(low+128 * .25);
+
+  int lastBit = 0;                     //set first clock check
+  uint32_t bitnum = 0;         //output counter
+  
+  uint8_t tol = 0;                     //clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave
+  if (*clk==32) tol = 1;       //clock tolerance may not be needed anymore currently set to + or - 1 but could be increased for poor waves or removed entirely 
+
   uint32_t gLen = *bitLen;
-  if (gLen > 500) gLen=500;
-  uint8_t errCnt =0;
-  uint32_t bestStart = *bitLen;
-  uint32_t bestErrCnt = (*bitLen/1000);
-  uint8_t midBit=0;
+  if (gLen > 500) gLen = 500;
 
+  uint32_t j = 0;
+  uint8_t errCnt = 0;
+  uint32_t bestStart = *bitLen;
+  uint32_t bestErrCnt = (*bitLen / 1000);
+  uint32_t errCntLimit = bestErrCnt;
+  uint8_t midBit = 0;
+  
   //loop to find first wave that works
-  for (iii=0; iii < gLen; ++iii){
-    if ((BinStream[iii]>=high)||(BinStream[iii]<=low)){
-      lastBit=iii-*clk;    
+  for (j = 0; j < gLen; ++j){
+  
+    if ((BinStream[j] >= high)||(BinStream[j] <= low)){
+      lastBit = j - *clk;    
       //loop through to see if this start location works
-      for (i = iii; i < *bitLen; ++i) {  
+      for (i = j; i < *bitLen; ++i) {  
         if ((BinStream[i] >= high) && ((i-lastBit)>(*clk-tol))){
-          lastBit+=*clk;
+          lastBit += *clk;
           BitStream[bitnum] =  *invert;
           bitnum++;
-          midBit=0;
+          midBit = 0;
         } else if ((BinStream[i] <= low) && ((i-lastBit)>(*clk-tol))){
           //low found and we are expecting a bar
-          lastBit+=*clk;
+          lastBit += *clk;
           BitStream[bitnum] = 1-*invert; 
           bitnum++;
           midBit=0;
         } else if ((BinStream[i]<=low) && (midBit==0) && ((i-lastBit)>((*clk/2)-tol))){
           //mid bar?
-          midBit=1;
-          BitStream[bitnum]= 1-*invert;
+          midBit = 1;
+          BitStream[bitnum] = 1 - *invert;
           bitnum++;
         } else if ((BinStream[i]>=high)&&(midBit==0) && ((i-lastBit)>((*clk/2)-tol))){
           //mid bar?
-          midBit=1;
-          BitStream[bitnum]= *invert;
+          midBit = 1;
+          BitStream[bitnum] = *invert;
           bitnum++;
         } else if ((i-lastBit)>((*clk/2)+tol)&&(midBit==0)){
           //no mid bar found
-          midBit=1;
-          BitStream[bitnum]= BitStream[bitnum-1];
+          midBit = 1;
+          BitStream[bitnum] = BitStream[bitnum-1];
           bitnum++;
         } else {
           //mid value found or no bar supposed to be here
 
-          if ((i-lastBit)>(*clk+tol)){
+          if (( i - lastBit) > ( *clk + tol)){
             //should have hit a high or low based on clock!!
 
             if (bitnum > 0){
-              BitStream[bitnum]=77;
+              BitStream[bitnum] = 77;
               bitnum++;
             }
 
             errCnt++;
-            lastBit+=*clk;//skip over until hit too many errors
-            if (errCnt>((*bitLen/1000))){  //allow 1 error for every 1000 samples else start over
-              errCnt=0;
-              bitnum=0;//start over
+            lastBit += *clk;//skip over until hit too many errors
+            if (errCnt > errCntLimit){  //allow 1 error for every 1000 samples else start over
+              errCnt = 0;
+              bitnum = 0;//start over
               break;
             }
           }          
         }
-        if (bitnum>500) break;
+        if (bitnum > 500) break;
       }
       //we got more than 64 good bits and not all errors
-      if ((bitnum > (64+errCnt)) && (errCnt<(*bitLen/1000))) {
-        //possible good read
-        if (errCnt==0) break;  //great read - finish
-        if (bestStart == iii) break;  //if current run == bestErrCnt run (after exhausted testing) then finish 
-        if (errCnt<bestErrCnt){  //set this as new best run
-          bestErrCnt=errCnt;
-          bestStart = iii;
+         //possible good read
+      if ((bitnum > (64 + errCnt)) && (errCnt < errCntLimit)) {
+
+               //great read - finish
+        if (errCnt == 0) break;  
+               
+               //if current run == bestErrCnt run (after exhausted testing) then finish 
+        if (bestStart == j) break;  
+        
+               //set this as new best run
+               if (errCnt < bestErrCnt){
+          bestErrCnt = errCnt;
+          bestStart = j;
         }
       }
     }
-    if (iii>=gLen){ //exhausted test
+    if (j >= gLen){ //exhausted test
       //if there was a ok test go back to that one and re-run the best run (then dump after that run)
-      if (bestErrCnt < (*bitLen/1000)) iii=bestStart;
+      if (bestErrCnt < errCntLimit) 
+               j = bestStart;
     }
   }
-       if (bitnum>16){
+       if (bitnum > 16){
 
-               for (i=0; i < bitnum; ++i){
-                       BinStream[i]=BitStream[i];
+               for (i = 0; i < bitnum; ++i){
+                       BinStream[i] = BitStream[i];
                }
                *bitLen = bitnum;
        } else {
@@ -403,43 +432,49 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow
 {
        uint32_t last_transition = 0;
        uint32_t idx = 1;
-       uint32_t maxVal=0;
-       if (fchigh==0) fchigh=10;
-       if (fclow==0) fclow=8;
+       uint32_t maxVal = 0;
+       
+       if (fchigh == 0) fchigh = 10;
+       if (fclow == 0) fclow = 8;
+       
        // we do care about the actual theshold value as sometimes near the center of the
        // wave we may get static that changes direction of wave for one value
        // if our value is too low it might affect the read.  and if our tag or
        // antenna is weak a setting too high might not see anything. [marshmellow]
-       if (size<100) return 0;
-       for(idx=1; idx<100; idx++){
-    if(maxVal<dest[idx]) maxVal = dest[idx];
-  }
+       if ( size < 100)
+               return 0;
+       
+       // Find high from first 100 samples
+       for ( idx = 1; idx < 100; idx++ ){
+               if ( maxVal < dest[idx]) 
+                       maxVal = dest[idx];
+       }
+       
     // set close to the top of the wave threshold with 25% margin for error
     // less likely to get a false transition up there. 
     // (but have to be careful not to go too high and miss some short waves)
-       uint8_t threshold_value = (uint8_t)(((maxVal-128)*.75)+128); 
+       uint8_t threshold_value = (uint8_t)(maxVal * .75);
        
        // sync to first lo-hi transition, and threshold
        // Need to threshold first sample
        
-       if(dest[0] < threshold_value) dest[0] = 0;
-       else dest[0] = 1;
+       dest[0] = (dest[0] < threshold_value) ? 0 : 1;
 
        size_t numBits = 0;
+       
        // count cycles between consecutive lo-hi transitions, there should be either 8 (fc/8)
        // or 10 (fc/10) cycles but in practice due to noise etc we may end up with with anywhere
        // between 7 to 11 cycles so fuzz it by treat anything <9 as 8 and anything else as 10
        for(idx = 1; idx < size; idx++) {
-               // threshold current value
 
-               if (dest[idx] < threshold_value) dest[idx] = 0;
-               else dest[idx] = 1;
+               // threshold current value
+               dest[idx] = (dest[idx] < threshold_value) ? 0 : 1;
 
                // Check for 0->1 transition
                if (dest[idx-1] < dest[idx]) { // 0 -> 1 transition
-                       if ((idx-last_transition)<(fclow-2)){            //0-5 = garbage noise
+                       if ( ( idx - last_transition ) <( fclow - 2 ) ) {      //0-5 = garbage noise
                                //do nothing with extra garbage
-                       } else if ((idx-last_transition) < (fchigh-1)) { //6-8 = 8 waves
+                       } else if ((idx - last_transition) < ( fchigh - 1 )) { //6-8 = 8 waves
                                dest[numBits]=1;
                        } else {                                                        //9+ = 10 waves
                                dest[numBits]=0;
@@ -448,7 +483,8 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow
                        numBits++;
                }
        }
-       return numBits; //Actually, it returns the number of bytes, but each byte represents a bit: 1 or 0
+       //it returns the number of bytes, but each byte represents a bit: 1 or 0
+       return numBits; 
 }
 
 uint32_t myround2(float f)
@@ -458,87 +494,92 @@ uint32_t myround2(float f)
 }
 
 //translate 11111100000 to 10 
-size_t aggregate_bits(uint8_t *dest,size_t size,  uint8_t rfLen, uint8_t maxConsequtiveBits, uint8_t invert,uint8_t fchigh,uint8_t fclow )// uint8_t h2l_crossing_value,uint8_t l2h_crossing_value, 
+size_t aggregate_bits(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t maxConsequtiveBits, uint8_t invert, uint8_t fchigh, uint8_t fclow )
 {
-       uint8_t lastval=dest[0];
-       uint32_t idx=0;
-       size_t numBits=0;
-       uint32_t n=1;
+       uint8_t lastval = dest[0];
+       uint32_t idx = 0;
+       uint32_t n = 1;
+       size_t numBits = 0;
 
-       for( idx=1; idx < size; idx++) {
+       for( idx = 1; idx < size; idx++) {
 
-               if (dest[idx]==lastval) {
+               if (dest[idx] == lastval) {
                        n++;
                        continue;
                }
                //if lastval was 1, we have a 1->0 crossing
-               if ( dest[idx-1]==1 ) {
-                       n=myround2((float)(n+1)/((float)(rfLen)/(float)fclow));
-                       //n=(n+1) / h2l_crossing_value;
-               } else {// 0->1 crossing
-                       n=myround2((float)(n+1)/((float)(rfLen-2)/(float)fchigh));  //-2 for fudge factor
-                       //n=(n+1) / l2h_crossing_value;
+               if ( dest[idx-1] == 1 ) {
+                       n = myround2( (float)( n + 1 ) / ((float)(rfLen)/(float)fclow));
+               } else { // 0->1 crossing
+                       n = myround2( (float)( n + 1 ) / ((float)(rfLen-2)/(float)fchigh));  //-2 for fudge factor
                }
                if (n == 0) n = 1;
 
                if(n < maxConsequtiveBits) //Consecutive 
                {
-                       if(invert==0){ //invert bits 
+                       if(invert == 0){ //invert bits 
                                memset(dest+numBits, dest[idx-1] , n);
                        }else{
                                memset(dest+numBits, dest[idx-1]^1 , n);        
                        }                       
                        numBits += n;
                }
-               n=0;
-               lastval=dest[idx];
+               n = 0;
+               lastval = dest[idx];
        }//end for
        return numBits;
 }
+
 //by marshmellow  (from holiman's base)
 // full fsk demod from GraphBuffer wave to decoded 1s and 0s (no mandemod)
 int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t fchigh, uint8_t fclow)
 {
-  // FSK demodulator
-  size = fsk_wave_demod(dest, size, fchigh, fclow);
-  size = aggregate_bits(dest, size,rfLen,192,invert,fchigh,fclow);
-  return size;
+       // FSK demodulator
+       size = fsk_wave_demod(dest, size, fchigh, fclow);
+       if ( size > 0 )
+               size = aggregate_bits(dest, size, rfLen, 192, invert, fchigh, fclow);
+       else
+               return -1;
+       return size;
 }
+
 // loop to get raw HID waveform then FSK demodulate the TAG ID from it
 int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_t *lo)
 {
-       
-       size_t idx=0; //, found=0; //size=0,
+       size_t idx = 0;
+       int numshifts = 0;
+
        // FSK demodulator
-       size = fskdemod(dest, size,50,0,10,8);
+       size = fskdemod(dest, size, 50, 0, 10, 8);
 
        // final loop, go over previously decoded manchester data and decode into usable tag ID
        // 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
        uint8_t frame_marker_mask[] = {1,1,1,0,0,0};
-       int numshifts = 0;
-       idx = 0;
+
+       uint8_t mask_len =  sizeof frame_marker_mask /  sizeof frame_marker_mask[0];
+       
        //one scan
-       while( idx + sizeof(frame_marker_mask) < size) {
+       while( idx + mask_len < size) {
        // search for a start of frame marker
                if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
                { // frame marker found
-                       idx+=sizeof(frame_marker_mask);
+                       idx += mask_len;
                        while(dest[idx] != dest[idx+1] && idx < size-2)
                        {       
                                // Keep going until next frame marker (or error)
                                // Shift in a bit. Start by shifting high registers
-                               *hi2 = (*hi2<<1)|(*hi>>31);
-                               *hi = (*hi<<1)|(*lo>>31);
+                               *hi2 = ( *hi2 << 1 ) | ( *hi >> 31 );
+                               *hi = ( *hi << 1 ) | ( *lo >> 31 );
                                //Then, shift in a 0 or one into low
                                if (dest[idx] && !dest[idx+1])  // 1 0
-                                       *lo=(*lo<<1)|0;
+                                       *lo = ( *lo << 1 ) | 0;
                                else // 0 1
-                                       *lo=(*lo<<1)|1;
+                                       *lo = ( *lo << 1 ) | 1;
                                numshifts++;
                                idx += 2;
                        }
                        // Hopefully, we read a tag and  hit upon the next frame marker
-                       if(idx + sizeof(frame_marker_mask) < size)
+                       if(idx + mask_len < size)
                        {
                                if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
                                {
@@ -556,10 +597,12 @@ int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_
        return -1;
 }
 
-uint32_t bytebits_to_byte(uint8_tsrc, int numbits)
+uint32_t bytebits_to_byte(uint8_t *src, int numbits)
 {
+       //HACK:  potential overflow in numbits is larger then uint32 bits.
+       
        uint32_t num = 0;
-       for(int i = 0 ; i < numbits ; i++)      {
+       for(int i = 0 ; i < numbits ; ++i)      {
                num = (num << 1) | (*src);
                src++;
        }
@@ -568,41 +611,54 @@ uint32_t bytebits_to_byte(uint8_t* src, int numbits)
 
 int IOdemodFSK(uint8_t *dest, size_t size)
 {
-  uint32_t idx=0;
        //make sure buffer has data
-       if (size < 66) return -1;
+       if (size < 100) return -1;
+       
+       uint32_t idx = 0;
+       uint8_t testMax = 0;
+       
        //test samples are not just noise
-       uint8_t testMax=0;
-       for(idx=0;idx<65;idx++){
-               if (testMax<dest[idx]) testMax=dest[idx];
+       for (; idx < 65; ++idx ){
+               if (testMax < dest[idx])
+                       testMax = dest[idx];
        }
-       idx=0;
+
        //if not just noise
-       if (testMax>170){
-               // FSK demodulator
-               size = fskdemod(dest, size,64,1,10,8);  //  RF/64 and invert
-               if (size < 65) return -1;  //did we get a good demod?
-               //Index map
-               //0           10          20          30          40          50          60
-               //|           |           |           |           |           |           |
-               //01234567 8 90123456 7 89012345 6 78901234 5 67890123 4 56789012 3 45678901 23
-               //-----------------------------------------------------------------------------
-               //00000000 0 11110000 1 facility 1 version* 1 code*one 1 code*two 1 ???????? 11
-               //
-               //XSF(version)facility:codeone+codetwo
-               //Handle the data
-         uint8_t mask[] = {0,0,0,0,0,0,0,0,0,1};
-               for( idx=0; idx < (size - 65); idx++) {
-       if ( memcmp(dest + idx, mask, sizeof(mask))==0) {
-               //frame marker found
-               if (!dest[idx+8] && dest[idx+17]==1 && dest[idx+26]==1 && dest[idx+35]==1 && dest[idx+44]==1 && dest[idx+53]==1){
-                       //confirmed proper separator bits found
-                       //return start position
-                                       return (int) idx;
-                               }
-                       }               
-               }
-       }       
+       if (testMax < 170) return -2;
+               
+       // FSK demodulator
+       size = fskdemod(dest, size, 64, 1, 10, 8);  //  RF/64 and invert
+       
+       //did we get a good demod?
+       if (size < 65) return -3;
+       
+       //Index map
+       //0           10          20          30          40          50          60
+       //|           |           |           |           |           |           |
+       //01234567 8 90123456 7 89012345 6 78901234 5 67890123 4 56789012 3 45678901 23
+       //-----------------------------------------------------------------------------
+       //00000000 0 11110000 1 facility 1 version* 1 code*one 1 code*two 1 ???????? 11
+       //
+       //XSF(version)facility:codeone+codetwo
+       //Handle the data
+       
+       uint8_t mask[] = {0,0,0,0,0,0,0,0,0,1};
+       
+       for( idx = 0; idx < (size - 65); ++idx) {
+       if ( memcmp(dest + idx, mask, sizeof(mask))==0) {
+               //frame marker found
+               if (!dest[idx+8] && 
+                       dest[idx+17] == 1 &&
+                       dest[idx+26] == 1 &&
+                       dest[idx+35] == 1 &&
+                       dest[idx+44] == 1 &&
+                       dest[idx+53] == 1){
+                               //confirmed proper separator bits found
+                               //return start position
+                               return (int) idx;
+                       }
+               }               
+       }
        return 0;
 }
 
@@ -611,67 +667,86 @@ int IOdemodFSK(uint8_t *dest, size_t size)
 // maybe somehow adjust peak trimming value based on samples to fix?
 int DetectASKClock(uint8_t dest[], size_t size, int clock)
 {
-  int i=0;
-  int peak=0;
-  int low=128;
-  int clk[]={16,32,40,50,64,100,128,256};
-  int loopCnt = 256;  //don't need to loop through entire array...
-  if (size<loopCnt) loopCnt = size;
-
-  //if we already have a valid clock quit
-  for (;i<8;++i)
-       if (clk[i]==clock) return clock;
-
-  //get high and low peak
-  for (i=0;i<loopCnt;++i){
-    if(dest[i]>peak){
-      peak = dest[i]; 
-    }
-    if(dest[i]<low){
-      low = dest[i];
-    }
-  }
-  peak=(int)((peak-128)*.75)+128;
-  low= (int)((low-128)*.75)+128;
-  int ii;
-  int clkCnt;
-  int tol = 0;
-  int bestErr=1000;
-  int errCnt[]={0,0,0,0,0,0,0,0};
-  //test each valid clock from smallest to greatest to see which lines up
-  for(clkCnt=0; clkCnt<6;++clkCnt){
-    if (clk[clkCnt]==32){
-      tol=1;
-    }else{
-      tol=0;
-    }
-    bestErr=1000;
-    //try lining up the peaks by moving starting point (try first 256) 
-    for (ii=0; ii<loopCnt; ++ii){
-      if ((dest[ii]>=peak) || (dest[ii]<=low)){
-        errCnt[clkCnt]=0;
-        // now that we have the first one lined up test rest of wave array
-        for (i=0; i<((int)(size/clk[clkCnt])-1); ++i){
-          if (dest[ii+(i*clk[clkCnt])]>=peak || dest[ii+(i*clk[clkCnt])]<=low){
-          }else if(dest[ii+(i*clk[clkCnt])-tol]>=peak || dest[ii+(i*clk[clkCnt])-tol]<=low){
-          }else if(dest[ii+(i*clk[clkCnt])+tol]>=peak || dest[ii+(i*clk[clkCnt])+tol]<=low){
-          }else{  //error no peak detected
-            errCnt[clkCnt]++;
-          }    
-        }
-        //if we found no errors this is correct one - return this clock
-        if(errCnt[clkCnt]==0) return clk[clkCnt];
-        //if we found errors see if it is lowest so far and save it as best run
-        if(errCnt[clkCnt]<bestErr) bestErr=errCnt[clkCnt];
-      }
-    } 
-  }
-  int iii=0;
-  int best=0;
-  for (iii=0; iii<6;++iii){
-    if (errCnt[iii]<errCnt[best]){
-      best = iii;
-    }
-  }
-  return clk[best];
+       int i = 0;
+       int clk[] = {16,32,40,50,64,100,128,256};
+       uint8_t clkLen = sizeof clk / sizeof clk[0];
+       
+       //if we already have a valid clock quit
+       for (; i < clkLen; ++i)
+               if (clk[i] == clock) 
+                       return clock;
+                       
+       int peak = 0;
+       int low = 128;  
+       int loopCnt = 256;
+       if (size < loopCnt) 
+               loopCnt = size;
+       
+       //get high and low peak
+       for ( i = 0; i < loopCnt; ++i ){
+               if(dest[i] > peak) 
+                       peak = dest[i]; 
+               if(dest[i] < low) 
+                       low = dest[i];
+       }
+
+       peak = (int)(peak * .75);
+       low  = (int)(low+128 * .25);
+       int ii, cnt, bestErr, tol = 0;
+       int errCnt[clkLen];
+       memset(errCnt, 0x00, clkLen);
+       
+       int tmpIndex, tmphigh, tmplow;
+       
+       //test each valid clock from smallest to greatest to see which lines up
+       for( cnt = 0; cnt < clkLen; ++cnt ){
+
+               tol = (clk[cnt] == 32) ? 1 : 0;
+               bestErr = 1000;
+               tmpIndex = tmphigh = tmplow = 0;
+
+               //try lining up the peaks by moving starting point (try first 256) 
+               for (ii=0; ii < loopCnt; ++ii){
+               
+                       // not a peak? continue
+                       if ( (dest[ii] < peak) && (dest[ii] > low)) 
+                               continue;
+
+                       errCnt[cnt] = 0;
+                       
+                       // now that we have the first one lined up test rest of wave array
+                       for ( i = 0; i < ((int)(size / clk[cnt]) - 1); ++i){
+                         
+                               tmpIndex = ii + (i * clk[cnt] );
+                               tmplow  = dest[ tmpIndex - tol];
+                               tmphigh = dest[ tmpIndex + tol];
+                               
+                               if ( dest[tmpIndex] >= peak || dest[tmpIndex] <= low ) {
+                               }
+                               else if ( tmplow >= peak || tmplow <= low){
+                               }                                       
+                               else if ( tmphigh >= peak || tmphigh <= low){
+                               }
+                               else 
+                                       errCnt[cnt]++; //error no peak detected
+                       }
+
+                       //if we found no errors this is correct one - return this clock
+                       if ( errCnt[cnt] == 0 )
+                               return clk[cnt];
+
+                       if ( errCnt[cnt] < bestErr) 
+                               bestErr = errCnt[cnt];
+               }
+               // save the least error.
+               errCnt[cnt] = bestErr;
+       }
+       // find best clock which has lowest number of errors
+       int j = 0, bestIndex = 0;
+       for (; j < clkLen; ++j){
+               if ( errCnt[j] < errCnt[bestIndex] )
+                       bestIndex = j;
+       }
+       return clk[bestIndex];
 }
Impressum, Datenschutz