From 8d0a3e87d7d2350f4a05698a42f57625e460e5d6 Mon Sep 17 00:00:00 2001 From: iceman1001 Date: Sun, 4 Jan 2015 22:49:54 +0100 Subject: [PATCH] FIX: a shot at fixing the "_" underscore problem in fileutils.c. This one uses _ifdefine. I hope it works. Linux people can let me know if it works. 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 --- armsrc/desfire_crypto.c | 6 +- armsrc/lfops.c | 313 +++++++------ client/cmddata.c | 897 +++++++++++++++++++------------------ client/cmdlf.c | 58 +-- client/cmdlfem4x.c | 64 ++- client/cmdlft55xx.c | 53 +-- client/graph.c | 212 ++++----- client/graph.h | 8 +- client/loclass/fileutils.c | 6 + client/proxguiqt.cpp | 2 +- client/ui.c | 67 +-- common/lfdemod.c | 881 +++++++++++++++++++----------------- 12 files changed, 1286 insertions(+), 1281 deletions(-) diff --git a/armsrc/desfire_crypto.c b/armsrc/desfire_crypto.c index b77ad8ef..9ea07371 100644 --- a/armsrc/desfire_crypto.c +++ b/armsrc/desfire_crypto.c @@ -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 diff --git a/armsrc/lfops.c b/armsrc/lfops.c index ea2b0c44..cc9814be 100644 --- a/armsrc/lfops.c +++ b/armsrc/lfops.c @@ -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(); } diff --git a/client/cmddata.c b/client/cmddata.c index de564a69..e9499ed8 100644 --- a/client/cmddata.c +++ b/client/cmddata.c @@ -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 (;ihigh) high=GraphBuffer[i]; - else if(GraphBuffer[i]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 (;ihigh)high=GraphBuffer[i]; - else if(GraphBuffer[i]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 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 (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, " -- 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, " -- 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"}, diff --git a/client/cmdlf.c b/client/cmdlf.c index 8257a5b3..e445b47b 100644 --- a/client/cmdlf.c +++ b/client/cmdlf.c @@ -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 [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 [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(" , 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; } diff --git a/client/cmdlfem4x.c b/client/cmdlfem4x.c index 6567ee41..a0cd87ca 100644 --- a/client/cmdlfem4x.c +++ b/client/cmdlfem4x.c @@ -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++) { diff --git a/client/cmdlft55xx.c b/client/cmdlft55xx.c index 6ea9d2d3..6f1ada7c 100644 --- a/client/cmdlft55xx.c +++ b/client/cmdlft55xx.c @@ -22,7 +22,7 @@ #include "data.h" -#define LF_TRACE_BUFF_SIZE 12000 // 32 x 32 x 10 (32 bit times numofblock (7), times clock skip..) +#define LF_TRACE_BUFF_SIZE 20000 // 32 x 32 x 10 (32 bit times numofblock (7), times clock skip..) #define LF_BITSSTREAM_LEN 1000 // more then 1000 bits shouldn't happend.. 8block * 4 bytes * 8bits = static int CmdHelp(const char *Cmd); @@ -48,7 +48,7 @@ int CmdReadBlk(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++) { @@ -85,7 +85,7 @@ int CmdReadBlkPWD(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++) { @@ -166,7 +166,7 @@ int CmdReadTrace(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++) { @@ -249,32 +249,31 @@ int CmdInfo(const char *Cmd){ return 0; } - if ( strlen(Cmd)==0){ + if ( strlen(Cmd) == 0 ){ CmdReadBlk("0"); } uint8_t bits[LF_BITSSTREAM_LEN] = {0x00}; - uint8_t * bitstream = bits; - - manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN); + + manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bits, LF_BITSSTREAM_LEN); uint8_t si = 5; - uint32_t bl0 = PackBits(si, 32, bitstream); + uint32_t bl0 = PackBits(si, 32, bits); - uint32_t safer = PackBits(si, 4, bitstream); si += 4; - uint32_t resv = PackBits(si, 7, bitstream); si += 7; - uint32_t dbr = PackBits(si, 3, bitstream); si += 3; - uint32_t extend = PackBits(si, 1, bitstream); si += 1; - uint32_t datamodulation = PackBits(si, 5, bitstream); si += 5; - uint32_t pskcf = PackBits(si, 2, bitstream); si += 2; - uint32_t aor = PackBits(si, 1, bitstream); si += 1; - uint32_t otp = PackBits(si, 1, bitstream); si += 1; - uint32_t maxblk = PackBits(si, 3, bitstream); si += 3; - uint32_t pwd = PackBits(si, 1, bitstream); si += 1; - uint32_t sst = PackBits(si, 1, bitstream); si += 1; - uint32_t fw = PackBits(si, 1, bitstream); si += 1; - uint32_t inv = PackBits(si, 1, bitstream); si += 1; - uint32_t por = PackBits(si, 1, bitstream); si += 1; + uint32_t safer = PackBits(si, 4, bits); si += 4; + uint32_t resv = PackBits(si, 7, bits); si += 7; + uint32_t dbr = PackBits(si, 3, bits); si += 3; + uint32_t extend = PackBits(si, 1, bits); si += 1; + uint32_t datamodulation = PackBits(si, 5, bits); si += 5; + uint32_t pskcf = PackBits(si, 2, bits); si += 2; + uint32_t aor = PackBits(si, 1, bits); si += 1; + uint32_t otp = PackBits(si, 1, bits); si += 1; + uint32_t maxblk = PackBits(si, 3, bits); si += 3; + uint32_t pwd = PackBits(si, 1, bits); si += 1; + uint32_t sst = PackBits(si, 1, bits); si += 1; + uint32_t fw = PackBits(si, 1, bits); si += 1; + uint32_t inv = PackBits(si, 1, bits); si += 1; + uint32_t por = PackBits(si, 1, bits); si += 1; PrintAndLog(""); PrintAndLog("-- T55xx Configuration --------------------------------------"); @@ -295,7 +294,7 @@ int CmdInfo(const char *Cmd){ PrintAndLog(" POR-Delay : %s", (por) ? "Yes":"No"); PrintAndLog("-------------------------------------------------------------"); PrintAndLog(" Raw Data - Page 0"); - PrintAndLog(" Block 0 : 0x%08X %s", bl0, sprint_bin(bitstream+5,32) ); + PrintAndLog(" Block 0 : 0x%08X %s", bl0, sprint_bin(bits+5,32) ); PrintAndLog("-------------------------------------------------------------"); return 0; @@ -357,8 +356,10 @@ int ManchesterDemod(int blockNum){ uint8_t bits[LF_BITSSTREAM_LEN] = {0x00}; uint8_t * bitstream = bits; - manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN); - blockData = PackBits(offset, sizebyte, bitstream); + //manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN); + manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bits, LF_BITSSTREAM_LEN); + //blockData = PackBits(offset, sizebyte, bitstream); + blockData = PackBits(offset, sizebyte, bits); if ( blockNum < 0) PrintAndLog(" Decoded : 0x%08X %s", blockData, sprint_bin(bitstream+offset,sizebyte) ); diff --git a/client/graph.c b/client/graph.c index ff5a02e4..d0f6fe74 100644 --- a/client/graph.c +++ b/client/graph.c @@ -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 (GraphTraceLenpeak){ - peak = GraphBuffer[i]; - } - if(GraphBuffer[i]=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] 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;i127) 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 diff --git a/client/graph.h b/client/graph.h index afe23686..c745270d 100644 --- a/client/graph.h +++ b/client/graph.h @@ -13,11 +13,11 @@ 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]; diff --git a/client/loclass/fileutils.c b/client/loclass/fileutils.c index deab3137..74c36a4d 100644 --- a/client/loclass/fileutils.c +++ b/client/loclass/fileutils.c @@ -49,8 +49,14 @@ * @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; } diff --git a/client/proxguiqt.cpp b/client/proxguiqt.cpp index a820fe41..3e9bdfd5 100644 --- a/client/proxguiqt.cpp +++ b/client/proxguiqt.cpp @@ -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)); diff --git a/client/ui.c b/client/ui.c index 5111e295..e464a533 100644 --- a/client/ui.c +++ b/client/ui.c @@ -20,13 +20,14 @@ #include "ui.h" #include "cmdmain.h" #include "cmddata.h" +#include "graph.h" //#include #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) { diff --git a/common/lfdemod.c b/common/lfdemod.c index d30262f3..5ab5e03a 100644 --- a/common/lfdemod.c +++ b/common/lfdemod.c @@ -8,389 +8,418 @@ // Low frequency commands //----------------------------------------------------------------------------- +#include #include #include #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 (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= 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 (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(maxVal1 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_t* src, 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 (testMax170){ - // 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 (sizepeak){ - peak = dest[i]; - } - if(dest[i]=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] 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]; } -- 2.39.2