lf read adjustments
authormarshmellow42 <marshmellowrf@gmail.com>
Fri, 7 Apr 2017 21:28:12 +0000 (17:28 -0400)
committermarshmellow42 <marshmellowrf@gmail.com>
Fri, 7 Apr 2017 21:28:12 +0000 (17:28 -0400)
add parameter for # bits to read
auto get samples after lf read/snoop (don't need to do a `data samples`
anymore)
add safe function to get DemodBuffer
add some lf demod comments and apply new lf_read function instead of
read then get samples.
fixed output bug in lf t55xx config print
fixed small bug in lf t55xx detect during ST check

27 files changed:
armsrc/appmain.c
armsrc/lfops.c
armsrc/lfsampling.c
armsrc/lfsampling.h
client/cmddata.c
client/cmddata.h
client/cmdlf.c
client/cmdlf.h
client/cmdlfawid.c
client/cmdlfcotag.c
client/cmdlfem4x.c
client/cmdlffdx.c
client/cmdlfgproxii.c
client/cmdlfhid.c
client/cmdlfindala.c
client/cmdlfio.c
client/cmdlfjablotron.c
client/cmdlfnexwatch.c
client/cmdlfnoralsy.c
client/cmdlfparadox.c
client/cmdlfpresco.c
client/cmdlfpyramid.c
client/cmdlfsecurakey.c
client/cmdlft55xx.c
client/cmdlfviking.c
client/cmdlfvisa2000.c
client/util.c

index d71590003ca8f29111db68a9d48b05dffd190cb9..4c475541b41ba28e572533b0c7f3121575316091 100644 (file)
@@ -938,7 +938,7 @@ void UsbPacketReceived(uint8_t *packet, int len)
                        setSamplingConfig((sample_config *) c->d.asBytes);
                        break;
                case CMD_ACQUIRE_RAW_ADC_SAMPLES_125K:
-                       cmd_send(CMD_ACK,SampleLF(c->arg[0]),0,0,0,0);
+                       cmd_send(CMD_ACK,SampleLF(c->arg[0], c->arg[1]),0,0,0,0);
                        break;
                case CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K:
                        ModThenAcquireRawAdcSamples125k(c->arg[0],c->arg[1],c->arg[2],c->d.asBytes);
index 4a261b42239ca793c094a0c344445b67e73de876..a3f7a02fb9dc5965fd3ed580d0582adfdd10495a 100644 (file)
@@ -72,7 +72,7 @@ void ModThenAcquireRawAdcSamples125k(uint32_t delay_off, uint32_t period_0, uint
        FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | FPGA_LF_ADC_READER_FIELD);
 
        // now do the read
-       DoAcquisition_config(false);
+       DoAcquisition_config(false, 0);
 }
 
 /* blank r/w tag data stream
@@ -1753,7 +1753,7 @@ void Cotag(uint32_t arg0) {
        switch(rawsignal) {
                case 0: doCotagAcquisition(50000); break;
                case 1: doCotagAcquisitionManchester(); break;
-               case 2: DoAcquisition_config(TRUE); break;
+               case 2: DoAcquisition_config(true, 0); break;
        }
 
        // Turn the field off
index 04c4211662c34acf088c5e1d42b54aa2324679be..5d1f9248284fa77b04de411de76fbaaadc113659 100644 (file)
@@ -215,35 +215,35 @@ uint32_t DoAcquisition_default(int trigger_threshold, bool silent)
 {
        return DoAcquisition(1,8,0,trigger_threshold,silent,0);
 }
-uint32_t DoAcquisition_config( bool silent)
+uint32_t DoAcquisition_config(bool silent, int sample_size)
 {
        return DoAcquisition(config.decimation
                                  ,config.bits_per_sample
                                  ,config.averaging
                                  ,config.trigger_threshold
                                  ,silent
-                                 ,0);
+                                 ,sample_size);
 }
 
 uint32_t DoPartialAcquisition(int trigger_threshold, bool silent, int sample_size) {
        return DoAcquisition(1,8,0,trigger_threshold,silent,sample_size);
 }
 
-uint32_t ReadLF(bool activeField, bool silent)
+uint32_t ReadLF(bool activeField, bool silent, int sample_size)
 {
        if (!silent) printConfig();
        LFSetupFPGAForADC(config.divisor, activeField);
        // Now call the acquisition routine
-       return DoAcquisition_config(silent);
+       return DoAcquisition_config(silent, sample_size);
 }
 
 /**
 * Initializes the FPGA for reader-mode (field on), and acquires the samples.
 * @return number of bits sampled
 **/
-uint32_t SampleLF(bool printCfg)
+uint32_t SampleLF(bool printCfg, int sample_size)
 {
-       uint32_t ret = ReadLF(true, printCfg);
+       uint32_t ret = ReadLF(true, printCfg, sample_size);
        FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
        return ret;
 }
@@ -254,7 +254,7 @@ uint32_t SampleLF(bool printCfg)
 
 uint32_t SnoopLF()
 {
-       uint32_t ret = ReadLF(false, true);
+       uint32_t ret = ReadLF(false, true, 0);
        FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
        return ret;
 }
index 9308215f7af1d3856631ebf56eaae694e6dcf125..0531e0c931a2ba31c94b84b77e823ca1d8238944 100644 (file)
@@ -12,7 +12,7 @@ uint32_t doCotagAcquisitionManchester(void);
 * Initializes the FPGA for reader-mode (field on), and acquires the samples.
 * @return number of bits sampled
 **/
-uint32_t SampleLF(bool silent);
+uint32_t SampleLF(bool silent, int sample_size);
 
 /**
 * Initializes the FPGA for snoop-mode (field off), and acquires the samples.
@@ -39,7 +39,7 @@ uint32_t DoAcquisition_default(int trigger_threshold, bool silent);
  * @return number of bits sampled
  */
 
-uint32_t DoAcquisition_config( bool silent);
+uint32_t DoAcquisition_config(bool silent, int sample_size);
 
 /**
 * Setup the FPGA to listen for samples. This method downloads the FPGA bitstream
index b3e23cb6a30e28c77c1792b9231a75dd0e97b981..f15d7ad06265de0304863089f811b6dbaf45e862 100644 (file)
@@ -51,6 +51,17 @@ void setDemodBuf(uint8_t *buff, size_t size, size_t startIdx)
        return;
 }
 
+bool getDemodBuf(uint8_t *buff, size_t *size) {
+       if (buff == NULL) return false;
+       if (size == NULL) return false;
+       if (*size == 0) return false;
+
+       *size = (*size > DemodBufferLen) ? DemodBufferLen : *size;
+
+       memcpy(buff, DemodBuffer, *size);
+       return true;
+}
+
 // option '1' to save DemodBuffer any other to restore
 void save_restoreDB(uint8_t saveOpt)
 {
@@ -62,7 +73,7 @@ void save_restoreDB(uint8_t saveOpt)
                memcpy(SavedDB, DemodBuffer, sizeof(DemodBuffer));
                SavedDBlen = DemodBufferLen;
                DB_Saved=true;
-       } else if (DB_Saved){ //restore
+       } else if (DB_Saved) { //restore
                memcpy(DemodBuffer, SavedDB, sizeof(DemodBuffer));
                DemodBufferLen = SavedDBlen;
        }
@@ -212,8 +223,8 @@ int ASKDemod_ext(const char *Cmd, bool verbose, bool emSearch, uint8_t askType,
        bool st = false;
        size_t ststart = 0, stend = 0;
        if (*stCheck) st = DetectST_ext(BitStream, &BitLen, &foundclk, &ststart, &stend);
+       *stCheck = st;
        if (st) {
-               *stCheck = st;
                clk = (clk == 0) ? foundclk : clk;
                CursorCPos = ststart;
                CursorDPos = stend;
@@ -373,13 +384,13 @@ int CmdBiphaseDecodeRaw(const char *Cmd)
                return 0;
        }
        sscanf(Cmd, "%i %i %i", &offset, &invert, &maxErr);
-       if (DemodBufferLen==0){
+       if (DemodBufferLen==0) {
                PrintAndLog("DemodBuffer Empty - run 'data rawdemod ar' first");
                return 0;
        }
        uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
-       memcpy(BitStream, DemodBuffer, DemodBufferLen); 
-       size = DemodBufferLen;
+       size = sizeof(BitStream);
+       if ( !getDemodBuf(BitStream, &size) ) return 0;
        errCnt=BiphaseRawDecode(BitStream, &size, offset, invert);
        if (errCnt<0){
                PrintAndLog("Error during decode:%d", errCnt);
@@ -1126,7 +1137,7 @@ uint8_t getByte(uint8_t bits_per_sample, BitstreamIn* b)
        return val;
 }
 
-int getSamples(const char *Cmd, bool silent)
+int getSamples(int n, bool silent)
 {
        //If we get all but the last byte in bigbuf,
        // we don't have to worry about remaining trash
@@ -1135,14 +1146,12 @@ int getSamples(const char *Cmd, bool silent)
 
        uint8_t got[BIGBUF_SIZE-1] = { 0 };
 
-       int n = strtol(Cmd, NULL, 0);
-
        if (n == 0 || n > sizeof(got))
                n = sizeof(got);
 
-       PrintAndLog("Reading %d bytes from device memory\n", n);
+       if (!silent) PrintAndLog("Reading %d bytes from device memory\n", n);
        GetFromBigBuf(got,n,0);
-       PrintAndLog("Data fetched");
+       if (!silent) PrintAndLog("Data fetched");
        UsbCommand response;
        WaitForResponse(CMD_ACK, &response);
        uint8_t bits_per_sample = 8;
@@ -1157,7 +1166,7 @@ int getSamples(const char *Cmd, bool silent)
        }
        if(bits_per_sample < 8)
        {
-               PrintAndLog("Unpacking...");
+               if (!silent) PrintAndLog("Unpacking...");
                BitstreamIn bout = { got, bits_per_sample * n,  0};
                int j =0;
                for (j = 0; j * bits_per_sample < n * 8 && j < n; j++) {
@@ -1180,7 +1189,8 @@ int getSamples(const char *Cmd, bool silent)
 
 int CmdSamples(const char *Cmd)
 {
-       return getSamples(Cmd, false);
+       int n = strtol(Cmd, NULL, 0);
+       return getSamples(n, false);
 }
 
 int CmdTuneSamples(const char *Cmd)
index 7e77d3132afda9ef025f4bcd862066e41131605d..f9c45ae28953fe30fd4768e72618d7b75b8cc695 100644 (file)
@@ -22,6 +22,7 @@ command_t * CmdDataCommands();
 int CmdData(const char *Cmd);
 void printDemodBuff(void);
 void setDemodBuf(uint8_t *buff, size_t size, size_t startIdx);
+bool getDemodBuf(uint8_t *buff, size_t *size);
 void save_restoreDB(uint8_t saveOpt);// option '1' to save DemodBuffer any other to restore
 int CmdPrintDemodBuff(const char *Cmd);
 int Cmdaskrawdemod(const char *Cmd);
@@ -62,7 +63,7 @@ int ASKDemod_ext(const char *Cmd, bool verbose, bool emSearch, uint8_t askType,
 int FSKrawDemod(const char *Cmd, bool verbose);
 int PSKDemod(const char *Cmd, bool verbose);
 int NRZrawDemod(const char *Cmd, bool verbose);
-int getSamples(const char *Cmd, bool silent);
+int getSamples(int n, bool silent);
 
 
 #define MAX_DEMOD_BUF_LEN (1024*128)
index f78b380151d87cdacfe6855765b2dd0e67eab15e..5b91d2e88e07ccaafe7f52a7ddb7941455d563c0 100644 (file)
@@ -12,6 +12,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <limits.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include "proxmark3.h"
 #include "cmdlf.h"
 #include "lfdemod.h"     // for psk2TOpsk1
@@ -211,7 +213,7 @@ int usage_lf_read(void)
        PrintAndLog("Options:        ");
        PrintAndLog("       h            This help");
        PrintAndLog("       s            silent run no printout");
-       PrintAndLog("This function takes no arguments. ");
+       PrintAndLog("       [# samples]  # samples to collect (optional)");     
        PrintAndLog("Use 'lf config' to set parameters.");
        return 0;
 }
@@ -331,29 +333,41 @@ int CmdLFSetConfig(const char *Cmd)
        return 0;
 }
 
+bool lf_read(bool silent, uint32_t samples) {
+       if (offline) return false;
+       UsbCommand c = {CMD_ACQUIRE_RAW_ADC_SAMPLES_125K, {silent,samples,0}};
+       clearCommandBuffer();
+       //And ship it to device
+       SendCommand(&c);
+
+       UsbCommand resp;
+       if (g_lf_threshold_set) {
+               WaitForResponse(CMD_ACK,&resp);
+       } else {
+               if ( !WaitForResponseTimeout(CMD_ACK,&resp,2500) ) {
+                       PrintAndLog("command execution time out");
+                       return false;
+               }
+       }
+       getSamples(resp.arg[0], silent);
+
+       return true;
+}
+
 int CmdLFRead(const char *Cmd)
 {
-       if (offline) return 0;
        uint8_t cmdp = 0;
-       bool arg1 = false;
+       bool silent = false;
        if (param_getchar(Cmd, cmdp) == 'h')
        {
                return usage_lf_read();
        }
-       if (param_getchar(Cmd, cmdp) == 's') arg1 = true; //suppress print
-       //And ship it to device
-       UsbCommand c = {CMD_ACQUIRE_RAW_ADC_SAMPLES_125K, {arg1,0,0}};
-       clearCommandBuffer();
-       SendCommand(&c);
-       if (g_lf_threshold_set) {
-               WaitForResponse(CMD_ACK,NULL);
-       } else {
-               if ( !WaitForResponseTimeout(CMD_ACK,NULL,2500) ) {
-                       PrintAndLog("command execution time out");
-                       return 1;
-               }
+       if (param_getchar(Cmd, cmdp) == 's') {
+               silent = true; //suppress print
+               cmdp++;
        }
-       return 0;
+       uint32_t samples = param_get32ex(Cmd, cmdp, 0, 10);
+       return lf_read(silent, samples);
 }
 
 int CmdLFSnoop(const char *Cmd)
@@ -368,6 +382,8 @@ int CmdLFSnoop(const char *Cmd)
        clearCommandBuffer();
        SendCommand(&c);
        WaitForResponse(CMD_ACK,NULL);
+       getSamples(0, true);
+
        return 0;
 }
 
@@ -905,9 +921,8 @@ int CmdLFfind(const char *Cmd)
                return 0;
        }
 
-       if (!offline && (cmdp != '1')){
-               CmdLFRead("s");
-               getSamples("30000",false);
+       if (!offline && (cmdp != '1')) {
+               lf_read(true, 30000);
        } else if (GraphTraceLen < minLength) {
                PrintAndLog("Data in Graphbuffer was too small.");
                return 0;
@@ -1065,7 +1080,7 @@ int CmdLFfind(const char *Cmd)
                if (ans>0) {
                        PrintAndLog("Possible unknown PSK1 Modulated Tag Found above!\n\nCould also be PSK2 - try 'data rawdemod p2'");
                        PrintAndLog("\nCould also be PSK3 - [currently not supported]");
-                       PrintAndLog("\nCould also be NRZ - try 'data nrzrawdemod");
+                       PrintAndLog("\nCould also be NRZ - try 'data nrzrawdemod'");
                        return 1;
                }
                PrintAndLog("\nNo Data Found!\n");
index 7dd1b044ddd07b884d4eb54db34e76a61e280d89..9f446ee0980bd46b5134a1b72a1e782c7859c156 100644 (file)
 #ifndef CMDLF_H__
 #define CMDLF_H__
 
-int CmdLF(const char *Cmd);
+#include <stdbool.h>
+#include <stdint.h>
 
-int CmdLFCommandRead(const char *Cmd);
-int CmdFlexdemod(const char *Cmd);
-int CmdIndalaDemod(const char *Cmd);
-int CmdIndalaClone(const char *Cmd);
-int CmdLFRead(const char *Cmd);
-int CmdLFSim(const char *Cmd);
-int CmdLFaskSim(const char *Cmd);
-int CmdLFfskSim(const char *Cmd);
-int CmdLFpskSim(const char *Cmd);
-int CmdLFSimBidir(const char *Cmd);
-int CmdLFSnoop(const char *Cmd);
-int CmdVchDemod(const char *Cmd);
-int CmdLFfind(const char *Cmd);
+extern int CmdLF(const char *Cmd);
+
+extern int CmdLFCommandRead(const char *Cmd);
+extern int CmdFlexdemod(const char *Cmd);
+extern int CmdIndalaDemod(const char *Cmd);
+extern int CmdIndalaClone(const char *Cmd);
+extern int CmdLFRead(const char *Cmd);
+extern int CmdLFSim(const char *Cmd);
+extern int CmdLFaskSim(const char *Cmd);
+extern int CmdLFfskSim(const char *Cmd);
+extern int CmdLFpskSim(const char *Cmd);
+extern int CmdLFSimBidir(const char *Cmd);
+extern int CmdLFSnoop(const char *Cmd);
+extern int CmdVchDemod(const char *Cmd);
+extern int CmdLFfind(const char *Cmd);
+extern bool lf_read(bool silent, uint32_t samples);
 
 #endif
index c60b7a57a4c2fbe8b69511c4bf03be22a880a402..225816df554496e020498590ab103b00fb36b623 100644 (file)
@@ -8,6 +8,7 @@
 // the license.
 //-----------------------------------------------------------------------------
 // Low frequency AWID26 commands
+// FSK2a, RF/50, 96 bits (complete)
 //-----------------------------------------------------------------------------
 
 #include <string.h>
index 71f171157a4bcfea6f8d6edcf8c89db96e2e820a..6d035e8c71d4e529561b46f4f482d98327964009 100644 (file)
@@ -96,7 +96,7 @@ int CmdCOTAGRead(const char *Cmd) {
                case 2: {
                        CmdPlot("");
                        CmdGrid("384");
-                       getSamples("", true); break;
+                       getSamples(0, true); break;
                }
                case 1: {
                        GetFromBigBuf(DemodBuffer, COTAG_BITS, 0);
index 7eb6070dc424623802ac975ab878561aed9178ee..6b1fa8838a033d0e3e14377eb2e772bd2678108a 100644 (file)
@@ -146,17 +146,18 @@ void printEM410x(uint32_t hi, uint64_t id)
 int AskEm410xDecode(bool verbose, uint32_t *hi, uint64_t *lo )
 {
        size_t idx = 0;
-       size_t BitLen = DemodBufferLen;
-       uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
-       memcpy(BitStream, DemodBuffer, BitLen); 
-       if (Em410xDecode(BitStream, &BitLen, &idx, hi, lo)){
+       uint8_t BitStream[512]={0};
+       size_t BitLen = sizeof(BitStream);
+       if ( !getDemodBuf(BitStream, &BitLen) ) return 0;
+
+       if (Em410xDecode(BitStream, &BitLen, &idx, hi, lo)) {
                //set GraphBuffer for clone or sim command
                setDemodBuf(BitStream, BitLen, idx);
-               if (g_debugMode){
+               if (g_debugMode) {
                        PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, BitLen);
                        printDemodBuff();
                }
-               if (verbose){
+               if (verbose) {
                        PrintAndLog("EM410x pattern found: ");
                        printEM410x(*hi, *lo);
                        g_em410xId = *lo;
@@ -298,9 +299,7 @@ int CmdEM410xWatch(const char *Cmd)
                        printf("\naborted via keyboard!\n");
                        break;
                }
-               
-               CmdLFRead("s");
-               getSamples("8201",true); 
+               lf_read(true, 8201);
        } while (!CmdAskEM410xDemod(""));
 
        return 0;
index a603a4d27bd8f52e200d80d40829169b5d4dad1a..e90d024e892c3e963fdacc8c239072533f35e4cf 100644 (file)
@@ -5,6 +5,7 @@
 // the license.
 //-----------------------------------------------------------------------------
 // Low frequency fdx-b tag commands
+// Differential Biphase, rf/32, 128 bits (known)
 //-----------------------------------------------------------------------------
 
 #include "cmdlffdx.h"
@@ -203,8 +204,7 @@ int CmdFdxDemod(const char *Cmd){
 }
 
 int CmdFdxRead(const char *Cmd) {
-       CmdLFRead("s");
-       getSamples("10000", true);
+       lf_read(true, 10000);
        return CmdFdxDemod(Cmd);
 }
 
index 06bd53eb11ecee5ecc326a26618652200ecef08f..1657f7618a78113d5a857b6e36bf2f3f5803942e 100644 (file)
@@ -5,6 +5,7 @@
 // the license.
 //-----------------------------------------------------------------------------
 // Low frequency G Prox II tag commands
+// Biphase, rf/ , 96 bits  (unknown key calc + some bits)
 //-----------------------------------------------------------------------------
 #include <stdio.h>
 #include <string.h>
@@ -89,9 +90,7 @@ int CmdG_Prox_II_Demod(const char *Cmd)
 //see ASKDemod for what args are accepted
 int CmdG_Prox_II_Read(const char *Cmd) {
        // read lf silently
-       CmdLFRead("s");
-       // get samples silently
-       getSamples("10000",false);
+       lf_read(true, 10000);
        // demod and output viking ID   
        return CmdG_Prox_II_Demod(Cmd);
 }
index a4b49481447601214d1be2f9b5da5e8d71054fe1..e580a10db5f44ebc68c8adc2b7e1356b3c87111a 100644 (file)
@@ -5,7 +5,7 @@
 // at your option, any later version. See the LICENSE.txt file for the text of
 // the license.
 //-----------------------------------------------------------------------------
-// Low frequency HID commands
+// Low frequency HID commands (known)
 //-----------------------------------------------------------------------------
 
 #include <stdio.h>
index 8cb5f63d131cae415de77982d636d708d92d9e08..fc396ac61db859e8314ec5f6b97bcbbddf4fe99b 100644 (file)
@@ -5,6 +5,7 @@
 // the license.
 //-----------------------------------------------------------------------------
 // Low frequency Indala commands
+// PSK1, rf/32, 64 or 224 bits (known)
 //-----------------------------------------------------------------------------
 
 #include <stdio.h>
@@ -73,8 +74,7 @@ int CmdIndalaDecode(const char *Cmd) {
 }
 
 int CmdIndalaRead(const char *Cmd) {
-       CmdLFRead("s");
-       getSamples("30000",false);
+       lf_read(true, 30000);
        return CmdIndalaDecode("");
 }
 
index 1b43d7dd9c0faf4f74910917665803d1d102c727..cfcc7d6294dc7093a77c1246587d1960fedea01c 100644 (file)
@@ -1,3 +1,13 @@
+//-----------------------------------------------------------------------------
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// Low frequency ioProx commands
+// FSK2a, rf/64, 64 bits (complete)
+//-----------------------------------------------------------------------------
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
index 0b7d28117c79edb7409064e2b157301354d5d943..a2984ac89948f2dad1cdf38b708d71b0a47a4e1b 100644 (file)
@@ -5,7 +5,7 @@
 // the license.
 //-----------------------------------------------------------------------------
 // Low frequency jablotron tag commands
-// Differential Biphase, RF/64, 64 bits long
+// Differential Biphase, RF/64, 64 bits long (complete)
 //-----------------------------------------------------------------------------
 
 #include "cmdlfjablotron.h"
@@ -141,8 +141,7 @@ int CmdJablotronDemod(const char *Cmd) {
 }
 
 int CmdJablotronRead(const char *Cmd) {
-       CmdLFRead("s");
-       getSamples("10000", true);
+       lf_read(true, 10000);
        return CmdJablotronDemod(Cmd);
 }
 
index 030c61c74dc5489759a35b45012d0047da8a0222..64ea54e5d88db84871c3bdc757fd4e7c45b8a256 100644 (file)
@@ -5,7 +5,7 @@
 // the license.
 //-----------------------------------------------------------------------------
 // Low frequency Honeywell NexWatch tag commands
-// PSK1 RF/16, RF/2, 128 bits long
+// PSK1 RF/16, RF/2, 128 bits long (known)
 //-----------------------------------------------------------------------------
 #include <stdio.h>
 #include <string.h>
@@ -66,9 +66,7 @@ int CmdPSKNexWatch(const char *Cmd)
 //see ASKDemod for what args are accepted
 int CmdNexWatchRead(const char *Cmd) {
        // read lf silently
-       CmdLFRead("s");
-       // get samples silently
-       getSamples("10000",false);
+       lf_read(true, 10000);
        // demod and output viking ID   
        return CmdPSKNexWatch(Cmd);
 }
index b806f29220d3e8a2dc47b2ef7fd63751d62ed997..282a79aed9492dfc3c0b4ee1dacdc590f13e28fa 100644 (file)
@@ -5,7 +5,7 @@
 // the license.
 //-----------------------------------------------------------------------------
 // Low frequency Noralsy tag commands
-// ASK/Manchester, STT, RF/32, 96 bits long
+// ASK/Manchester, STT, RF/32, 96 bits long (some bits unknown)
 //-----------------------------------------------------------------------------
 #include "cmdlfnoralsy.h"
 #include <string.h>
@@ -98,13 +98,14 @@ int NoralsyDemod_AM(uint8_t *dest, size_t *size) {
 /*
 *
 * 2520116 | BB0214FF2529900116360000 | 10111011 00000011 00010100 11111111 00100101 00101001 10010000 00000001 00010110 00110110 00000000 00000000
-*           aaaaaaaaiii***iiiicc----                                       iiiiiiii iiiiYYYY YYYY**** iiiiiiii iiiiiiii cccccccc
+*           aaa*aaaaiiiYY*iiiicc----                ****                   iiiiiiii iiiiYYYY YYYY**** iiiiiiii iiiiiiii cccccccc
 *
-* a = fixed value BB0314FF 
+* a = fixed value BB0*14FF 
 * i = printed id, BCD-format
 * Y = year
 * c = checksum
-* 
+* * = unknown
+*
 **/
 
 //see ASKDemod for what args are accepted
@@ -171,8 +172,7 @@ int CmdNoralsyDemod(const char *Cmd) {
 }
 
 int CmdNoralsyRead(const char *Cmd) {
-       CmdLFRead("s");
-       getSamples("8000",true);
+       lf_read(true, 8000);
        return CmdNoralsyDemod(Cmd);
 }
 
index 5225820b4b4590f53c95670fa2bd82f450f7d7f1..87e49b3a2e98d96eaa40cbdecd361c039fed36e9 100644 (file)
@@ -5,6 +5,7 @@
 // the license.
 //-----------------------------------------------------------------------------
 // Low frequency Paradox tag commands
+// FSK2a, rf/50, 96 bits (completely known)
 //-----------------------------------------------------------------------------
 #include <stdio.h>
 #include <string.h>
@@ -72,9 +73,7 @@ int CmdFSKdemodParadox(const char *Cmd)
 //see ASKDemod for what args are accepted
 int CmdParadoxRead(const char *Cmd) {
        // read lf silently
-       CmdLFRead("s");
-       // get samples silently
-       getSamples("10000",false);
+       lf_read(true, 10000);
        // demod and output viking ID   
        return CmdFSKdemodParadox(Cmd);
 }
index 8bb341496b39e2062c3d7063aa3fb5a19c574618..f18c3ec6488e30ff3cff0a999e27c2d5babf5f2a 100644 (file)
@@ -5,6 +5,7 @@
 // the license.
 //-----------------------------------------------------------------------------
 // Low frequency Presco tag commands
+// ASK/Manchester, rf/32, 128 bits (complete)
 //-----------------------------------------------------------------------------
 #include <string.h>
 #include <inttypes.h>
@@ -129,7 +130,7 @@ int CmdPrescoDemod(const char *Cmd) {
                return 0;
        }
        size_t size = DemodBufferLen;
-       //call lfdemod.c demod for Viking
+       //call lfdemod.c demod for presco
        int ans = PrescoDemod(DemodBuffer, &size);
        if (ans < 0) {
                if (g_debugMode) PrintAndLog("Error Presco_Demod %d", ans);
@@ -160,9 +161,7 @@ int CmdPrescoRead(const char *Cmd) {
        // Presco Number: 123456789 --> Sitecode 30 | usercode 8665
 
        // read lf silently
-       CmdLFRead("s");
-       // get samples silently
-       getSamples("30000",false);
+       lf_read(true, 10000);
        // demod and output Presco ID   
        return CmdPrescoDemod(Cmd);
 }
index 613a0b66a61cb7913328cc201756b8eab1ab5107..9cd4b207bbecfcef2be82b6e4d7bd06a8296c9fd 100644 (file)
@@ -5,6 +5,7 @@
 // the license.
 //-----------------------------------------------------------------------------
 // Low frequency Farpoint / Pyramid tag commands
+// FSK2a, rf/50, 128 bits (complete)
 //-----------------------------------------------------------------------------
 #include <string.h>
 #include <inttypes.h>
@@ -225,8 +226,7 @@ int CmdFSKdemodPyramid(const char *Cmd)
 }
 
 int CmdPyramidRead(const char *Cmd) {
-       CmdLFRead("s");
-       getSamples("30000",false);
+       lf_read(true, 15000);
        return CmdFSKdemodPyramid("");
 }
 
index 1e3899db0732f76cb788724a25f402a374fc1ef5..87ebb25e9dc3a6c9ef60b52d2390911c40adb355 100644 (file)
@@ -5,7 +5,7 @@
 // the license.
 //-----------------------------------------------------------------------------
 // Low frequency Securakey tag commands
-// ASK/Manchester, RF/40, 96 bits long
+// ASK/Manchester, RF/40, 96 bits long (unknown cs)
 //-----------------------------------------------------------------------------
 #include "cmdlfsecurakey.h"
 #include <string.h>
@@ -123,8 +123,7 @@ int CmdSecurakeyDemod(const char *Cmd) {
 }
 
 int CmdSecurakeyRead(const char *Cmd) {
-       CmdLFRead("s");
-       getSamples("8000",true);
+       lf_read(true, 8000);
        return CmdSecurakeyDemod(Cmd);
 }
 
index 7999880c04bc71f449a491d90c7b152ce7d573b9..8ab1892daf715ad18c64a01e0991c64d781c916d 100644 (file)
@@ -810,6 +810,7 @@ bool test(uint8_t mode, uint8_t *offset, int *fndBitRate, uint8_t clk, bool *Q5)
                        if (!testBitRate(bitRate, clk)) continue;\r
                } else { //extended mode bitrate = same function to calc bitrate as em4x05\r
                        if (EM4x05_GET_BITRATE(bitRate) != clk) continue;\r
+\r
                }\r
                //test modulation\r
                if (!testModulation(mode, modread)) continue;\r
@@ -869,7 +870,7 @@ int special(const char *Cmd) {
 int printConfiguration( t55xx_conf_block_t b){\r
        PrintAndLog("Chip Type  : %s", (b.Q5) ? "T5555(Q5)" : "T55x7");\r
        PrintAndLog("Modulation : %s", GetSelectedModulationStr(b.modulation) );\r
-       PrintAndLog("Bit Rate   : %s", GetBitRateStr(b.bitrate, (b.block0 & T55x7_X_MODE)) );\r
+       PrintAndLog("Bit Rate   : %s", GetBitRateStr(b.bitrate, (b.block0 & T55x7_X_MODE && (b.block0>>28==6 || b.block0>>28==9))) );\r
        PrintAndLog("Inverted   : %s", (b.inverted) ? "Yes" : "No" );\r
        PrintAndLog("Offset     : %d", b.offset);\r
        PrintAndLog("Seq. Term. : %s", (b.ST) ? "Yes" : "No" );\r
@@ -1233,11 +1234,7 @@ int AquireData( uint8_t page, uint8_t block, bool pwdmode, uint32_t password ){
                PrintAndLog("command execution time out");\r
                return 0;\r
        }\r
-\r
-       uint8_t got[12000];\r
-       GetFromBigBuf(got,sizeof(got),0);\r
-       WaitForResponse(CMD_ACK,NULL);\r
-       setGraphBuf(got, sizeof(got));\r
+       getSamples(12000,true);\r
        return 1;\r
 }\r
 \r
index 838bf79d51cae230bd8b6c72c512191a406f6236..3d525c1c9787bc1bcd421962aad0f3036e954673 100644 (file)
@@ -4,7 +4,8 @@
 // at your option, any later version. See the LICENSE.txt file for the text of
 // the license.
 //-----------------------------------------------------------------------------
-// Low frequency Viking tag commands
+// Low frequency Viking tag commands (AKA FDI Matalec Transit)
+// ASK/Manchester, RF/32, 64 bits (complete)
 //-----------------------------------------------------------------------------
 #include <stdio.h>
 #include <string.h>
@@ -80,9 +81,7 @@ int CmdVikingDemod(const char *Cmd) {
 //see ASKDemod for what args are accepted
 int CmdVikingRead(const char *Cmd) {
        // read lf silently
-       CmdLFRead("s");
-       // get samples silently
-       getSamples("10000",false);
+       lf_read(true, 10000);
        // demod and output viking ID   
        return CmdVikingDemod(Cmd);
 }
index 6166903545785bd6f6104f47d78dc97f2cf7d5dc..b461d94d56bb698265684ae48671dfb38f534908 100644 (file)
@@ -6,6 +6,7 @@
 //-----------------------------------------------------------------------------
 // Low frequency visa 2000 tag commands
 // by iceman
+// ASK/Manchester, RF/64, STT, 96 bits (complete)
 //-----------------------------------------------------------------------------
 
 #include "cmdlfvisa2000.h"
@@ -83,12 +84,12 @@ static uint8_t visa_parity( uint32_t id) {
 /**
 *
 * 56495332 00096ebd 00000077 —> tag id 618173
-* aaaaaaaa iiiiiiii -----..c
+* aaaaaaaa iiiiiiii -----ppc
 *
 * a = fixed value  ascii 'VIS2'
 * i = card id
+* p = even parity bit for each nibble in card id.
 * c = checksum  (xor of card id)
-* . = unknown 
 * 
 **/
 //see ASKDemod for what args are accepted
@@ -146,9 +147,8 @@ int CmdVisa2kDemod(const char *Cmd) {
 }
 
 int CmdVisa2kRead(const char *Cmd) {
-       CmdLFRead("s");
        //64*96*2=12288 samples just in case we just missed the first preamble we can still catch 2 of them
-       getSamples("12500",true); 
+       lf_read(true, 12500);
        return CmdVisa2kDemod(Cmd);
 }
 
index 593eaa526864f21600bf501207540fba02f05638..5c2579b1a904c7eb7cf3c2f1f9aeee75575427af 100644 (file)
@@ -174,7 +174,7 @@ char *sprint_bin_break(const uint8_t *data, const size_t len, const uint8_t brea
                if (data[in_index]<10)
                        sprintf(tmp++, "%u", (unsigned int) data[in_index]);
                // check if a line break is needed and we have room to print it in our array
-               if ( (breaks > 0) && !((in_index+1) % breaks) && (out_index+1 != max_len) ) {
+               if ( (breaks > 0) && !((in_index+1) % breaks) && (out_index+1 < max_len) ) {
                        // increment and print line break
                        out_index++;
                        sprintf(tmp++, "%s","\n");
Impressum, Datenschutz