]> cvs.zerfleddert.de Git - proxmark3-svn/commitdiff
lf Bug Fixes and lf demod additions
authormarshmellow42 <marshmellowrf@gmail.com>
Tue, 20 Jan 2015 22:28:51 +0000 (17:28 -0500)
committermarshmellow42 <marshmellowrf@gmail.com>
Tue, 20 Jan 2015 22:28:51 +0000 (17:28 -0500)
added data fskparadoxdemod
added data setdebugmode (for demods)
added data shiftgraphzero (to help clean weak reads)
fixed a few bugs with the data detectaskclock
added data fskfcdetect to detect FSK clocks
adjusted most of my demods to put raw tag binary to demod buffer for
future sim and clone commands (psk still needs work)

armsrc/lfops.c
client/cmddata.c
client/cmddata.h
client/cmdlf.c
client/graph.c
common/lfdemod.c
common/lfdemod.h

index f5040850c50cd2b1f93dfdf979bdbd74b463cfe2..8ea9b317fc00d6374016f6871e2ece5e9a5cf310 100644 (file)
@@ -633,7 +633,7 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
 {
     uint8_t *dest = (uint8_t *)BigBuf;
 
-    size_t size=0; //, found=0;
+    size_t size=sizeof(BigBuf), idx=0; //, found=0;
     uint32_t hi2=0, hi=0, lo=0;
 
     // Configure to go in 125Khz listen mode
@@ -646,11 +646,11 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
 
         DoAcquisition125k_internal(-1,true);
         // FSK demodulator
-               size = HIDdemodFSK(dest, sizeof(BigBuf), &hi2, &hi, &lo);
+               idx = HIDdemodFSK(dest, &size, &hi2, &hi, &lo);
 
         WDT_HIT();
 
-               if (size>0 && lo>0){
+               if (idx>0 && lo>0){
             // final loop, go over previously decoded manchester data and decode into usable tag ID
             // 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
             if (hi2 != 0){ //extra large HID tags
@@ -721,7 +721,7 @@ void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
 {
     uint8_t *dest = (uint8_t *)BigBuf;
 
-       size_t size=0;
+       size_t size=0, idx=0;
     int clk=0, invert=0, errCnt=0;
     uint64_t lo=0;
     // Configure to go in 125Khz listen mode
@@ -741,7 +741,7 @@ void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
         WDT_HIT();
 
         if (errCnt>=0){
-                       lo = Em410xDecode(dest,size);
+                       lo = Em410xDecode(dest, &size, &idx);
             //Dbprintf("DEBUG: EM GOT");
             if (lo>0){
                                Dbprintf("EM TAG ID: %02x%08x - (%05d_%03d_%08d)",
index 60d0d8752a59d6b5ee43652efce76b99c1e20d73..578587bcfd6b3fae6bc7a87859038582ee40e96d 100644 (file)
 #include "cmddata.h"
 #include "lfdemod.h"
 uint8_t DemodBuffer[MAX_DEMOD_BUF_LEN];
+uint8_t g_debugMode;
 int DemodBufferLen;
 static int CmdHelp(const char *Cmd);
 
 //set the demod buffer with given array of binary (one bit per byte)
 //by marshmellow
-void setDemodBuf(uint8_t *buff,int size)
+void setDemodBuf(uint8_t *buff, size_t size, size_t startIdx)
 {
-       int i=0;
-       for (; i < size; ++i){
-               DemodBuffer[i]=buff[i];
+       size_t i = 0;
+       for (; i < size; i++){
+               DemodBuffer[i]=buff[startIdx++];
        }
        DemodBufferLen=size;
        return;
 }
 
+int CmdSetDebugMode(const char *Cmd)
+{
+  int demod=0;
+  sscanf(Cmd, "%i", &demod);
+  g_debugMode=(uint8_t)demod;
+  return 1;
+}
+
 //by marshmellow
 void printDemodBuff()
 {
@@ -206,7 +215,7 @@ void printEM410x(uint64_t id)
 {
   if (id !=0){
       uint64_t iii=1;
-      uint64_t id2lo=0; //id2hi=0,
+      uint64_t id2lo=0;
       uint32_t ii=0;
       uint32_t i=0;
       for (ii=5; ii>0;ii--){
@@ -216,7 +225,7 @@ void printEM410x(uint64_t id)
       }
       //output em id
       PrintAndLog("EM TAG ID    : %010llx", id);
-      PrintAndLog("Unique TAG ID: %010llx",  id2lo); //id2hi,
+      PrintAndLog("Unique TAG ID: %010llx",  id2lo);
       PrintAndLog("DEZ 8        : %08lld",id & 0xFFFFFF);
       PrintAndLog("DEZ 10       : %010lld",id & 0xFFFFFF);
       PrintAndLog("DEZ 5.5      : %05lld.%05lld",(id>>16LL) & 0xFFFF,(id & 0xFFFF));
@@ -233,12 +242,17 @@ void printEM410x(uint64_t id)
 int CmdEm410xDecode(const char *Cmd)
 {
   uint64_t id=0;
- // uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
- // uint32_t i=0;
- // i=getFromGraphBuf(BitStream);
-       id = Em410xDecode(DemodBuffer,DemodBufferLen);
-  printEM410x(id);
-  if (id>0) return 1;
+  size_t size = DemodBufferLen, idx=0;
+       id = Em410xDecode(DemodBuffer, &size, &idx);
+  if (id>0){
+    setDemodBuf(DemodBuffer, size, idx);
+    if (g_debugMode){
+      PrintAndLog("DEBUG: Printing demod buffer:");
+      printDemodBuff();
+    }
+    printEM410x(id);
+    return 1; 
+  }
   return 0;
 }
 
@@ -249,7 +263,7 @@ int CmdEm410xDecode(const char *Cmd)
 //prints binary found and saves in graphbuffer for further commands
 int Cmdaskmandemod(const char *Cmd)
 {
-       int invert=0;
+  int invert=0;
        int clk=0;
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
        sscanf(Cmd, "%i %i", &clk, &invert);
@@ -259,11 +273,11 @@ int Cmdaskmandemod(const char *Cmd)
   }
 
        size_t BitLen = getFromGraphBuf(BitStream);
-  //  PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);
+  if (g_debugMode==1) PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);
   int errCnt=0;
    errCnt = askmandemod(BitStream, &BitLen,&clk,&invert);
        if (errCnt<0||BitLen<16){  //if fatal error (or -1)
-               // PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk);
+               if (g_debugMode==1) PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk);
     return 0;
        }
   PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,BitLen);
@@ -274,17 +288,22 @@ int Cmdaskmandemod(const char *Cmd)
   }
   PrintAndLog("ASK/Manchester decoded bitstream:");
   // Now output the bitstream to the scrollback by line of 16 bits
-       setDemodBuf(BitStream,BitLen);
+       setDemodBuf(BitStream,BitLen,0);
        printDemodBuff();
   uint64_t lo =0;
-  lo = Em410xDecode(BitStream,BitLen);
+  size_t idx=0;
+  lo = Em410xDecode(BitStream, &BitLen, &idx);
   if (lo>0){
     //set GraphBuffer for clone or sim command
+    setDemodBuf(BitStream, BitLen, idx);
+    if (g_debugMode){
+      PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, BitLen);
+      printDemodBuff();
+    }
     PrintAndLog("EM410x pattern found: ");
     printEM410x(lo);
     return 1;
   }
-  //if (BitLen>16) return 1;
   return 0;
 }
 
@@ -317,9 +336,14 @@ int Cmdmandecoderaw(const char *Cmd)
        printBitStream(BitStream, size);
   if (errCnt==0){
                uint64_t id = 0;
-               id = Em410xDecode(BitStream, size);
-               if (id>0) setDemodBuf(BitStream, size);
-               printEM410x(id);
+    size_t idx=0;
+               id = Em410xDecode(BitStream, &size, &idx);
+               if (id>0){
+      //need to adjust to set bitstream back to manchester encoded data
+      //setDemodBuf(BitStream, size, idx);
+
+      printEM410x(id);
+    }
   }
   return 1;
 }
@@ -366,7 +390,6 @@ int CmdBiphaseDecodeRaw(const char *Cmd)
   return 1;
 }
 
-
 //by marshmellow
 //takes 2 arguments - clock and invert both as integers
 //attempts to demodulate ask only
@@ -386,14 +409,15 @@ int Cmdaskrawdemod(const char *Cmd)
        errCnt = askrawdemod(BitStream, &BitLen,&clk,&invert);
        if (errCnt==-1||BitLen<16){  //throw away static - allow 1 and -1 (in case of threshold command first)
                PrintAndLog("no data found");
+    if (g_debugMode==1) PrintAndLog("errCnt: %d, BitLen: %d, clk: %d, invert: %d", errCnt, BitLen, clk, invert);
     return 0;
        }
   PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen);
-    //PrintAndLog("Data start pos:%d, lastBit:%d, stop pos:%d, numBits:%d",iii,lastBit,i,bitnum);
-               //move BitStream back to DemodBuffer
-       setDemodBuf(BitStream,BitLen);
+  
+  //move BitStream back to DemodBuffer
+       setDemodBuf(BitStream,BitLen,0);
 
-               //output
+       //output
   if (errCnt>0){
     PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
   }
@@ -541,6 +565,27 @@ int CmdDec(const char *Cmd)
   return 0;
 }
 
+//by marshmellow
+//shift graph zero up or down based on input + or -
+int CmdGraphShiftZero(const char *Cmd)
+{
+
+  int shift=0;
+  //set options from parameters entered with the command
+  sscanf(Cmd, "%i", &shift);
+  int shiftedVal=0;
+  for(int i = 0; i<GraphTraceLen; i++){
+    shiftedVal=GraphBuffer[i]+shift;
+    if (shiftedVal>127) 
+      shiftedVal=127;
+    else if (shiftedVal<-127) 
+      shiftedVal=-127;
+    GraphBuffer[i]= shiftedVal;
+  }
+  CmdNorm("");
+  return 0;
+}
+
 /* Print our clock rate */
 // uses data from graphbuffer
 int CmdDetectClockRate(const char *Cmd)
@@ -567,7 +612,6 @@ int CmdFSKrawdemod(const char *Cmd)
        sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow);
 
   if (strlen(Cmd)>0 && strlen(Cmd)<=2) {
-     //rfLen=param_get8(Cmd, 0); //if rfLen option only is used
      if (rfLen==1){
       invert=1;   //if invert option only is used
       rfLen = 50;
@@ -579,7 +623,7 @@ int CmdFSKrawdemod(const char *Cmd)
        int size  = fskdemod(BitStream,BitLen,(uint8_t)rfLen,(uint8_t)invert,(uint8_t)fchigh,(uint8_t)fclow);
   if (size>0){
     PrintAndLog("FSK decoded bitstream:");
-               setDemodBuf(BitStream,size);
+               setDemodBuf(BitStream,size,0);
 
     // Now output the bitstream to the scrollback by line of 16 bits
     if(size > (8*32)+2) size = (8*32)+2; //only output a max of 8 blocks of 32 bits  most tags will have full bit stream inside that sample size
@@ -601,20 +645,20 @@ int CmdFSKdemodHID(const char *Cmd)
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
        size_t BitLen = getFromGraphBuf(BitStream);
   //get binary from fsk wave
-       size_t size  = HIDdemodFSK(BitStream,BitLen,&hi2,&hi,&lo);
-  if (size<0){
-    PrintAndLog("Error demoding fsk");
+       size_t idx  = HIDdemodFSK(BitStream,&BitLen,&hi2,&hi,&lo);
+  if (idx<0){
+    if (g_debugMode) PrintAndLog("DEBUG: Error demoding fsk");
+    return 0;
+  }
+  if (hi2==0 && hi==0 && lo==0) {
+    if (g_debugMode) PrintAndLog("DEBUG: Error - no values found");
     return 0;
   }
-  if (hi2==0 && hi==0 && lo==0) return 0;
   if (hi2 != 0){ //extra large HID tags
                PrintAndLog("HID Prox TAG ID: %x%08x%08x (%d)",
        (unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
-               setDemodBuf(BitStream,BitLen);
-    return 1;
   }
   else {  //standard HID tags <38 bits
-    //Dbprintf("TAG ID: %x%08x (%d)",(unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); //old print cmd
     uint8_t fmtLen = 0;
     uint32_t fc = 0;
     uint32_t cardnum = 0;
@@ -654,12 +698,49 @@ int CmdFSKdemodHID(const char *Cmd)
                PrintAndLog("HID Prox TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d",
       (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF,
       (unsigned int) fmtLen, (unsigned int) fc, (unsigned int) cardnum);
-               setDemodBuf(BitStream,BitLen);
-    return 1;
   }
-  return 0;
+  setDemodBuf(BitStream,BitLen,idx);
+  if (g_debugMode){ 
+    PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, BitLen);
+    printDemodBuff();
+  }
+  return 1;
+}
+
+//by marshmellow (based on existing demod + holiman's refactor)
+//Paradox Prox demod - FSK RF/50 with preamble of 00011101 (then manchester encoded)
+//print full Paradox Prox ID and some bit format details if found
+int CmdFSKdemodParadox(const char *Cmd)
+{
+  //raw fsk demod no manchester decoding no start bit finding just get binary from wave
+  uint32_t hi2=0, hi=0, lo=0;
+
+  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
+  size_t BitLen = getFromGraphBuf(BitStream);
+  //get binary from fsk wave
+  size_t idx = ParadoxdemodFSK(BitStream,&BitLen,&hi2,&hi,&lo);
+  if (idx<0){
+    if (g_debugMode) PrintAndLog("DEBUG: Error demoding fsk");
+    return 0;
+  }
+  if (hi2==0 && hi==0 && lo==0){
+    if (g_debugMode) PrintAndLog("DEBUG: Error - no value found");
+    return 0;
+  }
+  uint32_t fc = ((hi & 0x3)<<6) | (lo>>26);
+  uint32_t cardnum = (lo>>10)&0xFFFF;
+  
+  PrintAndLog("Paradox TAG ID: %x%08x - FC: %d - Card: %d - Checksum: %02x",
+    hi>>10, (hi & 0x3)<<26 | (lo>>10), fc, cardnum, (lo>>2) & 0xFF );
+  setDemodBuf(BitStream,BitLen,idx);
+  if (g_debugMode){ 
+    PrintAndLog("DEBUG: idx: %d, len: %d, Printing Demod Buffer:", idx, BitLen);
+    printDemodBuff();
+  }
+  return 1;
 }
 
+
 //by marshmellow
 //IO-Prox demod - FSK RF/64 with preamble of 000000001
 //print ioprox ID and some format details
@@ -668,21 +749,25 @@ int CmdFSKdemodIO(const char *Cmd)
   //raw fsk demod no manchester decoding no start bit finding just get binary from wave
   //set defaults
        int idx=0;
-  //something in graphbuffer
-  if (GraphTraceLen < 65) return 0;
+  //something in graphbuffer?
+  if (GraphTraceLen < 65) {
+    if (g_debugMode)PrintAndLog("DEBUG: not enough samples in GraphBuffer");
+    return 0;
+  }
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
        size_t BitLen = getFromGraphBuf(BitStream);
+
   //get binary from fsk wave
- // PrintAndLog("DEBUG: got buff");
        idx = IOdemodFSK(BitStream,BitLen);
   if (idx<0){
-    //PrintAndLog("Error demoding fsk");
+    if (g_debugMode==1) PrintAndLog("DEBUG: demoding fsk error: %d", idx);
     return 0;
   }
- // PrintAndLog("DEBUG: Got IOdemodFSK");
   if (idx==0){
-    //PrintAndLog("IO Prox Data not found - FSK Data:");
-    //if (BitLen > 92) printBitStream(BitStream,92);
+    if (g_debugMode==1){
+      PrintAndLog("DEBUG: IO Prox Data not found - FSK Bits: %d",BitLen);
+      if (BitLen > 92) printBitStream(BitStream,92);
+    } 
     return 0;
   }
     //Index map
@@ -694,7 +779,10 @@ int CmdFSKdemodIO(const char *Cmd)
     //
     //XSF(version)facility:codeone+codetwo (raw)
     //Handle the data
-  if (idx+64>BitLen) return 0;
+  if (idx+64>BitLen) {
+    if (g_debugMode==1) PrintAndLog("not enough bits found - bitlen: %d",BitLen);
+    return 0;
+  }
   PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx],    BitStream[idx+1],  BitStream[idx+2], BitStream[idx+3], BitStream[idx+4], BitStream[idx+5], BitStream[idx+6], BitStream[idx+7], BitStream[idx+8]);
        PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx+9],  BitStream[idx+10], BitStream[idx+11],BitStream[idx+12],BitStream[idx+13],BitStream[idx+14],BitStream[idx+15],BitStream[idx+16],BitStream[idx+17]);
   PrintAndLog("%d%d%d%d%d%d%d%d %d facility",BitStream[idx+18], BitStream[idx+19], BitStream[idx+20],BitStream[idx+21],BitStream[idx+22],BitStream[idx+23],BitStream[idx+24],BitStream[idx+25],BitStream[idx+26]);
@@ -709,12 +797,12 @@ int CmdFSKdemodIO(const char *Cmd)
   uint8_t facilitycode = bytebits_to_byte(BitStream+idx+18,8) ;
   uint16_t number = (bytebits_to_byte(BitStream+idx+36,8)<<8)|(bytebits_to_byte(BitStream+idx+45,8)); //36,9
        PrintAndLog("IO Prox XSF(%02d)%02x:%05d (%08x%08x)",version,facilitycode,number,code,code2);
-       int i;
-       for (i=0;i<64;++i)
-               DemodBuffer[i]=BitStream[idx++];
-
-       DemodBufferLen=64;
-  return 1;
+  setDemodBuf(BitStream,64,idx);
+       if (g_debugMode){
+    PrintAndLog("DEBUG: idx: %d, Len: %d, Printing demod buffer:",idx,64);
+    printDemodBuff();
+  }
+       return 1;
 }
 
 
@@ -724,8 +812,8 @@ int CmdFSKdemodIO(const char *Cmd)
 int CmdFSKdemodAWID(const char *Cmd)
 {
 
-  int verbose=1;
-  sscanf(Cmd, "%i", &verbose);
+  //int verbose=1;
+  //sscanf(Cmd, "%i", &verbose);
 
   //raw fsk demod no manchester decoding no start bit finding just get binary from wave
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
@@ -734,17 +822,21 @@ int CmdFSKdemodAWID(const char *Cmd)
   //get binary from fsk wave
   int idx = AWIDdemodFSK(BitStream, size);
   if (idx<=0){
-    if (verbose){
+    if (g_debugMode==1){
       if (idx == -1)
-        PrintAndLog("Error: not enough samples");
+        PrintAndLog("DEBUG: Error - not enough samples");
       else if (idx == -2)
-        PrintAndLog("Error: only noise found - no waves");
+        PrintAndLog("DEBUG: Error - only noise found - no waves");
       else if (idx == -3)
-        PrintAndLog("Error: problem during FSK demod");
+        PrintAndLog("DEBUG: Error - problem during FSK demod");
     //  else if (idx == -3)
     //    PrintAndLog("Error: thought we had a tag but the parity failed");
       else if (idx == -4)
-        PrintAndLog("Error: AWID preamble not found");
+        PrintAndLog("DEBUG: Error - AWID preamble not found");
+      else if (idx == -5)
+        PrintAndLog("DEBUG: Error - Second AWID preamble not found");
+      else
+        PrintAndLog("DEBUG: Error %d",idx);
     }
     return 0;
   }
@@ -766,9 +858,11 @@ int CmdFSKdemodAWID(const char *Cmd)
   uint32_t rawLo = bytebits_to_byte(BitStream+idx+64,32);
   uint32_t rawHi = bytebits_to_byte(BitStream+idx+32,32);
   uint32_t rawHi2 = bytebits_to_byte(BitStream+idx,32);
+  setDemodBuf(BitStream,96,idx);
+
   size = removeParity(BitStream, idx+8, 4, 1, 88);
   if (size != 66){
-    if (verbose) PrintAndLog("Error: at parity check-tag size does not match AWID format");
+    if (g_debugMode==1) PrintAndLog("DEBUG: Error - at parity check-tag size does not match AWID format");
     return 0;
   }
   // ok valid card found!
@@ -807,9 +901,11 @@ int CmdFSKdemodAWID(const char *Cmd)
       PrintAndLog("AWID Found - BitLength: %d -unknown BitLength- (%d) - Wiegand: %x, Raw: %x%08x%08x", fmtLen, cardnum, code1, rawHi2, rawHi, rawLo);
     }
   }
-
+  if (g_debugMode){
+    PrintAndLog("DEBUG: idx: %d, Len: %d Printing Demod Buffer:", idx, 96);
+    printDemodBuff();
+  }
   //todo - convert hi2, hi, lo to demodbuffer for future sim/clone commands
-
   return 1;
 }
 
@@ -818,10 +914,6 @@ int CmdFSKdemodAWID(const char *Cmd)
 //print full Farpointe Data/Pyramid Prox ID and some bit format details if found
 int CmdFSKdemodPyramid(const char *Cmd)
 {
-
-  int verbose=1;
-  sscanf(Cmd, "%i", &verbose);
-
   //raw fsk demod no manchester decoding no start bit finding just get binary from wave
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
   size_t size = getFromGraphBuf(BitStream);
@@ -829,23 +921,22 @@ int CmdFSKdemodPyramid(const char *Cmd)
   //get binary from fsk wave
   int idx = PyramiddemodFSK(BitStream, size);
   if (idx < 0){
-    if (verbose){
+    if (g_debugMode==1){
       if (idx == -5)
-        PrintAndLog("Error: not enough samples");
+        PrintAndLog("DEBUG: Error - not enough samples");
       else if (idx == -1)
-        PrintAndLog("Error: only noise found - no waves");
+        PrintAndLog("DEBUG: Error - only noise found - no waves");
       else if (idx == -2)
-        PrintAndLog("Error: problem during FSK demod");
-      //else if (idx == -3)
-      //  PrintAndLog("Error: thought we had a tag but the parity failed");
+        PrintAndLog("DEBUG: Error - problem during FSK demod");
+      else if (idx == -3)
+        PrintAndLog("DEBUG: Error - Second Pyramid preamble not found");
       else if (idx == -4)
-        PrintAndLog("Error: AWID preamble not found");
+        PrintAndLog("DEBUG: Error - Pyramid preamble not found");
+      else
+        PrintAndLog("DEBUG: Error - idx: %d",idx);
     }
-    PrintAndLog("idx: %d",idx);
     return 0;
   }
-  //PrintAndLog("DEBUG: idx: %d",idx);
   // Index map
   // 0           10          20          30            40          50          60
   // |           |           |           |             |           |           |
@@ -872,9 +963,11 @@ int CmdFSKdemodPyramid(const char *Cmd)
   uint32_t rawHi = bytebits_to_byte(BitStream+idx+64,32);
   uint32_t rawHi2 = bytebits_to_byte(BitStream+idx+32,32);
   uint32_t rawHi3 = bytebits_to_byte(BitStream+idx,32);
+  setDemodBuf(BitStream,128,idx);
+
   size = removeParity(BitStream, idx+8, 8, 1, 120);
   if (size != 105){
-    if (verbose) PrintAndLog("Error: at parity check-tag size does not match Pyramid format, SIZE: %d, IDX: %d, hi3: %x",size, idx, rawHi3);
+    if (g_debugMode==1) PrintAndLog("DEBUG: Error at parity check-tag size does not match Pyramid format, SIZE: %d, IDX: %d, hi3: %x",size, idx, rawHi3);
     return 0;
   }
 
@@ -902,10 +995,9 @@ int CmdFSKdemodPyramid(const char *Cmd)
   // (26 bit format shown)
 
   //find start bit to get fmtLen
-  idx = 0;
   int j;
   for (j=0; j<size; j++){
-    if(BitStream[idx+j]) break;
+    if(BitStream[j]) break;
   }
   uint8_t fmtLen = size-j-8;
   uint32_t fc = 0;
@@ -916,25 +1008,28 @@ int CmdFSKdemodPyramid(const char *Cmd)
     fc = bytebits_to_byte(BitStream+73, 8);
     cardnum = bytebits_to_byte(BitStream+81, 16);
     code1 = bytebits_to_byte(BitStream+72,fmtLen);
-    PrintAndLog("AWID Found - BitLength: %d, FC: %d, Card: %d - Wiegand: %x, Raw: %x%08x%08x%08x", fmtLen, fc, cardnum, code1, rawHi3, rawHi2, rawHi, rawLo);
+    PrintAndLog("Pyramid ID Found - BitLength: %d, FC: %d, Card: %d - Wiegand: %x, Raw: %x%08x%08x%08x", fmtLen, fc, cardnum, code1, rawHi3, rawHi2, rawHi, rawLo);
   } else if (fmtLen==45){
     fmtLen=42; //end = 10 bits not 7 like 26 bit fmt
     fc = bytebits_to_byte(BitStream+53, 10);
     cardnum = bytebits_to_byte(BitStream+63, 32);
-    PrintAndLog("AWID Found - BitLength: %d, FC: %d, Card: %d - Raw: %x%08x%08x%08x", fmtLen, fc, cardnum, rawHi3, rawHi2, rawHi, rawLo);
+    PrintAndLog("Pyramid ID Found - BitLength: %d, FC: %d, Card: %d - Raw: %x%08x%08x%08x", fmtLen, fc, cardnum, rawHi3, rawHi2, rawHi, rawLo);
   } else {
     cardnum = bytebits_to_byte(BitStream+81, 16);
     if (fmtLen>32){
       //code1 = bytebits_to_byte(BitStream+(size-fmtLen),fmtLen-32);
       //code2 = bytebits_to_byte(BitStream+(size-32),32);
-      PrintAndLog("AWID Found - BitLength: %d -unknown BitLength- (%d), Raw: %x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo);
+      PrintAndLog("Pyramid ID Found - BitLength: %d -unknown BitLength- (%d), Raw: %x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo);
     } else{
       //code1 = bytebits_to_byte(BitStream+(size-fmtLen),fmtLen);
-      PrintAndLog("AWID Found - BitLength: %d -unknown BitLength- (%d), Raw: %x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo);
+      PrintAndLog("Pyramid ID Found - BitLength: %d -unknown BitLength- (%d), Raw: %x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo);
     }
   }
   //todo - convert hi2, hi, lo to demodbuffer for future sim/clone commands
-
+  if (g_debugMode){
+    PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, 128);
+    printDemodBuff();
+  }
   return 1;
 }
 
@@ -1057,6 +1152,8 @@ int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating
   return 0;
 }
 
+//by marshmellow
+//attempt to detect the field clock and bit clock for FSK
 int CmdFSKfcDetect(const char *Cmd)
 {
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
@@ -1078,7 +1175,8 @@ int CmdDetectNRZpskClockRate(const char *Cmd)
        return 0;
 }
 
-int PSKnrzDemod(const char *Cmd){
+int PSKnrzDemod(const char *Cmd)
+{
        int invert=0;
        int clk=0;
        sscanf(Cmd, "%i %i", &clk, &invert);
@@ -1091,13 +1189,13 @@ int PSKnrzDemod(const char *Cmd){
        int errCnt=0;
        errCnt = pskNRZrawDemod(BitStream, &BitLen,&clk,&invert);
        if (errCnt<0|| BitLen<16){  //throw away static - allow 1 and -1 (in case of threshold command first)
-               //PrintAndLog("no data found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt);
+               if (g_debugMode==1) PrintAndLog("no data found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt);
                return -1;
        }
        PrintAndLog("Tried PSK/NRZ Demod using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen);
 
        //prime demod buffer for output
-       setDemodBuf(BitStream,BitLen);
+       setDemodBuf(BitStream,BitLen,0);
        return errCnt;
 }
 // Indala 26 bit decode
@@ -1105,35 +1203,30 @@ int PSKnrzDemod(const char *Cmd){
 // optional arguments - same as CmdpskNRZrawDemod (clock & invert)
 int CmdIndalaDecode(const char *Cmd)
 {
-  uint8_t verbose = 1;
   int ans;
   if (strlen(Cmd)>0){
-    if (Cmd[0]=='0'){
-      verbose=0;
-      ans = PSKnrzDemod("32");
-    }else{
-      ans = PSKnrzDemod(Cmd);
-    }
+    ans = PSKnrzDemod(Cmd);
   } else{ //default to RF/32
     ans = PSKnrzDemod("32");
   }
 
        if (ans < 0){
-               if (verbose
+               if (g_debugMode==1
       PrintAndLog("Error1: %d",ans);
                return 0;
        }
        uint8_t invert=0;
        ans = indala26decode(DemodBuffer,(size_t *) &DemodBufferLen, &invert);
        if (ans < 1) {
-               if (verbose)
+               if (g_debugMode==1)
       PrintAndLog("Error2: %d",ans);
                return -1;
        }
        char showbits[251];
        if (invert)
-    if (verbose)
+    if (g_debugMode==1)
       PrintAndLog("Had to invert bits");
+
        //convert UID to HEX
        uint32_t uid1, uid2, uid3, uid4, uid5, uid6, uid7;
        int idx;
@@ -1197,25 +1290,28 @@ int CmdPskClean(const char *Cmd)
 //prints binary found and saves in graphbuffer for further commands
 int CmdpskNRZrawDemod(const char *Cmd)
 {
-  uint8_t verbose = 1;
   int errCnt;
-  if (strlen(Cmd)>0){
-    if (Cmd[0]=='0')
-      verbose=0;
-  }
-
   errCnt = PSKnrzDemod(Cmd);
        //output
-       if (errCnt<0) return 0;
+       if (errCnt<0){
+    if (g_debugMode) PrintAndLog("Error demoding: %d",errCnt);  
+    return 0;
+  } 
        if (errCnt>0){
-               if (verbose)
+               if (g_debugMode){
       PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
-       }
-       PrintAndLog("PSK or NRZ demoded bitstream:");
-       // Now output the bitstream to the scrollback by line of 16 bits
-       printDemodBuff();
-
-       return 1;
+      PrintAndLog("PSK or NRZ demoded bitstream:");
+      // Now output the bitstream to the scrollback by line of 16 bits
+      printDemodBuff();
+    }
+       }else{
+    PrintAndLog("PSK or NRZ demoded bitstream:");
+    // Now output the bitstream to the scrollback by line of 16 bits
+    printDemodBuff();  
+    return 1;
+  }
+  return 0;
 }
 
 int CmdGrid(const char *Cmd)
@@ -1367,14 +1463,14 @@ int CmdTuneSamples(const char *Cmd)
 
 int CmdLoad(const char *Cmd)
 {
-   char filename[FILE_PATH_SIZE] = {0x00};
-   int len = 0;
+  char filename[FILE_PATH_SIZE] = {0x00};
+  int len = 0;
 
-   len = strlen(Cmd);
-   if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
-   memcpy(filename, Cmd, len);
+  len = strlen(Cmd);
+  if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
+  memcpy(filename, Cmd, len);
        
-   FILE *f = fopen(filename, "r");
+  FILE *f = fopen(filename, "r");
   if (!f) {
      PrintAndLog("couldn't open '%s'", filename);
     return 0;
@@ -1403,6 +1499,8 @@ int CmdLtrim(const char *Cmd)
   RepaintGraphWindow();
   return 0;
 }
+
+// trim graph to input argument length
 int CmdRtrim(const char *Cmd)
 {
   int ds = atoi(Cmd);
@@ -1683,12 +1781,12 @@ int CmdPlot(const char *Cmd)
 
 int CmdSave(const char *Cmd)
 {
-   char filename[FILE_PATH_SIZE] = {0x00};
-   int len = 0;
+  char filename[FILE_PATH_SIZE] = {0x00};
+  int len = 0;
 
-   len = strlen(Cmd);
-   if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
-   memcpy(filename, Cmd, len);
+  len = strlen(Cmd);
+  if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
+  memcpy(filename, Cmd, len);
    
 
   FILE *f = fopen(filename, "w");
@@ -1814,6 +1912,7 @@ static command_t CommandTable[] =
   {"fskhiddemod",   CmdFSKdemodHID,     1, "Demodulate graph window as a HID FSK tag using raw"},
   {"fskiodemod",    CmdFSKdemodIO,      1, "Demodulate graph window as an IO Prox tag FSK using raw"},
   {"fskpyramiddemod",CmdFSKdemodPyramid,1, "Demodulate graph window as a Pyramid FSK tag using raw"},
+  {"fskparadoxdemod",CmdFSKdemodParadox,1, "Demodulate graph window as a Paradox FSK tag using raw"},
   {"fskrawdemod",   CmdFSKrawdemod,     1, "[clock rate] [invert] [rchigh] [rclow] Demodulate graph window from FSK to bin (clock = 50)(invert = 1|0)(rchigh = 10)(rclow=8)"},
   {"grid",          CmdGrid,            1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},
        {"hexsamples",    CmdHexsamples,      0, "<bytes> [<offset>] -- Dump big buffer as hex bytes"},
@@ -1834,6 +1933,8 @@ static command_t CommandTable[] =
   {"samples",       CmdSamples,         0, "[512 - 40000] -- Get raw samples for graph window"},
   {"save",          CmdSave,            1, "<filename> -- Save trace (from graph window)"},
   {"scale",         CmdScale,           1, "<int> -- Set cursor display scale"},
+  {"setdebugmode",  CmdSetDebugMode,    1, "<0|1> -- Turn on or off Debugging Mode for demods"},
+  {"shiftgraphzero",CmdGraphShiftZero,  1, "<shift> -- Shift 0 for Graphed wave + or - shift value"},
   {"threshold",     CmdThreshold,       1, "<threshold> -- Maximize/minimize every value in the graph window depending on threshold"},
        {"dirthreshold",  CmdDirectionalThreshold,   1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
        {"tune",          CmdTuneSamples,     0, "Get hw tune samples for graph window"},
index ffd6b983a041be2b58eb33a1d5ebbc1ef62b8c02..d87c8b82e3abdac24b4425b763fc06e1e9a6f0b9 100644 (file)
@@ -30,6 +30,7 @@ int CmdFSKdemodAWID(const char *Cmd);
 int CmdFSKdemod(const char *Cmd);
 int CmdFSKdemodHID(const char *Cmd);
 int CmdFSKdemodIO(const char *Cmd);
+int CmdFSKdemodParadox(const char *Cmd);
 int CmdFSKdemodPyramid(const char *Cmd);
 int CmdFSKrawdemod(const char *Cmd);
 int CmdDetectNRZpskClockRate(const char *Cmd);
index 945b45578bdd109a12b6a5d8b15379c45dcc6079..9fc6b999f31ef53bcd7af37d6bc43ecace1bd0a4 100644 (file)
@@ -575,36 +575,41 @@ int CmdLFfind(const char *Cmd)
   }
 
   PrintAndLog("NOTE: some demods output possible binary\n  if it finds something that looks like a tag");
-  PrintAndLog("Checking for known tags:");
+  PrintAndLog("\nChecking for known tags:\n");
   ans=CmdFSKdemodIO("");
   if (ans>0) {
-    PrintAndLog("Valid IO Prox ID Found!");
+    PrintAndLog("\nValid IO Prox ID Found!");
     return 1;
   }
-  ans=CmdFSKdemodPyramid("0");
+  ans=CmdFSKdemodPyramid("");
   if (ans>0) {
-    PrintAndLog("Valid Pyramid ID Found!");
+    PrintAndLog("\nValid Pyramid ID Found!");
     return 1;
   }
-  ans=CmdFSKdemodAWID("0");
+  ans=CmdFSKdemodParadox("");
   if (ans>0) {
-    PrintAndLog("Valid AWID ID Found!");
+    PrintAndLog("\nValid Paradox ID Found!");
+    return 1;
+  }
+  ans=CmdFSKdemodAWID("");
+  if (ans>0) {
+    PrintAndLog("\nValid AWID ID Found!");
     return 1;
   }
   ans=CmdFSKdemodHID("");
   if (ans>0) {
-    PrintAndLog("Valid HID Prox ID Found!");
+    PrintAndLog("\nValid HID Prox ID Found!");
     return 1;
   }
   //add psk and indala
-  ans=CmdIndalaDecode("0");
+  ans=CmdIndalaDecode("");
   if (ans>0) {
-    PrintAndLog("Valid Indala ID Found!");
+    PrintAndLog("\nValid Indala ID Found!");
     return 1;
   }
   ans=Cmdaskmandemod("");
   if (ans>0) {
-    PrintAndLog("Valid EM410x ID Found!");
+    PrintAndLog("\nValid EM410x ID Found!");
     return 1;
   }
   PrintAndLog("No Known Tags Found!\n");
index 6362c8fe242dc438914b5f34135db9874737b91d..174e4a5fe6abc71a2173faaf849088b4bcfae1de 100644 (file)
@@ -69,6 +69,8 @@ size_t getFromGraphBuf(uint8_t *buff)
   }
   return i;
 }
+
+
 // Get or auto-detect clock rate
 int GetClock(const char *str, int peak, int verbose)
 {
index 4a80a10c7b715341648d4014e746d11ca8fa6fbf..8f1a376422e9e13bb4782a95439f8873c3d57e1d 100644 (file)
@@ -31,7 +31,7 @@ int getHiLo(uint8_t *BitStream, size_t size, int *high, int *low, uint8_t fuzzHi
 
 //by marshmellow
 //takes 1s and 0s and searches for EM410x format - output EM ID
-uint64_t Em410xDecode(uint8_t *BitStream, size_t size)
+uint64_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx)
 {
        //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
@@ -48,17 +48,18 @@ uint64_t Em410xDecode(uint8_t *BitStream, size_t size)
        uint32_t idx = 0;
        uint32_t ii=0;
        uint8_t resetCnt = 0;
-       while( (idx + 64) < size) {
+       while( (idx + 64) < *size) {
  restart:
                // search for a start of frame marker
                if ( memcmp(BitStream+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
                { // frame marker found
+                       *startIdx=idx;
                        idx+=9;
                        for (i=0; i<10;i++){
                                for(ii=0; ii<5; ++ii){
                                        parityTest ^= BitStream[(i*5)+ii+idx];
                                }
-                               if (!parityTest){
+                               if (!parityTest){ //even parity
                                        parityTest=0;
                                        for (ii=0; ii<4;++ii){
                                                lo=(lo<<1LL)|(BitStream[(i*5)+ii+idx]);
@@ -74,6 +75,7 @@ uint64_t Em410xDecode(uint8_t *BitStream, size_t size)
                                }
                        }
                        //skip last 5 bit parity test for simplicity.
+                       *size = 64;
                        return lo;
                }else{
                        idx++;
@@ -89,10 +91,12 @@ uint64_t Em410xDecode(uint8_t *BitStream, size_t size)
 int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert)
 {
        int i;
+       int clk2=*clk;
        *clk=DetectASKClock(BinStream, *size, *clk); //clock default
 
-       if (*clk<8) *clk =64;
-       if (*clk<32) *clk=32;
+       // if autodetected too low then adjust  //MAY NEED ADJUSTMENT
+       if (clk2==0 && *clk<8) *clk =64;
+       if (clk2==0 && *clk<32) *clk=32;
        if (*invert != 0 && *invert != 1) *invert=0;
        uint32_t initLoopMax = 200;
        if (initLoopMax > *size) initLoopMax=*size;
@@ -106,7 +110,7 @@ int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert)
        int lastBit = 0;  //set first clock check
        uint32_t bitnum = 0;     //output counter
        int 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
+       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
        int iii = 0;
        uint32_t gLen = *size;
        if (gLen > 3000) gLen=3000;
@@ -198,6 +202,22 @@ int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert)
        return bestErrCnt;
 }
 
+//by marshmellow
+//encode binary data into binary manchester 
+int ManchesterEncode(uint8_t *BitStream, size_t size)
+{
+       size_t modIdx=20000, i=0;
+       if (size>modIdx) return -1;
+  for (size_t idx=0; idx < size; idx++){
+       BitStream[idx+modIdx++] = BitStream[idx];
+       BitStream[idx+modIdx++] = BitStream[idx]^1;
+  }
+  for (; i<(size*2); i++){
+       BitStream[i] = BitStream[i+20000];
+  }
+  return i;
+}
+
 //by marshmellow
 //take 10 and 01 and manchester decode
 //run through 2 times and take least errCnt
@@ -245,7 +265,6 @@ int manrawdecode(uint8_t * BitStream, size_t *size)
        return errCnt;
 }
 
-
 //by marshmellow
 //take 01 or 10 = 0 and 11 or 00 = 1
 int BiphaseRawDecode(uint8_t *BitStream, size_t *size, int offset, int invert)
@@ -282,8 +301,8 @@ int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert)
        //uint8_t BitStream[502] = {0};
 
        //HACK: if clock not detected correctly - default
-       if (*clk<8) *clk =64;
-       if (*clk<32 && clk2==0) *clk=32;
+       if (clk2==0 && *clk<8) *clk =64;
+       if (clk2==0 && *clk<32 && clk2==0) *clk=32;
        if (*invert != 0 && *invert != 1) *invert =0;
        uint32_t initLoopMax = 200;
        if (initLoopMax > *size) initLoopMax=*size;
@@ -534,12 +553,13 @@ int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t
        return size;
 }
 // loop to get raw HID waveform then FSK demodulate the TAG ID from it
-int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_t *lo)
+int HIDdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo)
 {
 
-       size_t idx=0; //, found=0; //size=0,
+       size_t idx=0, size2=*size, startIdx=0; 
        // FSK demodulator
-       size = fskdemod(dest, size,50,0,10,8);
+
+       *size = fskdemod(dest, size2,50,0,10,8);
 
        // final loop, go over previously decoded manchester data and decode into usable tag ID
        // 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
@@ -547,12 +567,13 @@ int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_
        int numshifts = 0;
        idx = 0;
        //one scan
-       while( idx + sizeof(frame_marker_mask) < size) {
+       while( idx + sizeof(frame_marker_mask) < *size) {
                // search for a start of frame marker
                if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
                { // frame marker found
+                       startIdx=idx;
                        idx+=sizeof(frame_marker_mask);
-                       while(dest[idx] != dest[idx+1] && idx < size-2)
+                       while(dest[idx] != dest[idx+1] && idx < *size-2)
                        {
                                // Keep going until next frame marker (or error)
                                // Shift in a bit. Start by shifting high registers
@@ -567,12 +588,13 @@ int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_
                                idx += 2;
                        }
                        // Hopefully, we read a tag and  hit upon the next frame marker
-                       if(idx + sizeof(frame_marker_mask) < size)
+                       if(idx + sizeof(frame_marker_mask) < *size)
                        {
                                if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
                                {
                                        //good return
-                                       return idx;
+                                       *size=idx-startIdx;
+                                       return startIdx;
                                }
                        }
                        // reset
@@ -585,6 +607,61 @@ int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_
        return -1;
 }
 
+// loop to get raw paradox waveform then FSK demodulate the TAG ID from it
+size_t ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo)
+{
+
+       size_t idx=0, size2=*size;
+       // FSK demodulator
+
+       *size = fskdemod(dest, size2,50,1,10,8);
+
+       // final loop, go over previously decoded manchester data and decode into usable tag ID
+       // 00001111 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
+       uint8_t frame_marker_mask[] = {0,0,0,0,1,1,1,1};
+       uint16_t numshifts = 0;
+       idx = 0;
+       //one scan
+       while( idx + sizeof(frame_marker_mask) < *size) {
+               // search for a start of frame marker
+               if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
+               { // frame marker found
+                       size2=idx;
+                       idx+=sizeof(frame_marker_mask);
+                       while(dest[idx] != dest[idx+1] && idx < *size-2)
+                       {
+                               // Keep going until next frame marker (or error)
+                               // Shift in a bit. Start by shifting high registers
+                               *hi2 = (*hi2<<1)|(*hi>>31);
+                               *hi = (*hi<<1)|(*lo>>31);
+                               //Then, shift in a 0 or one into low
+                               if (dest[idx] && !dest[idx+1])  // 1 0
+                                       *lo=(*lo<<1)|1;
+                               else // 0 1
+                                       *lo=(*lo<<1)|0;
+                               numshifts++;
+                               idx += 2;
+                       }
+                       // Hopefully, we read a tag and  hit upon the next frame marker and got enough bits
+                       if(idx + sizeof(frame_marker_mask) < *size && numshifts > 40)
+                       {
+                               if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
+                               {
+                                       //good return - return start grid position and bits found
+                                       *size = ((numshifts*2)+8);
+                                       return size2;
+                               }
+                       }
+                       // reset
+                       *hi2 = *hi = *lo = 0;
+                       numshifts = 0;
+               }else   {
+                       idx++;
+               }
+       }
+       return 0;
+}
+
 uint32_t bytebits_to_byte(uint8_t* src, size_t numbits)
 {
        uint32_t num = 0;
@@ -638,10 +715,10 @@ int IOdemodFSK(uint8_t *dest, size_t size)
 // by marshmellow
 // pass bits to be tested in bits, length bits passed in bitLen, and parity type (even=0 | odd=1) in pType
 // returns 1 if passed
-int parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType)
+uint8_t parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType)
 {
        uint8_t ans = 0;
-       for (int i = 0; i < bitLen; i++){
+       for (uint8_t i = 0; i < bitLen; i++){
                ans ^= ((bits >> i) & 1);
        }
   //PrintAndLog("DEBUG: ans: %d, ptype: %d",ans,pType);
@@ -676,7 +753,7 @@ size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t p
 int AWIDdemodFSK(uint8_t *dest, size_t size)
 {
        static const uint8_t THRESHOLD = 123;
-       uint32_t idx=0;
+       uint32_t idx=0, idx2=0;
        //make sure buffer has data
        if (size < 96*50) return -1;
        //test samples are not just noise
@@ -694,9 +771,12 @@ int AWIDdemodFSK(uint8_t *dest, size_t size)
        for( idx=0; idx < (size - 96); idx++) {
                if ( memcmp(dest + idx, mask, sizeof(mask))==0) {
                        // frame marker found
-                       //return ID start index and size
-                       return idx;  
-                       //size should always be 96
+                       //return ID start index
+                       if (idx2 == 0) idx2=idx;
+                       else if(idx-idx2==96) return idx2;
+                       else return -5;
+
+                       // should always get 96 bits if it is awid
                }
        }
        //never found mask
@@ -708,8 +788,8 @@ int AWIDdemodFSK(uint8_t *dest, size_t size)
 int PyramiddemodFSK(uint8_t *dest, size_t size)
 {
   static const uint8_t THRESHOLD = 123;
-  uint32_t idx=0;
- // size_t size2 = size;
+  uint32_t idx=0, idx2=0;
 // size_t size2 = size;
   //make sure buffer has data
   if (size < 128*50) return -5;
   //test samples are not just noise
@@ -727,78 +807,85 @@ int PyramiddemodFSK(uint8_t *dest, size_t size)
   for( idx=0; idx < (size - 128); idx++) {
     if ( memcmp(dest + idx, mask, sizeof(mask))==0) {
       // frame marker found
-      return idx;
+      if (idx2==0) idx2=idx;
+      else if (idx-idx2==128) return idx2;
+      else return -3;
     }
   }
   //never found mask
   return -4;
 }
 
+
 // by marshmellow
 // not perfect especially with lower clocks or VERY good antennas (heavy wave clipping)
 // maybe somehow adjust peak trimming value based on samples to fix?
 int DetectASKClock(uint8_t dest[], size_t size, int clock)
 {
-       int i=0;
-       int clk[]={8,16,32,40,50,64,100,128,256};
-       int loopCnt = 256;  //don't need to loop through entire array...
-       if (size<loopCnt) loopCnt = size;
+  int i=0;
+  int clk[]={8,16,32,40,50,64,100,128,256};
+  int loopCnt = 256;  //don't need to loop through entire array...
+  if (size<loopCnt) loopCnt = size;
 
-       //if we already have a valid clock quit
-       
-       for (;i<8;++i)
-               if (clk[i] == clock) return clock;
+  //if we already have a valid clock quit
+  
+  for (;i<8;++i)
+    if (clk[i] == clock) return clock;
 
-       //get high and low peak
-       int peak, low;
-       getHiLo(dest, loopCnt, &peak, &low, 75, 75);
-       
-       int ii;
-       int clkCnt;
-       int tol = 0;
-       int bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000,1000};
-       int errCnt=0;
-       //test each valid clock from smallest to greatest to see which lines up
-       for(clkCnt=0; clkCnt < 6; ++clkCnt){
-               if (clk[clkCnt] == 32){
-                       tol=1;
-               }else{
-                       tol=0;
-               }
-               bestErr[clkCnt]=1000;
-               //try lining up the peaks by moving starting point (try first 256)
-               for (ii=0; ii< loopCnt; ++ii){
-                       if ((dest[ii] >= peak) || (dest[ii] <= low)){
-                               errCnt=0;
-                               // now that we have the first one lined up test rest of wave array
-                               for (i=0; i<((int)(size/clk[clkCnt])-1); ++i){
-                                       if (dest[ii+(i*clk[clkCnt])]>=peak || dest[ii+(i*clk[clkCnt])]<=low){
-                                       }else if(dest[ii+(i*clk[clkCnt])-tol]>=peak || dest[ii+(i*clk[clkCnt])-tol]<=low){
-                                       }else if(dest[ii+(i*clk[clkCnt])+tol]>=peak || dest[ii+(i*clk[clkCnt])+tol]<=low){
-                                       }else{  //error no peak detected
-                                               errCnt++;
-                                       }
-                               }
-                               //if we found no errors this is correct one - return this clock
-                               if(errCnt==0) return clk[clkCnt];
-                               //if we found errors see if it is lowest so far and save it as best run
-                               if(errCnt<bestErr[clkCnt]) bestErr[clkCnt]=errCnt;
-                       }
-               }
-       }
-       int iii=0;
-       int best=0;
-       for (iii=0; iii<8;++iii){
-               if (bestErr[iii]<bestErr[best]){
-                       //                current best bit to error ratio     vs  new bit to error ratio
-                       if (((size/clk[best])/bestErr[best] < (size/clk[iii])/bestErr[iii]) ){
-                               best = iii;
-                       }
-               }
-       }
-       return clk[best];
+  //get high and low peak
+  int peak, low;
+  getHiLo(dest, loopCnt, &peak, &low, 75, 75);
+  
+  int ii;
+  int clkCnt;
+  int tol = 0;
+  int bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000,1000};
+  int errCnt=0;
+  //test each valid clock from smallest to greatest to see which lines up
+  for(clkCnt=0; clkCnt < 8; ++clkCnt){
+    if (clk[clkCnt] == 32){
+      tol=1;
+    }else{
+      tol=0;
+    }
+    bestErr[clkCnt]=1000;
+    //try lining up the peaks by moving starting point (try first 256)
+    for (ii=0; ii < loopCnt; ++ii){
+      if ((dest[ii] >= peak) || (dest[ii] <= low)){
+        errCnt=0;
+        // now that we have the first one lined up test rest of wave array
+        for (i=0; i<((int)((size-ii-tol)/clk[clkCnt])-1); ++i){
+          if (dest[ii+(i*clk[clkCnt])]>=peak || dest[ii+(i*clk[clkCnt])]<=low){
+          }else if(dest[ii+(i*clk[clkCnt])-tol]>=peak || dest[ii+(i*clk[clkCnt])-tol]<=low){
+          }else if(dest[ii+(i*clk[clkCnt])+tol]>=peak || dest[ii+(i*clk[clkCnt])+tol]<=low){
+          }else{  //error no peak detected
+            errCnt++;
+          }
+        }
+        //if we found no errors then we can stop here
+        //  this is correct one - return this clock
+            //PrintAndLog("DEBUG: clk %d, err %d, ii %d, i %d",clk[clkCnt],errCnt,ii,i);
+        if(errCnt==0 && clkCnt<6) return clk[clkCnt];
+        //if we found errors see if it is lowest so far and save it as best run
+        if(errCnt<bestErr[clkCnt]) bestErr[clkCnt]=errCnt;
+      }
+    }
+  }
+  uint8_t iii=0;
+  uint8_t best=0;
+  for (iii=0; iii<8; ++iii){
+    if (bestErr[iii]<bestErr[best]){
+      if (bestErr[iii]==0) bestErr[iii]=1;
+      // current best bit to error ratio     vs  new bit to error ratio
+      if (((size/clk[best])/bestErr[best] < (size/clk[iii])/bestErr[iii]) ){
+        best = iii;
+      }
+    }
+  }
+  return clk[best];
 }
 
+
 //by marshmellow
 //detect psk clock by reading #peaks vs no peaks(or errors)
 int DetectpskNRZClock(uint8_t dest[], size_t size, int clock)
@@ -809,7 +896,7 @@ int DetectpskNRZClock(uint8_t dest[], size_t size, int clock)
        if (size<loopCnt) loopCnt = size;
 
        //if we already have a valid clock quit
-       for (; i < 8; ++i)
+       for (; i < 7; ++i)
                if (clk[i] == clock) return clock;
 
        //get high and low peak
@@ -822,11 +909,11 @@ int DetectpskNRZClock(uint8_t dest[], size_t size, int clock)
        uint8_t tol = 0;
        int peakcnt=0;
        int errCnt=0;
-       int bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000,1000};
-       int peaksdet[]={0,0,0,0,0,0,0,0,0};
+       int bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000};
+       int peaksdet[]={0,0,0,0,0,0,0,0};
        //test each valid clock from smallest to greatest to see which lines up
-       for(clkCnt=0; clkCnt < 6; ++clkCnt){
-               if (clk[clkCnt] >= 32){
+       for(clkCnt=0; clkCnt < 7; ++clkCnt){
+               if (clk[clkCnt] <= 32){
                        tol=1;
                }else{
                        tol=0;
@@ -837,7 +924,7 @@ int DetectpskNRZClock(uint8_t dest[], size_t size, int clock)
                                errCnt=0;
                                peakcnt=0;
                                // now that we have the first one lined up test rest of wave array
-                               for (i=0; i < ((int)(size/clk[clkCnt])-1); ++i){
+                               for (i=0; i < ((int)((size-ii-tol)/clk[clkCnt])-1); ++i){
                                        if (dest[ii+(i*clk[clkCnt])]>=peak || dest[ii+(i*clk[clkCnt])]<=low){
                                                peakcnt++;
                                        }else if(dest[ii+(i*clk[clkCnt])-tol]>=peak || dest[ii+(i*clk[clkCnt])-tol]<=low){
index ae04bc2fa259fe35c8262d5049a76f09dec0be31..9698d8bd6ffda9f527b7132af71841231ddfcc8d 100644 (file)
 
 int DetectASKClock(uint8_t dest[], size_t size, int clock);
 int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert);
-uint64_t Em410xDecode(uint8_t *BitStream,size_t size);
+uint64_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx);
+int ManchesterEncode(uint8_t *BitStream, size_t size);
 int manrawdecode(uint8_t *BitStream, size_t *size);
 int BiphaseRawDecode(uint8_t * BitStream, size_t *size, int offset, int invert);
 int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert);
-int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_t *lo);
+int HIDdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo);
 int IOdemodFSK(uint8_t *dest, size_t size);
 int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t fchigh, uint8_t fclow);
 uint32_t bytebits_to_byte(uint8_t* src, size_t numbits);
@@ -34,5 +35,6 @@ int AWIDdemodFSK(uint8_t *dest, size_t size);
 size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t pType, size_t bLen);
 uint32_t countFC(uint8_t *BitStream, size_t size);
 int getHiLo(uint8_t *BitStream, size_t size, int *high, int *low, uint8_t fuzzHi, uint8_t fuzzLo);
+size_t ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo);
 
 #endif
Impressum, Datenschutz