]> git.zerfleddert.de Git - proxmark3-svn/blobdiff - client/cmddata.c
wasn't ready for these yet...
[proxmark3-svn] / client / cmddata.c
index 05c495d977969d0e647a588c168ad5f673f1e027..51f9a880b757653c1e68a1d1fd364acfc4e445a4 100644 (file)
@@ -8,27 +8,30 @@
 // Data and Graph commands
 //-----------------------------------------------------------------------------
 
 // Data and Graph commands
 //-----------------------------------------------------------------------------
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
-#include "proxmark3.h"
-#include "data.h"
-#include "ui.h"
-#include "graph.h"
-#include "cmdparser.h"
+#include <stdio.h>    // also included in util.h
+#include <string.h>   // also included in util.h
+#include <inttypes.h>
+#include <limits.h>   // for CmdNorm INT_MIN && INT_MAX
+#include "data.h"     // also included in util.h
+#include "cmddata.h"
 #include "util.h"
 #include "cmdmain.h"
 #include "util.h"
 #include "cmdmain.h"
-#include "cmddata.h"
-#include "lfdemod.h"
-#include "usb_cmd.h"
-#include "crc.h"
-#include "crc16.h"
-#include "loclass/cipherutils.h"
+#include "proxmark3.h"
+#include "ui.h"       // for show graph controls
+#include "graph.h"    // for graph data
+#include "cmdparser.h"// already included in cmdmain.h
+#include "usb_cmd.h"  // already included in cmdmain.h and proxmark3.h
+#include "lfdemod.h"  // for demod code
+#include "crc.h"      // for pyramid checksum maxim
+#include "crc16.h"    // for FDXB demod checksum
+#include "loclass/cipherutils.h" // for decimating samples in getsamples
 
 uint8_t DemodBuffer[MAX_DEMOD_BUF_LEN];
 uint8_t g_debugMode=0;
 size_t DemodBufferLen=0;
 
 uint8_t DemodBuffer[MAX_DEMOD_BUF_LEN];
 uint8_t g_debugMode=0;
 size_t DemodBufferLen=0;
+//size_t g_demodStartIdx=0;
+//uint8_t g_demodClock=0;
+
 static int CmdHelp(const char *Cmd);
 
 //set the demod buffer with given array of binary (one bit per byte)
 static int CmdHelp(const char *Cmd);
 
 //set the demod buffer with given array of binary (one bit per byte)
@@ -172,22 +175,22 @@ void printEM410x(uint32_t hi, uint64_t id)
                }
                if (hi){
                        //output 88 bit em id
                }
                if (hi){
                        //output 88 bit em id
-                       PrintAndLog("\nEM TAG ID      : %06X%016llX", hi, id);
+                       PrintAndLog("\nEM TAG ID      : %06X%016" PRIX64, hi, id);
                } else{
                        //output 40 bit em id
                } else{
                        //output 40 bit em id
-                       PrintAndLog("\nEM TAG ID      : %010llX", id);
-                       PrintAndLog("Unique TAG ID  : %010llX",  id2lo);
+                       PrintAndLog("\nEM TAG ID      : %010" PRIX64, id);
                        PrintAndLog("\nPossible de-scramble patterns");
                        PrintAndLog("\nPossible de-scramble patterns");
+                       PrintAndLog("Unique TAG ID  : %010" PRIX64,  id2lo);
                        PrintAndLog("HoneyWell IdentKey {");
                        PrintAndLog("HoneyWell IdentKey {");
-                       PrintAndLog("DEZ 8          : %08lld",id & 0xFFFFFF);
-                       PrintAndLog("DEZ 10         : %010lld",id & 0xFFFFFFFF);
-                       PrintAndLog("DEZ 5.5        : %05lld.%05lld",(id>>16LL) & 0xFFFF,(id & 0xFFFF));
-                       PrintAndLog("DEZ 3.5A       : %03lld.%05lld",(id>>32ll),(id & 0xFFFF));
-                       PrintAndLog("DEZ 3.5B       : %03lld.%05lld",(id & 0xFF000000) >> 24,(id & 0xFFFF));
-                       PrintAndLog("DEZ 3.5C       : %03lld.%05lld",(id & 0xFF0000) >> 16,(id & 0xFFFF));
-                       PrintAndLog("DEZ 14/IK2     : %014lld",id);
-                       PrintAndLog("DEZ 15/IK3     : %015lld",id2lo);
-                       PrintAndLog("DEZ 20/ZK      : %02lld%02lld%02lld%02lld%02lld%02lld%02lld%02lld%02lld%02lld",
+                       PrintAndLog("DEZ 8          : %08" PRIu64,id & 0xFFFFFF);
+                       PrintAndLog("DEZ 10         : %010" PRIu64,id & 0xFFFFFFFF);
+                       PrintAndLog("DEZ 5.5        : %05lld.%05" PRIu64,(id>>16LL) & 0xFFFF,(id & 0xFFFF));
+                       PrintAndLog("DEZ 3.5A       : %03lld.%05" PRIu64,(id>>32ll),(id & 0xFFFF));
+                       PrintAndLog("DEZ 3.5B       : %03lld.%05" PRIu64,(id & 0xFF000000) >> 24,(id & 0xFFFF));
+                       PrintAndLog("DEZ 3.5C       : %03lld.%05" PRIu64,(id & 0xFF0000) >> 16,(id & 0xFFFF));
+                       PrintAndLog("DEZ 14/IK2     : %014" PRIu64,id);
+                       PrintAndLog("DEZ 15/IK3     : %015" PRIu64,id2lo);
+                       PrintAndLog("DEZ 20/ZK      : %02" PRIu64 "%02" PRIu64 "%02" PRIu64 "%02" PRIu64 "%02" PRIu64 "%02" PRIu64 "%02" PRIu64 "%02" PRIu64 "%02" PRIu64 "%02" PRIu64,
                            (id2lo & 0xf000000000) >> 36,
                            (id2lo & 0x0f00000000) >> 32,
                            (id2lo & 0x00f0000000) >> 28,
                            (id2lo & 0xf000000000) >> 36,
                            (id2lo & 0x0f00000000) >> 32,
                            (id2lo & 0x00f0000000) >> 28,
@@ -200,8 +203,8 @@ void printEM410x(uint32_t hi, uint64_t id)
                            (id2lo & 0x000000000f)
                        );
                        uint64_t paxton = (((id>>32) << 24) | (id & 0xffffff))  + 0x143e00;
                            (id2lo & 0x000000000f)
                        );
                        uint64_t paxton = (((id>>32) << 24) | (id & 0xffffff))  + 0x143e00;
-                       PrintAndLog("}\nOther          : %05lld_%03lld_%08lld",(id&0xFFFF),((id>>16LL) & 0xFF),(id & 0xFFFFFF));  
-                       PrintAndLog("Pattern Paxton : %lld [0x%llX]", paxton, paxton);
+                       PrintAndLog("}\nOther          : %05" PRIu64 "_%03" PRIu64 "_%08" PRIu64 "",(id&0xFFFF),((id>>16LL) & 0xFF),(id & 0xFFFFFF));  
+                       PrintAndLog("Pattern Paxton : %" PRIu64 " [0x%" PRIX64 "]", paxton, paxton);
 
                        uint32_t p1id = (id & 0xFFFFFF);
                        uint8_t arr[32] = {0x00};
 
                        uint32_t p1id = (id & 0xFFFFFF);
                        uint8_t arr[32] = {0x00};
@@ -253,6 +256,7 @@ void printEM410x(uint32_t hi, uint64_t id)
        return;
 }
 
        return;
 }
 
+//should be moved to cmdlfem4x.c
 int AskEm410xDecode(bool verbose, uint32_t *hi, uint64_t *lo )
 {
        size_t idx = 0;
 int AskEm410xDecode(bool verbose, uint32_t *hi, uint64_t *lo )
 {
        size_t idx = 0;
@@ -274,13 +278,15 @@ int AskEm410xDecode(bool verbose, uint32_t *hi, uint64_t *lo )
        }
        return 0;
 }
        }
        return 0;
 }
-
+//should be moved to cmdlfem4x.c
 int AskEm410xDemod(const char *Cmd, uint32_t *hi, uint64_t *lo, bool verbose)
 {
 int AskEm410xDemod(const char *Cmd, uint32_t *hi, uint64_t *lo, bool verbose)
 {
-       if (!ASKDemod(Cmd, FALSE, FALSE, 1)) return 0;
+       bool st = true;
+       if (!ASKDemod_ext(Cmd, false, false, 1, &st)) return 0;
        return AskEm410xDecode(verbose, hi, lo);
 }
 
        return AskEm410xDecode(verbose, hi, lo);
 }
 
+//should be moved to cmdlfem4x.c
 //by marshmellow
 //takes 3 arguments - clock, invert and maxErr as integers
 //attempts to demodulate ask while decoding manchester
 //by marshmellow
 //takes 3 arguments - clock, invert and maxErr as integers
 //attempts to demodulate ask while decoding manchester
@@ -312,13 +318,12 @@ int CmdAskEM410xDemod(const char *Cmd)
 //verbose will print results and demoding messages
 //emSearch will auto search for EM410x format in bitstream
 //askType switches decode: ask/raw = 0, ask/manchester = 1 
 //verbose will print results and demoding messages
 //emSearch will auto search for EM410x format in bitstream
 //askType switches decode: ask/raw = 0, ask/manchester = 1 
-int ASKDemod(const char *Cmd, bool verbose, bool emSearch, uint8_t askType)
-{
+int ASKDemod_ext(const char *Cmd, bool verbose, bool emSearch, uint8_t askType, bool *stCheck) {
        int invert=0;
        int clk=0;
        int maxErr=100;
        int maxLen=0;
        int invert=0;
        int clk=0;
        int maxErr=100;
        int maxLen=0;
-       uint8_t askAmp = 0;
+       uint8_t askamp = 0;
        char amp = param_getchar(Cmd, 0);
        uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
        sscanf(Cmd, "%i %i %i %i %c", &clk, &invert, &maxErr, &maxLen, &amp);
        char amp = param_getchar(Cmd, 0);
        uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
        sscanf(Cmd, "%i %i %i %i %c", &clk, &invert, &maxErr, &maxLen, &amp);
@@ -331,18 +336,31 @@ int ASKDemod(const char *Cmd, bool verbose, bool emSearch, uint8_t askType)
                invert=1;
                clk=0;
        }
                invert=1;
                clk=0;
        }
-       if (amp == 'a' || amp == 'A') askAmp=1; 
        size_t BitLen = getFromGraphBuf(BitStream);
        if (g_debugMode) PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);
        size_t BitLen = getFromGraphBuf(BitStream);
        if (g_debugMode) PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);
-       if (BitLen<255) return 0;
-       if (maxLen<BitLen && maxLen != 0) BitLen = maxLen;
-
-       int errCnt = askdemod(BitStream, &BitLen, &clk, &invert, maxErr, askAmp, askType);
+       if (BitLen < 255) return 0;
+       if (maxLen < BitLen && maxLen != 0) BitLen = maxLen;
+       int foundclk = 0;
+       //amp before ST check
+       if (amp == 'a' || amp == 'A') {
+               askAmp(BitStream, BitLen); 
+       }
+       bool st = false;
+       size_t ststart = 0, stend = 0;
+       if (*stCheck) st = DetectST_ext(BitStream, &BitLen, &foundclk, &ststart, &stend);
+       if (st) {
+               *stCheck = st;
+               clk = (clk == 0) ? foundclk : clk;
+               CursorCPos = ststart;
+               CursorDPos = stend;
+               if (verbose || g_debugMode) PrintAndLog("\nFound Sequence Terminator - First one is shown by orange and blue graph markers");
+       }
+       int errCnt = askdemod(BitStream, &BitLen, &clk, &invert, maxErr, askamp, askType);
        if (errCnt<0 || BitLen<16){  //if fatal error (or -1)
                if (g_debugMode) PrintAndLog("DEBUG: 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) PrintAndLog("DEBUG: no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk);
                return 0;
        }
-       if (errCnt>maxErr){
+       if (errCnt > maxErr){
                if (g_debugMode) PrintAndLog("DEBUG: Too many errors found, errors:%d, bits:%d, clock:%d",errCnt, BitLen, clk);
                return 0;
        }
                if (g_debugMode) PrintAndLog("DEBUG: Too many errors found, errors:%d, bits:%d, clock:%d",errCnt, BitLen, clk);
                return 0;
        }
@@ -365,6 +383,10 @@ int ASKDemod(const char *Cmd, bool verbose, bool emSearch, uint8_t askType)
        }
        return 1;
 }
        }
        return 1;
 }
+int ASKDemod(const char *Cmd, bool verbose, bool emSearch, uint8_t askType) {
+       bool st = false;
+       return ASKDemod_ext(Cmd, verbose, emSearch, askType, &st);
+}
 
 //by marshmellow
 //takes 5 arguments - clock, invert, maxErr, maxLen as integers and amplify as char == 'a'
 
 //by marshmellow
 //takes 5 arguments - clock, invert, maxErr, maxLen as integers and amplify as char == 'a'
@@ -373,8 +395,9 @@ int ASKDemod(const char *Cmd, bool verbose, bool emSearch, uint8_t askType)
 int Cmdaskmandemod(const char *Cmd)
 {
        char cmdp = param_getchar(Cmd, 0);
 int Cmdaskmandemod(const char *Cmd)
 {
        char cmdp = param_getchar(Cmd, 0);
-       if (strlen(Cmd) > 25 || cmdp == 'h' || cmdp == 'H') {
-               PrintAndLog("Usage:  data rawdemod am [clock] <invert> [maxError] [maxLen] [amplify]");
+       if (strlen(Cmd) > 45 || cmdp == 'h' || cmdp == 'H') {
+               PrintAndLog("Usage:  data rawdemod am <s> [clock] <invert> [maxError] [maxLen] [amplify]");
+               PrintAndLog("     ['s'] optional, check for Sequence Terminator");
                PrintAndLog("     [set clock as integer] optional, if not set, autodetect");
                PrintAndLog("     <invert>, 1 to invert output");
                PrintAndLog("     [set maximum allowed errors], default = 100");
                PrintAndLog("     [set clock as integer] optional, if not set, autodetect");
                PrintAndLog("     <invert>, 1 to invert output");
                PrintAndLog("     [set maximum allowed errors], default = 100");
@@ -388,7 +411,13 @@ int Cmdaskmandemod(const char *Cmd)
                PrintAndLog("          : data rawdemod am 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;
        }
                PrintAndLog("          : data rawdemod am 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;
        }
-       return ASKDemod(Cmd, TRUE, TRUE, 1);
+       bool st = true;
+       if (Cmd[0]=='s') 
+               return ASKDemod_ext(Cmd++, true, true, 1, &st);
+       else if (Cmd[1] == 's')
+               return ASKDemod_ext(Cmd+=2, true, true, 1, &st);
+       else
+               return ASKDemod(Cmd, true, true, 1);
 }
 
 //by marshmellow
 }
 
 //by marshmellow
@@ -427,7 +456,8 @@ int Cmdmandecoderaw(const char *Cmd)
 
        sscanf(Cmd, "%i %i", &invert, &maxErr);
        size=i;
 
        sscanf(Cmd, "%i %i", &invert, &maxErr);
        size=i;
-       errCnt=manrawdecode(BitStream, &size, invert);
+       uint8_t alignPos = 0;
+       errCnt=manrawdecode(BitStream, &size, invert, &alignPos);
        if (errCnt>=maxErr){
                PrintAndLog("Too many errors: %d",errCnt);
                return 0;
        if (errCnt>=maxErr){
                PrintAndLog("Too many errors: %d",errCnt);
                return 0;
@@ -563,9 +593,10 @@ int Cmdaskbiphdemod(const char *Cmd)
                PrintAndLog("          : data rawdemod ab 0 64 1 0 0 a = demod an ask/biph tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors, and amp");
                return 0;
        }
                PrintAndLog("          : data rawdemod ab 0 64 1 0 0 a = demod an ask/biph tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors, and amp");
                return 0;
        }
-       return ASKbiphaseDemod(Cmd, TRUE);
+       return ASKbiphaseDemod(Cmd, true);
 }
 
 }
 
+//could be split to a gProxII file
 //by marshmellow
 //attempts to demodulate and identify a G_Prox_II verex/chubb card
 //WARNING: if it fails during some points it will destroy the DemodBuffer data
 //by marshmellow
 //attempts to demodulate and identify a G_Prox_II verex/chubb card
 //WARNING: if it fails during some points it will destroy the DemodBuffer data
@@ -573,8 +604,8 @@ int Cmdaskbiphdemod(const char *Cmd)
 //if successful it will push askraw data back to demod buffer ready for emulation
 int CmdG_Prox_II_Demod(const char *Cmd)
 {
 //if successful it will push askraw data back to demod buffer ready for emulation
 int CmdG_Prox_II_Demod(const char *Cmd)
 {
-       if (!ASKbiphaseDemod(Cmd, FALSE)){
-               if (g_debugMode) PrintAndLog("ASKbiphaseDemod failed 1st try");
+       if (!ASKbiphaseDemod(Cmd, false)){
+               if (g_debugMode) PrintAndLog("Error gProxII: ASKbiphaseDemod failed 1st try");
                return 0;
        }
        size_t size = DemodBufferLen;
                return 0;
        }
        size_t size = DemodBufferLen;
@@ -584,46 +615,32 @@ int CmdG_Prox_II_Demod(const char *Cmd)
                if (g_debugMode) PrintAndLog("Error gProxII_Demod");
                return 0;
        }
                if (g_debugMode) PrintAndLog("Error gProxII_Demod");
                return 0;
        }
-       //got a good demod
-       uint32_t ByteStream[65] = {0x00};
+       //got a good demod of 96 bits
+       uint8_t ByteStream[8] = {0x00};
        uint8_t xorKey=0;
        uint8_t xorKey=0;
-       uint8_t keyCnt=0;
-       uint8_t bitCnt=0;
-       uint8_t ByteCnt=0;
-       size_t startIdx = ans + 6; //start after preamble
-       for (size_t idx = 0; idx<size-6; idx++){
-               if ((idx+1) % 5 == 0){
-                       //spacer bit - should be 0
-                       if (DemodBuffer[startIdx+idx] != 0) {
-                               if (g_debugMode) PrintAndLog("Error spacer not 0: %d, pos: %d",DemodBuffer[startIdx+idx],startIdx+idx);
-                               return 0;
-                       }
-                       continue;
-               } 
-               if (keyCnt<8){ //lsb first
-                       xorKey = xorKey | (DemodBuffer[startIdx+idx]<<keyCnt);
-                       keyCnt++;
-                       if (keyCnt==8 && g_debugMode) PrintAndLog("xorKey Found: %02x", xorKey);
-                       continue;
-               }
-               //lsb first
-               ByteStream[ByteCnt] = ByteStream[ByteCnt] | (DemodBuffer[startIdx+idx]<<bitCnt);
-               bitCnt++;
-               if (bitCnt % 8 == 0){
-                       if (g_debugMode) PrintAndLog("byte %d: %02x",ByteCnt,ByteStream[ByteCnt]);
-                       bitCnt=0;
-                       ByteCnt++;
-               }
+       size_t startIdx = ans + 6; //start after 6 bit preamble
+
+       uint8_t bits_no_spacer[90];
+       //so as to not mess with raw DemodBuffer copy to a new sample array
+       memcpy(bits_no_spacer, DemodBuffer + startIdx, 90);
+       // remove the 18 (90/5=18) parity bits (down to 72 bits (96-6-18=72))
+       size_t bitLen = removeParity(bits_no_spacer, 0, 5, 3, 90); //source, startloc, paritylen, ptype, length_to_run
+       if (bitLen != 72) {
+               if (g_debugMode) PrintAndLog("Error gProxII: spacer removal did not produce 72 bits: %u, start: %u", bitLen, startIdx);
+               return 0;
        }
        }
-       for (uint8_t i = 0; i < ByteCnt; i++){
-               ByteStream[i] ^= xorKey; //xor
-               if (g_debugMode) PrintAndLog("byte %d after xor: %02x", i, ByteStream[i]);
+       // get key and then get all 8 bytes of payload decoded
+       xorKey = (uint8_t)bytebits_to_byteLSBF(bits_no_spacer, 8);
+       for (size_t idx = 0; idx < 8; idx++) {
+               ByteStream[idx] = ((uint8_t)bytebits_to_byteLSBF(bits_no_spacer+8 + (idx*8),8)) ^ xorKey;
+               if (g_debugMode) PrintAndLog("byte %u after xor: %02x", (unsigned int)idx, ByteStream[idx]);
        }
        }
-       //now ByteStream contains 64 bytes of decrypted raw tag data
+       //now ByteStream contains 8 Bytes (64 bits) of decrypted raw tag data
        // 
        uint8_t fmtLen = ByteStream[0]>>2;
        uint32_t FC = 0;
        uint32_t Card = 0;
        // 
        uint8_t fmtLen = ByteStream[0]>>2;
        uint32_t FC = 0;
        uint32_t Card = 0;
+       //get raw 96 bits to print
        uint32_t raw1 = bytebits_to_byte(DemodBuffer+ans,32);
        uint32_t raw2 = bytebits_to_byte(DemodBuffer+ans+32, 32);
        uint32_t raw3 = bytebits_to_byte(DemodBuffer+ans+64, 32);
        uint32_t raw1 = bytebits_to_byte(DemodBuffer+ans,32);
        uint32_t raw2 = bytebits_to_byte(DemodBuffer+ans+32, 32);
        uint32_t raw3 = bytebits_to_byte(DemodBuffer+ans+64, 32);
@@ -631,19 +648,21 @@ int CmdG_Prox_II_Demod(const char *Cmd)
        if (fmtLen==36){
                FC = ((ByteStream[3] & 0x7F)<<7) | (ByteStream[4]>>1);
                Card = ((ByteStream[4]&1)<<19) | (ByteStream[5]<<11) | (ByteStream[6]<<3) | (ByteStream[7]>>5);
        if (fmtLen==36){
                FC = ((ByteStream[3] & 0x7F)<<7) | (ByteStream[4]>>1);
                Card = ((ByteStream[4]&1)<<19) | (ByteStream[5]<<11) | (ByteStream[6]<<3) | (ByteStream[7]>>5);
-               PrintAndLog("G-Prox-II Found: FmtLen %d, FC %d, Card %d",fmtLen,FC,Card);
+               PrintAndLog("G-Prox-II Found: FmtLen %d, FC %u, Card %u", (int)fmtLen, FC, Card);
        } else if(fmtLen==26){
                FC = ((ByteStream[3] & 0x7F)<<1) | (ByteStream[4]>>7);
                Card = ((ByteStream[4]&0x7F)<<9) | (ByteStream[5]<<1) | (ByteStream[6]>>7);
        } else if(fmtLen==26){
                FC = ((ByteStream[3] & 0x7F)<<1) | (ByteStream[4]>>7);
                Card = ((ByteStream[4]&0x7F)<<9) | (ByteStream[5]<<1) | (ByteStream[6]>>7);
-               PrintAndLog("G-Prox-II Found: FmtLen %d, FC %d, Card %d",fmtLen,FC,Card);    
+               PrintAndLog("G-Prox-II Found: FmtLen %d, FC %u, Card %u", (int)fmtLen, FC, Card);
        } else {
        } else {
-               PrintAndLog("Unknown G-Prox-II Fmt Found: FmtLen %d",fmtLen);
+               PrintAndLog("Unknown G-Prox-II Fmt Found: FmtLen %d",(int)fmtLen);
+               PrintAndLog("Decoded Raw: %s", sprint_hex(ByteStream, 8)); 
        }
        PrintAndLog("Raw: %08x%08x%08x", raw1,raw2,raw3);
        setDemodBuf(DemodBuffer+ans, 96, 0);
        return 1;
 }
 
        }
        PrintAndLog("Raw: %08x%08x%08x", raw1,raw2,raw3);
        setDemodBuf(DemodBuffer+ans, 96, 0);
        return 1;
 }
 
+//could be moved to a viking file
 //by marshmellow
 //see ASKDemod for what args are accepted
 int CmdVikingDemod(const char *Cmd)
 //by marshmellow
 //see ASKDemod for what args are accepted
 int CmdVikingDemod(const char *Cmd)
@@ -664,7 +683,7 @@ int CmdVikingDemod(const char *Cmd)
        uint32_t raw2 = bytebits_to_byte(DemodBuffer+ans+32, 32);
        uint32_t cardid = bytebits_to_byte(DemodBuffer+ans+24, 32);
        uint8_t  checksum = bytebits_to_byte(DemodBuffer+ans+32+24, 8);
        uint32_t raw2 = bytebits_to_byte(DemodBuffer+ans+32, 32);
        uint32_t cardid = bytebits_to_byte(DemodBuffer+ans+24, 32);
        uint8_t  checksum = bytebits_to_byte(DemodBuffer+ans+32+24, 8);
-       PrintAndLog("Viking Tag Found: Card ID %08X, Checksum: %02X", cardid, checksum);
+       PrintAndLog("Viking Tag Found: Card ID %08X, Checksum: %02X", cardid, (unsigned int) checksum);
        PrintAndLog("Raw: %08X%08X", raw1,raw2);
        setDemodBuf(DemodBuffer+ans, 64, 0);
        return 1;
        PrintAndLog("Raw: %08X%08X", raw1,raw2);
        setDemodBuf(DemodBuffer+ans, 64, 0);
        return 1;
@@ -674,7 +693,7 @@ int CmdVikingDemod(const char *Cmd)
 int Cmdaskrawdemod(const char *Cmd)
 {
        char cmdp = param_getchar(Cmd, 0);
 int Cmdaskrawdemod(const char *Cmd)
 {
        char cmdp = param_getchar(Cmd, 0);
-       if (strlen(Cmd) > 25 || cmdp == 'h' || cmdp == 'H') {
+       if (strlen(Cmd) > 35 || cmdp == 'h' || cmdp == 'H') {
                PrintAndLog("Usage:  data rawdemod ar [clock] <invert> [maxError] [maxLen] [amplify]");
                PrintAndLog("     [set clock as integer] optional, if not set, autodetect");
                PrintAndLog("     <invert>, 1 to invert output");
                PrintAndLog("Usage:  data rawdemod ar [clock] <invert> [maxError] [maxLen] [amplify]");
                PrintAndLog("     [set clock as integer] optional, if not set, autodetect");
                PrintAndLog("     <invert>, 1 to invert output");
@@ -691,7 +710,7 @@ int Cmdaskrawdemod(const char *Cmd)
                PrintAndLog("          : data rawdemod ar 64 1 0 0 a = demod an ask tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors, and amp");
                return 0;
        }
                PrintAndLog("          : data rawdemod ar 64 1 0 0 a = demod an ask tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors, and amp");
                return 0;
        }
-       return ASKDemod(Cmd, TRUE, FALSE, 0);
+       return ASKDemod(Cmd, true, false, 0);
 }
 
 int AutoCorrelate(int window, bool SaveGrph, bool verbose)
 }
 
 int AutoCorrelate(int window, bool SaveGrph, bool verbose)
@@ -756,7 +775,7 @@ int CmdAutoCorr(const char *Cmd)
                return usage_data_autocorr();
        int window = 4000; //set default
        char grph=0;
                return usage_data_autocorr();
        int window = 4000; //set default
        char grph=0;
-       bool updateGrph = FALSE;
+       bool updateGrph = false;
        sscanf(Cmd, "%i %c", &window, &grph);
 
        if (window >= GraphTraceLen) {
        sscanf(Cmd, "%i %c", &window, &grph);
 
        if (window >= GraphTraceLen) {
@@ -764,8 +783,8 @@ int CmdAutoCorr(const char *Cmd)
                        GraphTraceLen);
                return 0;
        }
                        GraphTraceLen);
                return 0;
        }
-       if (grph == 'g') updateGrph=TRUE;
-       return AutoCorrelate(window, updateGrph, TRUE);
+       if (grph == 'g') updateGrph=true;
+       return AutoCorrelate(window, updateGrph, true);
 }
 
 int CmdBitsamples(const char *Cmd)
 }
 
 int CmdBitsamples(const char *Cmd)
@@ -830,16 +849,18 @@ int CmdUndec(const char *Cmd)
        uint8_t factor = param_get8ex(Cmd, 0,2, 10);
        //We have memory, don't we?
        int swap[MAX_GRAPH_TRACE_LEN] = { 0 };
        uint8_t factor = param_get8ex(Cmd, 0,2, 10);
        //We have memory, don't we?
        int swap[MAX_GRAPH_TRACE_LEN] = { 0 };
-       uint32_t g_index = 0 ,s_index = 0;
-       while(g_index < GraphTraceLen && s_index < MAX_GRAPH_TRACE_LEN)
+       uint32_t g_index = 0s_index = 0;
+       while(g_index < GraphTraceLen && s_index + factor < MAX_GRAPH_TRACE_LEN)
        {
                int count = 0;
        {
                int count = 0;
-               for(count = 0; count < factor && s_index+count < MAX_GRAPH_TRACE_LEN; count ++)
+               for(count = 0; count < factor && s_index + count < MAX_GRAPH_TRACE_LEN; count++)
                        swap[s_index+count] = GraphBuffer[g_index];
                        swap[s_index+count] = GraphBuffer[g_index];
-               s_index+=count;
+
+               s_index += count;
+               g_index++;
        }
 
        }
 
-       memcpy(GraphBuffer,swap, s_index * sizeof(int));
+       memcpy(GraphBuffer, swap, s_index * sizeof(int));
        GraphTraceLen = s_index;
        RepaintGraphWindow();
        return 0;
        GraphTraceLen = s_index;
        RepaintGraphWindow();
        return 0;
@@ -873,13 +894,15 @@ int CmdGraphShiftZero(const char *Cmd)
 int CmdAskEdgeDetect(const char *Cmd)
 {
        int thresLen = 25;
 int CmdAskEdgeDetect(const char *Cmd)
 {
        int thresLen = 25;
+       int Last = 0;
        sscanf(Cmd, "%i", &thresLen); 
 
        for(int i = 1; i<GraphTraceLen; i++){
                if (GraphBuffer[i]-GraphBuffer[i-1]>=thresLen) //large jump up
        sscanf(Cmd, "%i", &thresLen); 
 
        for(int i = 1; i<GraphTraceLen; i++){
                if (GraphBuffer[i]-GraphBuffer[i-1]>=thresLen) //large jump up
-                       GraphBuffer[i-1] = 127;
+                       Last = 127;
                else if(GraphBuffer[i]-GraphBuffer[i-1]<=-1*thresLen) //large jump down
                else if(GraphBuffer[i]-GraphBuffer[i-1]<=-1*thresLen) //large jump down
-                       GraphBuffer[i-1] = -127;
+                       Last = -127;
+               GraphBuffer[i-1] = Last;
        }
        RepaintGraphWindow();
        return 0;
        }
        RepaintGraphWindow();
        return 0;
@@ -919,19 +942,21 @@ int CmdDetectClockRate(const char *Cmd)
 
 char *GetFSKType(uint8_t fchigh, uint8_t fclow, uint8_t invert)
 {
 
 char *GetFSKType(uint8_t fchigh, uint8_t fclow, uint8_t invert)
 {
-       char *fskType;
+       static char fType[8];
+       memset(fType, 0x00, 8);
+       char *fskType = fType;
        if (fchigh==10 && fclow==8){
                if (invert) //fsk2a
        if (fchigh==10 && fclow==8){
                if (invert) //fsk2a
-                       fskType = "FSK2a";
+                       memcpy(fskType, "FSK2a", 5);
                else //fsk2
                else //fsk2
-                       fskType = "FSK2";
+                       memcpy(fskType, "FSK2", 4);
        } else if (fchigh == 8 && fclow == 5) {
                if (invert)
        } else if (fchigh == 8 && fclow == 5) {
                if (invert)
-                       fskType = "FSK1";
+                       memcpy(fskType, "FSK1", 4);
                else
                else
-                       fskType = "FSK1a";
+                       memcpy(fskType, "FSK1a", 5);
        } else {
        } else {
-               fskType = "FSK??";
+               memcpy(fskType, "FSK??", 5);
        }
        return fskType;
 }
        }
        return fskType;
 }
@@ -950,39 +975,40 @@ int FSKrawDemod(const char *Cmd, bool verbose)
        invert = param_get8(Cmd, 1);
        fchigh = param_get8(Cmd, 2);
        fclow = param_get8(Cmd, 3);
        invert = param_get8(Cmd, 1);
        fchigh = param_get8(Cmd, 2);
        fclow = param_get8(Cmd, 3);
+
        if (strlen(Cmd)>0 && strlen(Cmd)<=2) {
        if (strlen(Cmd)>0 && strlen(Cmd)<=2) {
-                if (rfLen==1){
+               if (rfLen==1) {
                        invert = 1;   //if invert option only is used
                        rfLen = 0;
                        invert = 1;   //if invert option only is used
                        rfLen = 0;
-                }
+               }
        }
        uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
        size_t BitLen = getFromGraphBuf(BitStream);
        if (BitLen==0) return 0;
        //get field clock lengths
        }
        uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
        size_t BitLen = getFromGraphBuf(BitStream);
        if (BitLen==0) return 0;
        //get field clock lengths
-       uint8_t fc1=0, fc2=0, rf1=0;
+       uint16_t fcs=0;
        if (!fchigh || !fclow) {
        if (!fchigh || !fclow) {
-               uint8_t ans = fskClocks(&fc1, &fc2, &rf1, false);
-               if (ans == 0) {
-                       if (g_debugMode) PrintAndLog("\nError: cannot detect valid fsk field clocks");                  
-                       return 0; // can't detect field clock
+               fcs = countFC(BitStream, BitLen, 1);
+               if (!fcs) {
+                       fchigh = 10;
+                       fclow = 8;
+               } else {
+                       fchigh = (fcs >> 8) & 0x00FF;
+                       fclow = fcs & 0x00FF;
                }
                }
-               fchigh = fc1;
-               fclow = fc2;
-               if (rfLen == 0) rfLen = rf1;
        }
        //get bit clock length
        }
        //get bit clock length
-       if (!rfLen){
+       if (!rfLen) {
                rfLen = detectFSKClk(BitStream, BitLen, fchigh, fclow);
                if (!rfLen) rfLen = 50;
        }
        int size = fskdemod(BitStream, BitLen, rfLen, invert, fchigh, fclow);
                rfLen = detectFSKClk(BitStream, BitLen, fchigh, fclow);
                if (!rfLen) rfLen = 50;
        }
        int size = fskdemod(BitStream, BitLen, rfLen, invert, fchigh, fclow);
-       if (size > 0){
+       if (size > 0) {
                setDemodBuf(BitStream,size,0);
 
                // Now output the bitstream to the scrollback by line of 16 bits
                if (verbose || g_debugMode) {
                setDemodBuf(BitStream,size,0);
 
                // Now output the bitstream to the scrollback by line of 16 bits
                if (verbose || g_debugMode) {
-                       PrintAndLog("\nUsing Clock:%d, invert:%d, fchigh:%d, fclow:%d", rfLen, invert, fchigh, fclow);
+                       PrintAndLog("\nUsing Clock:%u, invert:%u, fchigh:%u, fclow:%u", (unsigned int)rfLen, (unsigned int)invert, (unsigned int)fchigh, (unsigned int)fclow);
                        PrintAndLog("%s decoded bitstream:",GetFSKType(fchigh,fclow,invert));
                        printDemodBuff();
                }
                        PrintAndLog("%s decoded bitstream:",GetFSKType(fchigh,fclow,invert));
                        printDemodBuff();
                }
@@ -1001,7 +1027,7 @@ int FSKrawDemod(const char *Cmd, bool verbose)
 int CmdFSKrawdemod(const char *Cmd)
 {
        char cmdp = param_getchar(Cmd, 0);
 int CmdFSKrawdemod(const char *Cmd)
 {
        char cmdp = param_getchar(Cmd, 0);
-       if (strlen(Cmd) > 10 || cmdp == 'h' || cmdp == 'H') {
+       if (strlen(Cmd) > 20 || cmdp == 'h' || cmdp == 'H') {
                PrintAndLog("Usage:  data rawdemod fs [clock] <invert> [fchigh] [fclow]");
                PrintAndLog("     [set clock as integer] optional, omit for autodetect.");
                PrintAndLog("     <invert>, 1 for invert output, can be used even if the clock is omitted");
                PrintAndLog("Usage:  data rawdemod fs [clock] <invert> [fchigh] [fclow]");
                PrintAndLog("     [set clock as integer] optional, omit for autodetect.");
                PrintAndLog("     <invert>, 1 for invert output, can be used even if the clock is omitted");
@@ -1017,9 +1043,10 @@ int CmdFSKrawdemod(const char *Cmd)
                PrintAndLog("          : data rawdemod fs 50 1 10 8 = demod an fsk2a RF/50 tag from GraphBuffer");
                return 0;
        }
                PrintAndLog("          : data rawdemod fs 50 1 10 8 = demod an fsk2a RF/50 tag from GraphBuffer");
                return 0;
        }
-       return FSKrawDemod(Cmd, TRUE);
+       return FSKrawDemod(Cmd, true);
 }
 
 }
 
+//move to cmdlfhid.c
 //by marshmellow (based on existing demod + holiman's refactor)
 //HID Prox demod - FSK RF/50 with preamble of 00011101 (then manchester encoded)
 //print full HID Prox ID and some bit format details if found
 //by marshmellow (based on existing demod + holiman's refactor)
 //HID Prox demod - FSK RF/50 with preamble of 00011101 (then manchester encoded)
 //print full HID Prox ID and some bit format details if found
@@ -1106,6 +1133,7 @@ int CmdFSKdemodHID(const char *Cmd)
        return 1;
 }
 
        return 1;
 }
 
+
 //by marshmellow
 //Paradox Prox demod - FSK RF/50 with preamble of 00001111 (then manchester encoded)
 //print full Paradox Prox ID and some bit format details if found
 //by marshmellow
 //Paradox Prox demod - FSK RF/50 with preamble of 00001111 (then manchester encoded)
 //print full Paradox Prox ID and some bit format details if found
@@ -1255,7 +1283,7 @@ int CmdFSKdemodAWID(const char *Cmd)
        //get binary from fsk wave
        int idx = AWIDdemodFSK(BitStream, &size);
        if (idx<=0){
        //get binary from fsk wave
        int idx = AWIDdemodFSK(BitStream, &size);
        if (idx<=0){
-               if (g_debugMode==1){
+               if (g_debugMode){
                        if (idx == -1)
                                PrintAndLog("DEBUG: Error - not enough samples");
                        else if (idx == -2)
                        if (idx == -1)
                                PrintAndLog("DEBUG: Error - not enough samples");
                        else if (idx == -2)
@@ -1293,7 +1321,7 @@ int CmdFSKdemodAWID(const char *Cmd)
 
        size = removeParity(BitStream, idx+8, 4, 1, 88);
        if (size != 66){
 
        size = removeParity(BitStream, idx+8, 4, 1, 88);
        if (size != 66){
-               if (g_debugMode==1) PrintAndLog("DEBUG: Error - at parity check-tag size does not match AWID format");
+               if (g_debugMode) PrintAndLog("DEBUG: Error - at parity check-tag size does not match AWID format");
                return 0;
        }
        // ok valid card found!
                return 0;
        }
        // ok valid card found!
@@ -1353,7 +1381,7 @@ int CmdFSKdemodPyramid(const char *Cmd)
        //get binary from fsk wave
        int idx = PyramiddemodFSK(BitStream, &size);
        if (idx < 0){
        //get binary from fsk wave
        int idx = PyramiddemodFSK(BitStream, &size);
        if (idx < 0){
-               if (g_debugMode==1){
+               if (g_debugMode){
                        if (idx == -5)
                                PrintAndLog("DEBUG: Error - not enough samples");
                        else if (idx == -1)
                        if (idx == -5)
                                PrintAndLog("DEBUG: Error - not enough samples");
                        else if (idx == -1)
@@ -1409,7 +1437,7 @@ int CmdFSKdemodPyramid(const char *Cmd)
 
        size = removeParity(BitStream, idx+8, 8, 1, 120);
        if (size != 105){
 
        size = removeParity(BitStream, idx+8, 8, 1, 120);
        if (size != 105){
-               if (g_debugMode==1
+               if (g_debugMode) 
                        PrintAndLog("DEBUG: Error at parity check - tag size does not match Pyramid format, SIZE: %d, IDX: %d, hi3: %x",size, idx, rawHi3);
                return 0;
        }
                        PrintAndLog("DEBUG: Error at parity check - tag size does not match Pyramid format, SIZE: %d, IDX: %d, hi3: %x",size, idx, rawHi3);
                return 0;
        }
@@ -1558,8 +1586,8 @@ int CmdFDXBdemodBI(const char *Cmd){
        if (g_debugMode) PrintAndLog("Raw ID Hex: %s", sprint_hex(raw,8));
 
        uint16_t calcCrc = crc16_ccitt_kermit(raw, 8);
        if (g_debugMode) PrintAndLog("Raw ID Hex: %s", sprint_hex(raw,8));
 
        uint16_t calcCrc = crc16_ccitt_kermit(raw, 8);
-       PrintAndLog("Animal ID:     %04u-%012llu", countryCode, NationalCode);
-       PrintAndLog("National Code: %012llu", NationalCode);
+       PrintAndLog("Animal ID:     %04u-%012" PRIu64, countryCode, NationalCode);
+       PrintAndLog("National Code: %012" PRIu64, NationalCode);
        PrintAndLog("CountryCode:   %04u", countryCode);
        PrintAndLog("Extended Data: %s", dataBlockBit ? "True" : "False");
        PrintAndLog("reserved Code: %u", reservedCode);
        PrintAndLog("CountryCode:   %04u", countryCode);
        PrintAndLog("Extended Data: %s", dataBlockBit ? "True" : "False");
        PrintAndLog("reserved Code: %u", reservedCode);
@@ -1632,21 +1660,21 @@ int CmdIndalaDecode(const char *Cmd)
        }
 
        if (!ans){
        }
 
        if (!ans){
-               if (g_debugMode==1
+               if (g_debugMode) 
                        PrintAndLog("Error1: %d",ans);
                return 0;
        }
        uint8_t invert=0;
        size_t size = DemodBufferLen;
                        PrintAndLog("Error1: %d",ans);
                return 0;
        }
        uint8_t invert=0;
        size_t size = DemodBufferLen;
-       size_t startIdx = indala26decode(DemodBuffer, &size, &invert);
-       if (startIdx < 1 || size > 224) {
-               if (g_debugMode==1)
+       int startIdx = indala26decode(DemodBuffer, &size, &invert);
+       if (startIdx < 0 || size > 224) {
+               if (g_debugMode)
                        PrintAndLog("Error2: %d",ans);
                return -1;
        }
                        PrintAndLog("Error2: %d",ans);
                return -1;
        }
-       setDemodBuf(DemodBuffer, size, startIdx);
+       setDemodBuf(DemodBuffer, size, (size_t)startIdx);
        if (invert)
        if (invert)
-               if (g_debugMode==1)
+               if (g_debugMode)
                        PrintAndLog("Had to invert bits");
 
        PrintAndLog("BitLen: %d",DemodBufferLen);
                        PrintAndLog("Had to invert bits");
 
        PrintAndLog("BitLen: %d",DemodBufferLen);
@@ -1758,7 +1786,7 @@ int NRZrawDemod(const char *Cmd, bool verbose)
 int CmdNRZrawDemod(const char *Cmd)
 {
        char cmdp = param_getchar(Cmd, 0);
 int CmdNRZrawDemod(const char *Cmd)
 {
        char cmdp = param_getchar(Cmd, 0);
-       if (strlen(Cmd) > 10 || cmdp == 'h' || cmdp == 'H') {
+       if (strlen(Cmd) > 16 || cmdp == 'h' || cmdp == 'H') {
                PrintAndLog("Usage:  data rawdemod nr [clock] <0|1> [maxError]");
                PrintAndLog("     [set clock as integer] optional, if not set, autodetect.");
                PrintAndLog("     <invert>, 1 for invert output");
                PrintAndLog("Usage:  data rawdemod nr [clock] <0|1> [maxError]");
                PrintAndLog("     [set clock as integer] optional, if not set, autodetect.");
                PrintAndLog("     <invert>, 1 for invert output");
@@ -1771,7 +1799,7 @@ int CmdNRZrawDemod(const char *Cmd)
                PrintAndLog("          : data rawdemod nr 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;
        }
                PrintAndLog("          : data rawdemod nr 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;
        }
-       return NRZrawDemod(Cmd, TRUE);
+       return NRZrawDemod(Cmd, true);
 }
 
 // by marshmellow
 }
 
 // by marshmellow
@@ -1782,7 +1810,7 @@ int CmdPSK1rawDemod(const char *Cmd)
 {
        int ans;
        char cmdp = param_getchar(Cmd, 0);
 {
        int ans;
        char cmdp = param_getchar(Cmd, 0);
-       if (strlen(Cmd) > 10 || cmdp == 'h' || cmdp == 'H') {
+       if (strlen(Cmd) > 16 || cmdp == 'h' || cmdp == 'H') {
                PrintAndLog("Usage:  data rawdemod p1 [clock] <0|1> [maxError]");
                PrintAndLog("     [set clock as integer] optional, if not set, autodetect.");
                PrintAndLog("     <invert>, 1 for invert output");
                PrintAndLog("Usage:  data rawdemod p1 [clock] <0|1> [maxError]");
                PrintAndLog("     [set clock as integer] optional, if not set, autodetect.");
                PrintAndLog("     <invert>, 1 for invert output");
@@ -1795,7 +1823,7 @@ int CmdPSK1rawDemod(const char *Cmd)
                PrintAndLog("          : data rawdemod p1 64 1 0 = demod a psk1 tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors");
                return 0;
        }
                PrintAndLog("          : data rawdemod p1 64 1 0 = demod a psk1 tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors");
                return 0;
        }
-       ans = PSKDemod(Cmd, TRUE);
+       ans = PSKDemod(Cmd, true);
        //output
        if (!ans){
                if (g_debugMode) PrintAndLog("Error demoding: %d",ans); 
        //output
        if (!ans){
                if (g_debugMode) PrintAndLog("Error demoding: %d",ans); 
@@ -1814,7 +1842,7 @@ int CmdPSK2rawDemod(const char *Cmd)
 {
        int ans=0;
        char cmdp = param_getchar(Cmd, 0);
 {
        int ans=0;
        char cmdp = param_getchar(Cmd, 0);
-       if (strlen(Cmd) > 10 || cmdp == 'h' || cmdp == 'H') {
+       if (strlen(Cmd) > 16 || cmdp == 'h' || cmdp == 'H') {
                PrintAndLog("Usage:  data rawdemod p2 [clock] <0|1> [maxError]");
                PrintAndLog("     [set clock as integer] optional, if not set, autodetect.");
                PrintAndLog("     <invert>, 1 for invert output");
                PrintAndLog("Usage:  data rawdemod p2 [clock] <0|1> [maxError]");
                PrintAndLog("     [set clock as integer] optional, if not set, autodetect.");
                PrintAndLog("     <invert>, 1 for invert output");
@@ -1827,7 +1855,7 @@ int CmdPSK2rawDemod(const char *Cmd)
                PrintAndLog("          : data rawdemod p2 64 1 0  = demod a psk2 tag from GraphBuffer using a clock of RF/64, inverting output and allowing 0 demod errors");
                return 0;
        }
                PrintAndLog("          : data rawdemod p2 64 1 0  = demod a psk2 tag from GraphBuffer using a clock of RF/64, inverting output and allowing 0 demod errors");
                return 0;
        }
-       ans=PSKDemod(Cmd, TRUE);
+       ans=PSKDemod(Cmd, true);
        if (!ans){
                if (g_debugMode) PrintAndLog("Error demoding: %d",ans);  
                return 0;
        if (!ans){
                if (g_debugMode) PrintAndLog("Error demoding: %d",ans);  
                return 0;
@@ -1844,7 +1872,7 @@ int CmdRawDemod(const char *Cmd)
 {
        char cmdp = Cmd[0]; //param_getchar(Cmd, 0);
 
 {
        char cmdp = Cmd[0]; //param_getchar(Cmd, 0);
 
-       if (strlen(Cmd) > 20 || cmdp == 'h' || cmdp == 'H' || strlen(Cmd)<2) {
+       if (strlen(Cmd) > 35 || cmdp == 'h' || cmdp == 'H' || strlen(Cmd)<2) {
                PrintAndLog("Usage:  data rawdemod [modulation] <help>|<options>");
                PrintAndLog("   [modulation] as 2 char, 'ab' for ask/biphase, 'am' for ask/manchester, 'ar' for ask/raw, 'fs' for fsk, ...");           
                PrintAndLog("         'nr' for nrz/direct, 'p1' for psk1, 'p2' for psk2");
                PrintAndLog("Usage:  data rawdemod [modulation] <help>|<options>");
                PrintAndLog("   [modulation] as 2 char, 'ab' for ask/biphase, 'am' for ask/manchester, 'ar' for ask/raw, 'fs' for fsk, ...");           
                PrintAndLog("         'nr' for nrz/direct, 'p1' for psk1, 'p2' for psk2");
@@ -1892,6 +1920,12 @@ int CmdGrid(const char *Cmd)
        return 0;
 }
 
        return 0;
 }
 
+int CmdSetGraphMarkers(const char *Cmd) {
+       sscanf(Cmd, "%i %i", &CursorCPos, &CursorDPos);
+       RepaintGraphWindow();
+       return 0;
+}
+
 int CmdHexsamples(const char *Cmd)
 {
        int i, j;
 int CmdHexsamples(const char *Cmd)
 {
        int i, j;
@@ -2027,10 +2061,20 @@ int CmdSamples(const char *Cmd)
 
 int CmdTuneSamples(const char *Cmd)
 {
 
 int CmdTuneSamples(const char *Cmd)
 {
-       int timeout = 0;
+       int timeout = 0, arg = FLAG_TUNE_ALL;
+
+       if(*Cmd == 'l') {
+         arg = FLAG_TUNE_LF;
+       } else if (*Cmd == 'h') {
+         arg = FLAG_TUNE_HF;
+       } else if (*Cmd != '\0') {
+         PrintAndLog("use 'tune' or 'tune l' or 'tune h'");
+         return 0;
+       }
+
        printf("\nMeasuring antenna characteristics, please wait...");
 
        printf("\nMeasuring antenna characteristics, please wait...");
 
-       UsbCommand c = {CMD_MEASURE_ANTENNA_TUNING};
+       UsbCommand c = {CMD_MEASURE_ANTENNA_TUNING, {arg, 0, 0}};
        SendCommand(&c);
 
        UsbCommand resp;
        SendCommand(&c);
 
        UsbCommand resp;
@@ -2135,6 +2179,22 @@ int CmdRtrim(const char *Cmd)
        return 0;
 }
 
        return 0;
 }
 
+// trim graph (middle) piece
+int CmdMtrim(const char *Cmd) {
+       int start = 0, stop = 0;
+       sscanf(Cmd, "%i %i", &start, &stop);
+
+       if (start > GraphTraceLen       || stop > GraphTraceLen || start > stop) return 0;
+       start++; //leave start position sample
+
+       GraphTraceLen -= stop - start;
+       for (int i = 0; i < GraphTraceLen; i++) {
+               GraphBuffer[start+i] = GraphBuffer[stop+i];
+       }
+       return 0;
+}
+
+
 int CmdNorm(const char *Cmd)
 {
        int i;
 int CmdNorm(const char *Cmd)
 {
        int i;
@@ -2214,13 +2274,13 @@ int CmdDirectionalThreshold(const char *Cmd)
                if (GraphBuffer[i] >= upThres && GraphBuffer[i] > lastValue)
                {
                        lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
                if (GraphBuffer[i] >= upThres && GraphBuffer[i] > lastValue)
                {
                        lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
-                       GraphBuffer[i] = 1;
+                       GraphBuffer[i] = 127;
                }
                // Apply second threshold to samples heading down
                else if (GraphBuffer[i] <= downThres && GraphBuffer[i] < lastValue)
                {
                        lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
                }
                // Apply second threshold to samples heading down
                else if (GraphBuffer[i] <= downThres && GraphBuffer[i] < lastValue)
                {
                        lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
-                       GraphBuffer[i] = -1;
+                       GraphBuffer[i] = -127;
                }
                else
                {
                }
                else
                {
@@ -2313,9 +2373,8 @@ int Cmdbin2hex(const char *Cmd)
        return 0;
 }
 
        return 0;
 }
 
-int usage_data_hex2bin(){
-
-       PrintAndLog("Usage: data bin2hex <binary_digits>");
+int usage_data_hex2bin() {
+       PrintAndLog("Usage: data hex2bin <hex_digits>");
        PrintAndLog("       This function will ignore all non-hexadecimal characters (but stop reading on whitespace)");
        return 0;
 
        PrintAndLog("       This function will ignore all non-hexadecimal characters (but stop reading on whitespace)");
        return 0;
 
@@ -2386,6 +2445,7 @@ static command_t CommandTable[] =
        {"load",            CmdLoad,            1, "<filename> -- Load trace (to graph window"},
        {"ltrim",           CmdLtrim,           1, "<samples> -- Trim samples from left of trace"},
        {"rtrim",           CmdRtrim,           1, "<location to end trace> -- Trim samples from right of trace"},
        {"load",            CmdLoad,            1, "<filename> -- Load trace (to graph window"},
        {"ltrim",           CmdLtrim,           1, "<samples> -- Trim samples from left of trace"},
        {"rtrim",           CmdRtrim,           1, "<location to end trace> -- Trim samples from right of trace"},
+       {"mtrim",           CmdMtrim,           1, "<start> <stop> -- Trim out samples from the specified start to the specified stop"},
        {"manrawdecode",    Cmdmandecoderaw,    1, "[invert] [maxErr] -- Manchester decode binary stream in DemodBuffer"},
        {"norm",            CmdNorm,            1, "Normalize max/min to +/-128"},
        {"plot",            CmdPlot,            1, "Show graph window (hit 'h' in window for keystroke help)"},
        {"manrawdecode",    Cmdmandecoderaw,    1, "[invert] [maxErr] -- Manchester decode binary stream in DemodBuffer"},
        {"norm",            CmdNorm,            1, "Normalize max/min to +/-128"},
        {"plot",            CmdPlot,            1, "Show graph window (hit 'h' in window for keystroke help)"},
@@ -2395,6 +2455,7 @@ static command_t CommandTable[] =
        {"rawdemod",        CmdRawDemod,        1, "[modulation] ... <options> -see help (h option) -- Demodulate the data in the GraphBuffer and output binary"},  
        {"samples",         CmdSamples,         0, "[512 - 40000] -- Get raw samples for graph window (GraphBuffer)"},
        {"save",            CmdSave,            1, "<filename> -- Save trace (from graph window)"},
        {"rawdemod",        CmdRawDemod,        1, "[modulation] ... <options> -see help (h option) -- Demodulate the data in the GraphBuffer and output binary"},  
        {"samples",         CmdSamples,         0, "[512 - 40000] -- Get raw samples for graph window (GraphBuffer)"},
        {"save",            CmdSave,            1, "<filename> -- Save trace (from graph window)"},
+       {"setgraphmarkers", CmdSetGraphMarkers, 1, "[orange_marker] [blue_marker] (in graph window)"},
        {"scale",           CmdScale,           1, "<int> -- Set cursor display scale"},
        {"setdebugmode",    CmdSetDebugMode,    1, "<0|1|2> -- Turn on or off Debugging Level for lf demods"},
        {"shiftgraphzero",  CmdGraphShiftZero,  1, "<shift> -- Shift 0 for Graphed wave + or - shift value"},
        {"scale",           CmdScale,           1, "<int> -- Set cursor display scale"},
        {"setdebugmode",    CmdSetDebugMode,    1, "<0|1|2> -- Turn on or off Debugging Level for lf demods"},
        {"shiftgraphzero",  CmdGraphShiftZero,  1, "<shift> -- Shift 0 for Graphed wave + or - shift value"},
Impressum, Datenschutz