lf psk/nrz split, add maxErr argument

changed psk to use wave lengths instead of peaks
split out NRZ from psk demod
added maxErr argument to raw demods (except fsk)

diff --git a/armsrc/lfops.c b/armsrc/lfops.c
index 7b6fa97a71d51d73231d8251d8b9ff04b5c07be2..67652986afd87560d45e86fe0a2bfdbdbef7fa4e 100644 (file)
--- a/armsrc/lfops.c
+++ b/armsrc/lfops.c
@@ -724,7 +724,7 @@ void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
     uint8_t *dest = BigBuf_get_addr();
 
        size_t size=0, idx=0;
     uint8_t *dest = BigBuf_get_addr();
 
        size_t size=0, idx=0;

-    int clk=0, invert=0, errCnt=0;
+    int clk=0, invert=0, errCnt=0, maxErr=20;

     uint64_t lo=0;
     // Configure to go in 125Khz listen mode
     LFSetupFPGAForADC(95, true);
     uint64_t lo=0;
     // Configure to go in 125Khz listen mode
     LFSetupFPGAForADC(95, true);


@@ -738,7 +738,7 @@ void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
         size  = BigBuf_max_traceLen();
         //Dbprintf("DEBUG: Buffer got");
                //askdemod and manchester decode
         size  = BigBuf_max_traceLen();
         //Dbprintf("DEBUG: Buffer got");
                //askdemod and manchester decode

-               errCnt = askmandemod(dest, &size, &clk, &invert);
+               errCnt = askmandemod(dest, &size, &clk, &invert, maxErr);

         //Dbprintf("DEBUG: ASK Got");
         WDT_HIT();
 
         //Dbprintf("DEBUG: ASK Got");
         WDT_HIT();
 

diff --git a/client/cmddata.c b/client/cmddata.c
index 25d752f6a47eacf28a7ca827011a2e6aee31de26..b03a3ebcd51dff16521be259c2e8724f0871552d 100644 (file)
--- a/client/cmddata.c
+++ b/client/cmddata.c
@@ -267,24 +267,109 @@ int CmdEm410xDecode(const char *Cmd)
 
 
 //by marshmellow
 
 
 //by marshmellow

-//takes 2 arguments - clock and invert both as integers
+//takes 3 arguments - clock, invert and maxErr as integers
+//attempts to demodulate ask while decoding manchester
+//prints binary found and saves in graphbuffer for further commands
+int CmdAskEM410xDemod(const char *Cmd)
+{
+  int invert=0;
+  int clk=0;
+  int maxErr=100;
+  char cmdp = param_getchar(Cmd, 0);
+  if (strlen(Cmd) > 3 || cmdp == 'h' || cmdp == 'H') {
+    PrintAndLog("Usage:  data askem410xdemod [clock] <0|1> [maxError]");
+    PrintAndLog("     [set clock as integer] optional, if not set, autodetect.");
+    PrintAndLog("     <invert>, 1 for invert output");
+    PrintAndLog("     [set maximum allowed errors], default = 100.");
+    PrintAndLog("");
+    PrintAndLog("    sample: data askem410xdemod        = demod an EM410x Tag ID from GraphBuffer");
+    PrintAndLog("          : data askem410xdemod 32     = demod an EM410x Tag ID from GraphBuffer using a clock of RF/32");
+    PrintAndLog("          : data askem410xdemod 32 1   = demod an EM410x Tag ID from GraphBuffer using a clock of RF/32 and inverting data");
+    PrintAndLog("          : data askem410xdemod 1      = demod an EM410x Tag ID from GraphBuffer while inverting data");
+    PrintAndLog("          : data askem410xdemod 64 1 0 = demod an EM410x Tag ID from GraphBuffer using a clock of RF/64 and inverting data and allowing 0 demod errors");
+
+    return 0;
+  }
+
+
+  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
+  sscanf(Cmd, "%i %i %i", &clk, &invert, &maxErr);
+  if (invert != 0 && invert != 1) {
+    PrintAndLog("Invalid argument: %s", Cmd);
+    return 0;
+  }
+  size_t BitLen = getFromGraphBuf(BitStream);
+
+  if (g_debugMode==1) PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);
+  if (BitLen==0) return 0;
+  int errCnt=0;
+  errCnt = askmandemod(BitStream, &BitLen, &clk, &invert, maxErr);
+  if (errCnt<0||BitLen<16){  //if fatal error (or -1)
+    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);
+
+  //output
+  if (errCnt>0){
+    PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
+  }
+  //PrintAndLog("ASK/Manchester decoded bitstream:");
+  // Now output the bitstream to the scrollback by line of 16 bits
+  setDemodBuf(BitStream,BitLen,0);
+  //printDemodBuff();
+  uint64_t lo =0;
+  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;
+  }
+  return 0;
+}
+
+//by marshmellow
+//takes 3 arguments - clock, invert, maxErr as integers

 //attempts to demodulate ask while decoding manchester
 //prints binary found and saves in graphbuffer for further commands
 int Cmdaskmandemod(const char *Cmd)
 {
   int invert=0;
        int clk=0;
 //attempts to demodulate ask while decoding manchester
 //prints binary found and saves in graphbuffer for further commands
 int Cmdaskmandemod(const char *Cmd)
 {
   int invert=0;
        int clk=0;

+  int maxErr=100;
+  char cmdp = param_getchar(Cmd, 0);
+  if (strlen(Cmd) > 3 || cmdp == 'h' || cmdp == 'H') {
+    PrintAndLog("Usage:  data askmandemod [clock] <0|1> [maxError]");
+    PrintAndLog("     [set clock as integer] optional, if not set, autodetect.");
+    PrintAndLog("     <invert>, 1 for invert output");
+    PrintAndLog("     [set maximum allowed errors], default = 100.");
+    PrintAndLog("");
+    PrintAndLog("    sample: data askmandemod        = demod an ask/manchester tag from GraphBuffer");
+    PrintAndLog("          : data askmandemod 32     = demod an ask/manchester tag from GraphBuffer using a clock of RF/32");
+    PrintAndLog("          : data askmandemod 32 1   = demod an ask/manchester tag from GraphBuffer using a clock of RF/32 and inverting data");
+    PrintAndLog("          : data askmandemod 1      = demod an ask/manchester tag from GraphBuffer while inverting data");
+    PrintAndLog("          : data askmandemod 64 1 0 = demod an ask/manchester tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors");
+
+    return 0;
+  }

   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};

-       sscanf(Cmd, "%i %i", &clk, &invert);
+       sscanf(Cmd, "%i %i %i", &clk, &invert, &maxErr);

   if (invert != 0 && invert != 1) {
     PrintAndLog("Invalid argument: %s", Cmd);
     return 0;
   }
   if (invert != 0 && invert != 1) {
     PrintAndLog("Invalid argument: %s", Cmd);
     return 0;
   }

-

        size_t BitLen = getFromGraphBuf(BitStream);
   if (g_debugMode==1) PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);
        size_t BitLen = getFromGraphBuf(BitStream);
   if (g_debugMode==1) PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);

+  if (BitLen==0) return 0;

   int errCnt=0;
   int errCnt=0;

-   errCnt = askmandemod(BitStream, &BitLen,&clk,&invert);
+  errCnt = askmandemod(BitStream, &BitLen, &clk, &invert, maxErr);

        if (errCnt<0||BitLen<16){  //if fatal error (or -1)
                if (g_debugMode==1) PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk);
     return 0;
        if (errCnt<0||BitLen<16){  //if fatal error (or -1)
                if (g_debugMode==1) PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk);
     return 0;


@@ -313,7 +398,7 @@ int Cmdaskmandemod(const char *Cmd)
     printEM410x(lo);
     return 1;
   }
     printEM410x(lo);
     return 1;
   }

-  return 0;
+  return 1;

 }
 
 //by marshmellow
 }
 
 //by marshmellow


@@ -324,6 +409,16 @@ int Cmdmandecoderaw(const char *Cmd)
   int i =0;
   int errCnt=0;
        size_t size=0;
   int i =0;
   int errCnt=0;
        size_t size=0;

+  char cmdp = param_getchar(Cmd, 0);
+  if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') {
+    PrintAndLog("Usage:  data manrawdecode");
+    PrintAndLog("     Takes 10 and 01 and converts to 0 and 1 respectively");
+    PrintAndLog("     --must have binary sequence in demodbuffer (run data askrawdemod first)");
+    PrintAndLog("");
+    PrintAndLog("    sample: data manrawdecode   = decode manchester bitstream from the demodbuffer");
+    return 0;
+  }
+  if (DemodBufferLen==0) return 0;

   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
   int high=0,low=0;
        for (;i<DemodBufferLen;++i){
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
   int high=0,low=0;
        for (;i<DemodBufferLen;++i){


@@ -375,7 +470,21 @@ int CmdBiphaseDecodeRaw(const char *Cmd)
   int offset=0;
   int invert=0;
   int high=0, low=0;
   int offset=0;
   int invert=0;
   int high=0, low=0;

+  char cmdp = param_getchar(Cmd, 0);
+  if (strlen(Cmd) > 2 || cmdp == 'h' || cmdp == 'H') {
+    PrintAndLog("Usage:  data biphaserawdecode [offset] <invert>");
+    PrintAndLog("     Converts 10 or 01 to 0 and 11 or 00 to 1");
+    PrintAndLog("     --must have binary sequence in demodbuffer (run data askrawdemod first)");   
+    PrintAndLog("");
+    PrintAndLog("     [offset <0|1>], set to 0 not to adjust start position or to 1 to adjust decode start position");
+    PrintAndLog("     [invert <0|1>], set to 1 to invert output");
+    PrintAndLog("");
+    PrintAndLog("    sample: data biphaserawdecode     = decode biphase bitstream from the demodbuffer");
+    PrintAndLog("    sample: data biphaserawdecode 1 1 = decode biphase bitstream from the demodbuffer, set offset, and invert output");
+    return 0;
+  }

        sscanf(Cmd, "%i %i", &offset, &invert);
        sscanf(Cmd, "%i %i", &offset, &invert);

+  if (DemodBufferLen==0) return 0;

   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
   //get graphbuffer & high and low
        for (;i<DemodBufferLen;++i){
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
   //get graphbuffer & high and low
        for (;i<DemodBufferLen;++i){


@@ -400,35 +509,51 @@ int CmdBiphaseDecodeRaw(const char *Cmd)
 }
 
 //by marshmellow
 }
 
 //by marshmellow

-//takes 2 arguments - clock and invert both as integers
+//takes 3 arguments - clock, invert, maxErr as integers

 //attempts to demodulate ask only
 //prints binary found and saves in graphbuffer for further commands
 int Cmdaskrawdemod(const char *Cmd)
 {
        int invert=0;
        int clk=0;
 //attempts to demodulate ask only
 //prints binary found and saves in graphbuffer for further commands
 int Cmdaskrawdemod(const char *Cmd)
 {
        int invert=0;
        int clk=0;

+  int maxErr=100;
+  char cmdp = param_getchar(Cmd, 0);
+  if (strlen(Cmd) > 3 || cmdp == 'h' || cmdp == 'H') {
+    PrintAndLog("Usage:  data askrawdemod [clock] <0|1> [maxError]");
+    PrintAndLog("     [set clock as integer] optional, if not set, autodetect.");
+    PrintAndLog("     <invert>, 1 for invert output");
+    PrintAndLog("     [set maximum allowed errors], default = 100.");
+    PrintAndLog("");
+    PrintAndLog("    sample: data askrawdemod        = demod an ask tag from GraphBuffer");
+    PrintAndLog("          : data askrawdemod 32     = demod an ask tag from GraphBuffer using a clock of RF/32");
+    PrintAndLog("          : data askrawdemod 32 1   = demod an ask tag from GraphBuffer using a clock of RF/32 and inverting data");
+    PrintAndLog("          : data askrawdemod 1      = demod an ask tag from GraphBuffer while inverting data");
+    PrintAndLog("          : data askrawdemod 64 1 0 = demod an ask tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors");
+    return 0;
+  }

   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};

-       sscanf(Cmd, "%i %i", &clk, &invert);
+       sscanf(Cmd, "%i %i %i", &clk, &invert, &maxErr);

   if (invert != 0 && invert != 1) {
     PrintAndLog("Invalid argument: %s", Cmd);
     return 0;
   }
        size_t BitLen = getFromGraphBuf(BitStream);
   if (invert != 0 && invert != 1) {
     PrintAndLog("Invalid argument: %s", Cmd);
     return 0;
   }
        size_t BitLen = getFromGraphBuf(BitStream);

+  if (BitLen==0) return 0;

   int errCnt=0;
   int errCnt=0;

-       errCnt = askrawdemod(BitStream, &BitLen,&clk,&invert);
+       errCnt = askrawdemod(BitStream, &BitLen, &clk, &invert, maxErr);

        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;
        }
        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("Using Clock: %d - invert: %d - Bits Found: %d", clk, invert, BitLen);

   
   //move BitStream back to DemodBuffer
        setDemodBuf(BitStream,BitLen,0);
 
        //output
   if (errCnt>0){
   
   //move BitStream back to DemodBuffer
        setDemodBuf(BitStream,BitLen,0);
 
        //output
   if (errCnt>0){

-    PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
+    PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d", errCnt);

   }
   PrintAndLog("ASK demoded bitstream:");
   // Now output the bitstream to the scrollback by line of 16 bits
   }
   PrintAndLog("ASK demoded bitstream:");
   // Now output the bitstream to the scrollback by line of 16 bits


@@ -595,10 +720,8 @@ int CmdGraphShiftZero(const char *Cmd)
 // uses data from graphbuffer
 int CmdDetectClockRate(const char *Cmd)
 {
 // uses data from graphbuffer
 int CmdDetectClockRate(const char *Cmd)
 {

-  GetClock("",0,0);
-       //int clock = DetectASKClock(0);
-       //PrintAndLog("Auto-detected clock rate: %d", clock);
-  return 0;
+  int ans = GetClock("",0,0);
+  return ans;

 }
 
 //by marshmellow
 }
 
 //by marshmellow


@@ -613,6 +736,22 @@ int CmdFSKrawdemod(const char *Cmd)
   int invert=0;
   int fchigh=0;
   int fclow=0;
   int invert=0;
   int fchigh=0;
   int fclow=0;

+  char cmdp = param_getchar(Cmd, 0);
+  if (strlen(Cmd) > 4 || cmdp == 'h' || cmdp == 'H') {
+    PrintAndLog("Usage:  data fskrawdemod [clock] <0|1> [rchigh] [rclow]");
+    PrintAndLog("     [set clock as integer] optional, if not set, autodetect.");
+    PrintAndLog("     <invert>, 1 for invert output");
+
+    PrintAndLog("     [set maximum allowed errors], default = 100.");
+    PrintAndLog("");
+    PrintAndLog("    sample: data fskrawdemod           = demod an fsk tag from GraphBuffer using autodetect");
+    PrintAndLog("          : data fskrawdemod 32        = demod an fsk tag from GraphBuffer using a clock of RF/32, autodetect fc");
+    PrintAndLog("          : data fskrawdemod 32 1      = demod an fsk tag from GraphBuffer using a clock of RF/32, invert output, autodetect fc");
+    PrintAndLog("          : data fskrawdemod 64 0 8 5  = demod an fsk1 RF/64 tag from GraphBuffer");
+    PrintAndLog("          : data fskrawdemod 50 0 10 8 = demod an fsk2 RF/50 tag from GraphBuffer");
+    PrintAndLog("          : data fskrawdemod 50 1 10 8 = demod an fsk2a RF/50 tag from GraphBuffer");
+    return 0;
+  }

   //set options from parameters entered with the command
        sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow);
 
   //set options from parameters entered with the command
        sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow);
 


@@ -625,10 +764,12 @@ int CmdFSKrawdemod(const char *Cmd)
 
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
        size_t BitLen = getFromGraphBuf(BitStream);
 
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
        size_t BitLen = getFromGraphBuf(BitStream);

+  if (BitLen==0) return 0;

   //get field clock lengths
   uint16_t fcs=0;
   //get field clock lengths
   uint16_t fcs=0;

+  uint8_t dummy=0;

   if (fchigh==0 || fclow == 0){
   if (fchigh==0 || fclow == 0){

-    fcs=countFC(BitStream, BitLen);
+    fcs=countFC(BitStream, BitLen, &dummy);

     if (fcs==0){
       fchigh=10;
       fclow=8;
     if (fcs==0){
       fchigh=10;
       fclow=8;


@@ -651,6 +792,7 @@ int CmdFSKrawdemod(const char *Cmd)
     // 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
     printBitStream(BitStream,size);
     // 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
     printBitStream(BitStream,size);

+    return 1;

   } else{
     PrintAndLog("no FSK data found");
   }
   } else{
     PrintAndLog("no FSK data found");
   }


@@ -667,8 +809,9 @@ int CmdFSKdemodHID(const char *Cmd)
 
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
        size_t BitLen = getFromGraphBuf(BitStream);
 
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
        size_t BitLen = getFromGraphBuf(BitStream);

+       if (BitLen==0) return 0;

   //get binary from fsk wave
   //get binary from fsk wave

-       int idx  = HIDdemodFSK(BitStream,&BitLen,&hi2,&hi,&lo);
+  int idx  = HIDdemodFSK(BitStream,&BitLen,&hi2,&hi,&lo);

   if (idx<0){
     if (g_debugMode){
       if (idx==-1){
   if (idx<0){
     if (g_debugMode){
       if (idx==-1){


@@ -752,6 +895,7 @@ int CmdFSKdemodParadox(const char *Cmd)
 
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
   size_t BitLen = getFromGraphBuf(BitStream);
 
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
   size_t BitLen = getFromGraphBuf(BitStream);

+  if (BitLen==0) return 0;

   //get binary from fsk wave
   int idx = ParadoxdemodFSK(BitStream,&BitLen,&hi2,&hi,&lo);
   if (idx<0){
   //get binary from fsk wave
   int idx = ParadoxdemodFSK(BitStream,&BitLen,&hi2,&hi,&lo);
   if (idx<0){


@@ -803,6 +947,7 @@ int CmdFSKdemodIO(const char *Cmd)
   }
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
        size_t BitLen = getFromGraphBuf(BitStream);
   }
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
        size_t BitLen = getFromGraphBuf(BitStream);

+  if (BitLen==0) return 0;

 
   //get binary from fsk wave
        idx = IOdemodFSK(BitStream,BitLen);
 
   //get binary from fsk wave
        idx = IOdemodFSK(BitStream,BitLen);


@@ -879,6 +1024,7 @@ int CmdFSKdemodAWID(const char *Cmd)
   //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);
   //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);

+  if (size==0) return 0;

 
   //get binary from fsk wave
   int idx = AWIDdemodFSK(BitStream, &size);
 
   //get binary from fsk wave
   int idx = AWIDdemodFSK(BitStream, &size);


@@ -978,6 +1124,7 @@ int CmdFSKdemodPyramid(const char *Cmd)
   //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);
   //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);

+  if (size==0) return 0;

 
   //get binary from fsk wave
   int idx = PyramiddemodFSK(BitStream, &size);
 
   //get binary from fsk wave
   int idx = PyramiddemodFSK(BitStream, &size);


@@ -1217,8 +1364,9 @@ int CmdFSKfcDetect(const char *Cmd)
 {
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
   size_t size = getFromGraphBuf(BitStream);
 {
   uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
   size_t size = getFromGraphBuf(BitStream);

-
-  uint16_t ans = countFC(BitStream, size); 
+  if (size==0) return 0;
+  uint8_t dummy = 0;
+  uint16_t ans = countFC(BitStream, size, &dummy); 

   if (ans==0) {
     if (g_debugMode) PrintAndLog("DEBUG: No data found");
     return 0;
   if (ans==0) {
     if (g_debugMode) PrintAndLog("DEBUG: No data found");
     return 0;


@@ -1232,44 +1380,71 @@ int CmdFSKfcDetect(const char *Cmd)
     if (g_debugMode) PrintAndLog("DEBUG: Clock detect error");
     return 0;
   }
     if (g_debugMode) PrintAndLog("DEBUG: Clock detect error");
     return 0;
   }

-  PrintAndLog("Detected Field Clocks: FC/%d, FC/%d - Bit Clock: RF/%d", fc1, fc2, rf1);
-  return 1;
+  if ((fc1==10 && fc2==8) || (fc1==8 && fc2==5)){
+    if (g_debugMode){
+      PrintAndLog("Detected Field Clocks: FC/%d, FC/%d - Bit Clock: RF/%d", fc1, fc2, rf1);
+      return 1;
+    }
+  }
+  if (g_debugMode){
+    PrintAndLog("DEBUG: unknown fsk field clock detected");
+    PrintAndLog("Detected Field Clocks: FC/%d, FC/%d - Bit Clock: RF/%d", fc1, fc2, rf1);
+  }
+  return 0;

 }
 
 //by marshmellow
 }
 
 //by marshmellow

-//attempt to detect the bit clock for PSK or NRZ modulations
-int CmdDetectNRZpskClockRate(const char *Cmd)
+//attempt to detect the bit clock for PSK modulations
+int CmdDetectPSKClockRate(const char *Cmd)

 {
 {

-       GetNRZpskClock("",0,0);
+       GetPskClock("",0,0);

        return 0;
 }
 
 //by marshmellow
        return 0;
 }
 
 //by marshmellow

-//attempt to psk1 or nrz demod graph buffer
-//NOTE CURRENTLY RELIES ON PEAKS :(
-int PSKnrzDemod(const char *Cmd, uint8_t verbose)
+//attempt to detect the bit clock for NRZ modulations
+int CmdDetectNRZClockRate(const char *Cmd)

 {
 {

-       int invert=0;
-       int clk=0;
-       sscanf(Cmd, "%i %i", &clk, &invert);
-       if (invert != 0 && invert != 1) {
-               PrintAndLog("Invalid argument: %s", Cmd);
-               return -1;
-       }
-       uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
-       size_t BitLen = getFromGraphBuf(BitStream);
-       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)
-               if (g_debugMode==1) PrintAndLog("no data found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt);
-               return -1;
-       }
-  if (verbose) PrintAndLog("Tried PSK/NRZ Demod using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen);
+  GetNrzClock("",0,0);
+  return 0;
+}

 
 

-       //prime demod buffer for output
-       setDemodBuf(BitStream,BitLen,0);
-       return errCnt;
+//by marshmellow
+//attempt to psk1 demod graph buffer
+int PSKDemod(const char *Cmd, uint8_t verbose)
+{
+  int invert=0;
+  int clk=0;
+  int maxErr=100;
+  sscanf(Cmd, "%i %i %i", &clk, &invert, &maxErr);
+  if (clk==1){
+    invert=1;
+    clk=0;
+  }
+  if (invert != 0 && invert != 1) {
+    PrintAndLog("Invalid argument: %s", Cmd);
+    return -1;
+  }
+  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
+  size_t BitLen = getFromGraphBuf(BitStream);
+  if (BitLen==0) return 0;
+  int errCnt=0;
+  errCnt = pskRawDemod(BitStream, &BitLen,&clk,&invert);
+  if (errCnt > maxErr){
+    if (g_debugMode==1) PrintAndLog("Too many errors found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt);
+    return -1;
+  } 
+  if (errCnt<0|| BitLen<16){  //throw away static - allow 1 and -1 (in case of threshold command first)
+    if (g_debugMode==1) PrintAndLog("no data found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt);
+    return -1;
+  }
+  if (verbose) PrintAndLog("Tried PSK Demod using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen);
+  //prime demod buffer for output
+  setDemodBuf(BitStream,BitLen,0);
+  return errCnt;

 }
 }

+
+

 // Indala 26 bit decode
 // by marshmellow
 // optional arguments - same as CmdpskNRZrawDemod (clock & invert)
 // Indala 26 bit decode
 // by marshmellow
 // optional arguments - same as CmdpskNRZrawDemod (clock & invert)


@@ -1277,9 +1452,9 @@ int CmdIndalaDecode(const char *Cmd)
 {
   int ans;
   if (strlen(Cmd)>0){
 {
   int ans;
   if (strlen(Cmd)>0){

-    ans = PSKnrzDemod(Cmd, 0);
+    ans = PSKDemod(Cmd, 0);

   } else{ //default to RF/32
   } else{ //default to RF/32

-    ans = PSKnrzDemod("32", 0);
+    ans = PSKDemod("32", 0);

   }
 
        if (ans < 0){
   }
 
        if (ans < 0){


@@ -1351,6 +1526,7 @@ int CmdIndalaDecode(const char *Cmd)
        return 1;
 }
 
        return 1;
 }
 

+/*

 //by marshmellow
 //attempt to clean psk wave noise after a peak 
 //NOTE RELIES ON PEAKS :(
 //by marshmellow
 //attempt to clean psk wave noise after a peak 
 //NOTE RELIES ON PEAKS :(


@@ -1362,35 +1538,104 @@ int CmdPskClean(const char *Cmd)
        setGraphBuf(bitStream, bitLen);
        return 0;
 }
        setGraphBuf(bitStream, bitLen);
        return 0;
 }

+*/

 
 // by marshmellow
 
 // by marshmellow

-// takes 2 arguments - clock and invert both as integers
+// takes 3 arguments - clock, invert, maxErr as integers
+// attempts to demodulate nrz only
+// prints binary found and saves in demodbuffer for further commands
+int CmdNRZrawDemod(const char *Cmd)
+{
+  int invert=0;
+  int clk=0;
+  int maxErr=100;
+  char cmdp = param_getchar(Cmd, 0);
+  if (strlen(Cmd) > 3 || cmdp == 'h' || cmdp == 'H') {
+    PrintAndLog("Usage:  data nrzrawdemod [clock] <0|1> [maxError]");
+    PrintAndLog("     [set clock as integer] optional, if not set, autodetect.");
+    PrintAndLog("     <invert>, 1 for invert output");
+    PrintAndLog("     [set maximum allowed errors], default = 100.");
+    PrintAndLog("");
+    PrintAndLog("    sample: data nrzrawdemod        = demod a nrz/direct tag from GraphBuffer");
+    PrintAndLog("          : data nrzrawdemod 32     = demod a nrz/direct tag from GraphBuffer using a clock of RF/32");
+    PrintAndLog("          : data nrzrawdemod 32 1   = demod a nrz/direct tag from GraphBuffer using a clock of RF/32 and inverting data");
+    PrintAndLog("          : data nrzrawdemod 1      = demod a nrz/direct tag from GraphBuffer while inverting data");
+    PrintAndLog("          : data nrzrawdemod 64 1 0 = demod a nrz/direct tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors");
+
+    return 0;
+  }
+ 
+  sscanf(Cmd, "%i %i %i", &clk, &invert, &maxErr);
+  if (clk==1){
+    invert=1;
+    clk=0;
+  }
+  if (invert != 0 && invert != 1) {
+    PrintAndLog("Invalid argument: %s", Cmd);
+    return 0;
+  }
+  uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
+  size_t BitLen = getFromGraphBuf(BitStream);
+  if (BitLen==0) return 0;
+  int errCnt=0;
+  errCnt = nrzRawDemod(BitStream, &BitLen, &clk, &invert, maxErr);
+  if (errCnt > maxErr){
+    if (g_debugMode==1) PrintAndLog("Too many errors found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt);
+    return 0;
+  } 
+  if (errCnt<0|| BitLen<16){  //throw away static - allow 1 and -1 (in case of threshold command first)
+    if (g_debugMode==1) PrintAndLog("no data found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt);
+    return 0;
+  }
+  PrintAndLog("Tried NRZ Demod using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen);
+  //prime demod buffer for output
+  setDemodBuf(BitStream,BitLen,0);
+
+  if (errCnt>0){
+    PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
+  }else{
+  }
+  PrintAndLog("NRZ demoded bitstream:");
+  // Now output the bitstream to the scrollback by line of 16 bits
+  printDemodBuff();
+  return 1;
+}
+
+// by marshmellow
+// takes 3 arguments - clock, invert, maxErr as integers

 // attempts to demodulate psk only
 // prints binary found and saves in demodbuffer for further commands
 // attempts to demodulate psk only
 // prints binary found and saves in demodbuffer for further commands

-int CmdpskNRZrawDemod(const char *Cmd)
+int CmdPSK1rawDemod(const char *Cmd)

 {
   int errCnt;
 {
   int errCnt;

- 
-  errCnt = PSKnrzDemod(Cmd, 1);
+  char cmdp = param_getchar(Cmd, 0);
+  if (strlen(Cmd) > 3 || cmdp == 'h' || cmdp == 'H') {
+    PrintAndLog("Usage:  data psk1rawdemod [clock] <0|1> [maxError]");
+    PrintAndLog("     [set clock as integer] optional, if not set, autodetect.");
+    PrintAndLog("     <invert>, 1 for invert output");
+    PrintAndLog("     [set maximum allowed errors], default = 100.");
+    PrintAndLog("");
+    PrintAndLog("    sample: data psk1rawdemod        = demod a psk1 tag from GraphBuffer");
+    PrintAndLog("          : data psk1rawdemod 32     = demod a psk1 tag from GraphBuffer using a clock of RF/32");
+    PrintAndLog("          : data psk1rawdemod 32 1   = demod a psk1 tag from GraphBuffer using a clock of RF/32 and inverting data");
+    PrintAndLog("          : data psk1rawdemod 1      = demod a psk1 tag from GraphBuffer while inverting data");
+    PrintAndLog("          : data psk1rawdemod 64 1 0 = demod a psk1 tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors");
+    return 0;
+  }
+  errCnt = PSKDemod(Cmd, 1);

        //output
        if (errCnt<0){
        //output
        if (errCnt<0){

-    if (g_debugMode) PrintAndLog("Error demoding: %d",errCnt);  
+    if (g_debugMode) PrintAndLog("Error demoding: %d",errCnt); 

     return 0;
     return 0;

-  } 
+  }

        if (errCnt>0){
        if (errCnt>0){

-               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();
-    }
+    PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);

        }else{
        }else{

-    PrintAndLog("PSK or NRZ demoded bitstream:");
-    // Now output the bitstream to the scrollback by line of 16 bits
-    printDemodBuff();  
-    return 1;

   }
   }

-  return 0;
+  PrintAndLog("PSK demoded bitstream:");
+  // Now output the bitstream to the scrollback by line of 16 bits
+  printDemodBuff();
+  return 1;

 }
 
 // by marshmellow
 }
 
 // by marshmellow


@@ -1398,7 +1643,21 @@ int CmdpskNRZrawDemod(const char *Cmd)
 int CmdPSK2rawDemod(const char *Cmd)
 {
   int errCnt=0;
 int CmdPSK2rawDemod(const char *Cmd)
 {
   int errCnt=0;

-  errCnt=PSKnrzDemod(Cmd, 1);
+  char cmdp = param_getchar(Cmd, 0);
+  if (strlen(Cmd) > 3 || cmdp == 'h' || cmdp == 'H') {
+    PrintAndLog("Usage:  data psk2rawdemod [clock] <0|1> [maxError]");
+    PrintAndLog("     [set clock as integer] optional, if not set, autodetect.");
+    PrintAndLog("     <invert>, 1 for invert output");
+    PrintAndLog("     [set maximum allowed errors], default = 100.");
+    PrintAndLog("");
+    PrintAndLog("    sample: data psk2rawdemod        = demod a psk2 tag from GraphBuffer, autodetect clock");
+    PrintAndLog("          : data psk2rawdemod 32     = demod a psk2 tag from GraphBuffer using a clock of RF/32");
+    PrintAndLog("          : data psk2rawdemod 32 1   = demod a psk2 tag from GraphBuffer using a clock of RF/32 and inverting output");
+    PrintAndLog("          : data psk2rawdemod 1      = demod a psk2 tag from GraphBuffer, autodetect clock and invert output");
+    PrintAndLog("          : data psk2rawdemod 64 1 0 = demod a psk2 tag from GraphBuffer using a clock of RF/64, inverting output and allowing 0 demod errors");
+    return 0;
+  }
+  errCnt=PSKDemod(Cmd, 1);

   if (errCnt<0){
     if (g_debugMode) PrintAndLog("Error demoding: %d",errCnt);  
     return 0;
   if (errCnt<0){
     if (g_debugMode) PrintAndLog("Error demoding: %d",errCnt);  
     return 0;


@@ -2002,7 +2261,8 @@ static command_t CommandTable[] =
   {"help",          CmdHelp,            1, "This help"},
   {"amp",           CmdAmp,             1, "Amplify peaks"},
   {"askdemod",      Cmdaskdemod,        1, "<0 or 1> -- Attempt to demodulate simple ASK tags"},
   {"help",          CmdHelp,            1, "This help"},
   {"amp",           CmdAmp,             1, "Amplify peaks"},
   {"askdemod",      Cmdaskdemod,        1, "<0 or 1> -- Attempt to demodulate simple ASK tags"},

-       {"askmandemod",   Cmdaskmandemod,     1, "[clock] [invert<0|1>] -- Attempt to demodulate ASK/Manchester tags and output binary (args optional)"},
+  {"askem410xdemod",CmdAskEM410xDemod,  1, "[clock] [invert<0|1>] [maxErr] -- Attempt to demodulate ASK/Manchester tags and output binary (args optional)"},
+       {"askmandemod",   Cmdaskmandemod,     1, "[clock] [invert<0|1>] [maxErr] -- Attempt to demodulate ASK/Manchester tags and output binary (args optional)"},

        {"askrawdemod",   Cmdaskrawdemod,     1, "[clock] [invert<0|1>] -- Attempt to demodulate ASK tags and output bin (args optional)"},
   {"autocorr",      CmdAutoCorr,        1, "<window length> -- Autocorrelation over window"},
   {"biphaserawdecode",CmdBiphaseDecodeRaw,1,"[offset] [invert<0|1>] Biphase decode bin stream in demod buffer (offset = 0|1 bits to shift the decode start)"},
        {"askrawdemod",   Cmdaskrawdemod,     1, "[clock] [invert<0|1>] -- Attempt to demodulate ASK tags and output bin (args optional)"},
   {"autocorr",      CmdAutoCorr,        1, "<window length> -- Autocorrelation over window"},
   {"biphaserawdecode",CmdBiphaseDecodeRaw,1,"[offset] [invert<0|1>] Biphase decode bin stream in demod buffer (offset = 0|1 bits to shift the decode start)"},


@@ -2030,12 +2290,13 @@ static command_t CommandTable[] =
   {"manrawdecode",  Cmdmandecoderaw,    1, "Manchester decode binary stream already in graph buffer"},
   {"manmod",        CmdManchesterMod,   1, "[clock rate] -- Manchester modulate a binary stream"},
        {"norm",          CmdNorm,            1, "Normalize max/min to +/-128"},
   {"manrawdecode",  Cmdmandecoderaw,    1, "Manchester decode binary stream already in graph buffer"},
   {"manmod",        CmdManchesterMod,   1, "[clock rate] -- Manchester modulate a binary stream"},
        {"norm",          CmdNorm,            1, "Normalize max/min to +/-128"},

+  {"nrzdetectclock",CmdDetectNRZClockRate, 1, "Detect ASK, PSK, or NRZ clock rate"},
+  {"nrzrawdemod",   CmdNRZrawDemod,     1, "[clock] [invert<0|1>] [maxErr] -- Attempt to demodulate nrz tags and output binary (args optional)"},

   {"plot",          CmdPlot,            1, "Show graph window (hit 'h' in window for keystroke help)"},
   {"plot",          CmdPlot,            1, "Show graph window (hit 'h' in window for keystroke help)"},

-       {"pskclean",      CmdPskClean,        1, "Attempt to clean psk wave"},
-       {"pskdetectclock",CmdDetectNRZpskClockRate, 1, "Detect ASK, PSK, or NRZ clock rate"},
+       {"pskdetectclock",CmdDetectPSKClockRate, 1, "Detect ASK, PSK, or NRZ clock rate"},

        {"pskindalademod",CmdIndalaDecode,    1, "[clock] [invert<0|1>] -- Attempt to demodulate psk1 indala tags and output ID binary & hex (args optional)"},
        {"pskindalademod",CmdIndalaDecode,    1, "[clock] [invert<0|1>] -- Attempt to demodulate psk1 indala tags and output ID binary & hex (args optional)"},

-       {"psk1nrzrawdemod",CmdpskNRZrawDemod, 1, "[clock] [invert<0|1>] -- Attempt to demodulate psk1 or nrz tags and output binary (args optional)"},
-  {"psk2rawdemod",  CmdPSK2rawDemod,    1, "[clock] [invert<0|1>] -- Attempt to demodulate psk2 tags and output binary (args optional)"},
+       {"psk1rawdemod",  CmdPSK1rawDemod,    1, "[clock] [invert<0|1>] [maxErr] -- Attempt to demodulate psk1 tags and output binary (args optional)"},
+  {"psk2rawdemod",  CmdPSK2rawDemod,    1, "[clock] [invert<0|1>] [maxErr] -- Attempt to demodulate psk2 tags and output binary (args optional)"},

   {"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"},
   {"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"},

diff --git a/client/cmddata.h b/client/cmddata.h
index 514be3a2bb6c08a8a3a41c95abde3e6821c916fd..42954cbee0290fd66a47ce26903d998798545405 100644 (file)
--- a/client/cmddata.h
+++ b/client/cmddata.h
@@ -17,6 +17,7 @@ int CmdData(const char *Cmd);
 void printDemodBuff();
 int CmdAmp(const char *Cmd);
 int Cmdaskdemod(const char *Cmd);
 void printDemodBuff();
 int CmdAmp(const char *Cmd);
 int Cmdaskdemod(const char *Cmd);

+int CmdAskEM410xDemod(const char *Cmd);

 int Cmdaskrawdemod(const char *Cmd);
 int Cmdaskmandemod(const char *Cmd);
 int CmdAutoCorr(const char *Cmd);
 int Cmdaskrawdemod(const char *Cmd);
 int Cmdaskmandemod(const char *Cmd);
 int CmdAutoCorr(const char *Cmd);


@@ -26,15 +27,19 @@ int CmdBitstream(const char *Cmd);
 int CmdBuffClear(const char *Cmd);
 int CmdDec(const char *Cmd);
 int CmdDetectClockRate(const char *Cmd);
 int CmdBuffClear(const char *Cmd);
 int CmdDec(const char *Cmd);
 int CmdDetectClockRate(const char *Cmd);

+int CmdDetectNRZClockRate(const char *Cmd);
+int CmdDetectPSKClockRate(const char *Cmd);

 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 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 CmdFSKfcDetect(const char *Cmd);

 int CmdFSKrawdemod(const char *Cmd);
 int CmdFSKrawdemod(const char *Cmd);

-int CmdDetectNRZpskClockRate(const char *Cmd);
-int CmdpskNRZrawDemod(const char *Cmd);
+int CmdDetectPskClockRate(const char *Cmd);
+int CmdPSK1rawDemod(const char *Cmd);
+int CmdPSK2rawDemod(const char *Cmd);

 int CmdGrid(const char *Cmd);
 int CmdHexsamples(const char *Cmd);
 int CmdHide(const char *Cmd);
 int CmdGrid(const char *Cmd);
 int CmdHexsamples(const char *Cmd);
 int CmdHide(const char *Cmd);


@@ -46,6 +51,7 @@ int Cmdmandecoderaw(const char *Cmd);
 int CmdManchesterDemod(const char *Cmd);
 int CmdManchesterMod(const char *Cmd);
 int CmdNorm(const char *Cmd);
 int CmdManchesterDemod(const char *Cmd);
 int CmdManchesterMod(const char *Cmd);
 int CmdNorm(const char *Cmd);

+int CmdNRZrawDemod(const char *Cmd);

 int CmdPlot(const char *Cmd);
 int CmdSamples(const char *Cmd);
 int CmdTuneSamples(const char *Cmd);
 int CmdPlot(const char *Cmd);
 int CmdSamples(const char *Cmd);
 int CmdTuneSamples(const char *Cmd);

diff --git a/client/cmdlf.c b/client/cmdlf.c
index 07a8750f7d20e3b9a3131003276136892ed7824a..a34275f36763f664e9f0847542e8fd98a5f1cacf 100644 (file)
--- a/client/cmdlf.c
+++ b/client/cmdlf.c
@@ -559,13 +559,17 @@ int CmdLFfind(const char *Cmd)
 {
   int ans=0;
        char cmdp = param_getchar(Cmd, 0);
 {
   int ans=0;
        char cmdp = param_getchar(Cmd, 0);

-       
-       if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') {
-               PrintAndLog("Usage:  lf search <0|1>");
-               PrintAndLog("     <use data from Graphbuffer>, if not set, try reading data from tag.");
+       char testRaw = param_getchar(Cmd, 1);
+       if (strlen(Cmd) > 2 || cmdp == 'h' || cmdp == 'H') {
+               PrintAndLog("Usage:  lf search <0|1> [u]");
+               PrintAndLog("     <use data from Graphbuffer> , if not set, try reading data from tag.");
+    PrintAndLog("     [Search for Unknown tags] , if not set, reads only known tags.");

                PrintAndLog("");
                PrintAndLog("");

-               PrintAndLog("    sample: lf search");
-               PrintAndLog("          : lf search 1");
+               PrintAndLog("    sample: lf search     = try reading data from tag & search for known tags");
+               PrintAndLog("          : lf search 1   = use data from GraphBuffer & search for known tags");
+    PrintAndLog("          : lf search u   = try reading data from tag & search for known and unknown tags");
+    PrintAndLog("          : lf search 1 u = use data from GraphBuffer & search for known and unknown tags");
+

                return 0;
        }
 
                return 0;
        }
 


@@ -576,8 +580,9 @@ int CmdLFfind(const char *Cmd)
                PrintAndLog("Data in Graphbuffer was too small.");
                return 0;
   }
                PrintAndLog("Data in Graphbuffer was too small.");
                return 0;
   }

-
+  if (cmdp == 'u' || cmdp == 'U') testRaw = 'u';

   PrintAndLog("NOTE: some demods output possible binary\n  if it finds something that looks like a tag");
   PrintAndLog("NOTE: some demods output possible binary\n  if it finds something that looks like a tag");

+  PrintAndLog("False Positives ARE possible\n");  

   PrintAndLog("\nChecking for known tags:\n");
   ans=CmdFSKdemodIO("");
   if (ans>0) {
   PrintAndLog("\nChecking for known tags:\n");
   ans=CmdFSKdemodIO("");
   if (ans>0) {


@@ -610,12 +615,37 @@ int CmdLFfind(const char *Cmd)
     PrintAndLog("\nValid Indala ID Found!");
     return 1;
   }
     PrintAndLog("\nValid Indala ID Found!");
     return 1;
   }

-  ans=Cmdaskmandemod("");
+  ans=CmdAskEM410xDemod("");

   if (ans>0) {
     PrintAndLog("\nValid EM410x ID Found!");
     return 1;
   }
   if (ans>0) {
     PrintAndLog("\nValid EM410x ID Found!");
     return 1;
   }

-  PrintAndLog("No Known Tags Found!\n");
+  PrintAndLog("\nNo Known Tags Found!\n");
+  if (testRaw=='u' || testRaw=='U'){
+    //test unknown tag formats (raw mode)
+    PrintAndLog("\nChecking for Unknown tags:\n");
+    ans=CmdFSKfcDetect("");
+    if (ans == 1){ //fsk
+      ans=CmdFSKrawdemod("");
+      if (ans>0) {
+        PrintAndLog("\nUnknown FSK Modulated Tag Found!");
+        return 1;
+      }      
+    }
+    ans=Cmdaskmandemod("");
+    if (ans>0) {
+      PrintAndLog("\nUnknown ASK Modulated and Manchester encoded Tag Found!");
+      return 1;
+    }  
+    ans=CmdPSK1rawDemod("");
+    if (ans>0) {
+      PrintAndLog("Possible unknown PSK1 Modulated Tag Found above!\n\nCould also be PSK2 - try 'data psk2rawdemod'");
+      PrintAndLog("\nCould also be PSK3 - [currently not supported]");
+      PrintAndLog("\nCould also be NRZ - try 'data nrzrawdemod");
+      return 1;
+    }          
+    PrintAndLog("\nNo Data Found!\n");
+  }

   return 0;
 }
 
   return 0;
 }
 

diff --git a/client/graph.c b/client/graph.c
index 95050f558c169078e96a4d7aaad1a91e7419869b..009974371b3ed892dbaf2e96c176793b8d69faee 100644 (file)
--- a/client/graph.c
+++ b/client/graph.c
@@ -66,8 +66,7 @@ void setGraphBuf(uint8_t *buff, size_t size)
 }
 size_t getFromGraphBuf(uint8_t *buff)
 {
 }
 size_t getFromGraphBuf(uint8_t *buff)
 {

-       if ( buff == NULL ) return 0;
-       
+       if (buff == NULL ) return 0;

   uint32_t i;
   for (i=0;i<GraphTraceLen;++i){
     if (GraphBuffer[i]>127) GraphBuffer[i]=127; //trim
   uint32_t i;
   for (i=0;i<GraphTraceLen;++i){
     if (GraphBuffer[i]>127) GraphBuffer[i]=127; //trim


@@ -95,7 +94,7 @@ int GetClock(const char *str, int peak, int verbose)
                        PrintAndLog("Failed to copy from graphbuffer");
                        return -1;
                }
                        PrintAndLog("Failed to copy from graphbuffer");
                        return -1;
                }

-               clock = DetectASKClock(grph,size,0);
+               clock = DetectASKClock(grph,size,0,20);

                // Only print this message if we're not looping something
                if (!verbose){
                        PrintAndLog("Auto-detected clock rate: %d", clock);
                // Only print this message if we're not looping something
                if (!verbose){
                        PrintAndLog("Auto-detected clock rate: %d", clock);


@@ -136,7 +135,32 @@ void DetectHighLowInGraph(int *high, int *low, bool addFuzz) {
        }
 }
 
        }
 }
 

-int GetNRZpskClock(const char *str, int peak, int verbose)
+int GetPskClock(const char *str, int peak, int verbose)
+{
+       int clock;
+       sscanf(str, "%i", &clock);
+       if (!strcmp(str, ""))
+               clock = 0;
+
+       // Auto-detect clock
+       if (!clock)
+       {
+               uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};
+               size_t size = getFromGraphBuf(grph);
+               if ( size == 0 ) {
+                       PrintAndLog("Failed to copy from graphbuffer");
+                       return -1;
+               }
+               clock = DetectPSKClock(grph,size,0);
+               // Only print this message if we're not looping something
+               if (!verbose){
+                       PrintAndLog("Auto-detected clock rate: %d", clock);
+               }
+       }
+       return clock;
+}
+
+int GetNrzClock(const char *str, int peak, int verbose)

 {
        int clock;
        sscanf(str, "%i", &clock);
 {
        int clock;
        sscanf(str, "%i", &clock);


@@ -152,7 +176,7 @@ int GetNRZpskClock(const char *str, int peak, int verbose)
                        PrintAndLog("Failed to copy from graphbuffer");
                        return -1;
                }
                        PrintAndLog("Failed to copy from graphbuffer");
                        return -1;
                }

-               clock = DetectpskNRZClock(grph,size,0);
+               clock = DetectNRZClock(grph,size,0);

                // Only print this message if we're not looping something
                if (!verbose){
                        PrintAndLog("Auto-detected clock rate: %d", clock);
                // Only print this message if we're not looping something
                if (!verbose){
                        PrintAndLog("Auto-detected clock rate: %d", clock);

diff --git a/client/graph.h b/client/graph.h
index fe35d4f1c858aba645cf322346dfb7ca78487c02..56d6178c4995d648cee294378bce7ce1306d4e17 100644 (file)
--- a/client/graph.h
+++ b/client/graph.h
@@ -17,7 +17,8 @@ int ClearGraph(int redraw);
 //int DetectClock(int peak);
 size_t getFromGraphBuf(uint8_t *buff);
 int GetClock(const char *str, int peak, int verbose);
 //int DetectClock(int peak);
 size_t getFromGraphBuf(uint8_t *buff);
 int GetClock(const char *str, int peak, int verbose);

-int GetNRZpskClock(const char *str, int peak, int verbose);
+int GetPskClock(const char *str, int peak, int verbose);
+int GetNrzClock(const char *str, int peak, int verbose);

 void setGraphBuf(uint8_t *buff, size_t size);
 
 bool HasGraphData();
 void setGraphBuf(uint8_t *buff, size_t size);
 
 bool HasGraphData();