github/proxmark3
1
0
Fork 0
mirror of https://github.com/Proxmark/proxmark3.git synced 2025-08-23 06:25:28 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

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.

Browse source 
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
This commit is contained in:
iceman1001 2015-01-04 22:49:54 +01:00
commit 8d0a3e87d7
12 changed files with 1280 additions and 1275 deletions
Download patch file Download diff file Expand all files Collapse all files

6
armsrc/desfire_crypto.c
View file

@ -321,7 +321,7 @@ void* mifare_cryto_postprocess_data (desfiretag_t tag, void *data, ssize_t *nbyt
*nbytes = -1; *nbytes = -1;
res = NULL; res = NULL;
#ifdef WITH_DEBUG #ifdef WITH_DEBUG
printf ("No room for MAC!"); Dbprintf ("No room for MAC!");
#endif #endif
break; 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)) { if (0 != memcmp ((uint8_t *)data + *nbytes - 1, (uint8_t *)edata + edl - 8, 4)) {
#ifdef WITH_DEBUG #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 *)data + *nbytes - 1, key_macing_length (key), "Expect ", 0);
hexdump ((uint8_t *)edata + edl - 8, key_macing_length (key), "Actual ", 0); hexdump ((uint8_t *)edata + edl - 8, key_macing_length (key), "Actual ", 0);
#endif #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; ((uint8_t *)data)[*nbytes - 9] = first_cmac_byte;
if (0 != memcmp (DESFIRE (tag)->cmac, (uint8_t *)data + *nbytes - 9, 8)) { if (0 != memcmp (DESFIRE (tag)->cmac, (uint8_t *)data + *nbytes - 9, 8)) {
#ifdef WITH_DEBUG #ifdef WITH_DEBUG
printf ("CMAC NOT verified :-("); Dbprintf ("CMAC NOT verified :-(");
hexdump ((uint8_t *)data + *nbytes - 9, 8, "Expect ", 0); hexdump ((uint8_t *)data + *nbytes - 9, 8, "Expect ", 0);
hexdump (DESFIRE (tag)->cmac, 8, "Actual ", 0); hexdump (DESFIRE (tag)->cmac, 8, "Actual ", 0);
#endif #endif

115
armsrc/lfops.c
View file

@ -64,9 +64,9 @@ void SnoopLFRawAdcSamples(int divisor, int trigger_threshold)
// split into two routines so we can avoid timing issues after sending commands // // split into two routines so we can avoid timing issues after sending commands //
void DoAcquisition125k_internal(int trigger_threshold, bool silent) void DoAcquisition125k_internal(int trigger_threshold, bool silent)
{ {
uint8_t *dest = get_bigbufptr_recvrespbuf(); uint8_t *dest = (uint8_t *)BigBuf;
uint16_t i = 0; uint16_t i = 0;
memset(dest, 0x00, FREE_BUFFER_SIZE); memset(dest, 0x00, BIGBUF_SIZE);
for(;;) { for(;;) {
if (AT91C_BASE_SSC->SSC_SR & AT91C_SSC_TXRDY) { if (AT91C_BASE_SSC->SSC_SR & AT91C_SSC_TXRDY) {
@ -80,7 +80,7 @@ void DoAcquisition125k_internal(int trigger_threshold, bool silent)
continue; continue;
else else
trigger_threshold = -1; trigger_threshold = -1;
if (++i >= FREE_BUFFER_SIZE) break; if (++i >= BIGBUF_SIZE) break;
} }
} }
if (!silent){ if (!silent){
@ -161,8 +161,6 @@ void ReadTItag(void)
signed char *dest = (signed char *)BigBuf; signed char *dest = (signed char *)BigBuf;
int n = sizeof(BigBuf); int n = sizeof(BigBuf);
// int *dest = GraphBuffer;
// int n = GraphTraceLen;
// 128 bit shift register [shift3:shift2:shift1:shift0] // 128 bit shift register [shift3:shift2:shift1:shift0]
uint32_t shift3 = 0, shift2 = 0, shift1 = 0, shift0 = 0; 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) void SimulateTagLowFrequencyA(int len, int gap)
{ {
//Dbprintf("LEN %d || Gap %d",len, gap);
uint8_t *buf = (uint8_t *)BigBuf; uint8_t *buf = (uint8_t *)BigBuf;
FpgaDownloadAndGo(FPGA_BITSTREAM_LF); FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
@ -725,9 +721,7 @@ void CmdHIDsimTAG(int hi, int lo, uint8_t ledcontrol)
// loop to get raw HID waveform then FSK demodulate the TAG ID from it // loop to get raw HID waveform then FSK demodulate the TAG ID from it
void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol) void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
{ {
uint8_t *dest = get_bigbufptr_recvrespbuf(); uint8_t *dest = (uint8_t *)BigBuf;
size_t size=0; //, found=0;
uint32_t hi2 = 0, hi = 0, lo = 0; uint32_t hi2 = 0, hi = 0, lo = 0;
// Configure to go in 125Khz listen mode // Configure to go in 125Khz listen mode
@ -739,25 +733,31 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
if (ledcontrol) LED_A_ON(); if (ledcontrol) LED_A_ON();
DoAcquisition125k_internal(-1,true); 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(); 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 // 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 // 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
if (hi2 != 0){ //extra large HID tags
if (hi2 != 0){
//extra large HID tags
Dbprintf("TAG ID: %x%08x%08x (%d)", Dbprintf("TAG ID: %x%08x%08x (%d)",
(unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); (unsigned int) hi2,
}else { //standard HID tags <38 bits (unsigned int) hi,
//Dbprintf("TAG ID: %x%08x (%d)",(unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); //old print cmd (unsigned int) lo,
(unsigned int) (lo >> 1) & 0xFFFF);
} else {
//standard HID tags <38 bits
uint8_t bitlen = 0; uint8_t bitlen = 0;
uint32_t fc = 0; uint32_t fc = 0;
uint32_t cardnum = 0; uint32_t cardnum = 0;
if ((( hi >> 5 ) & 1) ==1){//if bit 38 is set then < 37 bit format is used if ((( hi >> 5 ) & 1) ==1){//if bit 38 is set then < 37 bit format is used
uint32_t lo2 = 0; uint32_t lo2 = 0;
lo2 = (((hi & 31) << 12) | (lo >> 20)); //get bits 21-37 to check for format len bit lo2 = (((hi & 31) << 12) | (lo >> 20)); //get bits 21-37 to check for format len bit
@ -795,11 +795,13 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
fc = ((hi & 0xF) << 12 ) |(lo >> 20); 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", 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) hi,
(unsigned int) bitlen, (unsigned int) fc, (unsigned int) cardnum); (unsigned int) lo,
(unsigned int) (lo >> 1) & 0xFFFF,
(unsigned int) bitlen,
(unsigned int) fc,
(unsigned int) cardnum);
} }
if (findone){ if (findone){
if (ledcontrol) LED_A_OFF(); if (ledcontrol) LED_A_OFF();
@ -809,7 +811,6 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
hi2 = hi = lo = 0; hi2 = hi = lo = 0;
} }
WDT_HIT(); WDT_HIT();
//SpinDelay(50);
} }
DbpString("Stopped"); DbpString("Stopped");
if (ledcontrol) LED_A_OFF(); 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) void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
{ {
uint8_t *dest = (uint8_t *)BigBuf; uint8_t *dest = (uint8_t *)BigBuf;
size_t size=0; //, found=0;
uint32_t bitLen = 0; uint32_t bitLen = 0;
int clk = 0, invert = 0, errCnt = 0; int clk = 0, invert = 0, errCnt = 0;
uint64_t lo = 0; uint64_t lo = 0;
// Configure to go in 125Khz listen mode // Configure to go in 125Khz listen mode
LFSetupFPGAForADC(95, true); LFSetupFPGAForADC(0, true);
while(!BUTTON_PRESS()) { while(!BUTTON_PRESS()) {
@ -832,37 +832,33 @@ void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
if (ledcontrol) LED_A_ON(); if (ledcontrol) LED_A_ON();
DoAcquisition125k_internal(-1,true); DoAcquisition125k_internal(-1,true);
size = sizeof(BigBuf);
if (size < 2000) continue;
// FSK demodulator // FSK demodulator
//int askmandemod(uint8_t *BinStream,uint32_t *BitLen,int *clk, int *invert); bitLen = BIGBUF_SIZE;
bitLen=size; errCnt = askmandemod(dest,&bitLen,&clk,&invert);
//Dbprintf("DEBUG: Buffer got"); if ( errCnt < 0 ) continue;
errCnt = askmandemod(dest,&bitLen,&clk,&invert); //HIDdemodFSK(dest,size,&hi2,&hi,&lo);
//Dbprintf("DEBUG: ASK Got");
WDT_HIT(); WDT_HIT();
if (errCnt>=0){
lo = Em410xDecode(dest,bitLen); lo = Em410xDecode(dest,bitLen);
//Dbprintf("DEBUG: EM GOT");
//printEM410x(lo); if ( lo <= 0) continue;
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)); 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 (findone){
if (ledcontrol) LED_A_OFF(); if (ledcontrol) LED_A_OFF();
return; return;
} }
} else {
//Dbprintf("DEBUG: No Tag");
}
WDT_HIT(); WDT_HIT();
lo = 0; lo = clk = invert = errCnt = 0;
clk=0;
invert=0;
errCnt=0;
size=0;
//SpinDelay(50);
} }
DbpString("Stopped"); DbpString("Stopped");
if (ledcontrol) LED_A_OFF(); 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) void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol)
{ {
uint8_t *dest = (uint8_t *)BigBuf; uint8_t *dest = (uint8_t *)BigBuf;
size_t size=0;
int idx = 0; int idx = 0;
uint32_t code = 0, code2 = 0; uint32_t code = 0, code2 = 0;
uint8_t version = 0; uint8_t version = 0;
uint8_t facilitycode = 0; uint8_t facilitycode = 0;
uint16_t number = 0; uint16_t number = 0;
// Configure to go in 125Khz listen mode
LFSetupFPGAForADC(0, true); LFSetupFPGAForADC(0, true);
while(!BUTTON_PRESS()) { while(!BUTTON_PRESS()) {
WDT_HIT(); WDT_HIT();
if (ledcontrol) LED_A_ON(); if (ledcontrol) LED_A_ON();
DoAcquisition125k_internal(-1, true); DoAcquisition125k_internal(-1, true);
size = sizeof(BigBuf);
//make sure buffer has data idx = IOdemodFSK(dest, BIGBUF_SIZE);
if (size < 2000) continue;
//fskdemod and get start index if ( idx < 0 )
continue;
WDT_HIT(); WDT_HIT();
idx = IOdemodFSK(dest,size);
if (idx>0){
//valid tag found
//Index map //Index map
//0 10 20 30 40 50 60 //0 10 20 30 40 50 60
@ -905,6 +898,7 @@ void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol)
// //
//XSF(version)facility:codeone+codetwo //XSF(version)facility:codeone+codetwo
//Handle the data //Handle the data
if(findone){ //only print binary if we are doing one 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], 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+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]);
@ -914,6 +908,7 @@ void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol)
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",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]); 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); code = bytebits_to_byte(dest+idx,32);
code2 = bytebits_to_byte(dest+idx+32,32); code2 = bytebits_to_byte(dest+idx+32,32);
version = bytebits_to_byte(dest+idx+27,8); //14,4 version = bytebits_to_byte(dest+idx+27,8); //14,4
@ -921,7 +916,6 @@ void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol)
number = (bytebits_to_byte(dest+idx+36,8)<<8)|(bytebits_to_byte(dest+idx+45,8)); //36,9 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); Dbprintf("XSF(%02d)%02x:%05d (%08x%08x)", version, facilitycode, number, code, code2);
// if we're only looking for one tag
if (findone){ if (findone){
if (ledcontrol) LED_A_OFF(); if (ledcontrol) LED_A_OFF();
return; return;
@ -931,8 +925,7 @@ void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol)
number = 0; number = 0;
idx = 0; idx = 0;
} }
WDT_HIT();
}
DbpString("Stopped"); DbpString("Stopped");
if (ledcontrol) LED_A_OFF(); if (ledcontrol) LED_A_OFF();
} }

419
client/cmddata.c
View file

@ -29,15 +29,11 @@ int CmdAmp(const char *Cmd)
int i, rising, falling; int i, rising, falling;
int max = INT_MIN, min = INT_MAX; int max = INT_MIN, min = INT_MAX;
for (i = 10; i < GraphTraceLen; ++i) { DetectHighLowInGraph( &max, &min, FALSE);
if (GraphBuffer[i] > max)
max = GraphBuffer[i];
if (GraphBuffer[i] < min)
min = GraphBuffer[i];
}
if (max != min) { if (max != min) {
rising = falling = 0; rising = falling = 0;
for (i = 0; i < GraphTraceLen; ++i) { for (i = 0; i < GraphTraceLen; ++i) {
if (GraphBuffer[i + 1] < GraphBuffer[i]) { if (GraphBuffer[i + 1] < GraphBuffer[i]) {
if (rising) { if (rising) {
@ -78,27 +74,23 @@ int Cmdaskdemod(const char *Cmd)
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) { if (c != 0 && c != 1) {
PrintAndLog("Invalid argument: %s", Cmd); PrintAndLog("Invalid argument: %s", Cmd);
return 0; return 0;
} }
DetectHighLowInGraph( &high, &low, FALSE);
high = abs(high * .75);
low = abs(low * .75);
//prime loop //prime loop
if (GraphBuffer[0] > 0) { if (GraphBuffer[0] > 0) {
GraphBuffer[0] = 1-c; GraphBuffer[0] = 1-c;
} else { } else {
GraphBuffer[0] = c; GraphBuffer[0] = c;
} }
for (i = 1; i < GraphTraceLen; ++i) { for (i = 1; i < GraphTraceLen; ++i) {
/* Transitions are detected at each peak /* Transitions are detected at each peak
* Transitions are either: * Transitions are either:
@ -121,49 +113,59 @@ int Cmdaskdemod(const char *Cmd)
return 0; return 0;
} }
void printBitStream(uint8_t BitStream[], uint32_t bitLen){ void printBitStream(uint8_t bits[], uint32_t bitLen){
uint32_t i = 0; uint32_t i = 0;
if (bitLen < 16) { if (bitLen < 16) {
PrintAndLog("Too few bits found: %d",bitLen); PrintAndLog("Too few bits found: %d",bitLen);
return; return;
} }
if (bitLen>512) bitLen=512; 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) { 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", PrintAndLog("%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i",
BitStream[i], bits[i],
BitStream[i+1], bits[i+1],
BitStream[i+2], bits[i+2],
BitStream[i+3], bits[i+3],
BitStream[i+4], bits[i+4],
BitStream[i+5], bits[i+5],
BitStream[i+6], bits[i+6],
BitStream[i+7], bits[i+7],
BitStream[i+8], bits[i+8],
BitStream[i+9], bits[i+9],
BitStream[i+10], bits[i+10],
BitStream[i+11], bits[i+11],
BitStream[i+12], bits[i+12],
BitStream[i+13], bits[i+13],
BitStream[i+14], bits[i+14],
BitStream[i+15]); bits[i+15]);
} }
return; return;
} }
void printEM410x(uint64_t id)
{ void printEM410x(uint64_t id) {
if (id !=0){
uint64_t iii=1; if ( id <= 0 ) return;
uint64_t id2lo=0; //id2hi=0,
uint32_t ii=0; uint64_t id2lo = 0;
uint32_t i=0; uint32_t i,j;
for (ii=5; ii>0;ii--){ i = j = 0;
for (j = 5; j > 0; j--){
for (i = 0; i < 8; i++){ for (i = 0; i < 8; i++){
id2lo=(id2lo<<1LL)|((id & (iii<<(i+((ii-1)*8))))>>(i+((ii-1)*8))); id2lo = ( id2lo << 1LL)|((id & ( 1 << ( i +( ( j-1 ) * 8 )))) >> ( i + (( j-1) *8 )));
} }
} }
//output em id //output em id
PrintAndLog("EM TAG ID : %010llx", id); PrintAndLog("EM TAG ID : %010llx", id);
PrintAndLog("Unique TAG ID: %010llx", id2lo); //id2hi, PrintAndLog("Unique TAG ID: %010llx", id2lo);
PrintAndLog("DEZ 8 : %08lld", id & 0xFFFFFF); PrintAndLog("DEZ 8 : %08lld", id & 0xFFFFFF);
PrintAndLog("DEZ 10 : %010lld", id & 0xFFFFFF); PrintAndLog("DEZ 10 : %010lld", id & 0xFFFFFF);
PrintAndLog("DEZ 5.5 : %05lld.%05lld", (id>>16LL) & 0xFFFF, (id & 0xFFFF)); PrintAndLog("DEZ 5.5 : %05lld.%05lld", (id>>16LL) & 0xFFFF, (id & 0xFFFF));
@ -172,18 +174,16 @@ void printEM410x(uint64_t id)
PrintAndLog("DEZ 15/IK3 : %015lld", id2lo); PrintAndLog("DEZ 15/IK3 : %015lld", id2lo);
PrintAndLog("Other : %05lld_%03lld_%08lld", (id & 0xFFFF), (( id >> 16LL) & 0xFF), (id & 0xFFFFFF)); PrintAndLog("Other : %05lld_%03lld_%08lld", (id & 0xFFFF), (( id >> 16LL) & 0xFF), (id & 0xFFFFFF));
} }
return;
}
int CmdEm410xDecode(const char *Cmd) int CmdEm410xDecode(const char *Cmd)
{ {
uint64_t id = 0; uint64_t id = 0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
uint32_t i=0; uint32_t len = GetFromGraphBuf(bits);
i=getFromGraphBuf(BitStream); id = Em410xDecode(bits, len);
id = Em410xDecode(BitStream,i);
printEM410x(id); printEM410x(id);
if (id>0) return 1; if ( id > 0 )
return 1;
return 0; return 0;
} }
@ -195,38 +195,39 @@ int Cmdaskmandemod(const char *Cmd)
{ {
int invert = 0; int invert = 0;
int clk = 0; int clk = 0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
sscanf(Cmd, "%i %i", &clk, &invert); sscanf(Cmd, "%i %i", &clk, &invert);
if (invert != 0 && invert != 1) { if (invert != 0 && invert != 1) {
PrintAndLog("Invalid argument: %s", Cmd); PrintAndLog("Invalid argument: %s", Cmd);
return 0; return 0;
} }
uint32_t BitLen = getFromGraphBuf(BitStream);
int errCnt=0; uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
errCnt = askmandemod(BitStream, &BitLen,&clk,&invert); uint32_t len = GetFromGraphBuf(bits);
if (errCnt<0){ //if fatal error (or -1)
// PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk); int errCnt = askmandemod(bits, &len, &clk, &invert);
return 0;
} if (errCnt < 0) return 0;
if (BitLen<16) return 0; if (len < 16) return 0;
PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,BitLen);
PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,len);
if (errCnt > 0){ if (errCnt > 0){
PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt); PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
} }
PrintAndLog("ASK/Manchester decoded bitstream:"); PrintAndLog("ASK/Manchester decoded bitstream:");
// Now output the bitstream to the scrollback by line of 16 bits
printBitStream(BitStream,BitLen); printBitStream(bits, len);
uint64_t lo =0; uint64_t lo = Em410xDecode(bits, len);
lo = Em410xDecode(BitStream,BitLen);
if (lo > 0){ if (lo > 0){
//set GraphBuffer for clone or sim command SetGraphBuf(bits,len);
setGraphBuf(BitStream,BitLen);
PrintAndLog("EM410x pattern found: "); PrintAndLog("EM410x pattern found: ");
printEM410x(lo); printEM410x(lo);
return 1;
} }
//if (BitLen>16) return 1;
return 0; return 0;
} }
@ -238,35 +239,36 @@ int Cmdmandecoderaw(const char *Cmd)
int i = 0; int i = 0;
int errCnt = 0; int errCnt = 0;
int bitnum = 0; int bitnum = 0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
int high = 0, low = 0; int high = 0, low = 0;
for (; i < GraphTraceLen; ++i){ for (; i < GraphTraceLen; ++i){
if (GraphBuffer[i] > high) high = GraphBuffer[i]; if (GraphBuffer[i] > high) high = GraphBuffer[i];
else if (GraphBuffer[i] < low) low = GraphBuffer[i]; else if (GraphBuffer[i] < low) low = GraphBuffer[i];
BitStream[i]=GraphBuffer[i]; bits[i] = GraphBuffer[i];
} }
if (high > 1 || low < 0 ){ if (high > 1 || low < 0 ){
PrintAndLog("Error: please raw demod the wave first then mancheseter raw decode"); PrintAndLog("Error: please raw demod the wave first then mancheseter raw decode");
return 0; return 0;
} }
bitnum = i; bitnum = i;
errCnt=manrawdecode(BitStream,&bitnum); errCnt = manrawdecode(bits, &bitnum);
if (errCnt>=20){ if (errCnt>=20){
PrintAndLog("Too many errors: %d",errCnt); PrintAndLog("Too many errors: %d",errCnt);
return 0; return 0;
} }
PrintAndLog("Manchester Decoded - # errors:%d - data:",errCnt); PrintAndLog("Manchester Decoded - # errors:%d - data:",errCnt);
printBitStream(BitStream,bitnum); printBitStream(bits,bitnum);
if (errCnt==0){ if (errCnt==0){
//put back in graphbuffer //put back in graphbuffer
ClearGraph(0); SetGraphBuf(bits, bitnum);
for (i=0; i < bitnum; ++i){
GraphBuffer[i]=BitStream[i]; uint64_t id = Em410xDecode(bits,i);
}
GraphTraceLen=bitnum;
RepaintGraphWindow();
uint64_t id = 0;
id = Em410xDecode(BitStream,i);
printEM410x(id); printEM410x(id);
} }
return 1; return 1;
@ -289,25 +291,27 @@ int CmdBiphaseDecodeRaw(const char *Cmd)
int offset = 0; int offset = 0;
int high = 0, low = 0; int high = 0, low = 0;
sscanf(Cmd, "%i", &offset); sscanf(Cmd, "%i", &offset);
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
uint8_t bits[MAX_GRAPH_TRACE_LEN]={0};
//get graphbuffer & high and low //get graphbuffer & high and low
for (; i<GraphTraceLen; ++i){ for (; i<GraphTraceLen; ++i){
if (GraphBuffer[i] > high) high = GraphBuffer[i]; if (GraphBuffer[i] > high) high = GraphBuffer[i];
else if (GraphBuffer[i] < low) low = GraphBuffer[i]; else if (GraphBuffer[i] < low) low = GraphBuffer[i];
BitStream[i]=GraphBuffer[i]; bits[i] = GraphBuffer[i];
} }
if (high > 1 || low < 0){ if (high > 1 || low < 0){
PrintAndLog("Error: please raw demod the wave first then decode"); PrintAndLog("Error: please raw demod the wave first then decode");
return 0; return 0;
} }
bitnum = i; bitnum = i;
errCnt=BiphaseRawDecode(BitStream,&bitnum, offset); errCnt = BiphaseRawDecode(bits, &bitnum, offset);
if (errCnt >= 20){ if (errCnt >= 20){
PrintAndLog("Too many errors attempting to decode: %d", errCnt); PrintAndLog("Too many errors attempting to decode: %d", errCnt);
return 0; return 0;
} }
PrintAndLog("Biphase Decoded using offset: %d - # errors:%d - data:", offset, errCnt); PrintAndLog("Biphase Decoded using offset: %d - # errors:%d - data:", offset, errCnt);
printBitStream(BitStream,bitnum); printBitStream(bits, bitnum);
PrintAndLog("\nif bitstream does not look right try offset=1"); PrintAndLog("\nif bitstream does not look right try offset=1");
return 1; return 1;
} }
@ -319,42 +323,48 @@ int CmdBiphaseDecodeRaw(const char *Cmd)
//prints binary found and saves in graphbuffer for further commands //prints binary found and saves in graphbuffer for further commands
int Cmdaskrawdemod(const char *Cmd) int Cmdaskrawdemod(const char *Cmd)
{ {
uint32_t i;
int invert = 0; int invert = 0;
int clk = 0; int clk = 0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
sscanf(Cmd, "%i %i", &clk, &invert); sscanf(Cmd, "%i %i", &clk, &invert);
if (invert != 0 && invert != 1 ) { if (invert != 0 && invert != 1 ) {
PrintAndLog("Invalid argument: %s", Cmd); PrintAndLog("Invalid argument: %s", Cmd);
return 0; return 0;
} }
int BitLen = getFromGraphBuf(BitStream);
if ( clock < 0 ) {
PrintAndLog("Wrong clock argument");
return 0;
}
uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
int len = GetFromGraphBuf(bits);
int errCnt = 0; 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) 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"); PrintAndLog("no data found");
return 0; return 0;
} }
if (BitLen<16) return 0;
PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen); if (len < 16) return 0;
//PrintAndLog("Data start pos:%d, lastBit:%d, stop pos:%d, numBits:%d",iii,lastBit,i,bitnum);
PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d",clk,invert,len);
//move BitStream back to GraphBuffer //move BitStream back to GraphBuffer
SetGraphBuf(bits, len);
ClearGraph(0);
for (i=0; i < BitLen; ++i){
GraphBuffer[i]=BitStream[i];
}
GraphTraceLen=BitLen;
RepaintGraphWindow();
//output
if (errCnt > 0){ if (errCnt > 0){
PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt); 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);
PrintAndLog("ASK demoded bitstream:");
// Now output the bitstream to the scrollback by line of 16 bits
printBitStream(bits,len);
return 1; return 1;
} }
@ -393,7 +403,7 @@ int CmdAutoCorr(const char *Cmd)
int CmdBitsamples(const char *Cmd) int CmdBitsamples(const char *Cmd)
{ {
int cnt = 0; int cnt = 0;
uint8_t got[12288]; uint8_t got[10000];
GetFromBigBuf(got,sizeof(got),0); GetFromBigBuf(got,sizeof(got),0);
WaitForResponse(CMD_ACK,NULL); WaitForResponse(CMD_ACK,NULL);
@ -426,16 +436,10 @@ int CmdBitstream(const char *Cmd)
int hithigh, hitlow, first; int hithigh, hitlow, first;
/* Detect high and lows and clock */ /* Detect high and lows and clock */
for (i = 0; i < GraphTraceLen; ++i) DetectHighLowInGraph( &high, &low, FALSE);
{
if (GraphBuffer[i] > high)
high = GraphBuffer[i];
else if (GraphBuffer[i] < low)
low = GraphBuffer[i];
}
/* Get our clock */ /* Get our clock */
clock = GetClock(Cmd, high, 1); clock = GetClock(Cmd, 0);
gtl = ClearGraph(0); gtl = ClearGraph(0);
bit = 0; bit = 0;
@ -467,10 +471,6 @@ int CmdBitstream(const char *Cmd)
bit ^= 1; bit ^= 1;
AppendGraph(0, clock, bit); 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(); RepaintGraphWindow();
@ -499,7 +499,7 @@ int CmdDec(const char *Cmd)
// uses data from graphbuffer // uses data from graphbuffer
int CmdDetectClockRate(const char *Cmd) int CmdDetectClockRate(const char *Cmd)
{ {
GetClock("",0,0); GetClock("",1);
return 0; return 0;
} }
@ -510,38 +510,43 @@ int CmdDetectClockRate(const char *Cmd)
int CmdFSKrawdemod(const char *Cmd) int CmdFSKrawdemod(const char *Cmd)
{ {
//raw fsk demod no manchester decoding no start bit finding just get binary from wave //raw fsk demod no manchester decoding no start bit finding just get binary from wave
//set defaults
int rfLen = 50; int rfLen = 50;
int invert = 0; int invert = 0;
int fchigh = 10; int fchigh = 10;
int fclow = 8; int fclow = 8;
//set options from parameters entered with the command //set options from parameters entered with the command
sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow); sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow);
// A lots of checks if chigh, clow is out-of bounds.
if (strlen(Cmd)>0 && strlen(Cmd)<=2) { 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; rfLen = 50;
} else if(rfLen==0) rfLen=50;
//if invert option only is used
if (rfLen == 1){
invert=1;
} }
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}; PrintAndLog("Args invert: %d - Clock:%d - FC high:%d - FC low: %d",invert,rfLen,fchigh, fclow);
uint32_t BitLen = getFromGraphBuf(BitStream);
int size = fskdemod(BitStream,BitLen,(uint8_t)rfLen,(uint8_t)invert,(uint8_t)fchigh,(uint8_t)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) { if (size > 0) {
PrintAndLog("FSK decoded bitstream:"); PrintAndLog("FSK decoded bitstream:");
ClearGraph(0);
for (i=0;i<size;++i){ SetGraphBuf(bits, size);
GraphBuffer[i]=BitStream[i];
}
GraphTraceLen=size;
RepaintGraphWindow();
// Now output the bitstream to the scrollback by line of 16 bits // Now output the bitstream to the scrollback by line of 16 bits
if(size > (8*32)+2) size = (8*32)+2; //only output a max of 8 blocks of 32 bits most tags will have full bit stream inside that sample size // only output a max of 8 blocks of 32 bits most tags will have full bit stream inside that sample size
printBitStream(BitStream,size); if(size > (8*32)+2)
size = (8*32)+2;
printBitStream(bits,size);
} else { } else {
PrintAndLog("no FSK data found"); PrintAndLog("no FSK data found");
} }
@ -556,37 +561,51 @@ int CmdFSKdemodHID(const char *Cmd)
//raw fsk demod no manchester decoding no start bit finding just get binary from wave //raw fsk demod no manchester decoding no start bit finding just get binary from wave
uint32_t hi2=0, hi=0, lo=0; uint32_t hi2=0, hi=0, lo=0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN] = {0x00};
uint32_t BitLen = getFromGraphBuf(BitStream); uint32_t BitLen = GetFromGraphBuf(BitStream);
//get binary from fsk wave //get binary from fsk wave
size_t size = HIDdemodFSK(BitStream,BitLen,&hi2,&hi,&lo); size_t size = HIDdemodFSK(BitStream,BitLen,&hi2,&hi,&lo);
if (size < 0){ if (size < 0){
PrintAndLog("Error demoding fsk"); PrintAndLog("Error demoding fsk");
return 0; return 0;
} }
if (hi2==0 && hi==0 && lo==0) return 0; if (hi2==0 && hi==0 && lo==0) return 0;
if (hi2 != 0){ //extra large HID tags
//extra large HID tags
if (hi2 != 0){
PrintAndLog("TAG ID: %x%08x%08x (%d)", PrintAndLog("TAG ID: %x%08x%08x (%d)",
(unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); (unsigned int) hi2,
setGraphBuf(BitStream,BitLen); (unsigned int) hi,
(unsigned int) lo,
(unsigned int) (lo>>1) & 0xFFFF);
SetGraphBuf(BitStream,BitLen);
return 1; return 1;
} } else {
else { //standard HID tags <38 bits //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; uint8_t fmtLen = 0;
uint32_t fc = 0; uint32_t fc = 0;
uint32_t cardnum = 0; uint32_t cardnum = 0;
if (((hi>>5)&1)==1){//if bit 38 is set then < 37 bit format is used
//if bit 38 is set then < 37 bit format is used
if (((hi>>5) & 1)==1){
uint32_t lo2 = 0; uint32_t lo2 = 0;
lo2=(((hi & 15) << 12) | (lo>>20)); //get bits 21-37 to check for format len bit
//get bits 21-37 to check for format len bit
lo2 = (((hi & 15) << 12) | (lo>>20));
uint8_t idx3 = 1; uint8_t idx3 = 1;
while(lo2>1){ //find last bit set to 1 (format len bit)
//find last bit set to 1 (format len bit)
while( lo2 > 1){
lo2=lo2>>1; lo2=lo2>>1;
idx3++; idx3++;
} }
fmtLen = idx3 + 19; fmtLen = idx3 + 19;
fc = 0; fc = 0;
cardnum = 0; cardnum = 0;
if(fmtLen==26){ if(fmtLen==26){
cardnum = (lo>>1)&0xFFFF; cardnum = (lo>>1)&0xFFFF;
fc = (lo>>17)&0xFF; fc = (lo>>17)&0xFF;
@ -603,20 +622,25 @@ int CmdFSKdemodHID(const char *Cmd)
cardnum = (lo>>1)&0xFFFFF; cardnum = (lo>>1)&0xFFFFF;
fc = ((hi&1)<<11)|(lo>>21); fc = ((hi&1)<<11)|(lo>>21);
} }
} } else {
else { //if bit 38 is not set then 37 bit format is used //if bit 38 is not set then 37 bit format is used
fmtLen= 37; fmtLen= 37;
fc =0; fc =0;
cardnum=0; cardnum=0;
if (fmtLen==37){ if (fmtLen==37){
cardnum = (lo>>1) & 0x7FFFF; cardnum = (lo>>1) & 0x7FFFF;
fc = ((hi&0xF) << 12) | (lo >> 20); fc = ((hi&0xF) << 12) | (lo >> 20);
} }
} }
PrintAndLog("TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d", 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) hi,
(unsigned int) fmtLen, (unsigned int) fc, (unsigned int) cardnum); (unsigned int) lo,
setGraphBuf(BitStream,BitLen); (unsigned int) (lo>>1) & 0xFFFF,
(unsigned int) fmtLen,
(unsigned int) fc,
(unsigned int) cardnum);
SetGraphBuf(BitStream,BitLen);
return 1; return 1;
} }
return 0; return 0;
@ -627,24 +651,38 @@ int CmdFSKdemodHID(const char *Cmd)
//print ioprox ID and some format details //print ioprox ID and some format details
int CmdFSKdemodIO(const char *Cmd) int CmdFSKdemodIO(const char *Cmd)
{ {
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 //raw fsk demod no manchester decoding no start bit finding just get binary from wave
//set defaults //set defaults
int idx = 0; int idx = 0;
//something in graphbuffer uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
if (GraphTraceLen < 65) return 0; uint32_t bitlen = GetFromGraphBuf(bits);
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
uint32_t BitLen = getFromGraphBuf(BitStream);
//get binary from fsk wave //get binary from fsk wave
idx = IOdemodFSK(BitStream,BitLen); idx = IOdemodFSK(bits, bitlen);
if (idx<0){
//PrintAndLog("Error demoding fsk");
return 0;
}
if (idx == 0) { if (idx == 0) {
//PrintAndLog("IO Prox Data not found - FSK Data:");
//if (BitLen > 92) printBitStream(BitStream,92);
return 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 //Index map
//0 10 20 30 40 50 60 //0 10 20 30 40 50 60
//| | | | | | | //| | | | | | |
@ -654,23 +692,23 @@ int CmdFSKdemodIO(const char *Cmd)
// //
//XSF(version)facility:codeone+codetwo (raw) //XSF(version)facility:codeone+codetwo (raw)
//Handle the data //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); 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]);
uint32_t code2 = bytebits_to_byte(BitStream+idx+32,32); 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]);
uint8_t version = bytebits_to_byte(BitStream+idx+27,8); //14,4 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]);
uint8_t facilitycode = bytebits_to_byte(BitStream+idx+18,8) ; 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]);
uint16_t number = (bytebits_to_byte(BitStream+idx+36,8)<<8)|(bytebits_to_byte(BitStream+idx+45,8)); //36,9 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); PrintAndLog("XSF(%02d)%02x:%05d (%08x%08x)", version, facilitycode, number, code, code2);
setGraphBuf(BitStream,BitLen); SetGraphBuf(bits, bitlen);
return 1; return 1;
} }
@ -760,8 +798,7 @@ int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating
PrintAndLog("actual data bits start at sample %d", maxPos); PrintAndLog("actual data bits start at sample %d", maxPos);
PrintAndLog("length %d/%d", highLen, lowLen); PrintAndLog("length %d/%d", highLen, lowLen);
uint8_t bits[46]; uint8_t bits[46] = {0x00};
bits[sizeof(bits)-1] = '\0';
// find bit pairs and manchester decode them // find bit pairs and manchester decode them
for (i = 0; i < arraylen(bits) - 1; ++i) { for (i = 0; i < arraylen(bits) - 1; ++i) {
@ -868,16 +905,17 @@ int CmdHpf(const char *Cmd)
int CmdSamples(const char *Cmd) int CmdSamples(const char *Cmd)
{ {
uint8_t got[36440] = {0x00}; uint8_t got[40000] = {0x00};
int n = strtol(Cmd, NULL, 0); int n = strtol(Cmd, NULL, 0);
if (n == 0) if (n == 0)
n = 20000; n = 20000;
if (n > sizeof(got)) if (n > sizeof(got))
n = sizeof(got); n = sizeof(got);
PrintAndLog("Reading %d samples from device memory\n", n); PrintAndLog("Reading %d samples from device memory\n", n);
GetFromBigBuf(got,n,3560); GetFromBigBuf(got,n,0);
WaitForResponse(CMD_ACK,NULL); WaitForResponse(CMD_ACK,NULL);
for (int j = 0; j < n; ++j) { for (int j = 0; j < n; ++j) {
GraphBuffer[j] = ((int)got[j]) - 128; GraphBuffer[j] = ((int)got[j]) - 128;
@ -1034,16 +1072,10 @@ int CmdManchesterDemod(const char *Cmd)
uint8_t BitStream[MAX_GRAPH_TRACE_LEN] = {0x00}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN] = {0x00};
/* Detect high and lows */ /* Detect high and lows */
for (i = 0; i < GraphTraceLen; i++) DetectHighLowInGraph( &high, &low, TRUE);
{
if (GraphBuffer[i] > high)
high = GraphBuffer[i];
else if (GraphBuffer[i] < low)
low = GraphBuffer[i];
}
/* Get our clock */ /* Get our clock */
clock = GetClock(Cmd, high, 1); clock = GetClock(Cmd, 0);
int tolerance = clock/4; int tolerance = clock/4;
/* Detect first transition */ /* Detect first transition */
@ -1201,9 +1233,7 @@ int CmdManchesterMod(const char *Cmd)
{ {
int i, j; int i, j;
int bit, lastbit, wave; int bit, lastbit, wave;
int clock = GetClock(Cmd, 0, 1); int clock = GetClock(Cmd, 0);
int clock1 = GetT55x7Clock( GraphBuffer, GraphTraceLen, 0 );
PrintAndLog("MAN MOD CLOCKS: %d ice %d", clock,clock1);
int half = (int)(clock/2); int half = (int)(clock/2);
@ -1373,8 +1403,8 @@ static command_t CommandTable[] =
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, 1, "This help"},
{"amp", CmdAmp, 1, "Amplify peaks"}, {"amp", CmdAmp, 1, "Amplify peaks"},
{"askdemod", Cmdaskdemod, 1, "<0 or 1> -- Attempt to demodulate simple ASK tags"}, {"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])"}, {"askmandemod", Cmdaskmandemod, 1, "[clock] [invert <0|1>] -- Attempt to demodulate ASK/Manchester tags and output binary"},
{"askrawdemod", Cmdaskrawdemod, 1, "[clock] [invert<0 or 1>] -- Attempt to demodulate ASK tags and output binary (args optional[clock will try Auto-detect])"}, {"askrawdemod", Cmdaskrawdemod, 1, "[clock] [invert <0|1>] -- Attempt to demodulate ASK tags and output binary"},
{"autocorr", CmdAutoCorr, 1, "<window length> -- Autocorrelation over window"}, {"autocorr", CmdAutoCorr, 1, "<window length> -- Autocorrelation over window"},
{"biphaserawdecode",CmdBiphaseDecodeRaw,1,"[offset] Biphase decode binary stream already in graph buffer (offset = bit to start decode from)"}, {"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"}, {"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"},
@ -1383,6 +1413,7 @@ static command_t CommandTable[] =
{"dec", CmdDec, 1, "Decimate samples"}, {"dec", CmdDec, 1, "Decimate samples"},
{"detectaskclock",CmdDetectClockRate, 1, "Detect ASK clock rate"}, {"detectaskclock",CmdDetectClockRate, 1, "Detect ASK clock rate"},
{"dirthreshold", CmdDirectionalThreshold, 1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."}, {"dirthreshold", CmdDirectionalThreshold, 1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
{"em4xdecode", CmdEm410xDecode, 1, "decode em4x from graph buffer"},
{"fskdemod", CmdFSKdemod, 1, "Demodulate graph window as a HID FSK"}, {"fskdemod", CmdFSKdemod, 1, "Demodulate graph window as a HID FSK"},
{"fskhiddemod", CmdFSKdemodHID, 1, "Demodulate graph window as a HID FSK using raw"}, {"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"}, {"fskiodemod", CmdFSKdemodIO, 1, "Demodulate graph window as an IO Prox FSK using raw"},

16
client/cmdlf.c
View file

@ -375,6 +375,8 @@ int CmdLFRead(const char *Cmd)
// load samples // load samples
CmdSamples(""); CmdSamples("");
// show plot
ShowGraphWindow();
return 0; return 0;
} }
@ -461,12 +463,12 @@ int CmdLFSimManchester(const char *Cmd)
int CmdLFSnoop(const char *Cmd) int CmdLFSnoop(const char *Cmd)
{ {
UsbCommand c = {CMD_LF_SNOOP_RAW_ADC_SAMPLES}; UsbCommand c = {CMD_LF_SNOOP_RAW_ADC_SAMPLES};
// 'h' means higher-low-frequency, 134 kHz // 'h' means higher-low-frequency, 134 kHz
c.arg[0] = 0; c.arg[0] = 0;
c.arg[1] = -1; c.arg[1] = -1;
if (*Cmd == 0) {
// empty if (*Cmd == 'l') {
} else if (*Cmd == 'l') {
sscanf(Cmd, "l %"lli, &c.arg[1]); sscanf(Cmd, "l %"lli, &c.arg[1]);
} else if (*Cmd == 'h') { } else if (*Cmd == 'h') {
c.arg[0] = 1; c.arg[0] = 1;
@ -475,18 +477,20 @@ int CmdLFSnoop(const char *Cmd)
PrintAndLog("use 'snoop' or 'snoop {l,h} [trigger threshold]', or 'snoop <divisor> [trigger threshold]'"); PrintAndLog("use 'snoop' or 'snoop {l,h} [trigger threshold]', or 'snoop <divisor> [trigger threshold]'");
return 0; return 0;
} }
SendCommand(&c); SendCommand(&c);
WaitForResponse(CMD_ACK,NULL); WaitForResponse(CMD_ACK,NULL);
size_t BUFF_SIZE = 8000; size_t BUFF_SIZE = 8000;
uint8_t data[BUFF_SIZE]; uint8_t data[BUFF_SIZE];
GetFromBigBuf(data,BUFF_SIZE,3560); //3560 -- should be offset.. GetFromBigBuf(data,BUFF_SIZE,0); //3560 -- should be offset..
WaitForResponseTimeout(CMD_ACK,NULL, 1500); WaitForResponseTimeout(CMD_ACK,NULL, 1500);
for (int j = 0; j < BUFF_SIZE; j++) { for (int j = 0; j < BUFF_SIZE; j++) {
GraphBuffer[j] = ((int)data[j]); GraphBuffer[j] = ((int)data[j]);
} }
GraphTraceLen = BUFF_SIZE; GraphTraceLen = BUFF_SIZE;
return 0; return 0;
@ -575,8 +579,8 @@ int CmdLFfind(const char *Cmd)
char cmdp = param_getchar(Cmd, 0); char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') { if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') {
PrintAndLog("Usage: lf search [use data from Graphbuffer]"); PrintAndLog("Usage: lf search <0|1>");
PrintAndLog(" [use data from Graphbuffer], if not set, try reading data from tag."); PrintAndLog(" <use data from Graphbuffer>, if not set, try reading data from tag.");
PrintAndLog(""); PrintAndLog("");
PrintAndLog(" sample: lf search"); PrintAndLog(" sample: lf search");
PrintAndLog(" : lf search 1"); PrintAndLog(" : lf search 1");

44
client/cmdlfem4x.c
View file

@ -28,20 +28,16 @@ char *global_em410xId;
static int CmdHelp(const char *Cmd); static int CmdHelp(const char *Cmd);
int CmdEMdemodASK(const char *Cmd) int CmdEMdemodASK(const char *Cmd)
{ {
int findone=0; char cmdp = param_getchar(Cmd, 0);
int findone = (cmdp == '1') ? 1 : 0;
UsbCommand c = { CMD_EM410X_DEMOD }; UsbCommand c = { CMD_EM410X_DEMOD };
if(Cmd[0]=='1') findone=1;
c.arg[0] = findone; c.arg[0] = findone;
SendCommand(&c); SendCommand(&c);
return 0; return 0;
} }
/* Read the ID of an EM410x tag. /* Read the ID of an EM410x tag.
* Format: * Format:
* 1111 1111 1 <-- standard non-repeatable header * 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 i, j, clock, header, rows, bit, hithigh, hitlow, first, bit2idx, high, low;
int parity[4]; int parity[4];
char id[11]; char id[11] = {0x00};
char id2[11]; char id2[11] = {0x00};
int retested = 0; int retested = 0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]; uint8_t BitStream[MAX_GRAPH_TRACE_LEN];
high = low = 0; high = low = 0;
/* Detect high and lows and clock */ // get clock
for (i = 0; i < GraphTraceLen; i++) clock = GetClock(Cmd, 0);
{
if (GraphBuffer[i] > high)
high = GraphBuffer[i];
else if (GraphBuffer[i] < low)
low = GraphBuffer[i];
}
/* get clock */ // Detect high and lows and clock
clock = GetClock(Cmd, high, 0); DetectHighLowInGraph( &high, &low, TRUE);
/* parity for our 4 columns */ PrintAndLog("NUMNUM");
// parity for our 4 columns
parity[0] = parity[1] = parity[2] = parity[3] = 0; parity[0] = parity[1] = parity[2] = parity[3] = 0;
header = rows = 0; header = rows = 0;
/* manchester demodulate */ // manchester demodulate
bit = bit2idx = 0; bit = bit2idx = 0;
for (i = 0; i < (int)(GraphTraceLen / clock); i++) 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 */ /* Find out if we hit both high and low peaks */
for (j = 0; j < clock; j++) for (j = 0; j < clock; j++)
{ {
if (GraphBuffer[(i * clock) + j] == high) if (GraphBuffer[(i * clock) + j] >= high)
hithigh = 1; hithigh = 1;
else if (GraphBuffer[(i * clock) + j] == low) else if (GraphBuffer[(i * clock) + j] <= low)
hitlow = 1; hitlow = 1;
/* it doesn't count if it's the first part of our read /* it doesn't count if it's the first part of our read
@ -190,6 +182,7 @@ retest:
/* if we've already retested after flipping bits, return */ /* if we've already retested after flipping bits, return */
if (retested++){ if (retested++){
PrintAndLog("Failed to decode");
return 0; return 0;
} }
@ -290,7 +283,8 @@ int CmdEM410xSim(const char *Cmd)
*/ */
int CmdEM410xWatch(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 do
{ {
if (ukbhit()) { if (ukbhit()) {
@ -551,7 +545,7 @@ int CmdReadWord(const char *Cmd)
uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00}; 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); WaitForResponseTimeout(CMD_ACK,NULL, 1500);
for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) { 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}; 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); WaitForResponseTimeout(CMD_ACK,NULL, 1500);
for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) { for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {

49
client/cmdlft55xx.c
View file

@ -22,7 +22,7 @@
#include "data.h" #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 = #define LF_BITSSTREAM_LEN 1000 // more then 1000 bits shouldn't happend.. 8block * 4 bytes * 8bits =
static int CmdHelp(const char *Cmd); static int CmdHelp(const char *Cmd);
@ -48,7 +48,7 @@ int CmdReadBlk(const char *Cmd)
uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00}; 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); WaitForResponseTimeout(CMD_ACK,NULL, 1500);
for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) { 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}; 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); WaitForResponseTimeout(CMD_ACK,NULL, 1500);
for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) { 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}; 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); WaitForResponseTimeout(CMD_ACK,NULL, 1500);
for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) { for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {
@ -254,27 +254,26 @@ int CmdInfo(const char *Cmd){
} }
uint8_t bits[LF_BITSSTREAM_LEN] = {0x00}; 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; 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 safer = PackBits(si, 4, bits); si += 4;
uint32_t resv = PackBits(si, 7, bitstream); si += 7; uint32_t resv = PackBits(si, 7, bits); si += 7;
uint32_t dbr = PackBits(si, 3, bitstream); si += 3; uint32_t dbr = PackBits(si, 3, bits); si += 3;
uint32_t extend = PackBits(si, 1, bitstream); si += 1; uint32_t extend = PackBits(si, 1, bits); si += 1;
uint32_t datamodulation = PackBits(si, 5, bitstream); si += 5; uint32_t datamodulation = PackBits(si, 5, bits); si += 5;
uint32_t pskcf = PackBits(si, 2, bitstream); si += 2; uint32_t pskcf = PackBits(si, 2, bits); si += 2;
uint32_t aor = PackBits(si, 1, bitstream); si += 1; uint32_t aor = PackBits(si, 1, bits); si += 1;
uint32_t otp = PackBits(si, 1, bitstream); si += 1; uint32_t otp = PackBits(si, 1, bits); si += 1;
uint32_t maxblk = PackBits(si, 3, bitstream); si += 3; uint32_t maxblk = PackBits(si, 3, bits); si += 3;
uint32_t pwd = PackBits(si, 1, bitstream); si += 1; uint32_t pwd = PackBits(si, 1, bits); si += 1;
uint32_t sst = PackBits(si, 1, bitstream); si += 1; uint32_t sst = PackBits(si, 1, bits); si += 1;
uint32_t fw = PackBits(si, 1, bitstream); si += 1; uint32_t fw = PackBits(si, 1, bits); si += 1;
uint32_t inv = PackBits(si, 1, bitstream); si += 1; uint32_t inv = PackBits(si, 1, bits); si += 1;
uint32_t por = PackBits(si, 1, bitstream); si += 1; uint32_t por = PackBits(si, 1, bits); si += 1;
PrintAndLog(""); PrintAndLog("");
PrintAndLog("-- T55xx Configuration --------------------------------------"); PrintAndLog("-- T55xx Configuration --------------------------------------");
@ -295,7 +294,7 @@ int CmdInfo(const char *Cmd){
PrintAndLog(" POR-Delay : %s", (por) ? "Yes":"No"); PrintAndLog(" POR-Delay : %s", (por) ? "Yes":"No");
PrintAndLog("-------------------------------------------------------------"); PrintAndLog("-------------------------------------------------------------");
PrintAndLog(" Raw Data - Page 0"); 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("-------------------------------------------------------------"); PrintAndLog("-------------------------------------------------------------");
return 0; return 0;
@ -357,8 +356,10 @@ int ManchesterDemod(int blockNum){
uint8_t bits[LF_BITSSTREAM_LEN] = {0x00}; uint8_t bits[LF_BITSSTREAM_LEN] = {0x00};
uint8_t * bitstream = bits; uint8_t * bitstream = bits;
manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN); //manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN);
blockData = PackBits(offset, sizebyte, bitstream); manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bits, LF_BITSSTREAM_LEN);
//blockData = PackBits(offset, sizebyte, bitstream);
blockData = PackBits(offset, sizebyte, bits);
if ( blockNum < 0) if ( blockNum < 0)
PrintAndLog(" Decoded : 0x%08X %s", blockData, sprint_bin(bitstream+offset,sizebyte) ); PrintAndLog(" Decoded : 0x%08X %s", blockData, sprint_bin(bitstream+offset,sizebyte) );

168
client/graph.c
View file

@ -49,106 +49,13 @@ int ClearGraph(int redraw)
return gtl; return gtl;
} }
/* void SetGraphBuf(uint8_t *buff, int size)
* Detect clock rate
*/
//decommissioned - has difficulty detecting rf/32
/*
int DetectClockOld(int peak)
{ {
int i; if ( buff == NULL ) return;
int clock = 0xFFFF;
int lastpeak = 0;
// Detect peak if we don't have one uint16_t i = 0;
if (!peak) if ( size > MAX_GRAPH_TRACE_LEN )
for (i = 0; i < GraphTraceLen; ++i) size = MAX_GRAPH_TRACE_LEN;
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;
}
}
return clock;
}
*/
/*
NOW IN LFDEMOD.C
// by marshmellow
// not perfect especially with lower clocks or VERY good antennas (heavy wave clipping)
// maybe somehow adjust peak trimming value based on samples to fix?
int DetectASKClock(int peak)
{
int i=0;
int low=0;
int clk[]={16,32,40,50,64,100,128,256};
int loopCnt = 256;
if (GraphTraceLen<loopCnt) loopCnt = GraphTraceLen;
if (!peak){
for (i=0;i<loopCnt;++i){
if(GraphBuffer[i]>peak){
peak = GraphBuffer[i];
}
if(GraphBuffer[i]<low){
low = GraphBuffer[i];
}
}
peak=(int)(peak*.75);
low= (int)(low*.75);
}
int ii;
int clkCnt;
int tol = 0;
int bestErr=1000;
int errCnt[]={0,0,0,0,0,0,0,0};
for(clkCnt=0; clkCnt<6;++clkCnt){
if (clk[clkCnt]==32){
tol=1;
}else{
tol=0;
}
bestErr=1000;
for (ii=0; ii<loopCnt; ++ii){
if ((GraphBuffer[ii]>=peak) || (GraphBuffer[ii]<=low)){
errCnt[clkCnt]=0;
for (i=0; i<((int)(GraphTraceLen/clk[clkCnt])-1); ++i){
if (GraphBuffer[ii+(i*clk[clkCnt])]>=peak || GraphBuffer[ii+(i*clk[clkCnt])]<=low){
}else if(GraphBuffer[ii+(i*clk[clkCnt])-tol]>=peak || GraphBuffer[ii+(i*clk[clkCnt])-tol]<=low){
}else if(GraphBuffer[ii+(i*clk[clkCnt])+tol]>=peak || GraphBuffer[ii+(i*clk[clkCnt])+tol]<=low){
}else{ //error no peak detected
errCnt[clkCnt]++;
}
}
if(errCnt[clkCnt]==0) return clk[clkCnt];
if(errCnt[clkCnt]<bestErr) bestErr=errCnt[clkCnt];
}
}
}
int iii=0;
int best=0;
for (iii=0; iii<6;++iii){
if (errCnt[iii]<errCnt[best]){
best = iii;
}
}
// PrintAndLog("DEBUG: clkCnt: %d, ii: %d, i: %d peak: %d, low: %d, errcnt: %d, errCnt64: %d",clkCnt,ii,i,peak,low,errCnt[best],errCnt[4]);
return clk[best];
}
*/
void setGraphBuf(uint8_t *buff,int size)
{
int i=0;
ClearGraph(0); ClearGraph(0);
for (; i < size; ++i){ for (; i < size; ++i){
GraphBuffer[i] = buff[i]; GraphBuffer[i] = buff[i];
@ -157,18 +64,28 @@ void setGraphBuf(uint8_t *buff,int size)
RepaintGraphWindow(); RepaintGraphWindow();
return; 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; if ( buff == NULL ) return -1;
for (i=0;i<GraphTraceLen;++i){ uint32_t i = 0;
if (GraphBuffer[i]>127) GraphBuffer[i]=127; //trim
if (GraphBuffer[i]<-127) GraphBuffer[i]=-127; //trim 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); buff[i] = (uint8_t)(GraphBuffer[i] + 128);
} }
return i; return i;
} }
/* Get or auto-detect clock rate */ /* Get or auto-detect clock rate */
int GetClock(const char *str, int peak, int verbose) int GetClock(const char *str, int verbose)
{ {
int clock; int clock;
@ -177,23 +94,24 @@ int GetClock(const char *str, int peak, int verbose)
clock = 0; clock = 0;
/* Auto-detect clock */ /* Auto-detect clock */
if (!clock) if (!clock) {
{
uint8_t grph[MAX_GRAPH_TRACE_LEN]={0}; uint8_t grph[MAX_GRAPH_TRACE_LEN] = {0x00};
int size = getFromGraphBuf(grph); int size = GetFromGraphBuf(grph);
if ( size < 0 ) {
PrintAndLog("Failed to copy from graphbuffer");
return -1;
}
clock = DetectASKClock(grph, size, 0); clock = DetectASKClock(grph, size, 0);
//clock2 = DetectClock2(peak);
/* Only print this message if we're not looping something */ /* Only print this message if we're not looping something */
if (!verbose) if (verbose)
PrintAndLog("Auto-detected clock rate: %d", clock); PrintAndLog("Auto-detected clock rate: %d", clock);
} }
return 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(){ bool HasGraphData(){
if ( GraphTraceLen <= 0) { if ( GraphTraceLen <= 0) {
@ -202,3 +120,25 @@ bool HasGraphData(){
} }
return true; 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);
}
}

8
client/graph.h
View file

@ -13,11 +13,11 @@
void AppendGraph(int redraw, int clock, int bit); void AppendGraph(int redraw, int clock, int bit);
int ClearGraph(int redraw); int ClearGraph(int redraw);
//int DetectClock(int peak); int GetFromGraphBuf(uint8_t *buff);
int getFromGraphBuf(uint8_t *buff); int GetClock(const char *str, int verbose);
int GetClock(const char *str, int peak, int verbose); void SetGraphBuf(uint8_t *buff,int size);
void setGraphBuf(uint8_t *buff,int size);
bool HasGraphData(); bool HasGraphData();
void DetectHighLowInGraph(int *high, int *low, bool addFuzz);
#define MAX_GRAPH_TRACE_LEN (1024*128) #define MAX_GRAPH_TRACE_LEN (1024*128)
extern int GraphBuffer[MAX_GRAPH_TRACE_LEN]; extern int GraphBuffer[MAX_GRAPH_TRACE_LEN];

6
client/loclass/fileutils.c
View file

@ -49,8 +49,14 @@
* @return * @return
*/ */
int fileExists(const char *filename) { int fileExists(const char *filename) {
#ifdef _WIN32
struct _stat fileStat; struct _stat fileStat;
int result = _stat(filename, &fileStat); int result = _stat(filename, &fileStat);
#else
struct stat fileStat;
int result = stat(filename, &fileStat);
#endif
return result == 0; return result == 0;
} }

2
client/proxguiqt.cpp
View file

@ -280,7 +280,7 @@ void ProxWidget::paintEvent(QPaintEvent *event)
ProxWidget::ProxWidget(QWidget *parent) : QWidget(parent), GraphStart(0), GraphPixelsPerPoint(1) ProxWidget::ProxWidget(QWidget *parent) : QWidget(parent), GraphStart(0), GraphPixelsPerPoint(1)
{ {
resize(600, 500); resize(600, 300);
QPalette palette(QColor(0,0,0,0)); QPalette palette(QColor(0,0,0,0));
palette.setColor(QPalette::WindowText, QColor(255,255,255)); palette.setColor(QPalette::WindowText, QColor(255,255,255));

57
client/ui.c
View file

@ -20,13 +20,14 @@
#include "ui.h" #include "ui.h"
#include "cmdmain.h" #include "cmdmain.h"
#include "cmddata.h" #include "cmddata.h"
#include "graph.h"
//#include <liquid/liquid.h> //#include <liquid/liquid.h>
#define M_PI 3.14159265358979323846264338327 #define M_PI 3.14159265358979323846264338327
double CursorScaleFactor; double CursorScaleFactor;
int PlotGridX, PlotGridY, PlotGridXdefault= 64, PlotGridYdefault= 64; int PlotGridX, PlotGridY, PlotGridXdefault= 64, PlotGridYdefault= 64;
int offline; int offline;
int flushAfterWrite = 0; //buzzy int flushAfterWrite = 0;
extern pthread_mutex_t print_lock; extern pthread_mutex_t print_lock;
static char *logfilename = "proxmark3.log"; static char *logfilename = "proxmark3.log";
@ -82,8 +83,7 @@ void PrintAndLog(char *fmt, ...)
} }
va_end(argptr2); va_end(argptr2);
if (flushAfterWrite == 1) //buzzy if (flushAfterWrite == 1) {
{
fflush(NULL); fflush(NULL);
} }
//release lock //release lock
@ -98,29 +98,25 @@ void SetLogFilename(char *fn)
int manchester_decode( int * data, const size_t len, uint8_t * dataout, size_t dataoutlen){ int manchester_decode( int * data, const size_t len, uint8_t * dataout, size_t dataoutlen){
int bitlength = 0; int bitlength = 0;
int i, clock, high, low, startindex; int clock, high, low, startindex;
low = startindex = 0; low = startindex = 0;
high = 1; high = 1;
uint8_t * bitStream = (uint8_t* ) malloc(sizeof(uint8_t) * dataoutlen); uint8_t * bitStream = (uint8_t* ) malloc(sizeof(uint8_t) * dataoutlen);
memset(bitStream, 0x00, dataoutlen); memset(bitStream, 0x00, dataoutlen);
/* Detect high and lows */ /* Detect high and lows */
for (i = 0; i < len; i++) { DetectHighLowInGraph(&high, &low, TRUE);
if (data[i] > high)
high = data[i];
else if (data[i] < low)
low = data[i];
}
/* get clock */ /* get clock */
clock = GetT55x7Clock( data, len, high ); clock = GetClock("", 0);
startindex = DetectFirstTransition(data, len, high); startindex = DetectFirstTransition(data, len, high);
//PrintAndLog(" Clock : %d", clock);
if (high != 1) if (high != 1)
// decode "raw"
bitlength = ManchesterConvertFrom255(data, len, bitStream, dataoutlen, high, low, clock, startindex); bitlength = ManchesterConvertFrom255(data, len, bitStream, dataoutlen, high, low, clock, startindex);
else else
// decode manchester
bitlength = ManchesterConvertFrom1(data, len, bitStream, dataoutlen, clock, startindex); bitlength = ManchesterConvertFrom1(data, len, bitStream, dataoutlen, clock, startindex);
memcpy(dataout, bitStream, bitlength); memcpy(dataout, bitStream, bitlength);
@ -128,41 +124,6 @@ int manchester_decode( int * data, const size_t len, uint8_t * dataout, size_t
return bitlength; 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 DetectFirstTransition(const int * data, const size_t len, int threshold){
int i = 0; int i = 0;

403
common/lfdemod.c
View file

@ -8,6 +8,7 @@
// Low frequency commands // Low frequency commands
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "lfdemod.h" #include "lfdemod.h"
@ -20,11 +21,12 @@ uint64_t Em410xDecode(uint8_t *BitStream,uint32_t BitLen)
// otherwise could be a void with no arguments // otherwise could be a void with no arguments
//set defaults //set defaults
int high = 0, low = 128; int high = 0, low = 128;
uint64_t lo=0; //hi=0, uint64_t lo = 0;
uint32_t i = 0; uint32_t i = 0;
uint32_t initLoopMax = 65; uint32_t initLoopMax = 65;
if (initLoopMax>BitLen) initLoopMax=BitLen;
if (initLoopMax > BitLen)
initLoopMax = BitLen;
for (; i < initLoopMax; ++i) //65 samples should be plenty to find high and low values for (; i < initLoopMax; ++i) //65 samples should be plenty to find high and low values
{ {
@ -33,35 +35,36 @@ uint64_t Em410xDecode(uint8_t *BitStream,uint32_t BitLen)
else if (BitStream[i] < low) else if (BitStream[i] < low)
low = BitStream[i]; low = BitStream[i];
} }
if (((high !=1)||(low !=0))){ //allow only 1s and 0s if (((high !=1)||(low !=0))){ //allow only 1s and 0s
// PrintAndLog("no data found");
return 0; return 0;
} }
uint8_t parityTest = 0; uint8_t parityTest = 0;
// 111111111 bit pattern represent start of frame // 111111111 bit pattern represent start of frame
uint8_t frame_marker_mask[] = {1,1,1,1,1,1,1,1,1}; uint8_t frame_marker_mask[] = {1,1,1,1,1,1,1,1,1};
uint32_t idx = 0; uint32_t idx = 0;
uint32_t ii=0; uint32_t j = 0;
uint8_t resetCnt = 0; uint8_t resetCnt = 0;
while( (idx + 64) < BitLen) { while( (idx + 64) < BitLen) {
restart: restart:
// search for a start of frame marker // search for a start of frame marker
if ( memcmp(BitStream+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0) if ( memcmp(BitStream+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0) {
{ // frame marker found // frame marker found
idx += 9;//sizeof(frame_marker_mask); idx += 9;//sizeof(frame_marker_mask);
for (i=0; i<10;i++){ for ( i = 0; i < 10; ++i){
for(ii=0; ii<5; ++ii){ for( j = 0; j < 5; ++j){
parityTest += BitStream[(i*5)+ii+idx]; parityTest += BitStream[(i*5) + j + idx];
} }
if (parityTest == ( (parityTest >> 1) << 1)){ if (parityTest == ( (parityTest >> 1) << 1)){
parityTest = 0; parityTest = 0;
for (ii=0; ii<4;++ii){ for (j = 0; j < 4; ++j){
//hi = (hi<<1)|(lo>>31); lo = ( lo << 1LL)|( BitStream[( i * 5 ) + j + idx]);
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 {
}else {//parity failed //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; parityTest = 0;
idx -= 8; idx -= 8;
if (resetCnt > 5) return 0; if (resetCnt > 5) return 0;
@ -93,43 +96,52 @@ int askmandemod(uint8_t * BinStream,uint32_t *BitLen,int *clk, int *invert)
if (*invert != 1) *invert = 0; if (*invert != 1) *invert = 0;
uint32_t initLoopMax = 200; uint32_t initLoopMax = 200;
if (initLoopMax>*BitLen) initLoopMax=*BitLen; if (initLoopMax > *BitLen)
initLoopMax = *BitLen;
// Detect high and lows // Detect high and lows
for (i = 0; i < initLoopMax; ++i) //200 samples should be enough to find high and low values // 200 samples should be enough to find high and low values
{ for (i = 0; i < initLoopMax; ++i) {
if (BinStream[i] > high) if (BinStream[i] > high)
high = BinStream[i]; high = BinStream[i];
else if (BinStream[i] < low) 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;
//PrintAndLog("DEBUG - valid high: %d - valid low: %d",high,low); //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 int lastBit = 0; // set first clock check
uint32_t bitnum = 0; // output counter 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 // clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave
int iii = 0; //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; uint32_t gLen = *BitLen;
if (gLen > 3000) gLen = 3000; if (gLen > 3000) gLen = 3000;
uint8_t errCnt = 0; uint8_t errCnt = 0;
uint32_t bestStart = *BitLen; uint32_t bestStart = *BitLen;
uint32_t bestErrCnt = (*BitLen/1000); uint32_t bestErrCnt = (*BitLen/1000);
uint32_t maxErr = (*BitLen/1000); uint32_t maxErr = bestErrCnt;
//loop to find first wave that works //loop to find first wave that works
for (iii=0; iii < gLen; ++iii){ for (j=0; j < gLen; ++j){
if ((BinStream[iii]>=high)||(BinStream[iii]<=low)){
lastBit=iii-*clk; if ((BinStream[j] >= high)||(BinStream[j] <= low)){
lastBit = j - *clk;
errCnt = 0; errCnt = 0;
//loop through to see if this start location works //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))){ if ((BinStream[i] >= high) && ((i-lastBit)>(*clk-tol))){
lastBit += *clk; lastBit += *clk;
} else if ((BinStream[i] <= low) && ((i-lastBit)>(*clk-tol))){ } else if ((BinStream[i] <= low) && ((i-lastBit)>(*clk-tol))){
@ -142,32 +154,32 @@ int askmandemod(uint8_t * BinStream,uint32_t *BitLen,int *clk, int *invert)
errCnt++; errCnt++;
lastBit += *clk;//skip over until hit too many errors lastBit += *clk;//skip over until hit too many errors
if (errCnt>(maxErr)) break; //allow 1 error for every 1000 samples else start over 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 //we got more than 64 good bits and not all errors
if ((((i-iii)/ *clk) > (64+errCnt)) && (errCnt<maxErr)) { if ((((i-j)/ *clk) > (64 + errCnt)) && (errCnt < maxErr)) {
//possible good read //possible good read
if (errCnt == 0){ if (errCnt == 0){
bestStart=iii; bestStart = j;
bestErrCnt = errCnt; bestErrCnt = errCnt;
break; //great read - finish break; //great read - finish
} }
if (errCnt < bestErrCnt){ //set this as new best run if (errCnt < bestErrCnt){ //set this as new best run
bestErrCnt = errCnt; bestErrCnt = errCnt;
bestStart = iii; bestStart = j;
} }
} }
} }
} }
if (bestErrCnt < maxErr){ if (bestErrCnt < maxErr){
//best run is good enough set to best run and set overwrite BinStream //best run is good enough set to best run and set overwrite BinStream
iii=bestStart; j = bestStart;
lastBit = bestStart - *clk; lastBit = bestStart - *clk;
bitnum = 0; bitnum = 0;
for (i = iii; i < *BitLen; ++i) { for (i = j; i < *BitLen; ++i) {
if ((BinStream[i] >= high) && ((i-lastBit)>(*clk-tol))){ if ((BinStream[i] >= high) && ((i-lastBit)>(*clk-tol))){
lastBit += *clk; lastBit += *clk;
BinStream[bitnum] = *invert; BinStream[bitnum] = *invert;
@ -181,12 +193,10 @@ int askmandemod(uint8_t * BinStream,uint32_t *BitLen,int *clk, int *invert)
//mid value found or no bar supposed to be here //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!! //should have hit a high or low based on clock!!
if (bitnum > 0){ if (bitnum > 0){
BinStream[bitnum] = 77; BinStream[bitnum] = 77;
bitnum++; bitnum++;
} }
lastBit += *clk;//skip over error lastBit += *clk;//skip over error
} }
} }
@ -195,7 +205,7 @@ int askmandemod(uint8_t * BinStream,uint32_t *BitLen,int *clk, int *invert)
*BitLen = bitnum; *BitLen = bitnum;
} else { } else {
*invert = bestStart; *invert = bestStart;
*clk=iii; *clk = j;
return -1; return -1;
} }
return bestErrCnt; return bestErrCnt;
@ -204,19 +214,20 @@ int askmandemod(uint8_t * BinStream,uint32_t *BitLen,int *clk, int *invert)
//by marshmellow //by marshmellow
//take 10 and 01 and manchester decode //take 10 and 01 and manchester decode
//run through 2 times and take least errCnt //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 bitnum = 0;
int errCnt = 0; int errCnt = 0;
int i=1;
int bestErr = 1000; int bestErr = 1000;
int bestRun = 0; int bestRun = 0;
int ii=1; int i = 1;
for (ii=1;ii<3;++ii){ int j = 1;
for (; j < 3; ++j){
i = 1; i = 1;
for (i=i+ii;i<*bitLen-2;i+=2){ for ( i = i + j; i < *bitlen-2; i += 2){
if(BitStream[i]==1 && (BitStream[i+1]==0)){ if ( bits[i]==1 && (bits[i+1]==0)){
} else if((BitStream[i]==0)&& BitStream[i+1]==1){ } else if ((bits[i]==0)&& bits[i+1]==1){
} else { } else {
errCnt++; errCnt++;
} }
@ -224,26 +235,25 @@ int manrawdecode(uint8_t * BitStream, int *bitLen)
} }
if (bestErr > errCnt){ if (bestErr > errCnt){
bestErr = errCnt; bestErr = errCnt;
bestRun=ii; bestRun = j;
} }
errCnt = 0; errCnt = 0;
} }
errCnt = bestErr; errCnt = bestErr;
if (errCnt < 20){ if (errCnt < 20){
ii=bestRun; j = bestRun;
i = 1; i = 1;
for (i=i+ii;i<*bitLen-2;i+=2){ for ( i = i+j; i < *bitlen-2; i += 2){
if(BitStream[i]==1 && (BitStream[i+1]==0)){ if ( bits[i] == 1 && bits[i + 1] == 0 ){
BitStream[bitnum++]=0; bits[bitnum++] = 0;
} else if((BitStream[i]==0)&& BitStream[i+1]==1){ } else if ( bits[i] == 0 && bits[i + 1] == 1 ){
BitStream[bitnum++]=1; bits[bitnum++] = 1;
} else { } else {
BitStream[bitnum++]=77; bits[bitnum++] = 77;
//errCnt++;
} }
if ( bitnum > 300 ) break; if ( bitnum > 300 ) break;
} }
*bitLen=bitnum; *bitlen = bitnum;
} }
return errCnt; return errCnt;
} }
@ -251,24 +261,26 @@ int manrawdecode(uint8_t * BitStream, int *bitLen)
//by marshmellow //by marshmellow
//take 01 or 10 = 0 and 11 or 00 = 1 //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; uint8_t bitnum = 0;
uint32_t errCnt = 0; uint32_t errCnt = 0;
uint32_t i = 1; uint32_t i = offset;
i=offset;
for (;i<*bitLen-2;i+=2){ for (; i < *bitlen-2; i += 2 ){
if((BitStream[i]==1 && BitStream[i+1]==0)||(BitStream[i]==0 && BitStream[i+1]==1)){ if ( (bits[i]==1 && bits[i+1]==0)||
BitStream[bitnum++]=1; (bits[i]==0 && bits[i+1]==1)){
} else if((BitStream[i]==0 && BitStream[i+1]==0)||(BitStream[i]==1 && BitStream[i+1]==1)){ bits[bitnum++] = 1;
BitStream[bitnum++]=0; } else if ( (bits[i]==0 && bits[i+1]==0)||
(bits[i]==1 && bits[i+1]==1)){
bits[bitnum++] = 0;
} else { } else {
BitStream[bitnum++]=77; bits[bitnum++] = 77;
errCnt++; errCnt++;
} }
if ( bitnum > 250) break; if ( bitnum > 250) break;
} }
*bitLen=bitnum; *bitlen = bitnum;
return errCnt; return errCnt;
} }
@ -279,17 +291,19 @@ int BiphaseRawDecode(uint8_t * BitStream, int *bitLen, int offset)
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; uint32_t i;
// int invert=0; //invert default uint32_t initLoopMax = 200;
int high = 0, low = 128; int high = 0, low = 128;
uint8_t BitStream[502] = {0x00};
*clk = DetectASKClock(BinStream, *bitLen, *clk); //clock default *clk = DetectASKClock(BinStream, *bitLen, *clk); //clock default
uint8_t BitStream[502] = {0};
if (*clk < 8) *clk = 64; if (*clk < 8) *clk = 64;
if (*clk < 32) *clk = 32; if (*clk < 32) *clk = 32;
if (*invert != 1) *invert = 0; if (*invert != 1) *invert = 0;
uint32_t initLoopMax = 200; if (initLoopMax > *bitLen)
if (initLoopMax>*bitLen) initLoopMax=*bitLen; initLoopMax = *bitLen;
// Detect high and lows // Detect high and lows
for (i = 0; i < initLoopMax; ++i) //200 samples should be plenty to find high and low values for (i = 0; i < initLoopMax; ++i) //200 samples should be plenty to find high and low values
{ {
@ -298,31 +312,39 @@ int askrawdemod(uint8_t *BinStream, int *bitLen,int *clk, int *invert)
else if (BinStream[i] < low) else if (BinStream[i] < low)
low = BinStream[i]; low = BinStream[i];
} }
if ((high < 158)){ //throw away static
//throw away static
if ((high < 158)){
return -2; return -2;
} }
//25% fuzz in case highs and lows aren't clipped [marshmellow] //25% fuzz in case highs and lows aren't clipped [marshmellow]
high=(int)((high-128)*.75)+128; high = (int)(high * .75);
low= (int)((low-128)*.75)+128; low = (int)(low+128 * .25);
int lastBit = 0; //set first clock check int lastBit = 0; //set first clock check
uint32_t bitnum = 0; //output counter 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 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 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;
uint32_t gLen = *bitLen; uint32_t gLen = *bitLen;
if (gLen > 500) gLen = 500; if (gLen > 500) gLen = 500;
uint32_t j = 0;
uint8_t errCnt = 0; uint8_t errCnt = 0;
uint32_t bestStart = *bitLen; uint32_t bestStart = *bitLen;
uint32_t bestErrCnt = (*bitLen / 1000); uint32_t bestErrCnt = (*bitLen / 1000);
uint32_t errCntLimit = bestErrCnt;
uint8_t midBit = 0; uint8_t midBit = 0;
//loop to find first wave that works //loop to find first wave that works
for (iii=0; iii < gLen; ++iii){ for (j = 0; j < gLen; ++j){
if ((BinStream[iii]>=high)||(BinStream[iii]<=low)){
lastBit=iii-*clk; if ((BinStream[j] >= high)||(BinStream[j] <= low)){
lastBit = j - *clk;
//loop through to see if this start location works //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))){ if ((BinStream[i] >= high) && ((i-lastBit)>(*clk-tol))){
lastBit += *clk; lastBit += *clk;
BitStream[bitnum] = *invert; BitStream[bitnum] = *invert;
@ -362,7 +384,7 @@ int askrawdemod(uint8_t *BinStream, int *bitLen,int *clk, int *invert)
errCnt++; errCnt++;
lastBit += *clk;//skip over until hit too many errors lastBit += *clk;//skip over until hit too many errors
if (errCnt>((*bitLen/1000))){ //allow 1 error for every 1000 samples else start over if (errCnt > errCntLimit){ //allow 1 error for every 1000 samples else start over
errCnt = 0; errCnt = 0;
bitnum = 0;//start over bitnum = 0;//start over
break; break;
@ -372,19 +394,26 @@ int askrawdemod(uint8_t *BinStream, int *bitLen,int *clk, int *invert)
if (bitnum > 500) break; if (bitnum > 500) break;
} }
//we got more than 64 good bits and not all errors //we got more than 64 good bits and not all errors
if ((bitnum > (64+errCnt)) && (errCnt<(*bitLen/1000))) {
//possible good read //possible good read
if (errCnt==0) break; //great read - finish if ((bitnum > (64 + errCnt)) && (errCnt < errCntLimit)) {
if (bestStart == iii) break; //if current run == bestErrCnt run (after exhausted testing) then finish
if (errCnt<bestErrCnt){ //set this as new best run //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; bestErrCnt = errCnt;
bestStart = iii; 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 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){
@ -404,36 +433,42 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow
uint32_t last_transition = 0; uint32_t last_transition = 0;
uint32_t idx = 1; uint32_t idx = 1;
uint32_t maxVal = 0; uint32_t maxVal = 0;
if (fchigh == 0) fchigh = 10; if (fchigh == 0) fchigh = 10;
if (fclow == 0) fclow = 8; if (fclow == 0) fclow = 8;
// we do care about the actual theshold value as sometimes near the center of the // 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 // 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 // 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] // antenna is weak a setting too high might not see anything. [marshmellow]
if (size<100) return 0; if ( size < 100)
return 0;
// Find high from first 100 samples
for ( idx = 1; idx < 100; idx++ ){ for ( idx = 1; idx < 100; idx++ ){
if(maxVal<dest[idx]) maxVal = dest[idx]; if ( maxVal < dest[idx])
maxVal = dest[idx];
} }
// set close to the top of the wave threshold with 25% margin for error // set close to the top of the wave threshold with 25% margin for error
// less likely to get a false transition up there. // less likely to get a false transition up there.
// (but have to be careful not to go too high and miss some short waves) // (but have to be careful not to go too high and miss some short waves)
uint8_t threshold_value = (uint8_t)(((maxVal-128)*.75)+128); uint8_t threshold_value = (uint8_t)(maxVal * .75);
// sync to first lo-hi transition, and threshold // sync to first lo-hi transition, and threshold
// Need to threshold first sample // Need to threshold first sample
if(dest[0] < threshold_value) dest[0] = 0; dest[0] = (dest[0] < threshold_value) ? 0 : 1;
else dest[0] = 1;
size_t numBits = 0; size_t numBits = 0;
// count cycles between consecutive lo-hi transitions, there should be either 8 (fc/8) // count cycles between consecutive lo-hi transitions, there should be either 8 (fc/8)
// or 10 (fc/10) cycles but in practice due to noise etc we may end up with with anywhere // or 10 (fc/10) cycles but in practice due to noise etc we may end up with with anywhere
// between 7 to 11 cycles so fuzz it by treat anything <9 as 8 and anything else as 10 // between 7 to 11 cycles so fuzz it by treat anything <9 as 8 and anything else as 10
for(idx = 1; idx < size; idx++) { for(idx = 1; idx < size; idx++) {
// threshold current value
if (dest[idx] < threshold_value) dest[idx] = 0; // threshold current value
else dest[idx] = 1; dest[idx] = (dest[idx] < threshold_value) ? 0 : 1;
// Check for 0->1 transition // Check for 0->1 transition
if (dest[idx-1] < dest[idx]) { // 0 -> 1 transition if (dest[idx-1] < dest[idx]) { // 0 -> 1 transition
@ -448,7 +483,8 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow
numBits++; 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) uint32_t myround2(float f)
@ -458,12 +494,12 @@ uint32_t myround2(float f)
} }
//translate 11111100000 to 10 //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]; uint8_t lastval = dest[0];
uint32_t idx = 0; uint32_t idx = 0;
size_t numBits=0;
uint32_t n = 1; uint32_t n = 1;
size_t numBits = 0;
for( idx = 1; idx < size; idx++) { for( idx = 1; idx < size; idx++) {
@ -474,10 +510,8 @@ size_t aggregate_bits(uint8_t *dest,size_t size, uint8_t rfLen, uint8_t maxCons
//if lastval was 1, we have a 1->0 crossing //if lastval was 1, we have a 1->0 crossing
if ( dest[idx-1] == 1 ) { if ( dest[idx-1] == 1 ) {
n = myround2( (float)( n + 1 ) / ((float)(rfLen)/(float)fclow)); n = myround2( (float)( n + 1 ) / ((float)(rfLen)/(float)fclow));
//n=(n+1) / h2l_crossing_value;
} else { // 0->1 crossing } else { // 0->1 crossing
n = myround2( (float)( n + 1 ) / ((float)(rfLen-2)/(float)fchigh)); //-2 for fudge factor n = myround2( (float)( n + 1 ) / ((float)(rfLen-2)/(float)fchigh)); //-2 for fudge factor
//n=(n+1) / l2h_crossing_value;
} }
if (n == 0) n = 1; if (n == 0) n = 1;
@ -495,34 +529,41 @@ size_t aggregate_bits(uint8_t *dest,size_t size, uint8_t rfLen, uint8_t maxCons
}//end for }//end for
return numBits; return numBits;
} }
//by marshmellow (from holiman's base) //by marshmellow (from holiman's base)
// full fsk demod from GraphBuffer wave to decoded 1s and 0s (no mandemod) // 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) int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t fchigh, uint8_t fclow)
{ {
// FSK demodulator // FSK demodulator
size = fsk_wave_demod(dest, size, fchigh, fclow); size = fsk_wave_demod(dest, size, fchigh, fclow);
if ( size > 0 )
size = aggregate_bits(dest, size, rfLen, 192, invert, fchigh, fclow); size = aggregate_bits(dest, size, rfLen, 192, invert, fchigh, fclow);
else
return -1;
return size; return size;
} }
// loop to get raw HID waveform then FSK demodulate the TAG ID from it // 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) int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_t *lo)
{ {
size_t idx = 0;
int numshifts = 0;
size_t idx=0; //, found=0; //size=0,
// FSK demodulator // 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 // 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 // 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}; 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 //one scan
while( idx + sizeof(frame_marker_mask) < size) { while( idx + mask_len < size) {
// search for a start of frame marker // search for a start of frame marker
if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0) if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
{ // frame marker found { // frame marker found
idx+=sizeof(frame_marker_mask); idx += mask_len;
while(dest[idx] != dest[idx+1] && idx < size-2) while(dest[idx] != dest[idx+1] && idx < size-2)
{ {
// Keep going until next frame marker (or error) // Keep going until next frame marker (or error)
@ -538,7 +579,7 @@ int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_
idx += 2; idx += 2;
} }
// Hopefully, we read a tag and hit upon the next frame marker // 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) if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
{ {
@ -558,8 +599,10 @@ int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_
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; uint32_t num = 0;
for(int i = 0 ; i < numbits ; i++) { for(int i = 0 ; i < numbits ; ++i) {
num = (num << 1) | (*src); num = (num << 1) | (*src);
src++; src++;
} }
@ -568,20 +611,27 @@ uint32_t bytebits_to_byte(uint8_t* src, int numbits)
int IOdemodFSK(uint8_t *dest, size_t size) int IOdemodFSK(uint8_t *dest, size_t size)
{ {
uint32_t idx=0;
//make sure buffer has data //make sure buffer has data
if (size < 66) return -1; if (size < 100) return -1;
//test samples are not just noise
uint32_t idx = 0;
uint8_t testMax = 0; uint8_t testMax = 0;
for(idx=0;idx<65;idx++){
if (testMax<dest[idx]) testMax=dest[idx]; //test samples are not just noise
for (; idx < 65; ++idx ){
if (testMax < dest[idx])
testMax = dest[idx];
} }
idx=0;
//if not just noise //if not just noise
if (testMax>170){ if (testMax < 170) return -2;
// FSK demodulator // FSK demodulator
size = fskdemod(dest, size, 64, 1, 10, 8); // RF/64 and invert size = fskdemod(dest, size, 64, 1, 10, 8); // RF/64 and invert
if (size < 65) return -1; //did we get a good demod?
//did we get a good demod?
if (size < 65) return -3;
//Index map //Index map
//0 10 20 30 40 50 60 //0 10 20 30 40 50 60
//| | | | | | | //| | | | | | |
@ -591,18 +641,24 @@ int IOdemodFSK(uint8_t *dest, size_t size)
// //
//XSF(version)facility:codeone+codetwo //XSF(version)facility:codeone+codetwo
//Handle the data //Handle the data
uint8_t mask[] = {0,0,0,0,0,0,0,0,0,1}; uint8_t mask[] = {0,0,0,0,0,0,0,0,0,1};
for( idx=0; idx < (size - 65); idx++) {
for( idx = 0; idx < (size - 65); ++idx) {
if ( memcmp(dest + idx, mask, sizeof(mask))==0) { if ( memcmp(dest + idx, mask, sizeof(mask))==0) {
//frame marker found //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){ 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 //confirmed proper separator bits found
//return start position //return start position
return (int) idx; return (int) idx;
} }
} }
} }
}
return 0; return 0;
} }
@ -612,66 +668,85 @@ int IOdemodFSK(uint8_t *dest, size_t size)
int DetectASKClock(uint8_t dest[], size_t size, int clock) int DetectASKClock(uint8_t dest[], size_t size, int clock)
{ {
int i = 0; int i = 0;
int peak=0;
int low=128;
int clk[] = {16,32,40,50,64,100,128,256}; int clk[] = {16,32,40,50,64,100,128,256};
int loopCnt = 256; //don't need to loop through entire array... uint8_t clkLen = sizeof clk / sizeof clk[0];
if (size<loopCnt) loopCnt = size;
//if we already have a valid clock quit //if we already have a valid clock quit
for (;i<8;++i) for (; i < clkLen; ++i)
if (clk[i]==clock) return clock; if (clk[i] == clock)
return clock;
int peak = 0;
int low = 128;
int loopCnt = 256;
if (size < loopCnt)
loopCnt = size;
//get high and low peak //get high and low peak
for ( i = 0; i < loopCnt; ++i ){ for ( i = 0; i < loopCnt; ++i ){
if(dest[i]>peak){ if(dest[i] > peak)
peak = dest[i]; peak = dest[i];
} if(dest[i] < low)
if(dest[i]<low){
low = dest[i]; low = dest[i];
} }
}
peak=(int)((peak-128)*.75)+128; peak = (int)(peak * .75);
low= (int)((low-128)*.75)+128; low = (int)(low+128 * .25);
int ii;
int clkCnt; int ii, cnt, bestErr, tol = 0;
int tol = 0; int errCnt[clkLen];
int bestErr=1000; memset(errCnt, 0x00, clkLen);
int errCnt[]={0,0,0,0,0,0,0,0};
int tmpIndex, tmphigh, tmplow;
//test each valid clock from smallest to greatest to see which lines up //test each valid clock from smallest to greatest to see which lines up
for(clkCnt=0; clkCnt<6;++clkCnt){ for( cnt = 0; cnt < clkLen; ++cnt ){
if (clk[clkCnt]==32){
tol=1; tol = (clk[cnt] == 32) ? 1 : 0;
}else{
tol=0;
}
bestErr = 1000; bestErr = 1000;
tmpIndex = tmphigh = tmplow = 0;
//try lining up the peaks by moving starting point (try first 256) //try lining up the peaks by moving starting point (try first 256)
for (ii=0; ii < loopCnt; ++ii){ for (ii=0; ii < loopCnt; ++ii){
if ((dest[ii]>=peak) || (dest[ii]<=low)){
errCnt[clkCnt]=0; // 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 // now that we have the first one lined up test rest of wave array
for (i=0; i<((int)(size/clk[clkCnt])-1); ++i){ for ( i = 0; i < ((int)(size / clk[cnt]) - 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){ tmpIndex = ii + (i * clk[cnt] );
}else if(dest[ii+(i*clk[clkCnt])+tol]>=peak || dest[ii+(i*clk[clkCnt])+tol]<=low){ tmplow = dest[ tmpIndex - tol];
}else{ //error no peak detected tmphigh = dest[ tmpIndex + tol];
errCnt[clkCnt]++;
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 we found no errors this is correct one - return this clock
if(errCnt[clkCnt]==0) return clk[clkCnt]; if ( errCnt[cnt] == 0 )
//if we found errors see if it is lowest so far and save it as best run return clk[cnt];
if(errCnt[clkCnt]<bestErr) bestErr=errCnt[clkCnt];
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;
} }
int iii=0; return clk[bestIndex];
int best=0;
for (iii=0; iii<6;++iii){
if (errCnt[iii]<errCnt[best]){
best = iii;
}
}
return clk[best];
} }