X-Git-Url: https://git.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/blobdiff_plain/a5d824656811693c9f31cf41766e419b2dd799f9..dbb4e93ad79a246c3a5a3cd0bf78be3db0a1f55f:/common/lfdemod.c diff --git a/common/lfdemod.c b/common/lfdemod.c index ff80b8b3..797bce40 100644 --- a/common/lfdemod.c +++ b/common/lfdemod.c @@ -7,33 +7,35 @@ //----------------------------------------------------------------------------- // Low frequency demod/decode commands //----------------------------------------------------------------------------- - -#include #include "lfdemod.h" -#include //un_comment to allow debug print calls when used not on device void dummy(char *fmt, ...){} +void dummy_sgc (int clock, int startidx) {} #ifndef ON_DEVICE -#include "ui.h" -#include "cmdparser.h" -#include "cmddata.h" -#define prnt PrintAndLog +# include "ui.h" // plotclock, plotclockstartindex +# include "cmdparser.h" +# include "cmddata.h" +# define prnt PrintAndLog +# define sgc SetGraphClock +void SetGraphClock(int clock, int startidx){ + PlotClock = clock; + PlockClockStartIndex = startidx; +} #else - uint8_t g_debugMode=0; -#define prnt dummy + uint8_t g_debugMode = 0; +# define prnt dummy +# define sgc dummy_sgc #endif -uint8_t justNoise(uint8_t *BitStream, size_t size) -{ - static const uint8_t THRESHOLD = 123; - //test samples are not just noise - uint8_t justNoise1 = 1; - for(size_t idx=0; idx < size && justNoise1 ;idx++){ - justNoise1 = BitStream[idx] < THRESHOLD; - } - return justNoise1; +//test samples are not just noise +uint8_t justNoise(uint8_t *bits, size_t size) { + #define THRESHOLD 123 + uint8_t val = 1; + for(size_t idx = 0; idx < size && val; idx++) + val = bits[idx] < THRESHOLD; + return val; } //by marshmellow @@ -62,7 +64,7 @@ uint8_t parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType) for (uint8_t i = 0; i < bitLen; i++){ ans ^= ((bits >> i) & 1); } - //PrintAndLog("DEBUG: ans: %d, ptype: %d",ans,pType); + if (g_debugMode) prnt("DEBUG: ans: %d, ptype: %d, bits: %08X",ans,pType,bits); return (ans == pType); } @@ -73,22 +75,21 @@ size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t p { uint32_t parityWd = 0; size_t j = 0, bitCnt = 0; - for (int word = 0; word < (bLen); word+=pLen){ + for (int word = 0; word < (bLen); word += pLen){ for (int bit=0; bit < pLen; bit++){ parityWd = (parityWd << 1) | BitStream[startIdx+word+bit]; BitStream[j++] = (BitStream[startIdx+word+bit]); } + if (word+pLen > bLen) break; + j--; // overwrite parity with next data // if parity fails then return 0 switch (pType) { - case 3: if (BitStream[j]==1) return 0; break; //should be 0 spacer bit - case 2: if (BitStream[j]==0) return 0; break; //should be 1 spacer bit - default: //test parity - if (parityTest(parityWd, pLen, pType) == 0) - return 0; - break; + case 3: if (BitStream[j]==1) { return 0; } break; //should be 0 spacer bit + case 2: if (BitStream[j]==0) { return 0; } break; //should be 1 spacer bit + default: if (parityTest(parityWd, pLen, pType) == 0) { return 0; } break; //test parity } - bitCnt+=(pLen-1); + bitCnt += (pLen-1); parityWd = 0; } // if we got here then all the parities passed @@ -146,71 +147,112 @@ uint32_t bytebits_to_byteLSBF(uint8_t *src, size_t numbits) return num; } +//by marshmellow +// search for given preamble in given BitStream and return success=1 or fail=0 and startIndex (where it was found) +bool preambleSearch(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t *size, size_t *startIdx){ + return preambleSearchEx(BitStream, preamble, pLen, size, startIdx, false); +} //by marshmellow //search for given preamble in given BitStream and return success=1 or fail=0 and startIndex and length -uint8_t preambleSearch(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t *size, size_t *startIdx) +// param @findone: look for a repeating preamble or only the first. +// em4x05/4x69 only sends preamble once, so look for it once in the first pLen bits +bool preambleSearchEx(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t *size, size_t *startIdx, bool findone) { // Sanity check. If preamble length is bigger than bitstream length. - if ( *size <= pLen ) return 0; + if ( *size <= pLen ) return false; uint8_t foundCnt = 0; for (int idx = 0; idx < *size - pLen; idx++){ if (memcmp(BitStream+idx, preamble, pLen) == 0){ + if (g_debugMode) prnt("DEBUG: preamble found at %i", idx); //first index found foundCnt++; if (foundCnt == 1){ *startIdx = idx; + if (findone) return true; } if (foundCnt == 2){ *size = idx - *startIdx; - return 1; + return true; } } } - return 0; + return false; +} + +// find start of modulating data (for fsk and psk) in case of beginning noise or slow chip startup. +size_t findModStart(uint8_t dest[], size_t size, uint8_t threshold_value, uint8_t expWaveSize) { + size_t i = 0; + size_t waveSizeCnt = 0; + uint8_t thresholdCnt = 0; + bool isAboveThreshold = dest[i++] >= threshold_value; + for (; i < size-20; i++ ) { + if(dest[i] < threshold_value && isAboveThreshold) { + thresholdCnt++; + if (thresholdCnt > 2 && waveSizeCnt < expWaveSize+1) break; + isAboveThreshold = false; + waveSizeCnt = 0; + } else if (dest[i] >= threshold_value && !isAboveThreshold) { + thresholdCnt++; + if (thresholdCnt > 2 && waveSizeCnt < expWaveSize+1) break; + isAboveThreshold = true; + waveSizeCnt = 0; + } else { + waveSizeCnt++; + } + if (thresholdCnt > 10) break; + } + if (g_debugMode == 2) prnt("DEBUG: threshold Count reached at %u, count: %u",i, thresholdCnt); + return i; } //by marshmellow //takes 1s and 0s and searches for EM410x format - output EM ID -uint8_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_t *hi, uint64_t *lo) +// actually, no arguments needed - built this way in case we want this to be a direct call from "data " cmds in the future +int Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_t *hi, uint64_t *lo) { - //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 - uint32_t i = 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}; - uint32_t idx = 0; - uint32_t parityBits = 0; - uint8_t errChk = 0; - uint8_t FmtLen = 10; + // sanity check + if (*size < 64) return -3; + if (BitStream[1] > 1) return -1; + + uint8_t fmtlen; *startIdx = 0; - errChk = preambleSearch(BitStream, preamble, sizeof(preamble), size, startIdx); - if (errChk == 0 || *size < 64) return 0; - if (*size > 64) FmtLen = 22; - *startIdx += 1; //get rid of 0 from preamble - idx = *startIdx + 9; - for (i=0; i> 63); - *lo = (*lo << 1) | (BitStream[(i*5)+ii+idx]); - } + + // preamble 0111111111 + // include 0 in front to help get start pos + uint8_t preamble[] = {0,1,1,1,1,1,1,1,1,1}; + if (!preambleSearch(BitStream, preamble, sizeof(preamble), size, startIdx)) + return -2; + + //XL and normal size. + if (*size != 64 && *size != 128) return -3; + + fmtlen = (*size == 128) ? 22 : 10; + + //skip last 4bit parity row for simplicity + *size = removeParity(BitStream, *startIdx + sizeof(preamble), 5, 0, fmtlen * 5); + + switch (*size) { + case 40: { + // std em410x format + *hi = 0; + *lo = ((uint64_t)(bytebits_to_byte(BitStream, 8)) << 32) | (bytebits_to_byte(BitStream + 8, 32)); + break; + } + case 88: { + // long em format + *hi = (bytebits_to_byte(BitStream, 24)); + *lo = ((uint64_t)(bytebits_to_byte(BitStream + 24, 32)) << 32) | (bytebits_to_byte(BitStream + 24 + 32, 32)); + break; + } + default: return -4; } - if (errChk != 0) return 1; - //skip last 5 bit parity test for simplicity. - // *size = 64 | 128; - return 0; + return 1; } //by marshmellow //demodulates strong heavily clipped samples +//RETURN: num of errors. if 0, is ok. int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int high, int low) { size_t bitCnt=0, smplCnt=0, errCnt=0; @@ -222,11 +264,12 @@ int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int smplCnt++; } else { //transition if ((BinStream[i] >= high && !waveHigh) || (BinStream[i] <= low && waveHigh)){ + if (smplCnt > clk-(clk/4)-1) { //full clock if (smplCnt > clk + (clk/4)+1) { //too many samples errCnt++; if (g_debugMode==2) prnt("DEBUG ASK: Modulation Error at: %u", i); - BinStream[bitCnt++]=7; + BinStream[bitCnt++] = 7; } else if (waveHigh) { BinStream[bitCnt++] = invert; BinStream[bitCnt++] = invert; @@ -284,8 +327,10 @@ int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr if (*clk==0 || start < 0) return -3; if (*invert != 1) *invert = 0; if (amp==1) askAmp(BinStream, *size); - if (g_debugMode==2) prnt("DEBUG ASK: clk %d, beststart %d", *clk, start); + if (g_debugMode==2) prnt("DEBUG ASK: clk %d, beststart %d, amp %d", *clk, start, amp); + sgc(*clk, start); + uint8_t initLoopMax = 255; if (initLoopMax > *size) initLoopMax = *size; // Detect high and lows @@ -301,8 +346,8 @@ int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr errCnt = cleanAskRawDemod(BinStream, size, *clk, *invert, high, low); if (askType) //askman return manrawdecode(BinStream, size, 0); - else //askraw - return errCnt; + //askraw + return errCnt; } if (g_debugMode==2) prnt("DEBUG ASK: Weak Wave Detected - using weak wave demod"); @@ -349,40 +394,43 @@ int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr *size = bitnum; return errCnt; } - //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, uint8_t invert) -{ - uint16_t bitnum=0, MaxBits = 512, errCnt = 0; - size_t i, ii; - uint16_t bestErr = 1000, bestRun = 0; +int manrawdecode(uint8_t *BitStream, size_t *size, uint8_t invert){ + + // sanity check if (*size < 16) return -1; + + int errCnt = 0, bestErr = 1000; + uint16_t bitnum = 0, MaxBits = 512, bestRun = 0; + size_t i, k; + //find correct start position [alignment] - for (ii=0;ii<2;++ii){ - for (i=ii; i<*size-3; i+=2) - if (BitStream[i]==BitStream[i+1]) + for (k = 0; k < 2; ++k){ + for (i = k; i < *size-3; i += 2) { + if (BitStream[i] == BitStream[i+1]) errCnt++; - - if (bestErr>errCnt){ - bestErr=errCnt; - bestRun=ii; } - errCnt=0; + if (bestErr > errCnt){ + bestErr = errCnt; + bestRun = k; + } + errCnt = 0; } + //decode - for (i=bestRun; i < *size-3; i+=2){ - if(BitStream[i] == 1 && (BitStream[i+1] == 0)){ - BitStream[bitnum++]=invert; - } else if((BitStream[i] == 0) && BitStream[i+1] == 1){ - BitStream[bitnum++]=invert^1; + for (i = bestRun; i < *size-3; i += 2){ + if (BitStream[i] == 1 && (BitStream[i+1] == 0)){ + BitStream[bitnum++] = invert; + } else if ((BitStream[i] == 0) && BitStream[i+1] == 1){ + BitStream[bitnum++] = invert^1; } else { - BitStream[bitnum++]=7; + BitStream[bitnum++] = 7; } - if(bitnum>MaxBits) break; + if (bitnum > MaxBits) break; } - *size=bitnum; + *size = bitnum; return bestErr; } @@ -461,9 +509,11 @@ int gProxII_Demod(uint8_t BitStream[], size_t *size) size_t startIdx=0; uint8_t preamble[] = {1,1,1,1,1,0}; - uint8_t errChk = preambleSearch(BitStream, preamble, sizeof(preamble), size, &startIdx); - if (errChk == 0) return -3; //preamble not found + if (!preambleSearch(BitStream, preamble, sizeof(preamble), size, &startIdx)) + return -3; //preamble not found + if (*size != 96) return -2; //should have found 96 bits + //check first 6 spacer bits to verify format if (!BitStream[startIdx+5] && !BitStream[startIdx+10] && !BitStream[startIdx+15] && !BitStream[startIdx+20] && !BitStream[startIdx+25] && !BitStream[startIdx+30]){ //confirmed proper separator bits found @@ -478,7 +528,6 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow { size_t last_transition = 0; size_t idx = 1; - //uint32_t maxVal=0; if (fchigh==0) fchigh=10; if (fclow==0) fclow=8; //set the threshold close to 0 (graph) or 128 std to avoid static @@ -486,19 +535,22 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow size_t preLastSample = 0; size_t LastSample = 0; size_t currSample = 0; - // sync to first lo-hi transition, and threshold + if ( size < 1024 ) return 0; // not enough samples + + //find start of modulating data in trace + idx = findModStart(dest, size, threshold_value, fchigh); // Need to threshold first sample - // skip 160 samples to allow antenna/samples to settle - if(dest[160] < threshold_value) dest[0] = 0; + if(dest[idx] < threshold_value) dest[0] = 0; else dest[0] = 1; + idx++; size_t numBits = 0; // count cycles between consecutive lo-hi transitions, there should be either 8 (fc/8) // or 10 (fc/10) cycles but in practice due to noise etc we may end up with anywhere // between 7 to 11 cycles so fuzz it by treat anything <9 as 8 and anything else as 10 // (could also be fc/5 && fc/7 for fsk1 = 4-9) - for(idx = 161; idx < size-20; idx++) { + for(; idx < size-20; idx++) { // threshold current value if (dest[idx] < threshold_value) dest[idx] = 0; @@ -513,13 +565,14 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow //do nothing with extra garbage } else if (currSample < (fchigh-1)) { //6-8 = 8 sample waves (or 3-6 = 5) //correct previous 9 wave surrounded by 8 waves (or 6 surrounded by 5) - if (LastSample > (fchigh-2) && (preLastSample < (fchigh-1) || preLastSample == 0 )){ + if (LastSample > (fchigh-2) && (preLastSample < (fchigh-1))){ dest[numBits-1]=1; } dest[numBits++]=1; - } else if (currSample > (fchigh) && !numBits) { //12 + and first bit = unusable garbage - //do nothing with beginning garbage + } else if (currSample > (fchigh+1) && numBits < 3) { //12 + and first two bit = unusable garbage + //do nothing with beginning garbage and reset.. should be rare.. + numBits = 0; } else if (currSample == (fclow+1) && LastSample == (fclow-1)) { // had a 7 then a 9 should be two 8's (or 4 then a 6 should be two 5's) dest[numBits++]=1; } else { //9+ = 10 sample waves (or 6+ = 7) @@ -542,7 +595,7 @@ size_t aggregate_bits(uint8_t *dest, size_t size, uint8_t rfLen, uint32_t n=1; for( idx=1; idx < size; idx++) { n++; - if (dest[idx]==lastval) continue; + if (dest[idx]==lastval) continue; //skip until we hit a transition //find out how many bits (n) we collected //if lastval was 1, we have a 1->0 crossing @@ -587,15 +640,14 @@ int HIDdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32 { if (justNoise(dest, *size)) return -1; - size_t numStart=0, size2=*size, startIdx=0; + size_t numStart=0, size2 = *size, startIdx=0; // FSK demodulator *size = fskdemod(dest, size2,50,1,10,8); //fsk2a if (*size < 96*2) return -2; // 00011101 bit pattern represent start of frame, 01 pattern represents a 0 and 10 represents a 1 uint8_t preamble[] = {0,0,0,1,1,1,0,1}; - // find bitstring in array - uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); - if (errChk == 0) return -3; //preamble not found + if (!preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx)) + return -3; //preamble not found numStart = startIdx + sizeof(preamble); // final loop, go over previously decoded FSK data and manchester decode into usable tag ID @@ -606,10 +658,11 @@ int HIDdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32 *hi2 = (*hi2<<1)|(*hi>>31); *hi = (*hi<<1)|(*lo>>31); //Then, shift in a 0 or one into low + *lo <<= 1; if (dest[idx] && !dest[idx+1]) // 1 0 - *lo=(*lo<<1)|1; + *lo |= 1; else // 0 1 - *lo=(*lo<<1)|0; + *lo |= 0; } return (int)startIdx; } @@ -619,16 +672,15 @@ int ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, ui { if (justNoise(dest, *size)) return -1; - size_t numStart=0, size2=*size, startIdx=0; + size_t numStart=0, size2 = *size, startIdx=0; // FSK demodulator *size = fskdemod(dest, size2,50,1,10,8); //fsk2a if (*size < 96) return -2; // 00001111 bit pattern represent start of frame, 01 pattern represents a 0 and 10 represents a 1 uint8_t preamble[] = {0,0,0,0,1,1,1,1}; - - uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); - if (errChk == 0) return -3; //preamble not found + if (preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx)) + return -3; //preamble not found numStart = startIdx + sizeof(preamble); // final loop, go over previously decoded FSK data and manchester decode into usable tag ID @@ -665,8 +717,8 @@ int IOdemodFSK(uint8_t *dest, size_t size) //Handle the data size_t startIdx = 0; uint8_t preamble[] = {0,0,0,0,0,0,0,0,0,1}; - uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), &size, &startIdx); - if (errChk == 0) return -4; //preamble not found + if (! preambleSearch(dest, preamble, sizeof(preamble), &size, &startIdx)) + return -4; //preamble not found if (!dest[startIdx+8] && dest[startIdx+17]==1 && dest[startIdx+26]==1 && dest[startIdx+35]==1 && dest[startIdx+44]==1 && dest[startIdx+53]==1){ //confirmed proper separator bits found @@ -681,11 +733,11 @@ int IOdemodFSK(uint8_t *dest, size_t size) int VikingDemod_AM(uint8_t *dest, size_t *size) { //make sure buffer has data if (*size < 64*2) return -2; - size_t startIdx = 0; uint8_t preamble[] = {1,1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; - uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); - if (errChk == 0) return -4; //preamble not found + if (!preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx)) + return -4; //preamble not found + uint32_t checkCalc = bytebits_to_byte(dest+startIdx,8) ^ bytebits_to_byte(dest+startIdx+8,8) ^ bytebits_to_byte(dest+startIdx+16,8) ^ @@ -697,67 +749,77 @@ int VikingDemod_AM(uint8_t *dest, size_t *size) { if ( checkCalc != 0xA8 ) return -5; if (*size != 64) return -6; //return start position - return (int) startIdx; + return (int)startIdx; } +// by iceman +// find Visa2000 preamble in already demoded data +int Visa2kDemod_AM(uint8_t *dest, size_t *size) { + if (*size < 96) return -1; //make sure buffer has data + size_t startIdx = 0; + uint8_t preamble[] = {0,1,0,1,0,1,1,0,0,1,0,0,1,0,0,1,0,1,0,1,0,0,1,1,0,0,1,1,0,0,1,0}; + if (!preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx)) + return -2; //preamble not found + if (*size != 96) return -3; //wrong demoded size + //return start position + return (int)startIdx; +} +// by iceman +// find Noralsy preamble in already demoded data +int NoralsyDemod_AM(uint8_t *dest, size_t *size) { + if (*size < 96) return -1; //make sure buffer has data + size_t startIdx = 0; + uint8_t preamble[] = {1,0,1,1,1,0,1,1,0,0,0,0}; + if (!preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx)) + return -2; //preamble not found + if (*size != 96) return -3; //wrong demoded size + //return start position + return (int)startIdx; +} // find presco preamble 0x10D in already demoded data int PrescoDemod(uint8_t *dest, size_t *size) { - //make sure buffer has data - if (*size < 64*2) return -2; - + if (*size < 128*2) return -1; //make sure buffer has data size_t startIdx = 0; - uint8_t preamble[] = {1,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0}; - uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); - if (errChk == 0) return -4; //preamble not found + uint8_t preamble[] = {0,0,0,1,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0}; + if (!preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx)) + return -2; //preamble not found + if (*size != 128) return -3; //wrong demoded size //return start position - return (int) startIdx; + return (int)startIdx; } // Ask/Biphase Demod then try to locate an ISO 11784/85 ID // BitStream must contain previously askrawdemod and biphasedemoded data -int FDXBdemodBI(uint8_t *dest, size_t *size) -{ - //make sure buffer has enough data - if (*size < 128) return -1; - +int FDXBdemodBI(uint8_t *dest, size_t *size) { + if (*size < 128*2) return -1; //make sure buffer has enough data size_t startIdx = 0; uint8_t preamble[] = {0,0,0,0,0,0,0,0,0,0,1}; - - uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); - if (errChk == 0) return -2; //preamble not found + if (!preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx)) + return -2; //preamble not found + if (*size != 128) return -3; //wrong demoded size + //return start position return (int)startIdx; } // ASK/Diphase fc/64 (inverted Biphase) // Note: this i s not a demod, this is only a detection // the parameter *dest needs to be demoded before call +// 0xFFFF preamble, 64bits int JablotronDemod(uint8_t *dest, size_t *size){ - //make sure buffer has enough data - if (*size < 64) return -1; - + if (*size < 64*2) return -1; //make sure buffer has enough data size_t startIdx = 0; - // 0xFFFF preamble, 64bits - uint8_t preamble[] = { - 1,1,1,1, - 1,1,1,1, - 1,1,1,1, - 1,1,1,1, - 0 - }; - - uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); - if (errChk == 0) return -4; //preamble not found - if (*size != 64) return -3; + uint8_t preamble[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0}; + if (!preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx)) + return -2; //preamble not found + if (*size != 64) return -3; // wrong demoded size uint8_t checkchksum = 0; for (int i=16; i < 56; i += 8) { checkchksum += bytebits_to_byte(dest+startIdx+i,8); } checkchksum ^= 0x3A; - uint8_t crc = bytebits_to_byte(dest+startIdx+56, 8); - - if ( checkchksum != crc ) return -5; + if ( checkchksum != crc ) return -5; return (int)startIdx; } @@ -776,8 +838,8 @@ int AWIDdemodFSK(uint8_t *dest, size_t *size) uint8_t preamble[] = {0,0,0,0,0,0,0,1}; size_t startIdx = 0; - uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); - if (errChk == 0) return -4; //preamble not found + if (!preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx)) + return -4; //preamble not found if (*size != 96) return -5; return (int)startIdx; } @@ -795,11 +857,10 @@ int PyramiddemodFSK(uint8_t *dest, size_t *size) // FSK demodulator *size = fskdemod(dest, *size, 50, 1, 10, 8); // fsk2a RF/50 if (*size < 128) return -2; //did we get a good demod? - - uint8_t preamble[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}; size_t startIdx = 0; - uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); - if (errChk == 0) return -4; //preamble not found + uint8_t preamble[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1}; + if (!preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx)) + return -4; //preamble not found if (*size != 128) return -3; return (int)startIdx; } @@ -812,8 +873,21 @@ int NedapDemod(uint8_t *dest, size_t *size) { size_t startIdx = 0; //uint8_t preamble[] = {1,1,1,1,1,1,1,1,1,0,0,0,1}; uint8_t preamble[] = {1,1,1,1,1,1,1,1,1,0}; - uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); - if (errChk == 0) return -4; //preamble not found + if (!preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx)) + return -4; //preamble not found + return (int) startIdx; +} + +// Find IDTEC PSK1, RF Preamble == 0x4944544B, Demodsize 64bits +// by iceman +int IdteckDemodPSK(uint8_t *dest, size_t *size) { + //make sure buffer has data + if (*size < 64*2) return -1; + size_t startIdx = 0; + uint8_t preamble[] = {0,1,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,1,0,1,0,1,0,0,0,1,0,0,1,0,1,1}; + if (!preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx)) + return -2; //preamble not found + if (*size != 64) return -3; // wrong demoded size return (int) startIdx; } @@ -839,13 +913,14 @@ uint8_t DetectCleanAskWave(uint8_t dest[], size_t size, uint8_t high, uint8_t lo // by marshmellow // to help detect clocks on heavily clipped samples // based on count of low to low -int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low) +int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low, int *clock) { - uint8_t fndClk[] = {8,16,32,40,50,64,128}; + uint8_t clocks[] = {8,16,32,40,50,64,128}; size_t startwave; size_t i = 100; size_t minClk = 255; - // get to first full low to prime loop and skip incomplete first pulse + int shortestWaveIdx = 0; + // 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)) @@ -862,14 +937,18 @@ int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low) while ((dest[i] > low) && (i < size)) ++i; //get minimum measured distance - if (i-startwave < minClk && i < size) + if (i-startwave < minClk && i < size) { minClk = i - startwave; + shortestWaveIdx = startwave; + } } // set clock if (g_debugMode==2) prnt("DEBUG ASK: detectstrongASKclk smallest wave: %d",minClk); for (uint8_t clkCnt = 0; clkCnt<7; clkCnt++) { - if (minClk >= fndClk[clkCnt]-(fndClk[clkCnt]/8) && minClk <= fndClk[clkCnt]+1) - return fndClk[clkCnt]; + if (minClk >= clocks[clkCnt]-(clocks[clkCnt]/8) && minClk <= clocks[clkCnt]+1) { + *clock = clocks[clkCnt]; + return shortestWaveIdx; + } } return 0; } @@ -880,15 +959,15 @@ int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low) // return start index of best starting position for that clock and return clock (by reference) int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr) { - size_t i=1; + size_t i = 1; 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 <= loopCnt+60) return -1; //not enough samples + if (size <= loopCnt + 60) return -1; //not enough samples size -= 60; //sometimes there is a strange end wave - filter out this.... //if we already have a valid clock - uint8_t clockFnd=0; - for (;i0; 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] - } + int ans = DetectStrongAskClock(dest, size, peak, low, clock); + if (g_debugMode==2) prnt("DEBUG ASK: detectaskclk Clean Ask Wave Detected: clk %i, ShortestWave: %i", clock ,ans); + if (ans > 0){ + return ans; // return shortest wave start pos } } } @@ -918,27 +992,31 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr) size_t errCnt = 0; size_t arrLoc, loopEnd; - if (clockFnd>0) { + if (clockFnd > 0) { clkCnt = clockFnd; clkEnd = clockFnd+1; + } else { + clkCnt = 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){ + for (; clkCnt < clkEnd; clkCnt++) { + if (clk[clkCnt] <= 32) { tol=1; - }else{ + } else { tol=0; } //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; + 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; ii++){ if (dest[ii] < peak && dest[ii] > low) continue; - errCnt=0; + errCnt = 0; // now that we have the first one lined up test rest of wave array loopEnd = ((size-ii-tol) / clk[clkCnt]) - 1; for (i=0; i < loopEnd; ++i){ @@ -952,60 +1030,67 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr) } //if we found no errors then we can stop here and a low clock (common clocks) // this is correct one - return this clock - if (g_debugMode == 2) prnt("DEBUG ASK: clk %d, err %d, startpos %d, endpos %d",clk[clkCnt],errCnt,ii,i); - if(errCnt==0 && clkCnt<7) { + if (g_debugMode == 2) prnt("DEBUG ASK: clk %d, err %d, startpos %d, endpos %d", clk[clkCnt], errCnt, ii, i); + 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 - if(errCnt= dest[i+2]){ if (waveStart == 0) { waveStart = i+1; @@ -1023,10 +1108,11 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock) } } } - if (g_debugMode ==2) prnt("DEBUG PSK: firstFullWave: %d, waveLen: %d",firstFullWave,fullWaveLen); + *firstPhaseShift = firstFullWave; + if (g_debugMode == 2) prnt("DEBUG PSK: firstFullWave: %d, waveLen: %d",firstFullWave,fullWaveLen); //test each valid clock from greatest to smallest to see which lines up - for(clkCnt=7; clkCnt >= 1 ; clkCnt--){ + for (clkCnt=7; clkCnt >= 1 ; clkCnt--){ lastClkBit = firstFullWave; //set end of wave as clock align waveStart = 0; errCnt=0; @@ -1060,19 +1146,17 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock) } } } - if (errCnt == 0){ - return clk[clkCnt]; - } - if (errCnt <= bestErr[clkCnt]) bestErr[clkCnt]=errCnt; - if (peakcnt > peaksdet[clkCnt]) peaksdet[clkCnt]=peakcnt; + if (errCnt == 0) return clk[clkCnt]; + if (errCnt <= bestErr[clkCnt]) bestErr[clkCnt] = errCnt; + if (peakcnt > peaksdet[clkCnt]) peaksdet[clkCnt] = peakcnt; } //all tested with errors //return the highest clk with the most peaks found - uint8_t best=7; - for (i=7; i>=1; i--){ - if (peaksdet[i] > peaksdet[best]) { + uint8_t best = 7; + for (i=7; i >= 1; i--){ + if (peaksdet[i] > peaksdet[best]) best = i; - } + if (g_debugMode == 2) prnt("DEBUG PSK: Clk: %d, peaks: %d, errs: %d, bestClk: %d",clk[i],peaksdet[i],bestErr[i],clk[best]); } return clk[best]; @@ -1107,18 +1191,25 @@ int DetectStrongNRZClk(uint8_t *dest, size_t size, int peak, int low){ return lowestTransition; } +int DetectNRZClock(uint8_t dest[], size_t size, int clock) { + int bestStart = 0; + return DetectNRZClock_ext(dest, size, clock, &bestStart); +} + //by marshmellow //detect nrz clock by reading #peaks vs no peaks(or errors) -int DetectNRZClock(uint8_t dest[], size_t size, int clock) -{ - size_t i=0; - uint8_t clk[]={8,16,32,40,50,64,100,128,255}; +int DetectNRZClock_ext(uint8_t dest[], size_t size, int clock, int *clockStartIdx) { + size_t i = 0; + uint8_t clk[] = {8,16,32,40,50,64,100,128,255}; size_t loopCnt = 4096; //don't need to loop through entire array... - if (size == 0) return 0; - if (size 6 ){ if (maxPeak > smplCnt){ maxPeak = smplCnt; @@ -1147,7 +1238,7 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) } peakcnt++; //prnt("maxPk: %d, smplCnt: %d, peakcnt: %d",maxPeak,smplCnt,peakcnt); - smplCnt=0; + smplCnt = 0; } } } @@ -1157,7 +1248,8 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) uint8_t ignoreWindow = 4; bool lastPeakHigh = 0; int lastBit = 0; - peakcnt=0; + int bestStart[] = {0,0,0,0,0,0,0,0,0}; + peakcnt = 0; //test each valid clock from smallest to greatest to see which lines up for(clkCnt=0; clkCnt < 8; ++clkCnt){ //ignore clocks smaller than smallest peak @@ -1177,7 +1269,7 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) if (dest[i] >= peak || dest[i] <= low) { //if same peak don't count it if ((dest[i] >= peak && !lastPeakHigh) || (dest[i] <= low && lastPeakHigh)) { - peakcnt++; + peakcnt++; } lastPeakHigh = (dest[i] >= peak); bitHigh = true; @@ -1189,9 +1281,10 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) } //else if not a clock bit and no peaks } else if (dest[i] < peak && dest[i] > low){ - if (ignoreCnt==0){ + if (ignoreCnt == 0){ bitHigh=false; - if (errBitHigh==true) peakcnt--; + if (errBitHigh==true) + peakcnt--; errBitHigh=false; } else { ignoreCnt--; @@ -1202,61 +1295,58 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) errBitHigh=true; } } - if(peakcnt>peaksdet[clkCnt]) { - peaksdet[clkCnt]=peakcnt; + if (peakcnt > peaksdet[clkCnt]) { + bestStart[clkCnt]=ii; + peaksdet[clkCnt] = peakcnt; } } } } - int iii=7; - uint8_t best=0; - for (iii=7; iii > 0; iii--){ - if ((peaksdet[iii] >= (peaksdet[best]-1)) && (peaksdet[iii] <= peaksdet[best]+1) && lowestTransition) { - if (clk[iii] > (lowestTransition - (clk[iii]/8)) && clk[iii] < (lowestTransition + (clk[iii]/8))) { - best = iii; - } - } else if (peaksdet[iii] > peaksdet[best]){ - best = iii; + + uint8_t best = 0; + for (int m = 7; m > 0; m--){ + if ((peaksdet[m] >= (peaksdet[best]-1)) && (peaksdet[m] <= peaksdet[best]+1) && lowestTransition) { + if (clk[m] > (lowestTransition - (clk[m]/8)) && clk[m] < (lowestTransition + (clk[m]/8))) { + best = m; + } + } else if (peaksdet[m] > peaksdet[best]){ + best = m; } - if (g_debugMode==2) prnt("DEBUG NRZ: Clk: %d, peaks: %d, maxPeak: %d, bestClk: %d, lowestTrs: %d",clk[iii],peaksdet[iii],maxPeak, clk[best], lowestTransition); + if (g_debugMode==2) prnt("DEBUG NRZ: Clk: %d, peaks: %d, maxPeak: %d, bestClk: %d, lowestTrs: %d", clk[m], peaksdet[m], maxPeak, clk[best], lowestTransition); } - + *clockStartIdx = bestStart[best]; return clk[best]; } // by marshmellow // convert psk1 demod to psk2 demod // only transition waves are 1s -void psk1TOpsk2(uint8_t *BitStream, size_t size) -{ - size_t i=1; - uint8_t lastBit=BitStream[0]; - for (; i BitStream[i-1] && BitStream[i]>=BitStream[i+1]) @@ -1347,7 +1441,10 @@ uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fc continue; // else new peak // if we got less than the small fc + tolerance then set it to the small fc - if (fcCounter < fcLow+fcTol) + // if it is inbetween set it to the last counter + if (fcCounter < fcHigh && fcCounter > fcLow) + fcCounter = lastFCcnt; + else if (fcCounter < fcLow+fcTol) fcCounter = fcLow; else //set it to the large fc fcCounter = fcHigh; @@ -1364,11 +1461,12 @@ uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fc } } if (rfCounter > 0 && rfLensFnd < 15){ - //PrintAndLog("DEBUG: rfCntr %d, fcCntr %d",rfCounter,fcCounter); + //prnt("DEBUG: rfCntr %d, fcCntr %d",rfCounter,fcCounter); rfCnts[rfLensFnd]++; rfLens[rfLensFnd++] = rfCounter; } } else { + *firstClockEdge = i; firstBitFnd++; } rfCounter=0; @@ -1413,7 +1511,7 @@ uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fc } } - if (ii<0) return 0; // oops we went too far + if (ii<2) return 0; // oops we went too far return clk[ii]; } @@ -1427,10 +1525,10 @@ uint16_t countFC(uint8_t *BitStream, size_t size, uint8_t fskAdj) uint8_t fcLens[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; uint16_t fcCnts[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; uint8_t fcLensFnd = 0; - uint8_t lastFCcnt=0; + uint8_t lastFCcnt = 0; uint8_t fcCounter = 0; size_t i; - if (size == 0) return 0; + if (size < 180) return 0; // prime i to first up transition for (i = 160; i < size-20; i++) @@ -1517,27 +1615,37 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert) size_t numBits=0; uint8_t curPhase = *invert; - size_t i, waveStart=1, waveEnd=0, firstFullWave=0, lastClkBit=0; - uint8_t fc=0, fullWaveLen=0, tol=1; - uint16_t errCnt=0, waveLenCnt=0; - fc = countFC(dest, *size, 0); + size_t i=0, waveStart=1, waveEnd=0, firstFullWave=0, lastClkBit=0; + uint16_t fc=0, fullWaveLen=0, tol=1; + uint16_t errCnt=0, waveLenCnt=0, errCnt2=0; + fc = countFC(dest, *size, 1); + uint8_t fc2 = fc >> 8; + if (fc2 == 10) return -1; //fsk found - quit + fc = fc & 0xFF; if (fc!=2 && fc!=4 && fc!=8) return -1; - //PrintAndLog("DEBUG: FC: %d",fc); + //prnt("DEBUG: FC: %d",fc); *clock = DetectPSKClock(dest, *size, *clock); if (*clock == 0) return -1; - int avgWaveVal=0, lastAvgWaveVal=0; + + //find start of modulating data in trace + uint8_t threshold_value = 123; //-5 + i = findModStart(dest, *size, threshold_value, fc); + //find first phase shift - for (i=0; i= dest[i+2]){ waveEnd = i+1; - //PrintAndLog("DEBUG: waveEnd: %d",waveEnd); + if (g_debugMode == 2) prnt("DEBUG PSK: waveEnd: %u, waveStart: %u",waveEnd, waveStart); waveLenCnt = waveEnd-waveStart; - if (waveLenCnt > fc && waveStart > fc && !(waveLenCnt > fc+2)){ //not first peak and is a large wave but not out of whack + if (waveLenCnt > fc && waveStart > fc && !(waveLenCnt > fc+3)){ //not first peak and is a large wave but not out of whack lastAvgWaveVal = avgWaveVal/(waveLenCnt); firstFullWave = waveStart; fullWaveLen=waveLenCnt; - //if average wave value is > graph 0 then it is an up wave or a 1 - if (lastAvgWaveVal > 123) curPhase ^= 1; //fudge graph 0 a little 123 vs 128 + //if average wave value is > graph 0 then it is an up wave or a 1 (could cause inverting) + if (lastAvgWaveVal > threshold_value) curPhase ^= 1; break; } waveStart = i+1; @@ -1558,7 +1666,7 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert) //set start of wave as clock align lastClkBit = firstFullWave; if (g_debugMode==2) prnt("DEBUG PSK: firstFullWave: %u, waveLen: %u",firstFullWave,fullWaveLen); - if (g_debugMode==2) prnt("DEBUG: clk: %d, lastClkBit: %u, fc: %u", *clock, lastClkBit,(unsigned int) fc); + if (g_debugMode==2) prnt("DEBUG PSK: clk: %d, lastClkBit: %u, fc: %u", *clock, lastClkBit,(unsigned int) fc); waveStart = 0; dest[numBits++] = curPhase; //set first read bit for (i = firstFullWave + fullWaveLen - 1; i < *size-3; i++){ @@ -1573,9 +1681,9 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert) waveLenCnt = waveEnd-waveStart; lastAvgWaveVal = avgWaveVal/waveLenCnt; if (waveLenCnt > fc){ - //PrintAndLog("DEBUG: avgWaveVal: %d, waveSum: %d",lastAvgWaveVal,avgWaveVal); + //prnt("DEBUG: avgWaveVal: %d, waveSum: %d",lastAvgWaveVal,avgWaveVal); //this wave is a phase shift - //PrintAndLog("DEBUG: phase shift at: %d, len: %d, nextClk: %d, i: %d, fc: %d",waveStart,waveLenCnt,lastClkBit+*clock-tol,i+1,fc); + //prnt("DEBUG: phase shift at: %d, len: %d, nextClk: %d, i: %d, fc: %d",waveStart,waveLenCnt,lastClkBit+*clock-tol,i+1,fc); if (i+1 >= lastClkBit + *clock - tol){ //should be a clock bit curPhase ^= 1; dest[numBits++] = curPhase; @@ -1589,6 +1697,9 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert) } else if (i+1 > lastClkBit + *clock + tol + fc){ lastClkBit += *clock; //no phase shift but clock bit dest[numBits++] = curPhase; + } else if (waveLenCnt < fc - 1) { //wave is smaller than field clock (shouldn't happen often) + errCnt2++; + if(errCnt2 > 101) return errCnt2; } avgWaveVal = 0; waveStart = i+1; @@ -1600,9 +1711,14 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert) return errCnt; } +bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) { + size_t ststart = 0, stend = 0; + return DetectST_ext(buffer, size, foundclock, &ststart, &stend); +} + //by marshmellow //attempt to identify a Sequence Terminator in ASK modulated raw wave -bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) { +bool DetectST_ext(uint8_t buffer[], size_t *size, int *foundclock, size_t *ststart, size_t *stend) { size_t bufsize = *size; //need to loop through all samples and identify our clock, look for the ST pattern uint8_t fndClk[] = {8,16,32,40,50,64,128}; @@ -1610,13 +1726,15 @@ bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) { int tol = 0; int i, j, skip, start, end, low, high, minClk, waveStart; bool complete = false; - int tmpbuff[bufsize / 64]; - int waveLen[bufsize / 64]; + int tmpbuff[bufsize / 32]; //guess rf/32 clock, if click is smaller we will only have room for a fraction of the samples captured + int waveLen[bufsize / 32]; // if clock is larger then we waste memory in array size that is not needed... size_t testsize = (bufsize < 512) ? bufsize : 512; int phaseoff = 0; high = low = 128; memset(tmpbuff, 0, sizeof(tmpbuff)); + memset(waveLen, 0, sizeof(waveLen)); + if ( getHiLo(buffer, testsize, &high, &low, 80, 80) == -1 ) { if (g_debugMode==2) prnt("DEBUG STT: just noise detected - quitting"); return false; //just noise @@ -1643,7 +1761,7 @@ bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) { waveStart = i; while ((buffer[i] > low) && (i < bufsize)) ++i; - if (j >= (bufsize/64)) { + if (j >= (bufsize/32)) { break; } waveLen[j] = i - waveStart; //first high to first low @@ -1689,6 +1807,8 @@ bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) { if (start < 0) { if (g_debugMode==2) prnt("DEBUG STT: first STT not found - quitting"); return false; + } else { + if (g_debugMode==2) prnt("DEBUG STT: first STT found at: %d, j=%d",start, j); } if (waveLen[i+2] > clk*1+tol) phaseoff = 0; @@ -1702,7 +1822,7 @@ bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) { end = skip; for (i += 3; i < j - 4; ++i) { end += tmpbuff[i]; - if (tmpbuff[i] >= clk*1-tol && tmpbuff[i] <= (clk*2)+tol) { //1 to 2 clocks depending on 2 bits prior + if (tmpbuff[i] >= clk*1-tol && tmpbuff[i] <= (clk*2)+tol && waveLen[i] < clk+tol) { //1 to 2 clocks depending on 2 bits prior if (tmpbuff[i+1] >= clk*2-tol && tmpbuff[i+1] <= clk*2+tol && waveLen[i+1] > clk*3/2-tol) { //2 clocks and wave size is 1 1/2 if (tmpbuff[i+2] >= (clk*3)/2-tol && tmpbuff[i+2] <= clk*2+tol && waveLen[i+2] > clk-tol) { //1 1/2 to 2 clocks and at least one full clock wave if (tmpbuff[i+3] >= clk*1-tol && tmpbuff[i+3] <= clk*2+tol) { //1 to 2 clocks for end of ST + first bit @@ -1724,12 +1844,15 @@ bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) { start = skip; size_t datalen = end - start; // check validity of datalen (should be even clock increments) - use a tolerance of up to 1/8th a clock - if (datalen % clk > clk/8) { + if ( clk - (datalen % clk) <= clk/8) { + // padd the amount off - could be problematic... but shouldn't happen often + datalen += clk - (datalen % clk); + } else if ( (datalen % clk) <= clk/8 ) { + // padd the amount off - could be problematic... but shouldn't happen often + datalen -= datalen % clk; + } else { if (g_debugMode==2) prnt("DEBUG STT: datalen not divisible by clk: %u %% %d = %d - quitting", datalen, clk, datalen % clk); return false; - } else { - // padd the amount off - could be problematic... but shouldn't happen often - datalen += datalen % clk; } // if datalen is less than one t55xx block - ERROR if (datalen/clk < 8*4) { @@ -1737,8 +1860,20 @@ bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) { return false; } size_t dataloc = start; + if (buffer[dataloc-(clk*4)-(clk/8)] <= low && buffer[dataloc] <= low && buffer[dataloc-(clk*4)] >= high) { + //we have low drift (and a low just before the ST and a low just after the ST) - compensate by backing up the start + for ( i=0; i <= (clk/8); ++i ) { + if ( buffer[dataloc - (clk*4) - i] <= low ) { + dataloc -= i; + break; + } + } + } + size_t newloc = 0; i=0; + if (g_debugMode==2) prnt("DEBUG STT: Starting STT trim - start: %d, datalen: %d ",dataloc, datalen); + bool firstrun = true; // warning - overwriting buffer given with raw wave data with ST removed... while ( dataloc < bufsize-(clk/2) ) { //compensate for long high at end of ST not being high due to signal loss... (and we cut out the start of wave high part) @@ -1746,6 +1881,15 @@ bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) { for(i=0; i < clk/2-tol; ++i) { buffer[dataloc+i] = high+5; } + } //test for single sample outlier (high between two lows) in the case of very strong waves + if (buffer[dataloc] >= high && buffer[dataloc+2] <= low) { + buffer[dataloc] = buffer[dataloc+2]; + buffer[dataloc+1] = buffer[dataloc+2]; + } + if (firstrun) { + *stend = dataloc; + *ststart = dataloc-(clk*4); + firstrun=false; } for (i=0; i