cleanup

combine preamble searches (thanks @iceman1001)
simplify Em410xDecode
fix bug in removeParity (I made recently)
move Unique TAG ID printout to avoid confusion

diff --git a/client/cmddata.c b/client/cmddata.c
index 2db1f8eb11d495e50c419ca2e58deb85067bc60b..f7addc535064b60fd95de7a4f63805a7ac6355b3 100644 (file)
--- a/client/cmddata.c
+++ b/client/cmddata.c
@@ -175,8 +175,8 @@ void printEM410x(uint32_t hi, uint64_t id)
                } else{
                        //output 40 bit em id
                        PrintAndLog("\nEM TAG ID      : %010llX", id);
-                       PrintAndLog("Unique TAG ID  : %010llX",  id2lo);
                        PrintAndLog("\nPossible de-scramble patterns");
+                       PrintAndLog("Unique TAG ID  : %010llX",  id2lo);
                        PrintAndLog("HoneyWell IdentKey {");
                        PrintAndLog("DEZ 8          : %08lld",id & 0xFFFFFF);
                        PrintAndLog("DEZ 10         : %010lld",id & 0xFFFFFFFF);

diff --git a/client/cmdlfem4x.c b/client/cmdlfem4x.c
index 0788b13852a2d17592382267403fda4efdd25703..c26b4f392b7b04f2392c0ca3af704bfd7a1ad502 100644 (file)
--- a/client/cmdlfem4x.c
+++ b/client/cmdlfem4x.c
@@ -540,7 +540,7 @@ bool EM4x05testDemodReadData(uint32_t *word, bool readCmd) {
        // sanity check
        size = (size > DemodBufferLen) ? DemodBufferLen : size;
        // test preamble
-       if ( !onePreambleSearch(DemodBuffer, preamble, sizeof(preamble), size, &startIdx) ) {
+       if ( !preambleSearchEx(DemodBuffer, preamble, sizeof(preamble), &size, &startIdx, true) ) {
                if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305 preamble not found :: %d", startIdx);
                return false;
        }
@@ -550,13 +550,13 @@ bool EM4x05testDemodReadData(uint32_t *word, bool readCmd) {
                        if (g_debugMode) PrintAndLog("DEBUG: Error - End Parity check failed");
                        return false;
                }
-               // test for even parity bits.
-               if ( removeParity(DemodBuffer, startIdx + sizeof(preamble),9,0,44) == 0 ) {             
+               // test for even parity bits and remove them. (leave out the end row of parities so 36 bits)
+               if ( removeParity(DemodBuffer, startIdx + sizeof(preamble),9,0,36) == 0 ) {             
                        if (g_debugMode) PrintAndLog("DEBUG: Error - Parity not detected");
                        return false;
                }
 
-               setDemodBuf(DemodBuffer, 40, 0);
+               setDemodBuf(DemodBuffer, 32, 0);
                *word = bytebits_to_byteLSBF(DemodBuffer, 32);
        }
        return true;

diff --git a/common/lfdemod.c b/common/lfdemod.c
index e9f19311c8b6c248d0ffcdabd1b4e1bc3c04f1c9..e1fcbf736ed4ffd5d6ed73e916d04271eba06415 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]);
                }
-               if (word+pLen >= bLen) break;
+               if (word+pLen > bLen) break;
 
                j--; // overwrite parity with next data
                // if parity fails then return 0
@@ -150,40 +150,30 @@ 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)
 {
+       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 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++;
-                       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;
-}
-
-// search for given preamble in given BitStream and return success=1 or fail=0 and startIndex (where it was found)
-// does not look for a repeating preamble
-// em4x05/4x69 only sends preamble once, so look for it once in the first pLen bits
-// leave it generic so it could be reused later...
-bool onePreambleSearch(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t size, size_t *startIdx) {
-       // Sanity check.  If preamble length is bigger than bitstream length.
-       if ( size <= pLen ) return false;
-       for (size_t idx = 0; idx < size - pLen; idx++) {
-               if (memcmp(BitStream+idx, preamble, pLen) == 0) {
-                       if (g_debugMode) prnt("DEBUG: preamble found at %u", idx);
-                       *startIdx = idx;
-                       return true;
-               }
-       }
        return false;
 }
 
@@ -217,39 +207,32 @@ size_t findModStart(uint8_t dest[], size_t size, uint8_t threshold_value, uint8_
 //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<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 (*size == 110) 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

diff --git a/common/lfdemod.h b/common/lfdemod.h
index 9c5c83fbf42d27b1c624ea136f56594632ddbc2b..a77eb604965fbd01e926b8cc9f3b72aaad3be386 100644 (file)
--- a/common/lfdemod.h
+++ b/common/lfdemod.h
@@ -39,7 +39,7 @@ int      manrawdecode(uint8_t *BitStream, size_t *size, uint8_t invert);
 int      nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert);
 uint8_t  parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType);
 uint8_t  preambleSearch(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t *size, size_t *startIdx);
-bool     onePreambleSearch(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t size, size_t *startIdx);
+bool     preambleSearchEx(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t *size, size_t *startIdx, bool findone);
 int      pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert);
 void     psk2TOpsk1(uint8_t *BitStream, size_t size);
 void     psk1TOpsk2(uint8_t *BitStream, size_t size);