Client code cleanup:

[proxmark3-svn] / common / lfdemod.c

diff --git a/common/lfdemod.c b/common/lfdemod.c
index c66f3e04cf0dd835ab748de21baedd0a00612ed8..3f597a1ff053cd69fdb1669f39a8966dda2ab0cb 100644 (file)
--- a/common/lfdemod.c
+++ b/common/lfdemod.c
@@ -78,7 +78,7 @@ size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t p
                        parityWd = (parityWd << 1) | BitStream[startIdx+word+bit];
                        BitStream[j++] = (BitStream[startIdx+word+bit]);
                }
                        parityWd = (parityWd << 1) | BitStream[startIdx+word+bit];
                        BitStream[j++] = (BitStream[startIdx+word+bit]);
                }

-               if (word+pLen >= bLen) break;
+               if (word+pLen > bLen) break;

 
                j--; // overwrite parity with next data
                // if parity fails then return 0
 
                j--; // overwrite parity with next data
                // if parity fails then return 0


@@ -150,63 +150,89 @@ uint32_t bytebits_to_byteLSBF(uint8_t *src, size_t numbits)
 //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)
 {
 //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)
 {

+       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.
        // 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){
+       uint8_t foundCnt = 0;
+       for (size_t idx = 0; idx < *size - pLen; idx++) {
+               if (memcmp(BitStream+idx, preamble, pLen) == 0) {

                        //first index found
                        foundCnt++;
                        //first index found
                        foundCnt++;

-                       if (foundCnt == 1){
+                       if (foundCnt == 1) {
+                               if (g_debugMode) prnt("DEBUG: preamble found at %u", idx);

                                *startIdx = idx;
                                *startIdx = idx;

-                       }
-                       if (foundCnt == 2){
+                               if (findone) return true;
+                       } else if (foundCnt == 2) {

                                *size = idx - *startIdx;
                                *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)
 {
 }
 
 //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};
        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 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);
        *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<FmtLen; i++){ //loop through 10 or 22 sets of 5 bits (50-10p = 40 bits or 88 bits)
-               parityBits = bytebits_to_byte(BitStream+(i*5)+idx,5);
-               //check even parity - quit if failed
-               if (parityTest(parityBits, 5, 0) == 0) return 0;
-               //set uint64 with ID from BitStream
-               for (uint8_t ii=0; ii<4; ii++){
-                       *hi = (*hi << 1) | (*lo >> 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
 }
 
 //by marshmellow


@@ -262,6 +288,7 @@ int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int
 }
 
 //by marshmellow
 }
 
 //by marshmellow

+//amplify based on ask edge detection

 void askAmp(uint8_t *BitStream, size_t size)
 {
        uint8_t Last = 128;
 void askAmp(uint8_t *BitStream, size_t size)
 {
        uint8_t Last = 128;


@@ -479,7 +506,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;
 {
        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
        if (fchigh==0) fchigh=10;
        if (fclow==0) fclow=8;
        //set the threshold close to 0 (graph) or 128 std to avoid static


@@ -489,28 +515,8 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow
        size_t currSample = 0;
        if ( size < 1024 ) return 0; // not enough samples
 
        size_t currSample = 0;
        if ( size < 1024 ) return 0; // not enough samples
 

-       // jump to modulating data by finding the first 4 threshold crossings (or first 2 waves)
-       // in case you have junk or noise at the beginning of the trace...
-       uint8_t thresholdCnt = 0;
-       size_t waveSizeCnt = 0;
-       bool isAboveThreshold = dest[idx++] >= threshold_value;
-       for (; idx < size-20; idx++ ) {
-               if(dest[idx] < threshold_value && isAboveThreshold) {
-                       thresholdCnt++;
-                       if (thresholdCnt > 2 && waveSizeCnt < fchigh+1) break;                  
-                       isAboveThreshold = false;
-                       waveSizeCnt = 0;
-               } else if (dest[idx] >= threshold_value && !isAboveThreshold) {
-                       thresholdCnt++;
-                       if (thresholdCnt > 2 && waveSizeCnt < fchigh+1) break;                  
-                       isAboveThreshold = true;
-                       waveSizeCnt = 0;
-               } else {
-                       waveSizeCnt++;
-               }
-               if (thresholdCnt > 10) break;
-       }
-       if (g_debugMode == 2) prnt("threshold Count reached at %u",idx);
+       //find start of modulating data in trace 
+       idx = findModStart(dest, size, threshold_value, fchigh);

 
        // Need to threshold first sample
        if(dest[idx] < threshold_value) dest[0] = 0;
 
        // Need to threshold first sample
        if(dest[idx] < threshold_value) dest[0] = 0;


@@ -1321,7 +1327,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
                        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;
                        fcCounter = fcLow;
                else //set it to the large fc
                        fcCounter = fcHigh;


@@ -1387,7 +1396,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];
 }
 
        return clk[ii];
 }


@@ -1492,42 +1501,26 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert)
        size_t numBits=0;
        uint8_t curPhase = *invert;
        size_t i=0, waveStart=1, waveEnd=0, firstFullWave=0, lastClkBit=0;
        size_t numBits=0;
        uint8_t curPhase = *invert;
        size_t i=0, 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);
+       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;
        if (fc!=2 && fc!=4 && fc!=8) return -1;
        //PrintAndLog("DEBUG: FC: %d",fc);
        *clock = DetectPSKClock(dest, *size, *clock);
        if (*clock == 0) return -1;

-       // jump to modulating data by finding the first 2 threshold crossings (or first 1 waves)
-       // in case you have junk or noise at the beginning of the trace...
-       uint8_t thresholdCnt = 0;
-       size_t waveSizeCnt = 0;
-       uint8_t threshold_value = 123; //-5
-       bool isAboveThreshold = dest[i++] >= threshold_value;
-       for (; i < *size-20; i++ ) {
-               if(dest[i] < threshold_value && isAboveThreshold) {
-                       thresholdCnt++;
-                       if (thresholdCnt > 2 && waveSizeCnt < fc+1) break;                      
-                       isAboveThreshold = false;
-                       waveSizeCnt = 0;
-               } else if (dest[i] >= threshold_value && !isAboveThreshold) {
-                       thresholdCnt++;
-                       if (thresholdCnt > 2 && waveSizeCnt < fc+1) break;                      
-                       isAboveThreshold = true;
-                       waveSizeCnt = 0;
-               } else {
-                       waveSizeCnt++;
-               }
-               if (thresholdCnt > 10) break;
-       }
-       if (g_debugMode == 2) prnt("DEBUG PSK: threshold Count reached at %u, count: %u",i, thresholdCnt);

 
 

+       //find start of modulating data in trace 
+       uint8_t threshold_value = 123; //-5
+       i = findModStart(dest, *size, threshold_value, fc);

 
 

-       int avgWaveVal=0, lastAvgWaveVal=0;
-       waveStart = i+1;

        //find first phase shift
        //find first phase shift

-       for (; i<loopCnt; i++){
+       int avgWaveVal=0, lastAvgWaveVal=0;
+       waveStart = i;
+       for (; i<loopCnt; i++) {
+               // find peak 

                if (dest[i]+fc < dest[i+1] && dest[i+1] >= dest[i+2]){
                        waveEnd = i+1;
                        if (g_debugMode == 2) prnt("DEBUG PSK: waveEnd: %u, waveStart: %u",waveEnd, waveStart);
                if (dest[i]+fc < dest[i+1] && dest[i+1] >= dest[i+2]){
                        waveEnd = i+1;
                        if (g_debugMode == 2) prnt("DEBUG PSK: waveEnd: %u, waveStart: %u",waveEnd, waveStart);


@@ -1536,8 +1529,8 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert)
                                lastAvgWaveVal = avgWaveVal/(waveLenCnt);
                                firstFullWave = waveStart;
                                fullWaveLen=waveLenCnt;
                                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 > threshold_value) 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;
                                break;
                        } 
                        waveStart = i+1;


@@ -1558,7 +1551,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);  
        //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++){
        waveStart = 0;
        dest[numBits++] = curPhase; //set first read bit
        for (i = firstFullWave + fullWaveLen - 1; i < *size-3; i++){


@@ -1589,6 +1582,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 (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;
                                }
                                avgWaveVal = 0;
                                waveStart = i+1;


@@ -1600,9 +1596,14 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert)
        return errCnt;
 }
 
        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
 //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};
        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};


@@ -1755,7 +1756,7 @@ bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) {
        size_t newloc = 0;
        i=0;
        if (g_debugMode==2) prnt("DEBUG STT: Starting STT trim - start: %d, datalen: %d ",dataloc, datalen);            
        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)
        // 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)


@@ -1763,6 +1764,15 @@ bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) {
                        for(i=0; i < clk/2-tol; ++i) {
                                buffer[dataloc+i] = high+5;
                        }
                        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<datalen; ++i) {
                        if (i+newloc < bufsize) {
                }
                for (i=0; i<datalen; ++i) {
                        if (i+newloc < bufsize) {