git.zerfleddert.de Git - proxmark3-svn/blobdiff

index 11ba131b07f5457a2a690b4559ec58c4836f9e6e..062818ef45a62f1dfda102035b8e4fea39f9a545 100644 (file)

--- a/common/lfdemod.c

+++ b/common/lfdemod.c

@@ -19,21 +19,9 @@ uint64_t Em410xDecode(uint8_t *BitStream, size_t size)

//no arguments needed - built this way in case we want this to be a direct call from "data " cmds in the future

// otherwise could be a void with no arguments

//set defaults

//no arguments needed - built this way in case we want this to be a direct call from "data " cmds in the future

// otherwise could be a void with no arguments

//set defaults

- int high=0, low=128;

- uint64_t lo=0; //hi=0,

+ uint64_t lo=0;

uint32_t i = 0;

- uint32_t initLoopMax = 65;

- if (initLoopMax>size) initLoopMax=size;

- for (;i < initLoopMax; ++i) //65 samples should be plenty to find high and low values

- {

- if (BitStream[i] > high)

- high = BitStream[i];

- else if (BitStream[i] < low)

- low = BitStream[i];

- }

- if (((high !=1)||(low !=0))){ //allow only 1s and 0s

+ if (BitStream[10]>1){ //allow only 1s and 0s

// PrintAndLog("no data found");

return 0;

}

// PrintAndLog("no data found");

return 0;

}

@@ -48,15 +36,14 @@ uint64_t Em410xDecode(uint8_t *BitStream, size_t size)

// search for a start of frame marker

if ( memcmp(BitStream+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)

{ // frame marker found

// search for a start of frame marker

if ( memcmp(BitStream+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)

{ // frame marker found

- idx+=9;//sizeof(frame_marker_mask);

+ idx+=9;

for (i=0; i<10;i++){

for(ii=0; ii<5; ++ii){

for (i=0; i<10;i++){

for(ii=0; ii<5; ++ii){

- parityTest += BitStream[(i*5)+ii+idx];

+ parityTest ^= BitStream[(i*5)+ii+idx];

}

- if (parityTest== ((parityTest>>1)<<1)){

+ if (!parityTest){

parityTest=0;

for (ii=0; ii<4;++ii){

parityTest=0;

for (ii=0; ii<4;++ii){

- //hi = (hi<<1)|(lo>>31);

lo=(lo<<1LL)|(BitStream[(i*5)+ii+idx]);

}

//PrintAndLog("DEBUG: EM parity passed parity val: %d, i:%d, ii:%d,idx:%d, Buffer: %d%d%d%d%d,lo: %d",parityTest,i,ii,idx,BitStream[idx+ii+(i*5)-5],BitStream[idx+ii+(i*5)-4],BitStream[idx+ii+(i*5)-3],BitStream[idx+ii+(i*5)-2],BitStream[idx+ii+(i*5)-1],lo);

lo=(lo<<1LL)|(BitStream[(i*5)+ii+idx]);

}

@@ -64,7 +51,7 @@ uint64_t Em410xDecode(uint8_t *BitStream, size_t size)

//PrintAndLog("DEBUG: EM parity failed parity val: %d, i:%d, ii:%d,idx:%d, Buffer: %d%d%d%d%d",parityTest,i,ii,idx,BitStream[idx+ii+(i*5)-5],BitStream[idx+ii+(i*5)-4],BitStream[idx+ii+(i*5)-3],BitStream[idx+ii+(i*5)-2],BitStream[idx+ii+(i*5)-1]);

parityTest=0;

idx-=8;

parityTest=0;

idx-=8;

- if (resetCnt>5)return 0;

+ if (resetCnt>5)return 0; //try 5 times

resetCnt++;

goto restart;//continue;

}

resetCnt++;

goto restart;//continue;

}

@@ -85,7 +72,7 @@ uint64_t Em410xDecode(uint8_t *BitStream, size_t size)

int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert)

{

int i;

int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert)

{

int i;

- int high = 0, low = 128;

+ int high = 0, low = 255;

*clk=DetectASKClock(BinStream, *size, *clk); //clock default

if (*clk<8) *clk =64;

*clk=DetectASKClock(BinStream, *size, *clk); //clock default

if (*clk<8) *clk =64;

@@ -101,13 +88,13 @@ int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert)

else if (BinStream[i] < low)

low = BinStream[i];

}

else if (BinStream[i] < low)

low = BinStream[i];

}

- if ((high < 158) ){ //throw away static

+ if ((high < 129) ){ //throw away static (anything < 1 graph)

//PrintAndLog("no data found");

return -2;

}

//25% fuzz in case highs and lows aren't clipped [marshmellow]

//PrintAndLog("no data found");

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;

+ high=(int)(((high-128)*.75)+128);

+ low= (int)(((low-128)*.75)+128);

//PrintAndLog("DEBUG - valid high: %d - valid low: %d",high,low);

int lastBit = 0; //set first clock check

//PrintAndLog("DEBUG - valid high: %d - valid low: %d",high,low);

int lastBit = 0; //set first clock check

@@ -284,7 +271,7 @@ int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert)

{

uint32_t i;

// int invert=0; //invert default

{

uint32_t i;

// int invert=0; //invert default

- int high = 0, low = 128;

+ int high = 0, low = 255;

*clk=DetectASKClock(BinStream, *size, *clk); //clock default

uint8_t BitStream[502] = {0};

*clk=DetectASKClock(BinStream, *size, *clk); //clock default

uint8_t BitStream[502] = {0};

@@ -292,7 +279,7 @@ int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert)

if (*clk<32) *clk=32;

if (*invert != 0 && *invert != 1) *invert =0;

uint32_t initLoopMax = 200;

if (*clk<32) *clk=32;

if (*invert != 0 && *invert != 1) *invert =0;

uint32_t initLoopMax = 200;

- if (initLoopMax>*size) initLoopMax=*size;

+ if (initLoopMax > *size) initLoopMax=*size;

// Detect high and lows

for (i = 0; i < initLoopMax; ++i) //200 samples should be plenty to find high and low values

{

// Detect high and lows

for (i = 0; i < initLoopMax; ++i) //200 samples should be plenty to find high and low values

{

@@ -301,19 +288,22 @@ int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert)

else if (BinStream[i] < low)

low = BinStream[i];

}

else if (BinStream[i] < low)

low = BinStream[i];

}

- if ((high < 158)){ //throw away static

+ if ((high < 129)){ //throw away static high has to be more than 0 on graph.

+ //noise <= -10 here

// PrintAndLog("no data found");

return -2;

}

//25% fuzz in case highs and lows aren't clipped [marshmellow]

// PrintAndLog("no data found");

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;

+ high=(int)(((high-128)*.75)+128);

+ low= (int)(((low-128)*.75)+128);

//PrintAndLog("DEBUG - valid high: %d - valid low: %d",high,low);

int lastBit = 0; //set first clock check

uint32_t bitnum = 0; //output counter

//PrintAndLog("DEBUG - valid high: %d - valid low: %d",high,low);

int lastBit = 0; //set first clock check

uint32_t bitnum = 0; //output counter

- uint8_t tol = 0; //clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave

- if (*clk==32)tol=1; //clock tolerance may not be needed anymore currently set to + or - 1 but could be increased for poor waves or removed entirely

+ uint8_t tol = 0; //clock tolerance adjust - waves will be accepted as within the clock

+ // if they fall + or - this value + clock from last valid wave

+ if (*clk == 32) tol=1; //clock tolerance may not be needed anymore currently set to

+ // + or - 1 but could be increased for poor waves or removed entirely

uint32_t iii = 0;

uint32_t gLen = *size;

if (gLen > 500) gLen=500;

uint32_t iii = 0;

uint32_t gLen = *size;

if (gLen > 500) gLen=500;

@@ -366,7 +356,6 @@ int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert)

bitnum++;

}

bitnum++;

}

errCnt++;

lastBit+=*clk;//skip over until hit too many errors

if (errCnt > ((*size/1000))){ //allow 1 error for every 1000 samples else start over

errCnt++;

lastBit+=*clk;//skip over until hit too many errors

if (errCnt > ((*size/1000))){ //allow 1 error for every 1000 samples else start over

@@ -395,26 +384,10 @@ int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert)

}

if (bitnum>16){

}

if (bitnum>16){

- // PrintAndLog("Data start pos:%d, lastBit:%d, stop pos:%d, numBits:%d",iii,lastBit,i,bitnum);

- //move BitStream back to BinStream

- // ClearGraph(0);

for (i=0; i < bitnum; ++i){

BinStream[i]=BitStream[i];

}

*size=bitnum;

for (i=0; i < bitnum; ++i){

BinStream[i]=BitStream[i];

}

*size=bitnum;

- // RepaintGraphWindow();

- //output

- // if (errCnt>0){

- // PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);

- // }

- // PrintAndLog("ASK decoded bitstream:");

- // Now output the bitstream to the scrollback by line of 16 bits

- // printBitStream2(BitStream,bitnum);

- //int errCnt=0;

- //errCnt=manrawdemod(BitStream,bitnum);

- // Em410xDecode(Cmd);

} else return -1;

return errCnt;

}

} else return -1;

return errCnt;

}

@@ -423,21 +396,11 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow

{

uint32_t last_transition = 0;

uint32_t idx = 1;

{

uint32_t last_transition = 0;

uint32_t idx = 1;

- uint32_t maxVal=0;

+ //uint32_t maxVal=0;

if (fchigh==0) fchigh=10;

if (fclow==0) fclow=8;

if (fchigh==0) fchigh=10;

if (fclow==0) fclow=8;

- // we do care about the actual theshold value as sometimes near the center of the

- // wave we may get static that changes direction of wave for one value

- // if our value is too low it might affect the read. and if our tag or

- // antenna is weak a setting too high might not see anything. [marshmellow]

- if (size<100) return 0;

- for(idx=1; idx<100; idx++){

- if(maxVal<dest[idx]) maxVal = dest[idx];

- }

- // set close to the top of the wave threshold with 25% margin for error

- // less likely to get a false transition up there.

- // (but have to be careful not to go too high and miss some short waves)

- uint8_t threshold_value = (uint8_t)(((maxVal-128)*.75)+128);

+ //set the threshold close to 0 (graph) or 128 std to avoid static

+ uint8_t threshold_value = 123;

// sync to first lo-hi transition, and threshold

@@ -496,10 +459,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 ( dest[idx-1]==1 ) {

n=myround2((float)(n+1)/((float)(rfLen)/(float)fclow));

//if lastval was 1, we have a 1->0 crossing

if ( dest[idx-1]==1 ) {

n=myround2((float)(n+1)/((float)(rfLen)/(float)fclow));

- //n=(n+1) / h2l_crossing_value;

} else {// 0->1 crossing

- n=myround2((float)(n+1)/((float)(rfLen-2)/(float)fchigh)); //-2 for fudge factor

- //n=(n+1) / l2h_crossing_value;

+ n=myround2((float)(n+1)/((float)(rfLen-1)/(float)fchigh)); //-1 for fudge factor

}

if (n == 0) n = 1;

}

if (n == 0) n = 1;

@@ -591,7 +552,7 @@ uint32_t bytebits_to_byte(uint8_t* src, size_t numbits)

int IOdemodFSK(uint8_t *dest, size_t size)

{

int IOdemodFSK(uint8_t *dest, size_t size)

{

- static const uint8_t THRESHOLD = 140;

+ static const uint8_t THRESHOLD = 129;

uint32_t idx=0;

//make sure buffer has data

if (size < 66) return -1;

uint32_t idx=0;

//make sure buffer has data

if (size < 66) return -1;

@@ -635,21 +596,21 @@ int DetectASKClock(uint8_t dest[], size_t size, int clock)

{

int i=0;

int peak=0;

{

int i=0;

int peak=0;

- int low=128;

+ int low=255;

int clk[]={16,32,40,50,64,100,128,256};

int loopCnt = 256; //don't need to loop through entire array...

if (size<loopCnt) loopCnt = size;

//if we already have a valid clock quit

for (;i<8;++i)

int clk[]={16,32,40,50,64,100,128,256};

int loopCnt = 256; //don't need to loop through entire array...

if (size<loopCnt) loopCnt = size;

//if we already have a valid clock quit

for (;i<8;++i)

- if (clk[i]==clock) return clock;

+ if (clk[i] == clock) return clock;

//get high and low peak

- for (i=0;i<loopCnt;++i){

- if(dest[i]>peak){

+ for (i=0; i < loopCnt; ++i){

+ if(dest[i] > peak){

peak = dest[i];

}

peak = dest[i];

}

- if(dest[i]<low){

+ if(dest[i] < low){

low = dest[i];

}

low = dest[i];

}

@@ -661,16 +622,16 @@ int DetectASKClock(uint8_t dest[], size_t size, int clock)

int bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000};

int errCnt=0;

//test each valid clock from smallest to greatest to see which lines up

int bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000};

int errCnt=0;

//test each valid clock from smallest to greatest to see which lines up

- for(clkCnt=0; clkCnt<6;++clkCnt){

- if (clk[clkCnt]==32){

+ for(clkCnt=0; clkCnt < 6; ++clkCnt){

+ if (clk[clkCnt] == 32){

tol=1;

}else{

tol=0;

}

bestErr[clkCnt]=1000;

//try lining up the peaks by moving starting point (try first 256)

tol=1;

}else{

tol=0;

}

bestErr[clkCnt]=1000;

//try lining up the peaks by moving starting point (try first 256)

- for (ii=0; ii<loopCnt; ++ii){

- if ((dest[ii]>=peak) || (dest[ii]<=low)){

+ for (ii=0; ii< loopCnt; ++ii){

+ if ((dest[ii] >= peak) || (dest[ii] <= low)){

errCnt=0;

// now that we have the first one lined up test rest of wave array

for (i=0; i<((int)(size/clk[clkCnt])-1); ++i){

errCnt=0;

// now that we have the first one lined up test rest of wave array

for (i=0; i<((int)(size/clk[clkCnt])-1); ++i){

@@ -693,7 +654,7 @@ int DetectASKClock(uint8_t dest[], size_t size, int clock)

for (iii=0; iii<7;++iii){

if (bestErr[iii]<bestErr[best]){

// current best bit to error ratio vs new bit to error ratio

for (iii=0; iii<7;++iii){

if (bestErr[iii]<bestErr[best]){

// current best bit to error ratio vs new bit to error ratio

- if (((size/clk[best])/bestErr[best]<(size/clk[iii])/bestErr[iii]) ){

+ if (((size/clk[best])/bestErr[best] < (size/clk[iii])/bestErr[iii]) ){

best = iii;

}

best = iii;

}

@@ -707,26 +668,26 @@ int DetectpskNRZClock(uint8_t dest[], size_t size, int clock)

{

int i=0;

int peak=0;

{

int i=0;

int peak=0;

- int low=128;

+ int low=255;

int clk[]={16,32,40,50,64,100,128,256};

int loopCnt = 2048; //don't need to loop through entire array...

if (size<loopCnt) loopCnt = size;

//if we already have a valid clock quit

int clk[]={16,32,40,50,64,100,128,256};

int loopCnt = 2048; //don't need to loop through entire array...

if (size<loopCnt) loopCnt = size;

//if we already have a valid clock quit

- for (;i<8;++i)

- if (clk[i]==clock) return clock;

+ for (; i < 8; ++i)

+ if (clk[i] == clock) return clock;

//get high and low peak

- for (i=0;i<loopCnt;++i){

- if(dest[i]>peak){

+ for (i=0; i < loopCnt; ++i){

+ 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)*.90)+128);

- low= (int)(((low-128)*.90)+128);

+ peak=(int)(((peak-128)*.75)+128);

+ low= (int)(((low-128)*.75)+128);

//PrintAndLog("DEBUG: peak: %d, low: %d",peak,low);

int ii;

uint8_t clkCnt;

//PrintAndLog("DEBUG: peak: %d, low: %d",peak,low);

int ii;

uint8_t clkCnt;

@@ -736,19 +697,19 @@ int DetectpskNRZClock(uint8_t dest[], size_t size, int clock)

int bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000,1000};

int peaksdet[]={0,0,0,0,0,0,0,0,0};

//test each valid clock from smallest to greatest to see which lines up

int bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000,1000};

int peaksdet[]={0,0,0,0,0,0,0,0,0};

//test each valid clock from smallest to greatest to see which lines up

- for(clkCnt=0; clkCnt<6;++clkCnt){

- if (clk[clkCnt]==32){

- tol=0;

+ for(clkCnt=0; clkCnt < 6; ++clkCnt){

+ if (clk[clkCnt] == 32){

+ tol=1;

}else{

tol=0;

}

//try lining up the peaks by moving starting point (try first 256)

}else{

tol=0;

}

//try lining up the peaks by moving starting point (try first 256)

- for (ii=0; ii<loopCnt; ++ii){

- if ((dest[ii]>=peak) || (dest[ii]<=low)){

+ for (ii=0; ii< loopCnt; ++ii){

+ if ((dest[ii] >= peak) || (dest[ii] <= low)){

errCnt=0;

peakcnt=0;

// now that we have the first one lined up test rest of wave array

errCnt=0;

peakcnt=0;

// now that we have the first one lined up test rest of wave array

- for (i=0; i<((int)(size/clk[clkCnt])-1); ++i){

+ for (i=0; i < ((int)(size/clk[clkCnt])-1); ++i){

if (dest[ii+(i*clk[clkCnt])]>=peak || dest[ii+(i*clk[clkCnt])]<=low){

peakcnt++;

}else if(dest[ii+(i*clk[clkCnt])-tol]>=peak || dest[ii+(i*clk[clkCnt])-tol]<=low){

if (dest[ii+(i*clk[clkCnt])]>=peak || dest[ii+(i*clk[clkCnt])]<=low){

peakcnt++;

}else if(dest[ii+(i*clk[clkCnt])-tol]>=peak || dest[ii+(i*clk[clkCnt])-tol]<=low){

@@ -771,13 +732,13 @@ int DetectpskNRZClock(uint8_t dest[], size_t size, int clock)

//int ratio2; //debug

int ratio;

//int bits;

//int ratio2; //debug

int ratio;

//int bits;

- for (iii=0; iii<7;++iii){

+ for (iii=0; iii < 7; ++iii){

ratio=1000;

//ratio2=1000; //debug

//bits=size/clk[iii]; //debug

ratio=1000;

//ratio2=1000; //debug

//bits=size/clk[iii]; //debug

- if (peaksdet[iii]>0){

+ if (peaksdet[iii] > 0){

ratio=bestErr[iii]/peaksdet[iii];

- if (((bestErr[best]/peaksdet[best])>(ratio)+1)){

+ if (((bestErr[best]/peaksdet[best]) > (ratio)+1)){

best = iii;

}

//ratio2=bits/peaksdet[iii]; //debug

best = iii;

}

//ratio2=bits/peaksdet[iii]; //debug

@@ -791,37 +752,37 @@ int DetectpskNRZClock(uint8_t dest[], size_t size, int clock)

void pskCleanWave(uint8_t *bitStream, size_t size)

{

int i;

void pskCleanWave(uint8_t *bitStream, size_t size)

{

int i;

- int low=128;

+ int low=255;

int high=0;

int gap = 4;

// int loopMax = 2048;

int newLow=0;

int newHigh=0;

int high=0;

int gap = 4;

// int loopMax = 2048;

int newLow=0;

int newHigh=0;

- for (i=0; i<size; ++i){

- if (bitStream[i]<low) low=bitStream[i];

- if (bitStream[i]>high) high=bitStream[i];

+ for (i=0; i < size; ++i){

+ if (bitStream[i] < low) low=bitStream[i];

+ if (bitStream[i] > high) high=bitStream[i];

}

high = (int)(((high-128)*.80)+128);

low = (int)(((low-128)*.90)+128);

//low = (uint8_t)(((int)(low)-128)*.80)+128;

}

high = (int)(((high-128)*.80)+128);

low = (int)(((low-128)*.90)+128);

//low = (uint8_t)(((int)(low)-128)*.80)+128;

- for (i=0; i<size; ++i){

- if (newLow==1){

+ for (i=0; i < size; ++i){

+ if (newLow == 1){

bitStream[i]=low+8;

gap--;

bitStream[i]=low+8;

gap--;

- if (gap==0){

+ if (gap == 0){

newLow=0;

gap=4;

}

newLow=0;

gap=4;

}

- }else if (newHigh==1){

+ }else if (newHigh == 1){

bitStream[i]=high-8;

gap--;

bitStream[i]=high-8;

gap--;

- if (gap==0){

+ if (gap == 0){

newHigh=0;

gap=4;

}

newHigh=0;

gap=4;

}

- if (bitStream[i]<=low) newLow=1;

- if (bitStream[i]>=high) newHigh=1;

+ if (bitStream[i] <= low) newLow=1;

+ if (bitStream[i] >= high) newHigh=1;

}

return;

}

return;

}

@@ -833,8 +794,7 @@ int indala26decode(uint8_t *bitStream, size_t *size, uint8_t *invert)

{

//26 bit 40134 format (don't know other formats)

int i;

{

//26 bit 40134 format (don't know other formats)

int i;

- int long_wait;

- long_wait = 29;//29 leading zeros in format

+ int long_wait=29;//29 leading zeros in format

int start;

int first = 0;

int first2 = 0;

int start;

int first = 0;

int first2 = 0;

@@ -856,7 +816,6 @@ int indala26decode(uint8_t *bitStream, size_t *size, uint8_t *invert)

// did not find start sequence

return -1;

}

// did not find start sequence

return -1;

}

- //found start once now test length by finding next one

// Inverting signal if needed

if (first == 1) {

for (i = start; i < *size; i++) {

// Inverting signal if needed

if (first == 1) {

for (i = start; i < *size; i++) {

@@ -866,6 +825,7 @@ int indala26decode(uint8_t *bitStream, size_t *size, uint8_t *invert)

}else *invert=0;

int iii;

}else *invert=0;

int iii;

+ //found start once now test length by finding next one

for (ii=start+29; ii <= *size - 250; ii++) {

first2 = bitStream[ii];

for (iii = ii; iii < ii + long_wait; iii++) {

for (ii=start+29; ii <= *size - 250; ii++) {

first2 = bitStream[ii];

for (iii = ii; iii < ii + long_wait; iii++) {

@@ -901,13 +861,13 @@ int pskNRZrawDemod(uint8_t *dest, size_t *size, int *clk, int *invert)

int clk2 = DetectpskNRZClock(dest, *size, *clk);

*clk=clk2;

uint32_t i;

int clk2 = DetectpskNRZClock(dest, *size, *clk);

*clk=clk2;

uint32_t i;

- uint8_t high=0, low=128;

+ uint8_t high=0, low=255;

uint32_t gLen = *size;

if (gLen > 1280) gLen=1280;

// get high

uint32_t gLen = *size;

if (gLen > 1280) gLen=1280;

// get high

- for (i=0; i<gLen; ++i){

- if (dest[i]>high) high = dest[i];

- if (dest[i]<low) low=dest[i];

+ for (i=0; i < gLen; ++i){

+ if (dest[i] > high) high = dest[i];

+ if (dest[i] < low) low = dest[i];

}

//fudge high/low bars by 25%

high = (uint8_t)((((int)(high)-128)*.75)+128);

}

//fudge high/low bars by 25%

high = (uint8_t)((((int)(high)-128)*.75)+128);

@@ -917,7 +877,7 @@ int pskNRZrawDemod(uint8_t *dest, size_t *size, int *clk, int *invert)

int lastBit = 0; //set first clock check

uint32_t bitnum = 0; //output counter

uint8_t tol = 0; //clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave

int lastBit = 0; //set first clock check

uint32_t bitnum = 0; //output counter

uint8_t tol = 0; //clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave

- if (*clk==32)tol=2; //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 = 2; //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;

uint8_t errCnt =0;

uint32_t bestStart = *size;

uint32_t iii = 0;

uint8_t errCnt =0;

uint32_t bestStart = *size;

@@ -930,7 +890,7 @@ int pskNRZrawDemod(uint8_t *dest, size_t *size, int *clk, int *invert)

//PrintAndLog("DEBUG - lastbit - %d",lastBit);

//loop to find first wave that works - align to clock

for (iii=0; iii < gLen; ++iii){

//PrintAndLog("DEBUG - lastbit - %d",lastBit);

//loop to find first wave that works - align to clock

for (iii=0; iii < gLen; ++iii){

- if ((dest[iii]>=high)||(dest[iii]<=low)){

+ if ((dest[iii]>=high) || (dest[iii]<=low)){

lastBit=iii-*clk;

//loop through to see if this start location works

for (i = iii; i < *size; ++i) {

lastBit=iii-*clk;

//loop through to see if this start location works

for (i = iii; i < *size; ++i) {

@@ -947,12 +907,12 @@ int pskNRZrawDemod(uint8_t *dest, size_t *size, int *clk, int *invert)

ignorewin=*clk/8;

bitnum++;

//else if no bars found

ignorewin=*clk/8;

bitnum++;

//else if no bars found

- }else if(dest[i]<high && dest[i]>low) {

+ }else if(dest[i] < high && dest[i] > low) {

if (ignorewin==0){

bitHigh=0;

}else ignorewin--;

//if we are past a clock point

if (ignorewin==0){

bitHigh=0;

}else ignorewin--;

//if we are past a clock point

- if (i>=lastBit+*clk+tol){ //clock val

+ if (i >= lastBit+*clk+tol){ //clock val

lastBit+=*clk;

bitnum++;

}

lastBit+=*clk;

bitnum++;

}

@@ -964,29 +924,29 @@ int pskNRZrawDemod(uint8_t *dest, size_t *size, int *clk, int *invert)

if (bitnum>=1000) break;

}

//we got more than 64 good bits and not all errors

if (bitnum>=1000) break;

}

//we got more than 64 good bits and not all errors

- if ((bitnum > (64+errCnt)) && (errCnt<(maxErr))) {

+ if ((bitnum > (64+errCnt)) && (errCnt < (maxErr))) {

//possible good read

- if (errCnt==0){

+ if (errCnt == 0){

bestStart = iii;

- bestErrCnt=errCnt;

+ bestErrCnt = errCnt;

break; //great read - finish

}

if (bestStart == iii) break; //if current run == bestErrCnt run (after exhausted testing) then finish

break; //great read - finish

}

if (bestStart == iii) break; //if current run == bestErrCnt run (after exhausted testing) then finish

- if (errCnt<bestErrCnt){ //set this as new best run

- bestErrCnt=errCnt;

+ if (errCnt < bestErrCnt){ //set this as new best run

+ bestErrCnt = errCnt;

bestStart = iii;

}

bestStart = iii;

}

- if (bestErrCnt<maxErr){

+ if (bestErrCnt < maxErr){

//best run is good enough set to best run and set overwrite BinStream

iii=bestStart;

lastBit=bestStart-*clk;

bitnum=0;

for (i = iii; i < *size; ++i) {

//if we found a high bar and we are at a clock bit

//best run is good enough set to best run and set overwrite BinStream

iii=bestStart;

lastBit=bestStart-*clk;

bitnum=0;

for (i = iii; i < *size; ++i) {

//if we found a high bar and we are at a clock bit

- if ((dest[i]>=high ) && (i>=lastBit+*clk-tol && i<=lastBit+*clk+tol)){

+ if ((dest[i] >= high ) && (i>=lastBit+*clk-tol && i<=lastBit+*clk+tol)){

bitHigh=1;

lastBit+=*clk;

curBit=1-*invert;

bitHigh=1;

lastBit+=*clk;

curBit=1-*invert;