X-Git-Url: http://cvs.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/blobdiff_plain/643fb10b2df5248f830f0a9e3d8ae43b24e1c2b2..efd193519c5e4613a16b7a13dd69a9962df0b218:/common/lfdemod.c?ds=inline

diff --git a/common/lfdemod.c b/common/lfdemod.c
index c00222b3..7d40d22e 100644
--- a/common/lfdemod.c
+++ b/common/lfdemod.c
@@ -81,10 +81,8 @@ uint8_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_
 	//  otherwise could be a void with no arguments
 	//set defaults
 	uint32_t i = 0;
-	if (BitStream[1]>1){  //allow only 1s and 0s
-		// PrintAndLog("no data found");
-		return 0;
-	}
+	if (BitStream[1]>1) return 0;  //allow only 1s and 0s
+
 	// 111111111 bit pattern represent start of frame
 	//  include 0 in front to help get start pos
 	uint8_t preamble[] = {0,1,1,1,1,1,1,1,1,1};
@@ -114,12 +112,12 @@ uint8_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_
 	return 0;
 }
 
-// demodulates strong heavily clipped samples
+//by marshmellow
+//demodulates strong heavily clipped samples
 int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int high, int low)
 {
 	size_t bitCnt=0, smplCnt=0, errCnt=0;
 	uint8_t waveHigh = 0;
-	//PrintAndLog("clk: %d", clk);
 	for (size_t i=0; i < *size; i++){
 		if (BinStream[i] >= high && waveHigh){
 			smplCnt++;
@@ -130,7 +128,7 @@ int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int
 				if (smplCnt > clk-(clk/4)-1) { //full clock
 					if (smplCnt > clk + (clk/4)+1) { //too many samples
 						errCnt++;
-						BinStream[bitCnt++]=77;
+						BinStream[bitCnt++]=7;
 					} else if (waveHigh) {
 						BinStream[bitCnt++] = invert;
 						BinStream[bitCnt++] = invert;
@@ -166,52 +164,81 @@ int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int
 }
 
 //by marshmellow
-//takes 3 arguments - clock, invert, maxErr as integers
-//attempts to demodulate ask while decoding manchester
-//prints binary found and saves in graphbuffer for further commands
-int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr)
+void askAmp(uint8_t *BitStream, size_t size)
 {
-	size_t i;
+	for(size_t i = 1; i<size; i++){
+		if (BitStream[i]-BitStream[i-1]>=30) //large jump up
+			BitStream[i]=127;
+		else if(BitStream[i]-BitStream[i-1]<=-20) //large jump down
+			BitStream[i]=-127;
+	}
+	return;
+}
+
+//by marshmellow
+//attempts to demodulate ask modulations, askType == 0 for ask/raw, askType==1 for ask/manchester
+int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr, uint8_t amp, uint8_t askType)
+{
+	if (*size==0) return -1;
 	int start = DetectASKClock(BinStream, *size, clk, maxErr); //clock default
 	if (*clk==0 || start < 0) return -3;
-	if (*invert != 1) *invert=0;
+	if (*invert != 1) *invert = 0;
+	if (amp==1) askAmp(BinStream, *size);
+
 	uint8_t initLoopMax = 255;
 	if (initLoopMax > *size) initLoopMax = *size;
 	// Detect high and lows
-	// 25% fuzz in case highs and lows aren't clipped [marshmellow]
+	//25% clip in case highs and lows aren't clipped [marshmellow]
 	int high, low;
-	if (getHiLo(BinStream, initLoopMax, &high, &low, 75, 75) < 1) return -2; //just noise
+	if (getHiLo(BinStream, initLoopMax, &high, &low, 75, 75) < 1) 
+		return -2; //just noise
 
+	size_t errCnt = 0;
 	// if clean clipped waves detected run alternate demod
 	if (DetectCleanAskWave(BinStream, *size, high, low)) {
-		cleanAskRawDemod(BinStream, size, *clk, *invert, high, low);
-		return manrawdecode(BinStream, size);	
+		errCnt = cleanAskRawDemod(BinStream, size, *clk, *invert, high, low);
+		if (askType) //askman
+			return manrawdecode(BinStream, size, 0);	
+		else //askraw
+			return errCnt;
 	}
 
-	// PrintAndLog("DEBUG - valid high: %d - valid low: %d",high,low);
-	int lastBit;  //set first clock check
-	uint16_t bitnum = 0;     //output counter
+	int lastBit;  //set first clock check - can go negative
+	size_t i, bitnum = 0;     //output counter
+	uint8_t midBit = 0;
 	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
-	uint16_t errCnt = 0, MaxBits = 512;
+	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
+	size_t MaxBits = 1024;
 	lastBit = start - *clk;
+
 	for (i = start; i < *size; ++i) {
-		if ((BinStream[i] >= high) && ((i-lastBit) > (*clk-tol))){
-			//high found and we are expecting a bar
-			lastBit += *clk;
-			BinStream[bitnum++] = *invert;
-		} else if ((BinStream[i] <= low) && ((i-lastBit) > (*clk-tol))){
-			//low found and we are expecting a bar
+		if (i-lastBit >= *clk-tol){
+			if (BinStream[i] >= high) {
+				BinStream[bitnum++] = *invert;
+			} else if (BinStream[i] <= low) {
+				BinStream[bitnum++] = *invert ^ 1;
+			} else if (i-lastBit >= *clk+tol) {
+				if (bitnum > 0) {
+					BinStream[bitnum++]=7;
+					errCnt++;						
+				} 
+			} else { //in tolerance - looking for peak
+				continue;
+			}
+			midBit = 0;
 			lastBit += *clk;
-			BinStream[bitnum++] = *invert ^ 1;
-		} else if ((i-lastBit)>(*clk+tol)){
-			//should have hit a high or low based on clock!!
-			//PrintAndLog("DEBUG - no wave in expected area - location: %d, expected: %d-%d, lastBit: %d - resetting search",i,(lastBit+(clk-((int)(tol)))),(lastBit+(clk+((int)(tol)))),lastBit);
-			if (bitnum > 0) {
-				BinStream[bitnum++] = 77;
-				errCnt++;
-			}		
-			lastBit += *clk;//skip over error
+		} else if (i-lastBit >= (*clk/2-tol) && !midBit && !askType){
+			if (BinStream[i] >= high) {
+				BinStream[bitnum++] = *invert;
+			} else if (BinStream[i] <= low) {
+				BinStream[bitnum++] = *invert ^ 1;
+			} else if (i-lastBit >= *clk/2+tol) {
+				BinStream[bitnum] = BinStream[bitnum-1];
+				bitnum++;
+			} else { //in tolerance - looking for peak
+				continue;
+			}
+			midBit = 1;
 		}
 		if (bitnum >= MaxBits) break;
 	}
@@ -219,33 +246,18 @@ int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int max
 	return errCnt;
 }
 
-//by marshmellow
-//encode binary data into binary manchester 
-int ManchesterEncode(uint8_t *BitStream, size_t size)
-{
-	size_t modIdx=20000, i=0;
-	if (size>modIdx) return -1;
-	for (size_t idx=0; idx < size; idx++){
-		BitStream[idx+modIdx++] = BitStream[idx];
-		BitStream[idx+modIdx++] = BitStream[idx]^1;
-	}
-	for (; i<(size*2); i++){
-		BitStream[i] = BitStream[i+20000];
-	}
-	return i;
-}
-
 //by marshmellow
 //take 10 and 01 and manchester decode
 //run through 2 times and take least errCnt
-int manrawdecode(uint8_t * BitStream, size_t *size)
+int manrawdecode(uint8_t * BitStream, size_t *size, uint8_t invert)
 {
 	uint16_t bitnum=0, MaxBits = 512, errCnt = 0;
 	size_t i, ii;
 	uint16_t bestErr = 1000, bestRun = 0;
-	if (size == 0) return -1;
+	if (*size < 16) return -1;
+	//find correct start position [alignment]
 	for (ii=0;ii<2;++ii){
-		for (i=ii; i<*size-2; i+=2)
+		for (i=ii; i<*size-3; i+=2)
 			if (BitStream[i]==BitStream[i+1])
 				errCnt++;
 
@@ -255,13 +267,14 @@ int manrawdecode(uint8_t * BitStream, size_t *size)
 		}
 		errCnt=0;
 	}
-	for (i=bestRun; i < *size-2; i+=2){
+	//decode
+	for (i=bestRun; i < *size-3; i+=2){
 		if(BitStream[i] == 1 && (BitStream[i+1] == 0)){
-			BitStream[bitnum++]=0;
+			BitStream[bitnum++]=invert;
 		} else if((BitStream[i] == 0) && BitStream[i+1] == 1){
-			BitStream[bitnum++]=1;
+			BitStream[bitnum++]=invert^1;
 		} else {
-			BitStream[bitnum++]=77;
+			BitStream[bitnum++]=7;
 		}
 		if(bitnum>MaxBits) break;
 	}
@@ -269,6 +282,22 @@ int manrawdecode(uint8_t * BitStream, size_t *size)
 	return bestErr;
 }
 
+//by marshmellow
+//encode binary data into binary manchester 
+int ManchesterEncode(uint8_t *BitStream, size_t size)
+{
+	size_t modIdx=20000, i=0;
+	if (size>modIdx) return -1;
+	for (size_t idx=0; idx < size; idx++){
+		BitStream[idx+modIdx++] = BitStream[idx];
+		BitStream[idx+modIdx++] = BitStream[idx]^1;
+	}
+	for (; i<(size*2); i++){
+		BitStream[i] = BitStream[i+20000];
+	}
+	return i;
+}
+
 //by marshmellow
 //take 01 or 10 = 1 and 11 or 00 = 0
 //check for phase errors - should never have 111 or 000 should be 01001011 or 10110100 for 1010
@@ -291,7 +320,7 @@ int BiphaseRawDecode(uint8_t *BitStream, size_t *size, int offset, int invert)
 	for (i=offset; i<*size-3; i+=2){
 		//check for phase error
 		if (BitStream[i+1]==BitStream[i+2]) {
-			BitStream[bitnum++]=77;
+			BitStream[bitnum++]=7;
 			errCnt++;
 		}
 		if((BitStream[i]==1 && BitStream[i+1]==0) || (BitStream[i]==0 && BitStream[i+1]==1)){
@@ -299,7 +328,7 @@ int BiphaseRawDecode(uint8_t *BitStream, size_t *size, int offset, int invert)
 		} else if((BitStream[i]==0 && BitStream[i+1]==0) || (BitStream[i]==1 && BitStream[i+1]==1)){
 			BitStream[bitnum++]=invert;
 		} else {
-			BitStream[bitnum++]=77;
+			BitStream[bitnum++]=7;
 			errCnt++;
 		}
 		if(bitnum>MaxBits) break;
@@ -308,89 +337,7 @@ int BiphaseRawDecode(uint8_t *BitStream, size_t *size, int offset, int invert)
 	return errCnt;
 }
 
-//by marshmellow
-void askAmp(uint8_t *BitStream, size_t size)
-{
-	int shift = 127;
-	int shiftedVal=0;
-	for(size_t i = 1; i<size; i++){
-		if (BitStream[i]-BitStream[i-1]>=30) //large jump up
-			shift=127;
-		else if(BitStream[i]-BitStream[i-1]<=-20) //large jump down
-			shift=-127;
-
-		shiftedVal=BitStream[i]+shift;
-
-		if (shiftedVal>255) 
-			shiftedVal=255;
-		else if (shiftedVal<0) 
-			shiftedVal=0;
-		BitStream[i-1] = shiftedVal;
-	}
-	return;
-}
-
-//by marshmellow
-//takes 3 arguments - clock, invert and maxErr as integers
-//attempts to demodulate ask only
-int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr, uint8_t amp)
-{
-	if (*size==0) return -1;
-	int start = DetectASKClock(BinStream, *size, clk, maxErr); //clock default
-	if (*clk==0 || start < 0) return -1;
-	if (*invert != 1) *invert = 0;
-	if (amp==1) askAmp(BinStream, *size);
-
-	uint8_t initLoopMax = 255;
-	if (initLoopMax > *size) initLoopMax = *size;
-	// Detect high and lows
-	//25% clip in case highs and lows aren't clipped [marshmellow]
-	int high, low;
-	if (getHiLo(BinStream, initLoopMax, &high, &low, 75, 75) < 1) 
-		return -1; //just noise
-
-	// if clean clipped waves detected run alternate demod
-	if (DetectCleanAskWave(BinStream, *size, high, low))
-		return cleanAskRawDemod(BinStream, size, *clk, *invert, high, low);
-
-	int lastBit;  //set first clock check - can go negative
-	size_t i, errCnt = 0, bitnum = 0;     //output counter
-	uint8_t midBit = 0;
-	size_t MaxBits = 1024;
-	lastBit = start - *clk;
-
-	for (i = start; i < *size; ++i) {
-		if (i - lastBit > *clk){
-			if (BinStream[i] >= high) {
-				BinStream[bitnum++] = *invert;
-			} else if (BinStream[i] <= low) {
-				BinStream[bitnum++] = *invert ^ 1;
-			} else {
-				if (bitnum > 0) {
-					BinStream[bitnum++]=77;
-					errCnt++;						
-				} 
-			}
-			midBit = 0;
-			lastBit += *clk;
-		} else if (i-lastBit > (*clk/2) && midBit == 0){
-			if (BinStream[i] >= high) {
-				BinStream[bitnum++] = *invert;
-			} else if (BinStream[i] <= low) {
-				BinStream[bitnum++] = *invert ^ 1;
-			} else {
-
-				BinStream[bitnum] = BinStream[bitnum-1];
-				bitnum++;
-			}
-			midBit = 1;
-		}
-		if (bitnum >= MaxBits) break;
-	}
-	*size = bitnum;
-	return errCnt;
-}
-
+// by marshmellow
 // demod gProxIIDemod 
 // error returns as -x 
 // success returns start position in BitStream
@@ -686,12 +633,13 @@ int PyramiddemodFSK(uint8_t *dest, size_t *size)
 	return (int)startIdx;
 }
 
-
-uint8_t DetectCleanAskWave(uint8_t dest[], size_t size, int high, int low)
+// by marshmellow
+// to detect a wave that has heavily clipped (clean) samples
+uint8_t DetectCleanAskWave(uint8_t dest[], size_t size, uint8_t high, uint8_t low)
 {
 	uint16_t allPeaks=1;
 	uint16_t cntPeaks=0;
-	size_t loopEnd = 572;
+	size_t loopEnd = 512+60;
 	if (loopEnd > size) loopEnd = size;
 	for (size_t i=60; i<loopEnd; i++){
 		if (dest[i]>low && dest[i]<high) 
@@ -707,53 +655,39 @@ uint8_t DetectCleanAskWave(uint8_t dest[], size_t size, int high, int low)
 
 // by marshmellow
 // to help detect clocks on heavily clipped samples
-// based on counts between zero crossings
-int DetectStrongAskClock(uint8_t dest[], size_t size)
+// based on count of low to low
+int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low)
 {
-	int clk[]={0,8,16,32,40,50,64,100,128};
-	size_t idx = 40;
-	uint8_t high=0;
-	size_t cnt = 0;
-	size_t highCnt = 0;
-	size_t highCnt2 = 0;
-	for (;idx < size; idx++){
-		if (dest[idx]>128) {
-			if (!high){
-				high=1;
-				if (cnt > highCnt){
-					if (highCnt != 0) highCnt2 = highCnt;
-					highCnt = cnt;
-				} else if (cnt > highCnt2) {
-					highCnt2 = cnt;
-				}
-				cnt=1;
-			} else {
-				cnt++;
-			}
-		} else if (dest[idx] <= 128){
-			if (high) {
-				high=0;
-				if (cnt > highCnt) {
-					if (highCnt != 0) highCnt2 = highCnt;
-					highCnt = cnt;
-				} else if (cnt > highCnt2) {
-					highCnt2 = cnt;
-				}
-				cnt=1;
-			} else {
-				cnt++;
-			}
-		}
+	uint8_t fndClk[] = {8,16,32,40,50,64,128};
+	size_t startwave;
+	size_t i = 0;
+	size_t minClk = 255;
+		// get to first full low to prime loop and skip incomplete first pulse
+	while ((dest[i] < high) && (i < size))
+		++i;
+	while ((dest[i] > low) && (i < size))
+		++i;
+
+	// loop through all samples
+	while (i < size) {
+		// measure from low to low
+		while ((dest[i] > low) && (i < size))
+			++i;
+		startwave= i;
+		while ((dest[i] < high) && (i < size))
+			++i;
+		while ((dest[i] > low) && (i < size))
+			++i;
+		//get minimum measured distance
+		if (i-startwave < minClk && i < size)
+			minClk = i - startwave;
 	}
-	uint8_t tol;
-	for (idx=8; idx>0; idx--){
-		tol = clk[idx]/8;
-		if (clk[idx] >= highCnt - tol && clk[idx] <= highCnt + tol)
-			return clk[idx];
-		if (clk[idx] >= highCnt2 - tol && clk[idx] <= highCnt2 + tol)
-			return clk[idx];
+	// set clock
+	for (uint8_t clkCnt = 0; clkCnt<7; clkCnt++) {
+		if (minClk >= fndClk[clkCnt]-(fndClk[clkCnt]/8) && minClk <= fndClk[clkCnt]+1)
+			return fndClk[clkCnt];
 	}
-	return -1;
+	return 0;
 }
 
 // by marshmellow
@@ -763,15 +697,15 @@ int DetectStrongAskClock(uint8_t dest[], size_t size)
 int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
 {
 	size_t i=1;
-	uint8_t clk[]={255,8,16,32,40,50,64,100,128,255};
+	uint8_t clk[] = {255,8,16,32,40,50,64,100,128,255};
+	uint8_t clkEnd = 9;
 	uint8_t loopCnt = 255;  //don't need to loop through entire array...
-	if (size==0) return -1;
-	if (size <= loopCnt) loopCnt = size-1; //not enough samples
+	if (size <= loopCnt) return -1; //not enough samples
 
 	//if we already have a valid clock
 	uint8_t clockFnd=0;
-	for (;i<9;++i)
-		if (clk[i] == *clock) clockFnd=i;
+	for (;i<clkEnd;++i)
+		if (clk[i] == *clock) clockFnd = i;
 		//clock found but continue to find best startpos
 
 	//get high and low peak
@@ -779,37 +713,45 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
 	if (getHiLo(dest, loopCnt, &peak, &low, 75, 75) < 1) return -1;
 	
 	//test for large clean peaks
-	if (DetectCleanAskWave(dest, size, peak, low)==1){
-		int ans = DetectStrongAskClock(dest, size);
-		for (i=8; i>1; i--){
-			if (clk[i] == ans) {
-				*clock = ans;
-				clockFnd = i;
-				break; //clock found but continue to find best startpos
+	if (!clockFnd){
+		if (DetectCleanAskWave(dest, size, peak, low)==1){
+			int ans = DetectStrongAskClock(dest, size, peak, low);
+			for (i=clkEnd-1; i>0; i--){
+				if (clk[i] == ans) {
+					*clock = ans;
+					//clockFnd = i;
+					return 0;  // for strong waves i don't use the 'best start position' yet...
+					//break; //clock found but continue to find best startpos [not yet]
+				}
 			}
 		}
 	}
+	
 	uint8_t ii;
 	uint8_t clkCnt, tol = 0;
 	uint16_t bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000,1000};
 	uint8_t bestStart[]={0,0,0,0,0,0,0,0,0};
 	size_t errCnt = 0;
 	size_t arrLoc, loopEnd;
-	//test each valid clock from smallest to greatest to see which lines up
-	uint8_t clkEnd=9;
-	if (clockFnd>0) clkEnd=clockFnd+1;
-	else clockFnd=1;
 
-	for(clkCnt=clockFnd; clkCnt < clkEnd; clkCnt++){
-		if (clk[clkCnt] == 32){
+	if (clockFnd>0) {
+		clkCnt = clockFnd;
+		clkEnd = clockFnd+1;
+	}
+	else clkCnt=1;
+
+	//test each valid clock from smallest to greatest to see which lines up
+	for(; clkCnt < clkEnd; clkCnt++){
+		if (clk[clkCnt] <= 32){
 			tol=1;
 		}else{
 			tol=0;
 		}
-		if (!maxErr && loopCnt>clk[clkCnt]*3) loopCnt=clk[clkCnt]*3;
+		//if no errors allowed - keep start within the first clock
+		if (!maxErr && size > clk[clkCnt]*2 + tol && clk[clkCnt]<128) loopCnt=clk[clkCnt]*2;
 		bestErr[clkCnt]=1000;
 		//try lining up the peaks by moving starting point (try first few clocks)
-		for (ii=0; ii < loopCnt-tol-clk[clkCnt]; ii++){
+		for (ii=0; ii < loopCnt; ii++){
 			if (dest[ii] < peak && dest[ii] > low) continue;
 
 			errCnt=0;
@@ -824,11 +766,11 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
 					errCnt++;
 				}
 			}
-			//if we found no errors then we can stop here
+			//if we found no errors then we can stop here and a low clock (common clocks)
 			//  this is correct one - return this clock
 					//PrintAndLog("DEBUG: clk %d, err %d, ii %d, i %d",clk[clkCnt],errCnt,ii,i);
-			if(errCnt==0 && clkCnt<6) {
-				*clock = clk[clkCnt];
+			if(errCnt==0 && clkCnt<7) { 
+				if (!clockFnd) *clock = clk[clkCnt];
 				return ii;
 			}
 			//if we found errors see if it is lowest so far and save it as best run
@@ -838,9 +780,9 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
 			}
 		}
 	}
-	uint8_t iii=0;
+	uint8_t iii;
 	uint8_t best=0;
-	for (iii=0; iii<8; ++iii){
+	for (iii=1; iii<clkEnd; ++iii){
 		if (bestErr[iii] < bestErr[best]){
 			if (bestErr[iii] == 0) bestErr[iii]=1;
 			// current best bit to error ratio     vs  new bit to error ratio
@@ -849,8 +791,8 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
 			}
 		}
 	}
-	if (bestErr[best] > maxErr) return -1;
-	*clock = clk[best];
+	//if (bestErr[best] > maxErr) return -1;
+	if (!clockFnd) *clock = clk[best];
 	return bestStart[best];
 }
 
@@ -1029,7 +971,7 @@ void psk1TOpsk2(uint8_t *BitStream, size_t size)
 	size_t i=1;
 	uint8_t lastBit=BitStream[0];
 	for (; i<size; i++){
-		if (BitStream[i]==77){
+		if (BitStream[i]==7){
 			//ignore errors
 		} else if (lastBit!=BitStream[i]){
 			lastBit=BitStream[i];
@@ -1222,7 +1164,7 @@ int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert, int maxErr)
 			if (ignoreCnt == 0){
 				bitHigh = 0;
 				if (errBitHigh == 1){
-					dest[bitnum++] = 77;
+					dest[bitnum++] = 7;
 					errCnt++;
 				}
 				errBitHigh=0;
@@ -1497,7 +1439,7 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert)
 						//noise after a phase shift - ignore
 					} else { //phase shift before supposed to based on clock
 						errCnt++;
-						dest[numBits++] = 77;
+						dest[numBits++] = 7;
 					}
 				} else if (i+1 > lastClkBit + *clock + tol + fc){
 					lastClkBit += *clock; //no phase shift but clock bit