X-Git-Url: https://git.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/blobdiff_plain/db8296025f78251ffa2c28d6fe995bbb0a386c77..0691975406414516cdc977454a7965a8ca40b88d:/common/lfdemod.c diff --git a/common/lfdemod.c b/common/lfdemod.c index 063c8a74..1b53c445 100644 --- a/common/lfdemod.c +++ b/common/lfdemod.c @@ -9,8 +9,22 @@ //----------------------------------------------------------------------------- #include -#include #include "lfdemod.h" +#include + +//to allow debug print calls when used not on device +void dummy(char *fmt, ...){} + +#ifndef ON_DEVICE +#include "ui.h" +#include "cmdparser.h" +#include "cmddata.h" +#define prnt PrintAndLog +#else + uint8_t g_debugMode=0; +#define prnt dummy +#endif + uint8_t justNoise(uint8_t *BitStream, size_t size) { static const uint8_t THRESHOLD = 123; @@ -48,68 +62,177 @@ 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); } +// by marshmellow +// takes a array of binary values, start position, length of bits per parity (includes parity bit), +// Parity Type (1 for odd; 0 for even; 2 for Always 1's; 3 for Always 0's), and binary Length (length to run) +size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t pType, size_t bLen) +{ + uint32_t parityWd = 0; + size_t j = 0, bitCnt = 0; + 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: if (parityTest(parityWd, pLen, pType) == 0) {return 0;} break; //test parity + } + bitCnt+=(pLen-1); + parityWd = 0; + } + // if we got here then all the parities passed + //return ID start index and size + return bitCnt; +} + +// by marshmellow +// takes a array of binary values, length of bits per parity (includes parity bit), +// Parity Type (1 for odd; 0 for even; 2 Always 1's; 3 Always 0's), and binary Length (length to run) +// Make sure *dest is long enough to store original sourceLen + #_of_parities_to_be_added +size_t addParity(uint8_t *BitSource, uint8_t *dest, uint8_t sourceLen, uint8_t pLen, uint8_t pType) +{ + uint32_t parityWd = 0; + size_t j = 0, bitCnt = 0; + for (int word = 0; word < sourceLen; word+=pLen-1) { + for (int bit=0; bit < pLen-1; bit++){ + parityWd = (parityWd << 1) | BitSource[word+bit]; + dest[j++] = (BitSource[word+bit]); + } + // if parity fails then return 0 + switch (pType) { + case 3: dest[j++]=0; break; // marker bit which should be a 0 + case 2: dest[j++]=1; break; // marker bit which should be a 1 + default: + dest[j++] = parityTest(parityWd, pLen-1, pType) ^ 1; + break; + } + bitCnt += pLen; + parityWd = 0; + } + // if we got here then all the parities passed + //return ID start index and size + return bitCnt; +} + +uint32_t bytebits_to_byte(uint8_t *src, size_t numbits) +{ + uint32_t num = 0; + for(int i = 0 ; i < numbits ; i++) + { + num = (num << 1) | (*src); + src++; + } + return num; +} + +//least significant bit first +uint32_t bytebits_to_byteLSBF(uint8_t *src, size_t numbits) +{ + uint32_t num = 0; + for(int i = 0 ; i < numbits ; i++) + { + num = (num << 1) | *(src + (numbits-(i+1))); + } + return num; +} + //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) { - uint8_t foundCnt=0; - for (int idx=0; idx < *size - pLen; idx++){ - if (memcmp(BitStream+idx, preamble, pLen) == 0){ + return (preambleSearchEx(BitStream, preamble, pLen, size, startIdx, false)) ? 1 : 0; +} + +// search for given preamble in given BitStream and return success=1 or fail=0 and startIndex (where it was found) and length if not fineone +// fineone does not look for a repeating preamble for em4x05/4x69 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 false; + + uint8_t foundCnt = 0; + for (size_t idx = 0; idx < *size - pLen; idx++) { + if (memcmp(BitStream+idx, preamble, pLen) == 0) { //first index found foundCnt++; - if (foundCnt == 1){ + if (foundCnt == 1) { + if (g_debugMode) prnt("DEBUG: preamble found at %u", idx); *startIdx = idx; - } - if (foundCnt == 2){ + if (findone) return true; + } else 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) { - //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; + //sanity checks + if (*size < 64) 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}; - uint32_t idx = 0; - uint32_t parityBits = 0; uint8_t errChk = 0; - uint8_t FmtLen = 10; + uint8_t FmtLen = 10; // sets of 4 bits = end data *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]); - } + if ( errChk == 0 || (*size != 64 && *size != 128) ) return 0; + if (*size == 128) FmtLen = 22; // 22 sets of 4 bits + + //skip last 4bit parity row for simplicity + *size = removeParity(BitStream, *startIdx + sizeof(preamble), 5, 0, FmtLen * 5); + if (*size == 40) { // std em410x format + *hi = 0; + *lo = ((uint64_t)(bytebits_to_byte(BitStream, 8)) << 32) | (bytebits_to_byte(BitStream + 8, 32)); + } else if (*size == 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)); + } else { + return 0; } - if (errChk != 0) return 1; - //skip last 5 bit parity test for simplicity. - // *size = 64 | 128; - return 0; + return 1; } //by marshmellow @@ -128,6 +251,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++; + if (g_debugMode==2) prnt("DEBUG ASK: Modulation Error at: %u", i); BinStream[bitCnt++]=7; } else if (waveHigh) { BinStream[bitCnt++] = invert; @@ -164,17 +288,21 @@ int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int } //by marshmellow +//amplify based on ask edge detection void askAmp(uint8_t *BitStream, size_t size) { + uint8_t Last = 128; for(size_t i = 1; i=30) //large jump up - BitStream[i]=127; - else if(BitStream[i]-BitStream[i-1]<=-20) //large jump down - BitStream[i]=-127; + Last = 255; + else if(BitStream[i-1]-BitStream[i]>=20) //large jump down + Last = 0; + + BitStream[i-1] = Last; } 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) @@ -184,6 +312,7 @@ 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, amp %d", *clk, start, amp); uint8_t initLoopMax = 255; if (initLoopMax > *size) initLoopMax = *size; @@ -196,19 +325,21 @@ int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr size_t errCnt = 0; // if clean clipped waves detected run alternate demod if (DetectCleanAskWave(BinStream, *size, high, low)) { + if (g_debugMode==2) prnt("DEBUG ASK: Clean Wave Detected - using clean wave demod"); errCnt = cleanAskRawDemod(BinStream, size, *clk, *invert, high, low); if (askType) //askman return manrawdecode(BinStream, size, 0); else //askraw return errCnt; } + if (g_debugMode==2) prnt("DEBUG ASK: Weak Wave Detected - using weak wave demod"); - int lastBit; //set first clock check - can go negative + 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 - size_t MaxBits = 1024; + 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 + size_t MaxBits = 3072; //max bits to collect lastBit = start - *clk; for (i = start; i < *size; ++i) { @@ -219,6 +350,7 @@ int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr BinStream[bitnum++] = *invert ^ 1; } else if (i-lastBit >= *clk+tol) { if (bitnum > 0) { + if (g_debugMode==2) prnt("DEBUG ASK: Modulation Error at: %u", i); BinStream[bitnum++]=7; errCnt++; } @@ -366,15 +498,14 @@ int gProxII_Demod(uint8_t BitStream[], size_t *size) //return start position return (int) startIdx; } - return -5; + return -5; //spacer bits not found - not a valid gproxII } -//translate wave to 11111100000 (1 for each short wave 0 for each long wave) +//translate wave to 11111100000 (1 for each short wave [higher freq] 0 for each long wave [lower freq]) 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 @@ -382,41 +513,47 @@ 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 - // Need to threshold first sample + //find start of modulating data in trace + idx = findModStart(dest, size, threshold_value, fchigh); - if(dest[0] < threshold_value) dest[0] = 0; + // Need to threshold first sample + 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 with anywhere + // 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 - for(idx = 1; idx < size; idx++) { + // (could also be fc/5 && fc/7 for fsk1 = 4-9) + for(; idx < size-20; idx++) { // threshold current value if (dest[idx] < threshold_value) dest[idx] = 0; else dest[idx] = 1; // Check for 0->1 transition - if (dest[idx-1] < dest[idx]) { // 0 -> 1 transition + if (dest[idx-1] < dest[idx]) { preLastSample = LastSample; LastSample = currSample; currSample = idx-last_transition; - if (currSample < (fclow-2)){ //0-5 = garbage noise + if (currSample < (fclow-2)) { //0-5 = garbage noise (or 0-3) //do nothing with extra garbage - } else if (currSample < (fchigh-1)) { //6-8 = 8 sample waves - if (LastSample > (fchigh-2) && (preLastSample < (fchigh-1) || preLastSample == 0 )){ - dest[numBits-1]=1; //correct last 9 wave surrounded by 8 waves + } 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))){ + dest[numBits-1]=1; } dest[numBits++]=1; - } else if (currSample > (fchigh) && !numBits) { //12 + and first bit = garbage - //do nothing with beginning garbage - } else if (currSample == (fclow+1) && LastSample == (fclow-1)) { // had a 7 then a 9 should be two 8's + } 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 + } else { //9+ = 10 sample waves (or 6+ = 7) dest[numBits++]=0; } last_transition = idx; @@ -426,6 +563,7 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow } //translate 11111100000 to 10 +//rfLen = clock, fchigh = larger field clock, fclow = smaller field clock size_t aggregate_bits(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t fchigh, uint8_t fclow) { @@ -435,31 +573,18 @@ 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 if (dest[idx-1]==1) { - if (!numBits) { - if (n < rfLen/fclow) { - n=0; - lastval = dest[idx]; - continue; - } - n = (n * fclow + rfLen/4) / rfLen; - } else { - n = (n * fclow + rfLen/2) / rfLen; - } + n = (n * fclow + rfLen/2) / rfLen; } else {// 0->1 crossing - //test first bitsample too small - if (!numBits && n < rfLen/fchigh) { - n=0; - lastval = dest[idx]; - continue; - } n = (n * fchigh + rfLen/2) / rfLen; } if (n == 0) n = 1; + //add to our destination the bits we collected memset(dest+numBits, dest[idx-1]^invert , n); numBits += n; n=0; @@ -477,6 +602,7 @@ size_t aggregate_bits(uint8_t *dest, size_t size, uint8_t rfLen, } return numBits; } + //by marshmellow (from holiman's base) // full fsk demod from GraphBuffer wave to decoded 1s and 0s (no mandemod) int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t fchigh, uint8_t fclow) @@ -551,28 +677,6 @@ int ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, ui return (int)startIdx; } -uint32_t bytebits_to_byte(uint8_t *src, size_t numbits) -{ - uint32_t num = 0; - for(int i = 0 ; i < numbits ; i++) - { - num = (num << 1) | (*src); - src++; - } - return num; -} - -//least significant bit first -uint32_t bytebits_to_byteLSBF(uint8_t *src, size_t numbits) -{ - uint32_t num = 0; - for(int i = 0 ; i < numbits ; i++) - { - num = (num << 1) | *(src + (numbits-(i+1))); - } - return num; -} - int IOdemodFSK(uint8_t *dest, size_t size) { if (justNoise(dest, size)) return -1; @@ -622,31 +726,17 @@ int VikingDemod_AM(uint8_t *dest, size_t *size) { return (int) startIdx; } -// by marshmellow -// takes a array of binary values, start position, length of bits per parity (includes parity bit), -// Parity Type (1 for odd; 0 for even; 2 Always 1's), and binary Length (length to run) -size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t pType, size_t bLen) -{ - uint32_t parityWd = 0; - size_t j = 0, bitCnt = 0; - 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]); - } - j--; // overwrite parity with next data - // if parity fails then return 0 - if (pType == 2) { // then marker bit which should be a 1 - if (!BitStream[j]) return 0; - } else { - if (parityTest(parityWd, pLen, pType) == 0) return 0; - } - bitCnt+=(pLen-1); - parityWd = 0; - } - // if we got here then all the parities passed - //return ID start index and size - return bitCnt; +// 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; + + 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 + //return start position + return (int) startIdx; } // Ask/Biphase Demod then try to locate an ISO 11784/85 ID @@ -686,7 +776,7 @@ int AWIDdemodFSK(uint8_t *dest, size_t *size) } // by marshmellow -// FSK Demod then try to locate an Farpointe Data (pyramid) ID +// FSK Demod then try to locate a Farpointe Data (pyramid) ID int PyramiddemodFSK(uint8_t *dest, size_t *size) { //make sure buffer has data @@ -707,45 +797,34 @@ int PyramiddemodFSK(uint8_t *dest, size_t *size) return (int)startIdx; } -/* -void dummy(char *fmt, ...){} - -#ifndef ON_DEVICE -#include "ui.h" -#define prnt PrintAndLog -#else - -#define prnt dummy -#endif -*/ // 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; + bool allArePeaks = true; uint16_t cntPeaks=0; size_t loopEnd = 512+160; if (loopEnd > size) loopEnd = size; for (size_t i=160; ilow && dest[i] 300) return 1; + if (!allArePeaks){ + if (cntPeaks > 300) return true; } - return allPeaks; + return allArePeaks; } // 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}; size_t startwave; size_t i = 100; size_t minClk = 255; + int shortestWaveIdx = 0; // get to first full low to prime loop and skip incomplete first pulse while ((dest[i] < high) && (i < size)) ++i; @@ -757,20 +836,24 @@ int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low) // measure from low to low while ((dest[i] > low) && (i < size)) ++i; - startwave= 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) + if (i-startwave < minClk && i < size) { minClk = i - startwave; + shortestWaveIdx = startwave; + } } // set clock - //prnt("minClk: %d",minClk); + 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 >= fndClk[clkCnt]-(fndClk[clkCnt]/8) && minClk <= fndClk[clkCnt]+1) { + *clock = fndClk[clkCnt]; + return shortestWaveIdx; + } } return 0; } @@ -800,14 +883,10 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr) //test for large clean peaks 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] - } + 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 position } } } @@ -852,7 +931,7 @@ 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 - //prnt("DEBUG: clk %d, err %d, ii %d, i %d",clk[clkCnt],errCnt,ii,i); + 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; @@ -874,17 +953,22 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr) best = iii; } } + if (g_debugMode == 2) prnt("DEBUG ASK: clk %d, # Errors %d, Current Best Clk %d, bestStart %d",clk[iii],bestErr[iii],clk[best],bestStart[best]); } - //if (bestErr[best] > maxErr) return -1; if (!clockFnd) *clock = clk[best]; return bestStart[best]; } + +int DetectPSKClock(uint8_t dest[], size_t size, int clock) { + int firstPhaseShift = 0; + return DetectPSKClock_ext(dest, size, clock, &firstPhaseShift); +} + //by marshmellow //detect psk clock by reading each phase shift // a phase shift is determined by measuring the sample length of each wave -int DetectPSKClock(uint8_t dest[], size_t size, int clock) -{ +int DetectPSKClock_ext(uint8_t dest[], size_t size, int clock, int *firstPhaseShift) { uint8_t clk[]={255,16,32,40,50,64,100,128,255}; //255 is not a valid clock uint16_t loopCnt = 4096; //don't need to loop through entire array... if (size == 0) return 0; @@ -902,7 +986,7 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock) uint16_t peaksdet[]={0,0,0,0,0,0,0,0,0}; fc = countFC(dest, size, 0); if (fc!=2 && fc!=4 && fc!=8) return -1; - //prnt("DEBUG: FC: %d",fc); + if (g_debugMode==2) prnt("DEBUG PSK: FC: %d",fc); //find first full wave for (i=160; i= 1 ; clkCnt--){ lastClkBit = firstFullWave; //set end of wave as clock align waveStart = 0; errCnt=0; peakcnt=0; - //prnt("DEBUG: clk: %d, lastClkBit: %d",clk[clkCnt],lastClkBit); + if (g_debugMode == 2) prnt("DEBUG PSK: clk: %d, lastClkBit: %d",clk[clkCnt],lastClkBit); for (i = firstFullWave+fullWaveLen-1; i < loopCnt-2; i++){ //top edge of wave = start of new wave @@ -944,7 +1028,7 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock) waveLenCnt = waveEnd-waveStart; if (waveLenCnt > fc){ //if this wave is a phase shift - //prnt("DEBUG: phase shift at: %d, len: %d, nextClk: %d, ii: %d, fc: %d",waveStart,waveLenCnt,lastClkBit+clk[clkCnt]-tol,ii+1,fc); + if (g_debugMode == 2) prnt("DEBUG PSK: phase shift at: %d, len: %d, nextClk: %d, i: %d, fc: %d",waveStart,waveLenCnt,lastClkBit+clk[clkCnt]-tol,i+1,fc); if (i+1 >= lastClkBit + clk[clkCnt] - tol){ //should be a clock bit peakcnt++; lastClkBit+=clk[clkCnt]; @@ -973,7 +1057,7 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock) if (peaksdet[i] > peaksdet[best]) { best = i; } - //prnt("DEBUG: Clk: %d, peaks: %d, errs: %d, bestClk: %d",clk[iii],peaksdet[iii],bestErr[iii],clk[best]); + 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]; } @@ -983,26 +1067,15 @@ int DetectStrongNRZClk(uint8_t *dest, size_t size, int peak, int low){ size_t i = 0; size_t transition1 = 0; int lowestTransition = 255; - uint8_t lastWasHigh=0; - //find first valid beginning of a high/low wave - if (dest[i] >= peak) { - for (; i < size; i++) { - if (dest[i] <= low) break; - } - lastWasHigh=0; - } else if (dest[i] <= low) { - for (; i < size; i++) { - if (dest[i] >= peak) break; - } - lastWasHigh=1; - } else { - for (; i < size; i++) { - if (dest[i] >= peak || dest[i] <= low) { - lastWasHigh = (dest[i] >= peak); - break; - } - } - } + bool lastWasHigh = false; + + //find first valid beginning of a high or low wave + while ((dest[i] >= peak || dest[i] <= low) && (i < size)) + ++i; + while ((dest[i] < peak && dest[i] > low) && (i < size)) + ++i; + lastWasHigh = (dest[i] >= peak); + if (i==size) return 0; transition1 = i; @@ -1014,13 +1087,19 @@ int DetectStrongNRZClk(uint8_t *dest, size_t size, int peak, int low){ } } if (lowestTransition == 255) lowestTransition = 0; + if (g_debugMode==2) prnt("DEBUG NRZ: detectstrongNRZclk smallest wave: %d",lowestTransition); return lowestTransition; } +int DetectNRZClock(uint8_t dest[], size_t size, int clock) { + size_t 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) -{ +int DetectNRZClock_ext(uint8_t dest[], size_t size, int clock, size_t *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... @@ -1035,7 +1114,6 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) if (getHiLo(dest, loopCnt, &peak, &low, 75, 75) < 1) return 0; int lowestTransition = DetectStrongNRZClk(dest, size-20, peak, low); - //prnt("DEBUG: peak: %d, low: %d",peak,low); size_t ii; uint8_t clkCnt; uint8_t tol = 0; @@ -1043,14 +1121,14 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) int16_t peakcnt = 0; int16_t peaksdet[] = {0,0,0,0,0,0,0,0}; uint16_t maxPeak = 255; - uint8_t firstpeak = 0; + bool firstpeak = false; //test for large clipped waves for (i=0; i= peak || dest[i] <= low){ if (!firstpeak) continue; smplCnt++; } else { - firstpeak=1; + firstpeak=true; if (smplCnt > 6 ){ if (maxPeak > smplCnt){ maxPeak = smplCnt; @@ -1062,8 +1140,13 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) } } } - uint8_t samePeak=0; - uint8_t errBitHigh=0; + bool errBitHigh = 0; + bool bitHigh = 0; + uint8_t ignoreCnt = 0; + uint8_t ignoreWindow = 4; + bool lastPeakHigh = 0; + int lastBit = 0; + size_t 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){ @@ -1072,45 +1155,45 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) //try lining up the peaks by moving starting point (try first 256) for (ii=20; ii < loopCnt; ++ii){ if ((dest[ii] >= peak) || (dest[ii] <= low)){ - peakcnt=0; - uint8_t bitHigh =0; - uint8_t ignoreCnt = 0; - uint8_t ignoreWindow = 4; - int lastBit = ii-clk[clkCnt]; + peakcnt = 0; + bitHigh = false; + ignoreCnt = 0; + lastBit = ii-clk[clkCnt]; //loop through to see if this start location works for (i = ii; i < size-20; ++i) { - // if we are at a clock bit + //if we are at a clock bit if ((i >= lastBit + clk[clkCnt] - tol) && (i <= lastBit + clk[clkCnt] + tol)) { //test high/low if (dest[i] >= peak || dest[i] <= low) { - if (samePeak) peakcnt--; - bitHigh=1; - peakcnt++; - errBitHigh = 0; + //if same peak don't count it + if ((dest[i] >= peak && !lastPeakHigh) || (dest[i] <= low && lastPeakHigh)) { + peakcnt++; + } + lastPeakHigh = (dest[i] >= peak); + bitHigh = true; + errBitHigh = false; ignoreCnt = ignoreWindow; lastBit += clk[clkCnt]; - samePeak = 1; } else if (i == lastBit + clk[clkCnt] + tol) { lastBit += clk[clkCnt]; - samePeak = 0; } //else if not a clock bit and no peaks } else if (dest[i] < peak && dest[i] > low){ - samePeak = 0; if (ignoreCnt==0){ - bitHigh=0; - if (errBitHigh==1) peakcnt--; - errBitHigh=0; + bitHigh=false; + if (errBitHigh==true) peakcnt--; + errBitHigh=false; } else { ignoreCnt--; } // else if not a clock bit but we have a peak - } else if ((dest[i]>=peak || dest[i]<=low) && (bitHigh==0)) { + } else if ((dest[i]>=peak || dest[i]<=low) && (!bitHigh)) { //error bar found no clock... - errBitHigh=1; + errBitHigh=true; } } if(peakcnt>peaksdet[clkCnt]) { + bestStart[clkCnt]=ii; peaksdet[clkCnt]=peakcnt; } } @@ -1119,16 +1202,16 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) int iii=7; uint8_t best=0; for (iii=7; iii > 0; iii--){ - if (peaksdet[iii] > peaksdet[best]){ - best = iii; - } else if (peaksdet[iii] == peaksdet[best] && lowestTransition){ - if (clk[iii] > (lowestTransition - (clk[iii]/8)) && clk[iii] < (lowestTransition + (clk[iii]/8))){ + 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; } - //prnt("DEBUG: 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[iii],peaksdet[iii],maxPeak, clk[best], lowestTransition); } - + *clockStartIdx = bestStart[best]; return clk[best]; } @@ -1188,7 +1271,7 @@ int indala26decode(uint8_t *bitStream, size_t *size, uint8_t *invert) return (int) startidx; } -// by marshmellow - demodulate NRZ wave +// by marshmellow - demodulate NRZ wave - requires a read with strong signal // peaks invert bit (high=1 low=0) each clock cycle = 1 bit determined by last peak int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert){ if (justNoise(dest, *size)) return -1; @@ -1221,10 +1304,14 @@ int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert){ return 0; } +uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fcLow) { + int firstClockEdge = 0; + return detectFSKClk_ext(BitStream, size, fcHigh, fcLow, &firstClockEdge); +} + //by marshmellow //detects the bit clock for FSK given the high and low Field Clocks -uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fcLow) -{ +uint8_t detectFSKClk_ext(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fcLow, int *firstClockEdge) { uint8_t clk[] = {8,16,32,40,50,64,100,128,0}; uint16_t rfLens[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; uint8_t rfCnts[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; @@ -1236,18 +1323,18 @@ uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fc size_t i; if (size == 0) return 0; - uint8_t fcTol = (uint8_t)(0.5+(float)(fcHigh-fcLow)/2); + uint8_t fcTol = ((fcHigh*100 - fcLow*100)/2 + 50)/100; //(uint8_t)(0.5+(float)(fcHigh-fcLow)/2); rfLensFnd=0; fcCounter=0; rfCounter=0; firstBitFnd=0; //PrintAndLog("DEBUG: fcTol: %d",fcTol); - // prime i to first up transition - for (i = 1; i < size-1; i++) + // prime i to first peak / up transition + for (i = 160; i < size-20; i++) if (BitStream[i] > BitStream[i-1] && BitStream[i]>=BitStream[i+1]) break; - for (; i < size-1; i++){ + for (; i < size-20; i++){ fcCounter++; rfCounter++; @@ -1255,7 +1342,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; @@ -1265,7 +1355,7 @@ uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fc //not the same size as the last wave - start of new bit sequence if (firstBitFnd > 1){ //skip first wave change - probably not a complete bit for (int ii=0; ii<15; ii++){ - if (rfLens[ii] == rfCounter){ + if (rfLens[ii] >= (rfCounter-4) && rfLens[ii] <= (rfCounter+4)){ rfCnts[ii]++; rfCounter = 0; break; @@ -1277,6 +1367,7 @@ uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fc rfLens[rfLensFnd++] = rfCounter; } } else { + *firstClockEdge = i; firstBitFnd++; } rfCounter=0; @@ -1287,7 +1378,6 @@ uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fc uint8_t rfHighest=15, rfHighest2=15, rfHighest3=15; for (i=0; i<15; i++){ - //PrintAndLog("DEBUG: RF %d, cnts %d",rfLens[i], rfCnts[i]); //get highest 2 RF values (might need to get more values to compare or compare all?) if (rfCnts[i]>rfCnts[rfHighest]){ rfHighest3=rfHighest2; @@ -1299,27 +1389,30 @@ uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fc } else if(rfCnts[i]>rfCnts[rfHighest3]){ rfHighest3=i; } + if (g_debugMode==2) prnt("DEBUG FSK: RF %d, cnts %d",rfLens[i], rfCnts[i]); } // set allowed clock remainder tolerance to be 1 large field clock length+1 // we could have mistakenly made a 9 a 10 instead of an 8 or visa versa so rfLens could be 1 FC off uint8_t tol1 = fcHigh+1; - //PrintAndLog("DEBUG: hightest: 1 %d, 2 %d, 3 %d",rfLens[rfHighest],rfLens[rfHighest2],rfLens[rfHighest3]); + if (g_debugMode==2) prnt("DEBUG FSK: most counted rf values: 1 %d, 2 %d, 3 %d",rfLens[rfHighest],rfLens[rfHighest2],rfLens[rfHighest3]); // loop to find the highest clock that has a remainder less than the tolerance // compare samples counted divided by + // test 128 down to 32 (shouldn't be possible to have fc/10 & fc/8 and rf/16 or less) int ii=7; - for (; ii>=0; ii--){ + for (; ii>=2; ii--){ if (rfLens[rfHighest] % clk[ii] < tol1 || rfLens[rfHighest] % clk[ii] > clk[ii]-tol1){ if (rfLens[rfHighest2] % clk[ii] < tol1 || rfLens[rfHighest2] % clk[ii] > clk[ii]-tol1){ if (rfLens[rfHighest3] % clk[ii] < tol1 || rfLens[rfHighest3] % clk[ii] > clk[ii]-tol1){ + if (g_debugMode==2) prnt("DEBUG FSK: clk %d divides into the 3 most rf values within tolerance",clk[ii]); break; } } } } - if (ii<0) return 0; // oops we went too far + if (ii<2) return 0; // oops we went too far return clk[ii]; } @@ -1330,20 +1423,20 @@ uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fc //mainly used for FSK field clock detection 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}; - uint16_t fcCnts[] = {0,0,0,0,0,0,0,0,0,0}; + 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 = 1; i < size-1; i++) + for (i = 160; i < size-20; i++) if (BitStream[i] > BitStream[i-1] && BitStream[i] >= BitStream[i+1]) break; - for (; i < size-1; i++){ + for (; i < size-20; i++){ if (BitStream[i] > BitStream[i-1] && BitStream[i] >= BitStream[i+1]){ // new up transition fcCounter++; @@ -1356,14 +1449,14 @@ uint16_t countFC(uint8_t *BitStream, size_t size, uint8_t fskAdj) lastFCcnt = fcCounter; } // find which fcLens to save it to: - for (int ii=0; ii<10; ii++){ + for (int ii=0; ii<15; ii++){ if (fcLens[ii]==fcCounter){ fcCnts[ii]++; fcCounter=0; break; } } - if (fcCounter>0 && fcLensFnd<10){ + if (fcCounter>0 && fcLensFnd<15){ //add new fc length fcCnts[fcLensFnd]++; fcLens[fcLensFnd++]=fcCounter; @@ -1375,11 +1468,10 @@ uint16_t countFC(uint8_t *BitStream, size_t size, uint8_t fskAdj) } } - uint8_t best1=9, best2=9, best3=9; + uint8_t best1=14, best2=14, best3=14; uint16_t maxCnt1=0; // go through fclens and find which ones are bigest 2 - for (i=0; i<10; i++){ - // PrintAndLog("DEBUG: FC %d, Cnt %d, Errs %d",fcLens[i],fcCnts[i],errCnt); + for (i=0; i<15; i++){ // get the 3 best FC values if (fcCnts[i]>maxCnt1) { best3=best2; @@ -1392,7 +1484,9 @@ uint16_t countFC(uint8_t *BitStream, size_t size, uint8_t fskAdj) } else if(fcCnts[i]>fcCnts[best3]){ best3=i; } + if (g_debugMode==2) prnt("DEBUG countfc: FC %u, Cnt %u, best fc: %u, best2 fc: %u",fcLens[i],fcCnts[i],fcLens[best1],fcLens[best2]); } + if (fcLens[best1]==0) return 0; uint8_t fcH=0, fcL=0; if (fcLens[best1]>fcLens[best2]){ fcH=fcLens[best1]; @@ -1401,11 +1495,13 @@ uint16_t countFC(uint8_t *BitStream, size_t size, uint8_t fskAdj) fcH=fcLens[best2]; fcL=fcLens[best1]; } - + if ((size-180)/fcH/3 > fcCnts[best1]+fcCnts[best2]) { + if (g_debugMode==2) prnt("DEBUG countfc: fc is too large: %u > %u. Not psk or fsk",(size-180)/fcH/3,fcCnts[best1]+fcCnts[best2]); + return 0; //lots of waves not psk or fsk + } // TODO: take top 3 answers and compare to known Field clocks to get top 2 uint16_t fcs = (((uint16_t)fcH)<<8) | fcL; - // PrintAndLog("DEBUG: Best %d best2 %d best3 %d",fcLens[best1],fcLens[best2],fcLens[best3]); if (fskAdj) return fcs; return fcLens[best1]; } @@ -1420,27 +1516,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); *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; @@ -1460,8 +1566,8 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert) numBits += (firstFullWave / *clock); //set start of wave as clock align lastClkBit = firstFullWave; - //PrintAndLog("DEBUG: firstFullWave: %d, waveLen: %d",firstFullWave,fullWaveLen); - //PrintAndLog("DEBUG: clk: %d, lastClkBit: %d", *clock, lastClkBit); + if (g_debugMode==2) prnt("DEBUG PSK: firstFullWave: %u, waveLen: %u",firstFullWave,fullWaveLen); + 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++){ @@ -1492,6 +1598,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; @@ -1502,3 +1611,211 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert) *size = numBits; 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_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}; + int clk = 0; + int tol = 0; + int i, j, skip, start, end, low, high, minClk, waveStart; + bool complete = false; + 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)); + + if ( getHiLo(buffer, testsize, &high, &low, 80, 80) == -1 ) { + if (g_debugMode==2) prnt("DEBUG STT: just noise detected - quitting"); + return false; //just noise + } + i = 0; + j = 0; + minClk = 255; + // get to first full low to prime loop and skip incomplete first pulse + while ((buffer[i] < high) && (i < bufsize)) + ++i; + while ((buffer[i] > low) && (i < bufsize)) + ++i; + skip = i; + + // populate tmpbuff buffer with pulse lengths + while (i < bufsize) { + // measure from low to low + while ((buffer[i] > low) && (i < bufsize)) + ++i; + start= i; + while ((buffer[i] < high) && (i < bufsize)) + ++i; + //first high point for this wave + waveStart = i; + while ((buffer[i] > low) && (i < bufsize)) + ++i; + if (j >= (bufsize/32)) { + break; + } + waveLen[j] = i - waveStart; //first high to first low + tmpbuff[j++] = i - start; + if (i-start < minClk && i < bufsize) { + minClk = i - start; + } + } + // set clock - might be able to get this externally and remove this work... + if (!clk) { + for (uint8_t clkCnt = 0; clkCnt<7; clkCnt++) { + tol = fndClk[clkCnt]/8; + if (minClk >= fndClk[clkCnt]-tol && minClk <= fndClk[clkCnt]+1) { + clk=fndClk[clkCnt]; + break; + } + } + // clock not found - ERROR + if (!clk) { + if (g_debugMode==2) prnt("DEBUG STT: clock not found - quitting"); + return false; + } + } else tol = clk/8; + + *foundclock = clk; + + // look for Sequence Terminator - should be pulses of clk*(1 or 1.5), clk*2, clk*(1.5 or 2) + start = -1; + for (i = 0; i < j - 4; ++i) { + skip += tmpbuff[i]; + 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 + start = i + 3; + break; + } + } + } + } + } + // first ST not found - ERROR + 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; + else + phaseoff = clk/2; + + // skip over the remainder of ST + skip += clk*7/2; //3.5 clocks from tmpbuff[i] = end of st - also aligns for ending point + + // now do it again to find the end + end = skip; + for (i += 3; i < j - 4; ++i) { + end += tmpbuff[i]; + 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 + complete = true; + break; + } + } + } + } + } + end -= phaseoff; + //didn't find second ST - ERROR + if (!complete) { + if (g_debugMode==2) prnt("DEBUG STT: second STT not found - quitting"); + return false; + } + if (g_debugMode==2) prnt("DEBUG STT: start of data: %d end of data: %d, datalen: %d, clk: %d, bits: %d, phaseoff: %d", skip, end, end-skip, clk, (end-skip)/clk, phaseoff); + //now begin to trim out ST so we can use normal demod cmds + 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 ( 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; + } + // if datalen is less than one t55xx block - ERROR + if (datalen/clk < 8*4) { + if (g_debugMode==2) prnt("DEBUG STT: datalen is less than 1 full t55xx block - quitting"); + 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) + if (buffer[dataloc]low && buffer[dataloc+3]low) { + 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