ADD: @piwi's changes to .gitignore.

[proxmark3-svn] / common / lfdemod.c

diff --git a/common/lfdemod.c b/common/lfdemod.c
index 2c65014409eebcb09ca22ea6a85d79f9649b179f..9a4051c9b125a29bc7baabf1a82d2d4b1e37de73 100644 (file)
--- a/common/lfdemod.c
+++ b/common/lfdemod.c
@@ -282,6 +282,16 @@ int manrawdecode(uint8_t * BitStream, size_t *size, uint8_t invert)
        return bestErr;
 }
 
+uint32_t manchesterEncode2Bytes(uint16_t datain) {
+       uint32_t output = 0;
+       uint8_t curBit = 0;
+       for (uint8_t i=0; i<16; i++) {
+               curBit = (datain >> (15-i) & 1);
+               output |= (1<<(((15-i)*2)+curBit));
+       }
+       return output;
+}
+
 //by marshmellow
 //encode binary data into binary manchester 
 int ManchesterEncode(uint8_t *BitStream, size_t size)
@@ -369,7 +379,9 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow
        if (fclow==0) fclow=8;
        //set the threshold close to 0 (graph) or 128 std to avoid static
        uint8_t threshold_value = 123; 
-
+       size_t preLastSample = 0;
+       size_t LastSample = 0;
+       size_t currSample = 0;
        // sync to first lo-hi transition, and threshold
 
        // Need to threshold first sample
@@ -389,13 +401,22 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow
 
                // Check for 0->1 transition
                if (dest[idx-1] < dest[idx]) { // 0 -> 1 transition
-                       if ((idx-last_transition)<(fclow-2)){            //0-5 = garbage noise
+                       preLastSample = LastSample;
+                       LastSample = currSample;
+                       currSample = idx-last_transition;
+                       if (currSample < (fclow-2)){            //0-5 = garbage noise
                                //do nothing with extra garbage
-                       } else if ((idx-last_transition) < (fchigh-1)) { //6-8 = 8 waves
+                       } else if (currSample < (fchigh-1)) { //6-8 = 8 sample waves
+                               if (LastSample > (fchigh-2) && preLastSample < (fchigh-1)){
+                                       dest[numBits-1]=1;  //correct last 9 wave surrounded by 8 waves
+                               }
                                dest[numBits++]=1;
-                       } else if ((idx-last_transition) > (fchigh+1) && !numBits) { //12 + and first bit = garbage 
+
+                       } else if (currSample > (fchigh+1) && !numBits) { //12 + and first bit = garbage 
                                //do nothing with beginning garbage
-                       } else {                                         //9+ = 10 waves
+                       } else if (currSample == (fclow+1) && LastSample == (fclow-1)) { // had a 7 then a 9 should be two 8's
+                               dest[numBits++]=1;
+                       } else {                                         //9+ = 10 sample waves
                                dest[numBits++]=0;
                        }
                        last_transition = idx;
@@ -537,6 +558,17 @@ uint32_t bytebits_to_byte(uint8_t* src, size_t numbits)
        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;
@@ -569,7 +601,7 @@ int IOdemodFSK(uint8_t *dest, size_t size)
 
 // 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), and binary Length (length to run) 
+//   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;
@@ -579,9 +611,13 @@ 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]);
                }
-               j--;
+               j--; // overwrite parity with next data
                // if parity fails then return 0
-               if (parityTest(parityWd, pLen, pType) == 0) return -1;
+               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;
        }
@@ -589,23 +625,19 @@ size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t p
        //return ID start index and size
        return bitCnt;
 }
+
 // Ask/Biphase Demod then try to locate an ISO 11784/85 ID
-int ISO11784demodBI(uint8_t *dest, size_t *size)
+// 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*50) return -1;
-
-       if (justNoise(dest, *size)) return -2;
-
-       // FSK demodulator
-       *size = fskdemod(dest, *size, 50, 1, 10, 8);  // fsk2a RF/50 
-       if (*size < 96) return -3;  //did we get a good demod?
+       if (*size < 128) return -1;
 
-       uint8_t preamble[] = {0,0,0,0,0,0,0,0,0,0,1};
        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 -4; //preamble not found
-       if (*size != 128) return -5;
+       if (errChk == 0) return -2; //preamble not found
        return (int)startIdx;
 }
 
@@ -1473,3 +1505,30 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert)
        *size = numBits;
        return errCnt;
 }
+// on successful return 1 otherwise return 0
+int VikingDecode(uint8_t *BitStream, 
+                                       size_t size,
+                                       size_t *startIdx,
+                                       uint8_t *id_bits,
+                                       size_t id_bits_size)
+{
+    //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;
+    uint32_t lastcheckindex = size - (id_bits_size * 2);
+    int found = 0;
+    while (i < lastcheckindex)
+    {
+        if (memcmp(BitStream + i,id_bits,id_bits_size) == 0)
+        {
+            *startIdx = i;
+            found = 1;
+            break;
+        }
+        i++;
+    }
+    return found;
+}
+
+