ADD: @marshmellow's fixes to awid, viking and T55x7

ADD: 'lf t55xx detect' now can be called with a password.
ADD: trying to add the read counter and increase counter commands for ntag sim.

diff --git a/armsrc/appmain.c b/armsrc/appmain.c
index c51aa54e44e3d6ccfd90a41aab3aaf38c6c8cdbe..b29a61010de21b31edfcca4466ebf8ab9137d34d 100644 (file)
--- a/armsrc/appmain.c
+++ b/armsrc/appmain.c
@@ -1007,10 +1007,8 @@ void UsbPacketReceived(uint8_t *packet, int len)
                        CmdAWIDdemodFSK(c->arg[0], 0, 0, 1);
                        break;
         case CMD_VIKING_CLONE_TAG:
                        CmdAWIDdemodFSK(c->arg[0], 0, 0, 1);
                        break;
         case CMD_VIKING_CLONE_TAG:

-            CopyViKingtoT55x7(c->arg[0],c->arg[1]);
+                       CopyVikingtoT55xx(c->arg[0], c->arg[1], c->arg[2]);

             break;
             break;

-
-    

 #endif
 
 #ifdef WITH_HITAG
 #endif
 
 #ifdef WITH_HITAG

diff --git a/armsrc/apps.h b/armsrc/apps.h
index 52c4b77cc7b421aa7499ce064739e1532226683c..3baf11ae8cf4bdf387a28a64bdfbb02427dff6a9 100644 (file)
--- a/armsrc/apps.h
+++ b/armsrc/apps.h
@@ -74,6 +74,7 @@ void WriteTItag(uint32_t idhi, uint32_t idlo, uint16_t crc);
 void AcquireTiType(void);
 void AcquireRawBitsTI(void);
 void SimulateTagLowFrequency(int period, int gap, int ledcontrol);
 void AcquireTiType(void);
 void AcquireRawBitsTI(void);
 void SimulateTagLowFrequency(int period, int gap, int ledcontrol);

+void SimulateTagLowFrequencyBidir(int divisor, int max_bitlen);

 void CmdHIDsimTAG(int hi, int lo, int ledcontrol);
 void CmdFSKsimTAG(uint16_t arg1, uint16_t arg2, size_t size, uint8_t *BitStream);
 void CmdASKsimTag(uint16_t arg1, uint16_t arg2, size_t size, uint8_t *BitStream);
 void CmdHIDsimTAG(int hi, int lo, int ledcontrol);
 void CmdFSKsimTAG(uint16_t arg1, uint16_t arg2, size_t size, uint8_t *BitStream);
 void CmdASKsimTag(uint16_t arg1, uint16_t arg2, size_t size, uint8_t *BitStream);


@@ -83,21 +84,19 @@ void CmdAWIDdemodFSK(int findone, int *high, int *low, int ledcontrol); // Realt
 void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol);
 void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol);
 void CopyIOtoT55x7(uint32_t hi, uint32_t lo); // Clone an ioProx card to T5557/T5567
 void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol);
 void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol);
 void CopyIOtoT55x7(uint32_t hi, uint32_t lo); // Clone an ioProx card to T5557/T5567

-void SimulateTagLowFrequencyBidir(int divisor, int max_bitlen);

 void CopyHIDtoT55x7(uint32_t hi2, uint32_t hi, uint32_t lo, uint8_t longFMT); // Clone an HID card to T5557/T5567
 void CopyHIDtoT55x7(uint32_t hi2, uint32_t hi, uint32_t lo, uint8_t longFMT); // Clone an HID card to T5557/T5567

+void CopyVikingtoT55xx(uint32_t block1, uint32_t block2, uint8_t Q5);

 void WriteEM410x(uint32_t card, uint32_t id_hi, uint32_t id_lo);
 void CopyIndala64toT55x7(uint32_t hi, uint32_t lo); // Clone Indala 64-bit tag by UID to T55x7
 void CopyIndala224toT55x7(uint32_t uid1, uint32_t uid2, uint32_t uid3, uint32_t uid4, uint32_t uid5, uint32_t uid6, uint32_t uid7); // Clone Indala 224-bit tag by UID to T55x7
 void T55xxResetRead(void);
 void WriteEM410x(uint32_t card, uint32_t id_hi, uint32_t id_lo);
 void CopyIndala64toT55x7(uint32_t hi, uint32_t lo); // Clone Indala 64-bit tag by UID to T55x7
 void CopyIndala224toT55x7(uint32_t uid1, uint32_t uid2, uint32_t uid3, uint32_t uid4, uint32_t uid5, uint32_t uid6, uint32_t uid7); // Clone Indala 224-bit tag by UID to T55x7
 void T55xxResetRead(void);

-void T55xxWriteBlock(uint32_t Data, uint8_t Block, uint32_t Pwd, uint8_t arg);
-void T55xxWriteBlockExt(uint32_t Data, uint8_t Block, uint32_t Pwd, uint8_t arg);
+void T55xxWriteBlock(uint32_t Data, uint8_t Block, uint32_t Pwd, uint8_t PwdMode);
+void T55xxWriteBlockExt(uint32_t Data, uint8_t Block, uint32_t Pwd, uint8_t PwdMode);

 void T55xxReadBlock(uint16_t arg0, uint8_t Block, uint32_t Pwd);
 void T55xxWakeUp(uint32_t Pwd);
 void TurnReadLFOn();
 void EM4xReadWord(uint8_t Address, uint32_t Pwd, uint8_t PwdMode);
 void EM4xWriteWord(uint32_t Data, uint8_t Address, uint32_t Pwd, uint8_t PwdMode);
 void T55xxReadBlock(uint16_t arg0, uint8_t Block, uint32_t Pwd);
 void T55xxWakeUp(uint32_t Pwd);
 void TurnReadLFOn();
 void EM4xReadWord(uint8_t Address, uint32_t Pwd, uint8_t PwdMode);
 void EM4xWriteWord(uint32_t Data, uint8_t Address, uint32_t Pwd, uint8_t PwdMode);

-void CopyViKingtoT55x7(uint32_t block1,uint32_t block2);
-

 
 /// iso14443.h
 void SimulateIso14443bTag(void);
 
 /// iso14443.h
 void SimulateIso14443bTag(void);

diff --git a/armsrc/iso14443a.c b/armsrc/iso14443a.c
index ad2bf6589ee4989760f00c73ecacbe61a95271e3..d7a86a0990f3dc27de105411add47973e4f3b78c 100644 (file)
--- a/armsrc/iso14443a.c
+++ b/armsrc/iso14443a.c
@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------------
+ //-----------------------------------------------------------------------------

 // Merlok - June 2011, 2012
 // Gerhard de Koning Gans - May 2008
 // Hagen Fritsch - June 2010
 // Merlok - June 2011, 2012
 // Gerhard de Koning Gans - May 2008
 // Hagen Fritsch - June 2010


@@ -939,6 +939,7 @@ bool prepare_allocated_tag_modulation(tag_response_info_t* response_info) {
 //-----------------------------------------------------------------------------
 void SimulateIso14443aTag(int tagType, int flags, byte_t* data)
 {
 //-----------------------------------------------------------------------------
 void SimulateIso14443aTag(int tagType, int flags, byte_t* data)
 {

+       uint32_t counters[] = {0,0,0};

        //Here, we collect UID,NT,AR,NR,UID2,NT2,AR2,NR2
        // This can be used in a reader-only attack.
        // (it can also be retrieved via 'hf 14a list', but hey...
        //Here, we collect UID,NT,AR,NR,UID2,NT2,AR2,NR2
        // This can be used in a reader-only attack.
        // (it can also be retrieved via 'hf 14a list', but hey...


@@ -1182,7 +1183,7 @@ void SimulateIso14443aTag(int tagType, int flags, byte_t* data)
                                // We already responded, do not send anything with the EmSendCmd14443aRaw() that is called below
                                p_response = NULL;
                        }
                                // We already responded, do not send anything with the EmSendCmd14443aRaw() that is called below
                                p_response = NULL;
                        }

-               } else if(receivedCmd[0] == 0x3A) {     // Received a FAST READ (ranged read) -- just returns all zeros.
+               } else if(receivedCmd[0] == 0x3A) {     // Received a FAST READ (ranged read)

                                
                                uint8_t emdata[MAX_FRAME_SIZE];
                                int start =  receivedCmd[1] * 4;
                                
                                uint8_t emdata[MAX_FRAME_SIZE];
                                int start =  receivedCmd[1] * 4;


@@ -1202,15 +1203,19 @@ void SimulateIso14443aTag(int tagType, int flags, byte_t* data)
                                AppendCrc14443a(data, sizeof(data)-2);
                                EmSendCmdEx(data,sizeof(data),false);
                                p_response = NULL;                                      
                                AppendCrc14443a(data, sizeof(data)-2);
                                EmSendCmdEx(data,sizeof(data),false);
                                p_response = NULL;                                      

-               } else if(receivedCmd[0] == 0x39 && tagType == 7) {     // Received a READ COUNTER -- 
-                               uint8_t data[] =  {0x00,0x00,0x00,0x14,0xa5};
-                               EmSendCmdEx(data,sizeof(data),false);                           
-                               p_response = NULL;
-               } else if(receivedCmd[0] == 0xA5 && tagType == 7) {     // Received a INC COUNTER -- 
+               } else if (receivedCmd[0] == 0x39 && tagType == 7) {    // Received a READ COUNTER -- 
+                       uint8_t counter = receivedCmd[1];
+                       uint32_t value = counters[counter];
+                       uint8_t data[] =  {0x00,0x00,0x00,0x14,0xa5};
+                       AppendCrc14443a(data, sizeof(data)-2);
+                       EmSendCmdEx(data,sizeof(data),false);                           
+                       p_response = NULL;
+               } else if (receivedCmd[0] == 0xA5 && tagType == 7) {    // Received a INC COUNTER -- 

                        // number of counter
                        // number of counter

-                       //uint8_t counter = receivedCmd[1];
-                       //uint32_t val = bytes_to_num(receivedCmd+2,4);
-                       
+                       uint8_t counter = receivedCmd[1];
+                       uint32_t val = bytes_to_num(receivedCmd+2,4);
+                       counters[counter] = val;
+               

                        // send ACK
                        uint8_t ack[] = {0x0a};
                        EmSendCmdEx(ack,sizeof(ack),false);
                        // send ACK
                        uint8_t ack[] = {0x0a};
                        EmSendCmdEx(ack,sizeof(ack),false);

diff --git a/armsrc/lfops.c b/armsrc/lfops.c
index 00b5085204460ea9b1a1223757de95c599d208c5..70b4010bbf08a607379c636a80b66bda03511786 100644 (file)
--- a/armsrc/lfops.c
+++ b/armsrc/lfops.c
@@ -839,7 +839,7 @@ void CmdAWIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
                size = 50*128*2; //big enough to catch 2 sequences of largest format
                idx = AWIDdemodFSK(dest, &size);
                
                size = 50*128*2; //big enough to catch 2 sequences of largest format
                idx = AWIDdemodFSK(dest, &size);
                

-               if (idx>0 && size==96){
+               if (idx<=0 || size!=96) continue;

                // Index map
                // 0            10            20            30              40            50              60
                // |            |             |             |               |             |               |
                // Index map
                // 0            10            20            30              40            50              60
                // |            |             |             |               |             |               |


@@ -859,6 +859,7 @@ void CmdAWIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
                uint32_t rawHi2 = bytebits_to_byte(dest+idx,32);
 
                size = removeParity(dest, idx+8, 4, 1, 88);
                uint32_t rawHi2 = bytebits_to_byte(dest+idx,32);
 
                size = removeParity(dest, idx+8, 4, 1, 88);

+               if (size != 66) continue;

                // ok valid card found!
 
                // Index map
                // ok valid card found!
 
                // Index map


@@ -900,7 +901,6 @@ void CmdAWIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
                                return;
                        }
                        // reset
                                return;
                        }
                        // reset

-               }

                idx = 0;
                WDT_HIT();
        }
                idx = 0;
                WDT_HIT();
        }


@@ -1267,7 +1267,6 @@ void WriteT55xx(uint32_t *blockdata, uint8_t startblock, uint8_t numblocks) {
 // Copy HID id to card and setup block 0 config
 void CopyHIDtoT55x7(uint32_t hi2, uint32_t hi, uint32_t lo, uint8_t longFMT) {
        uint32_t data[] = {0,0,0,0,0,0,0};
 // Copy HID id to card and setup block 0 config
 void CopyHIDtoT55x7(uint32_t hi2, uint32_t hi, uint32_t lo, uint8_t longFMT) {
        uint32_t data[] = {0,0,0,0,0,0,0};

-       //int data1=0, data2=0, data3=0, data4=0, data5=0, data6=0; //up to six blocks for long format

        uint8_t last_block = 0;
 
        if (longFMT){
        uint8_t last_block = 0;
 
        if (longFMT){


@@ -1357,6 +1356,15 @@ void CopyIndala224toT55x7(uint32_t uid1, uint32_t uid2, uint32_t uid3, uint32_t
        //      T5567WriteBlock(0x603E10E2,0);
        DbpString("DONE!");
 }
        //      T5567WriteBlock(0x603E10E2,0);
        DbpString("DONE!");
 }

+// clone viking tag to T55xx
+void CopyVikingtoT55xx(uint32_t block1, uint32_t block2, uint8_t Q5) {
+       uint32_t data[] = {T55x7_BITRATE_RF_32 | T55x7_MODULATION_MANCHESTER | (2 << T55x7_MAXBLOCK_SHIFT), block1, block2};
+       if (Q5) data[0] = (32 << T5555_BITRATE_SHIFT) | T5555_MODULATION_MANCHESTER | 2 << T5555_MAXBLOCK_SHIFT;
+       // Program the data blocks for supplied ID and the block 0 config
+       WriteT55xx(data, 0, 3);
+       LED_D_OFF();
+       cmd_send(CMD_ACK,0,0,0,0,0);
+}

 
 // Define 9bit header for EM410x tags
 #define EM410X_HEADER          0x1FF
 
 // Define 9bit header for EM410x tags
 #define EM410X_HEADER          0x1FF


@@ -1657,12 +1665,3 @@ void EM4xWriteWord(uint32_t Data, uint8_t Address, uint32_t Pwd, uint8_t PwdMode
        FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); // field off
        LED_D_OFF();
 }
        FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); // field off
        LED_D_OFF();
 }

-
-void CopyViKingtoT55x7(uint32_t block1, uint32_t block2) {
-
-       uint32_t data[] = {T55x7_BITRATE_RF_32 | T55x7_MODULATION_MANCHESTER | (2 << T55x7_MAXBLOCK_SHIFT), block1, block2};
-       // Program the data blocks for supplied ID and the block 0 config
-       WriteT55xx(data, 0, 3);
-       LED_D_OFF();
-}
-

diff --git a/client/cmddata.c b/client/cmddata.c
index 3d56a971b182ea8476d2b12566176fe0e84390d8..aaff0302f901e964017904749f81d85627dd6f26 100644 (file)
--- a/client/cmddata.c
+++ b/client/cmddata.c
@@ -635,6 +635,32 @@ int CmdG_Prox_II_Demod(const char *Cmd)
        return 1;
 }
 
        return 1;
 }
 

+//by marshmellow
+//see ASKDemod for what args are accepted
+int CmdVikingDemod(const char *Cmd)
+{
+       if (!ASKDemod(Cmd, false, false, 1)) {
+               if (g_debugMode) PrintAndLog("ASKDemod failed");
+               return 0;
+       }
+       size_t size = DemodBufferLen;
+       //call lfdemod.c demod for Viking
+       int ans = VikingDemod_AM(DemodBuffer, &size);
+       if (ans < 0) {
+               if (g_debugMode) PrintAndLog("Error Viking_Demod %d", ans);
+               return 0;
+       }
+       //got a good demod
+       uint32_t raw1 = bytebits_to_byte(DemodBuffer+ans, 32);
+       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("Raw: %08X%08X", raw1,raw2);
+       setDemodBuf(DemodBuffer+ans, 64, 0);
+       return 1;
+}
+

 //by marshmellow - see ASKDemod
 int Cmdaskrawdemod(const char *Cmd)
 {
 //by marshmellow - see ASKDemod
 int Cmdaskrawdemod(const char *Cmd)
 {


@@ -1128,8 +1154,6 @@ int CmdFSKdemodParadox(const char *Cmd)
 //print ioprox ID and some format details
 int CmdFSKdemodIO(const char *Cmd)
 {
 //print ioprox ID and some format details
 int CmdFSKdemodIO(const char *Cmd)
 {

-       //raw fsk demod no manchester decoding no start bit finding just get binary from wave
-       //set defaults

        int idx=0;
        //something in graphbuffer?
        if (GraphTraceLen < 65) {
        int idx=0;
        //something in graphbuffer?
        if (GraphTraceLen < 65) {


@@ -1218,7 +1242,6 @@ int CmdFSKdemodIO(const char *Cmd)
 //print full AWID Prox ID and some bit format details if found
 int CmdFSKdemodAWID(const char *Cmd)
 {
 //print full AWID Prox ID and some bit format details if found
 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);
        if (size==0) return 0;
        uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
        size_t size = getFromGraphBuf(BitStream);
        if (size==0) return 0;


@@ -2373,7 +2396,7 @@ static command_t CommandTable[] =
        {"samples",         CmdSamples,         0, "[512 - 40000] -- Get raw samples for graph window (GraphBuffer)"},
        {"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 (GraphBuffer)"},
        {"save",            CmdSave,            1, "<filename> -- Save trace (from graph window)"},
        {"scale",           CmdScale,           1, "<int> -- Set cursor display scale"},

-       {"setdebugmode",    CmdSetDebugMode,    1, "<0|1> -- Turn on or off Debugging Mode for demods"},
+       {"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"},
        {"dirthreshold",    CmdDirectionalThreshold,   1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
        {"tune",            CmdTuneSamples,     0, "Get hw tune samples for graph window"},
        {"shiftgraphzero",  CmdGraphShiftZero,  1, "<shift> -- Shift 0 for Graphed wave + or - shift value"},
        {"dirthreshold",    CmdDirectionalThreshold,   1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
        {"tune",            CmdTuneSamples,     0, "Get hw tune samples for graph window"},

diff --git a/client/cmdlf.c b/client/cmdlf.c
index ebf8242baaa6e6c8aba2abad0b284f587c2f3c15..3a63972c2cbaa5618f28935d951cacd12f0639f4 100644 (file)
--- a/client/cmdlf.c
+++ b/client/cmdlf.c
@@ -192,7 +192,6 @@ int CmdLFCommandRead(const char *Cmd)
        if (errors) return usage_lf_cmdread();
        
        // in case they specified 'H'
        if (errors) return usage_lf_cmdread();
        
        // in case they specified 'H'

-       // added to the end..  

        strcpy((char *)&c.d.asBytes + strLength, dummy);
 
        clearCommandBuffer();
        strcpy((char *)&c.d.asBytes + strLength, dummy);
 
        clearCommandBuffer();


@@ -505,6 +504,7 @@ int CmdIndalaClone(const char *Cmd)
     c.arg[1] = uid2;
   }
 
     c.arg[1] = uid2;
   }
 

+       clearCommandBuffer();

   SendCommand(&c);
   return 0;
 }
   SendCommand(&c);
   return 0;
 }


@@ -582,6 +582,7 @@ int CmdLFSetConfig(const char *Cmd)
        //Averaging is a flag on high-bit of arg[1]
        UsbCommand c = {CMD_SET_LF_SAMPLING_CONFIG};
        memcpy(c.d.asBytes,&config,sizeof(sample_config));
        //Averaging is a flag on high-bit of arg[1]
        UsbCommand c = {CMD_SET_LF_SAMPLING_CONFIG};
        memcpy(c.d.asBytes,&config,sizeof(sample_config));

+       clearCommandBuffer();

        SendCommand(&c);
        return 0;
 }
        SendCommand(&c);
        return 0;
 }


@@ -760,6 +761,7 @@ int CmdLFfskSim(const char *Cmd)
   UsbCommand c = {CMD_FSK_SIM_TAG, {arg1, arg2, size}};
 
   memcpy(c.d.asBytes, DemodBuffer, size);
   UsbCommand c = {CMD_FSK_SIM_TAG, {arg1, arg2, size}};
 
   memcpy(c.d.asBytes, DemodBuffer, size);

+       clearCommandBuffer();

   SendCommand(&c);
   return 0;
 }
   SendCommand(&c);
   return 0;
 }


@@ -853,6 +855,7 @@ int CmdLFaskSim(const char *Cmd)
   UsbCommand c = {CMD_ASK_SIM_TAG, {arg1, arg2, size}};
   PrintAndLog("preparing to sim ask data: %d bits", size);
   memcpy(c.d.asBytes, DemodBuffer, size);
   UsbCommand c = {CMD_ASK_SIM_TAG, {arg1, arg2, size}};
   PrintAndLog("preparing to sim ask data: %d bits", size);
   memcpy(c.d.asBytes, DemodBuffer, size);

+       clearCommandBuffer();

   SendCommand(&c);
   return 0;
 }
   SendCommand(&c);
   return 0;
 }


@@ -960,6 +963,7 @@ int CmdLFpskSim(const char *Cmd)
   UsbCommand c = {CMD_PSK_SIM_TAG, {arg1, arg2, size}};
   PrintAndLog("DEBUG: Sending DemodBuffer Length: %d", size);
   memcpy(c.d.asBytes, DemodBuffer, size);
   UsbCommand c = {CMD_PSK_SIM_TAG, {arg1, arg2, size}};
   PrintAndLog("DEBUG: Sending DemodBuffer Length: %d", size);
   memcpy(c.d.asBytes, DemodBuffer, size);

+       clearCommandBuffer();

   SendCommand(&c);
   
   return 0;
   SendCommand(&c);
   
   return 0;

diff --git a/client/cmdlfawid.c b/client/cmdlfawid.c
index 3b189efee5665494dd29e0f754da1aa1f6a81a17..7709d75bdd1fcec533298edff8ffeb4aaae19a3b 100644 (file)
--- a/client/cmdlfawid.c
+++ b/client/cmdlfawid.c
@@ -16,149 +16,93 @@
 #include "cmdparser.h"  // CmdsParse, CmdsHelp
 #include "cmdlfawid.h"  // AWID function declarations
 #include "lfdemod.h"    // parityTest
 #include "cmdparser.h"  // CmdsParse, CmdsHelp
 #include "cmdlfawid.h"  // AWID function declarations
 #include "lfdemod.h"    // parityTest

+#include "util.h"       // weigandparity
+#include "protocols.h"  // for T55xx config register definitions

 #include "cmdmain.h"
 #include "cmdmain.h"

+

 static int CmdHelp(const char *Cmd);
 
 int usage_lf_awid_fskdemod(void) {
 static int CmdHelp(const char *Cmd);
 
 int usage_lf_awid_fskdemod(void) {

-  PrintAndLog("Enables AWID26 compatible reader mode printing details of scanned AWID26 tags.");
-  PrintAndLog("By default, values are printed and logged until the button is pressed or another USB command is issued.");
-  PrintAndLog("If the ['1'] option is provided, reader mode is exited after reading a single AWID26 card.");
-  PrintAndLog("");
-  PrintAndLog("Usage:  lf awid fskdemod ['1']");
-  PrintAndLog("Options :");
-  PrintAndLog("  1 : (optional) stop after reading a single card");
-  PrintAndLog("");
-  PrintAndLog("   sample : lf awid fskdemod");
-  PrintAndLog("          : lf awid fskdemod 1");
-  return 0;
+       PrintAndLog("Enables AWID26 compatible reader mode printing details of scanned AWID26 tags.");
+       PrintAndLog("By default, values are printed and logged until the button is pressed or another USB command is issued.");
+       PrintAndLog("If the ['1'] option is provided, reader mode is exited after reading a single AWID26 card.");
+       PrintAndLog("");
+       PrintAndLog("Usage:  lf awid fskdemod ['1']");
+       PrintAndLog("Options :");
+       PrintAndLog("  1 : (optional) stop after reading a single card");
+       PrintAndLog("");
+       PrintAndLog("Samples : lf awid fskdemod");
+       PrintAndLog("          : lf awid fskdemod 1");
+       return 0;

 }
 
 int usage_lf_awid_sim(void) {
 }
 
 int usage_lf_awid_sim(void) {

-  PrintAndLog("Enables simulation of AWID26 card with specified facility-code and card number.");
-  PrintAndLog("Simulation runs until the button is pressed or another USB command is issued.");
-  PrintAndLog("Per AWID26 format, the facility-code is 8-bit and the card number is 16-bit.  Larger values are truncated.");
-  PrintAndLog("");
-  PrintAndLog("Usage:  lf awid sim <Facility-Code> <Card-Number>");
-  PrintAndLog("Options :");
-  PrintAndLog("  <Facility-Code> :  8-bit value AWID facility code");
-  PrintAndLog("  <Card Number>   : 16-bit value AWID card number");
-  PrintAndLog("");
-  PrintAndLog("sample   : lf awid sim 224 1337");
-  return 0;
+       PrintAndLog("Enables simulation of AWID26 card with specified facility-code and card number.");
+       PrintAndLog("Simulation runs until the button is pressed or another USB command is issued.");
+       PrintAndLog("Per AWID26 format, the facility-code is 8-bit and the card number is 16-bit.  Larger values are truncated.");
+       PrintAndLog("");
+       PrintAndLog("Usage:  lf awid sim <Facility-Code> <Card-Number>");
+       PrintAndLog("Options :");
+       PrintAndLog("  <Facility-Code> :  8-bit value AWID facility code");
+       PrintAndLog("  <Card Number>   : 16-bit value AWID card number");
+       PrintAndLog("");
+       PrintAndLog("Sample : lf awid sim 224 1337");
+       return 0;

 }
 
 int usage_lf_awid_clone(void) {
 }
 
 int usage_lf_awid_clone(void) {

-  PrintAndLog("Enables cloning of AWID26 card with specified facility-code and card number onto T55x7.");
-  PrintAndLog("The T55x7 must be on the antenna when issuing this command.  T55x7 blocks are calculated and printed in the process.");
-  PrintAndLog("Per AWID26 format, the facility-code is 8-bit and the card number is 16-bit.  Larger values are truncated.");
-  PrintAndLog("");
-  PrintAndLog("Usage:  lf awid clone <Facility-Code> <Card-Number>");
-  PrintAndLog("Options :");
-  PrintAndLog("  <Facility-Code> :  8-bit value AWID facility code");
-  PrintAndLog("  <Card Number>   : 16-bit value AWID card number");
-  PrintAndLog("");
-  PrintAndLog("sample  : lf awid clone 224 1337");
-  return 0;
+       PrintAndLog("Enables cloning of AWID26 card with specified facility-code and card number onto T55x7.");
+       PrintAndLog("The T55x7 must be on the antenna when issuing this command.  T55x7 blocks are calculated and printed in the process.");
+       PrintAndLog("Per AWID26 format, the facility-code is 8-bit and the card number is 16-bit.  Larger values are truncated.");
+       PrintAndLog("");
+       PrintAndLog("Usage:  lf awid clone <Facility-Code> <Card-Number>");
+       PrintAndLog("Options :");
+       PrintAndLog("  <Facility-Code> :  8-bit value AWID facility code");
+       PrintAndLog("  <Card Number>   : 16-bit value AWID card number");
+       PrintAndLog("  Q5              : optional - clone to Q5 (T5555) instead of T55x7 chip");
+       PrintAndLog("");
+       PrintAndLog("Sample  : lf awid clone 224 1337");
+       return 0;

 }
 
 int CmdAWIDDemodFSK(const char *Cmd) {
 }
 
 int CmdAWIDDemodFSK(const char *Cmd) {

-  int findone = 0;
-  if (Cmd[0] == 'h' || Cmd[0] == 'H') return usage_lf_awid_fskdemod();
-  
-  if (Cmd[0] == '1') findone = 1;
-  
-  UsbCommand c = {CMD_AWID_DEMOD_FSK, {findone, 0, 0}};
-  clearCommandBuffer();
-  SendCommand(&c);
-  return 0;   
+       int findone = 0;
+       if (Cmd[0] == 'h' || Cmd[0] == 'H') return usage_lf_awid_fskdemod();
+       if (Cmd[0] == '1') findone = 1;
+
+       UsbCommand c = {CMD_AWID_DEMOD_FSK, {findone, 0, 0}};
+       clearCommandBuffer();
+       SendCommand(&c);
+       return 0;   

 }
 
 }
 

-int getAWIDBits(unsigned int fc, unsigned int cn, uint8_t *AWIDBits)
-{
-       //int i;
-       uint32_t fcode = (fc & 0x000000FF);
-       uint32_t cnum = (cn & 0x0000FFFF);
-       uint32_t uBits = 0;
-  
-       if (fcode != fc)
-               PrintAndLog("NOTE: Facility code truncated for AWID26 format (8-bit facility code)");
-       if (cnum!=cn)
-               PrintAndLog("NOTE: Card number was truncated for AWID26 format (16-bit card number)");
+//refactored by marshmellow
+int getAWIDBits(uint32_t fc, uint32_t cn, uint8_t      *AWIDBits) {
+       uint8_t pre[66];
+       memset(pre, 0, sizeof(pre));
+       AWIDBits[7]=1;
+       num_to_bytebits(26, 8, pre);

 
 

-       uint8_t pre[] = {0x01, 0x1D, 0x80, 0x00,0x00,0x00,0x00, 0x11, 0x11, 0x11, 0x11, 0x11};
-       memcpy(AWIDBits, pre , sizeof(pre));
-       
-       // AWIDBits[0] = 0x01; // 6-bit Preamble with 2 parity bits
-       // AWIDBits[1] = 0x1D; // First byte from card format (26-bit) plus parity bits
-       // AWIDBits[2] = 0x80; // Set the next two bits as 0b10 to finish card format
+       uint8_t wiegand[24];
+       num_to_bytebits(fc, 8, wiegand);
+       num_to_bytebits(cn, 16, wiegand+8);

 
 

-       // for (i = 7; i<12; i++)
-               // AWIDBits[i]=0x11;
-       
-       uBits = (fcode<<4) + (cnum>>12);
-       
-       if (!parityTest(uBits,12,0)) AWIDBits[2] |= (1<<5); // If not already even parity, set bit to make even
-       
-       uBits = AWIDBits[2]>>5;
-       
-       if (!parityTest(uBits, 3, 1)) AWIDBits[2] |= (1<<4);
-       
-       uBits = fcode>>5; // first 3 bits of facility-code
-       AWIDBits[2] += (uBits<<1);
-       
-       if (!parityTest(uBits, 3, 1)) AWIDBits[2]++; // Set parity bit to make odd parity
-       
-       uBits = (fcode & 0x1C)>>2;
-       AWIDBits[3] = 0;
-       
-       if (!parityTest(uBits,3,1)) AWIDBits[3] |= (1<<4);
-       
-       AWIDBits[3] += (uBits<<5);
-       uBits = ((fcode & 0x3)<<1) + ((cnum & 0x8000)>>15); // Grab/shift 2 LSBs from facility code and add shifted MSB from cardnum
-       
-       if (!parityTest(uBits,3,1))     AWIDBits[3]++; // Set LSB for parity
-       
-       AWIDBits[3]+= (uBits<<1);
-       uBits = (cnum & 0x7000)>>12;
-       AWIDBits[4] = uBits<<5;
-       
-       if (!parityTest(uBits,3,1))     AWIDBits[4] |= (1<<4);
-       
-       uBits = (cnum & 0x0E00)>>9;
-       AWIDBits[4] += (uBits<<1);
-       
-       if (!parityTest(uBits,3,1))     AWIDBits[4]++; // Set LSB for parity
-       
-       uBits = (cnum & 0x1C0)>>6; // Next bits from card number
-       AWIDBits[5]=(uBits<<5);
-       
-       if (!parityTest(uBits,3,1))     AWIDBits[5] |= (1<<4); // Set odd parity bit as needed
-       
-       uBits = (cnum & 0x38)>>3;
-       AWIDBits[5]+= (uBits<<1);
-       
-       if (!parityTest(uBits,3,1))     AWIDBits[5]++; // Set odd parity bit as needed
-       
-       uBits = (cnum & 0x7); // Last three bits from card number!
-       AWIDBits[6] = (uBits<<5);
-       
-       if (!parityTest(uBits,3,1))     AWIDBits[6] |= (1<<4);
-       
-       uBits = (cnum & 0x0FFF);
-       
-       if (!parityTest(uBits,12,1))
-               AWIDBits[6] |= (1<<3);
-       else
-               AWIDBits[6]++;
-       
+       wiegand_add_parity(pre+8, wiegand, 24);
+
+       size_t bitLen = addParity(pre, AWIDBits+8, 66, 4, 1);
+       if (bitLen != 88) return 0;
+       //for (uint8_t i = 0; i<3; i++){
+       //      PrintAndLog("DEBUG: %08X", bytebits_to_byte(AWIDBits+(32*i),32));
+       //}

        return 1;
 }
 
        return 1;
 }
 

-int CmdAWIDSim(const char *Cmd)
-{
-       uint32_t fcode = 0, cnum = 0, fc=0, cn=0, i=0;
-       uint8_t bits[12];
-       uint8_t *bs=bits;
+int CmdAWIDSim(const char *Cmd) {
+       uint32_t fcode = 0, cnum = 0, fc=0, cn=0;
+       uint8_t bits[96];
+       uint8_t *bs = bits;
+       size_t size = sizeof(bits);
+       memset(bs, 0, size);

 
        uint64_t arg1 = (10<<8) + 8; // fcHigh = 10, fcLow = 8
        uint64_t arg2 = 50; // clk RF/50 invert=0
 
        uint64_t arg1 = (10<<8) + 8; // fcHigh = 10, fcLow = 8
        uint64_t arg2 = 50; // clk RF/50 invert=0


@@ -179,30 +123,28 @@ int CmdAWIDSim(const char *Cmd)
                return 1;
        }
        // AWID uses: fcHigh: 10, fcLow: 8, clk: 50, invert: 0
                return 1;
        }
        // AWID uses: fcHigh: 10, fcLow: 8, clk: 50, invert: 0

-       PrintAndLog("Running 'lf simfsk c 50 H 10 L 8 d %s'", sprint_hex(bs, sizeof(bs)));
-  

        // arg1 --- fcHigh<<8 + fcLow
        // arg2 --- Inversion and clk setting
        // 96   --- Bitstream length: 96-bits == 12 bytes
        // arg1 --- fcHigh<<8 + fcLow
        // arg2 --- Inversion and clk setting
        // 96   --- Bitstream length: 96-bits == 12 bytes

-       UsbCommand c = {CMD_FSK_SIM_TAG, {arg1, arg2, 96}};  
-
-       for (i=0; i < 96; i++)
-               c.d.asBytes[i] = (bs[i/8] & (1<<(7-(i%8)))) ? 1 : 0;
-
+       UsbCommand c = {CMD_FSK_SIM_TAG, {arg1, arg2, size}};  
+       memcpy(c.d.asBytes, bs, size);

        clearCommandBuffer();
        SendCommand(&c);
        return 0;
 }
 
        clearCommandBuffer();
        SendCommand(&c);
        return 0;
 }
 

-int CmdAWIDClone(const char *Cmd)
-{
-       uint32_t blocks[4] = {0x00107060, 0, 0, 0x11111111};
-       uint32_t fc=0, cn=0, i=0;
-       uint8_t bits[12];
+int CmdAWIDClone(const char *Cmd) {
+       uint32_t blocks[4] = {T55x7_MODULATION_FSK2a | T55x7_BITRATE_RF_50 | 3<<T55x7_MAXBLOCK_SHIFT, 0, 0, 0};
+       uint32_t fc=0,cn=0;
+       uint8_t bits[96];

        uint8_t *bs=bits;
        uint8_t *bs=bits;

+       memset(bs,0,sizeof(bits));

        
        if (sscanf(Cmd, "%u %u", &fc, &cn ) != 2) return usage_lf_awid_clone();
 
        
        if (sscanf(Cmd, "%u %u", &fc, &cn ) != 2) return usage_lf_awid_clone();
 

+       if (param_getchar(Cmd, 3) == 'Q' || param_getchar(Cmd, 3) == 'q')
+               blocks[0] = T5555_MODULATION_FSK2 | T5555_INVERT_OUTPUT | 50<<T5555_BITRATE_SHIFT | 3<<T5555_MAXBLOCK_SHIFT;
+

        if ((fc & 0xFF) != fc) {
                fc &= 0xFF;
                PrintAndLog("Facility-Code Truncated to 8-bits (AWID26): %u", fc);
        if ((fc & 0xFF) != fc) {
                fc &= 0xFF;
                PrintAndLog("Facility-Code Truncated to 8-bits (AWID26): %u", fc);


@@ -218,12 +160,12 @@ int CmdAWIDClone(const char *Cmd)
                return 1;
        }       
 
                return 1;
        }       
 

-       PrintAndLog("Preparing to clone AWID26 to T55x7 with FC: %u, CN: %u ", fc, cn);
-       PrintAndLog("Raw: %s", sprint_hex(bs, sizeof(bs)));
+       blocks[1] = bytebits_to_byte(bs,32);
+       blocks[2] = bytebits_to_byte(bs+32,32);
+       blocks[3] = bytebits_to_byte(bs+64,32);

 
 

-       blocks[1] = (bs[0]<<24) + (bs[1]<<16) + (bs[2]<<8) + (bs[3]);
-       blocks[2] = (bs[4]<<24) + (bs[5]<<16) + (bs[6]<<8) + (bs[7]);
-       
+       PrintAndLog("Preparing to clone AWID26 to T55x7 with FC: %u, CN: %u", 
+           fc, cn);

        PrintAndLog("Blk | Data ");
        PrintAndLog("----+------------");
        PrintAndLog(" 00 | 0x%08x", blocks[0]);
        PrintAndLog("Blk | Data ");
        PrintAndLog("----+------------");
        PrintAndLog(" 00 | 0x%08x", blocks[0]);


@@ -234,7 +176,7 @@ int CmdAWIDClone(const char *Cmd)
        UsbCommand resp;
        UsbCommand c = {CMD_T55XX_WRITE_BLOCK, {0,0,0}};
 
        UsbCommand resp;
        UsbCommand c = {CMD_T55XX_WRITE_BLOCK, {0,0,0}};
 

-       for (i=0; i<4; i++) {
+       for (uint8_t i=0; i<4; i++) {

                c.arg[0] = blocks[i];
                c.arg[1] = i;
                clearCommandBuffer();
                c.arg[0] = blocks[i];
                c.arg[1] = i;
                clearCommandBuffer();


@@ -247,23 +189,20 @@ int CmdAWIDClone(const char *Cmd)
        return 0;
 }
 
        return 0;
 }
 

-static command_t CommandTable[] = 
-{
+static command_t CommandTable[] = {

        {"help",      CmdHelp,         1, "This help"},
        {"fskdemod",  CmdAWIDDemodFSK, 0, "['1'] Realtime AWID FSK demodulator (option '1' for one tag only)"},
        {"sim",       CmdAWIDSim,      0, "<Facility-Code> <Card Number> -- AWID tag simulator"},
        {"help",      CmdHelp,         1, "This help"},
        {"fskdemod",  CmdAWIDDemodFSK, 0, "['1'] Realtime AWID FSK demodulator (option '1' for one tag only)"},
        {"sim",       CmdAWIDSim,      0, "<Facility-Code> <Card Number> -- AWID tag simulator"},

-       {"clone",     CmdAWIDClone,    0, "<Facility-Code> <Card Number> -- Clone AWID to T55x7 (tag must be in range of antenna)"},
+       {"clone",     CmdAWIDClone,    0, "<Facility-Code> <Card Number> <Q5> -- Clone AWID to T55x7"},

        {NULL, NULL, 0, NULL}
 };
 
        {NULL, NULL, 0, NULL}
 };
 

-int CmdLFAWID(const char *Cmd)
-{
+int CmdLFAWID(const char *Cmd) {

        CmdsParse(CommandTable, Cmd);
        return 0;
 }
 
        CmdsParse(CommandTable, Cmd);
        return 0;
 }
 

-int CmdHelp(const char *Cmd)
-{
+int CmdHelp(const char *Cmd) {

        CmdsHelp(CommandTable);
        return 0;
 }
        CmdsHelp(CommandTable);
        return 0;
 }

diff --git a/client/cmdlft55xx.c b/client/cmdlft55xx.c
index 21406fc8831ad369994fc6f19dfd126f617bd561..d864c9ed0ec1fe6075645877abe0edad2200bd43 100644 (file)
--- a/client/cmdlft55xx.c
+++ b/client/cmdlft55xx.c
@@ -126,13 +126,15 @@ int usage_t55xx_dump(){
        return 0;\r
 }\r
 int usage_t55xx_detect(){\r
        return 0;\r
 }\r
 int usage_t55xx_detect(){\r

-       PrintAndLog("Usage:  lf t55xx detect [1]");\r
+       PrintAndLog("Usage:  lf t55xx detect [1] [p <password>]");\r

        PrintAndLog("Options:");\r
        PrintAndLog("Options:");\r

-       PrintAndLog("     [graph buffer data]  - if set, use Graphbuffer otherwise read data from tag.");\r
+       PrintAndLog("     1             - if set, use Graphbuffer otherwise read data from tag.");\r
+       PrintAndLog("     p <password>  - OPTIONAL password (8 hex characters)");\r

        PrintAndLog("");\r
        PrintAndLog("Examples:");\r
        PrintAndLog("      lf t55xx detect");\r
        PrintAndLog("      lf t55xx detect 1");\r
        PrintAndLog("");\r
        PrintAndLog("Examples:");\r
        PrintAndLog("      lf t55xx detect");\r
        PrintAndLog("      lf t55xx detect 1");\r

+       PrintAndLog("      lf t55xx detect 11223344");\r

        PrintAndLog("");\r
        return 0;\r
 }\r
        PrintAndLog("");\r
        return 0;\r
 }\r


@@ -397,28 +399,41 @@ bool DecodeT55xxBlock(){
 \r
 int CmdT55xxDetect(const char *Cmd){\r
 \r
 \r
 int CmdT55xxDetect(const char *Cmd){\r
 \r

-       //bool override = false;\r
-       //bool pwdmode = false;\r
+       bool errors = FALSE;\r
+       bool useGB = FALSE;\r
+       bool usepwd = FALSE;\r
+       uint32_t password = 0;\r
+       uint8_t cmdp = 0;\r

 \r
 \r

-       uint32_t password = 0; //default to blank Block 7\r
-       bool usepwd = ( strlen(Cmd) > 0);       \r
-       if ( usepwd ){\r
-               password = param_get32ex(Cmd, 0, 0, 16);\r
-               // if (param_getchar(Cmd, 1) =='o' )\r
-                       // override = true;\r
+       while(param_getchar(Cmd, cmdp) != 0x00 && !errors) {\r
+               switch(param_getchar(Cmd, cmdp)) {\r
+               case 'h':\r
+               case 'H':\r
+                       return usage_t55xx_detect();\r
+               case 'p':\r
+               case 'P':\r
+                       password = param_get32ex(Cmd, cmdp+1, 0, 16);\r
+                       usepwd = TRUE;\r
+                       cmdp += 2;\r
+                       break;\r
+               case '1':\r
+                       // use Graphbuffer data\r
+                       useGB = TRUE;\r
+                       cmdp++;\r
+                       break;\r
+               default:\r
+                       PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp));\r
+                       errors = true;\r
+                       break;\r
+               }\r

        }\r
        }\r

-\r
-       char cmdp = param_getchar(Cmd, 0);\r
-       if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') return usage_t55xx_detect();\r
+       if (errors) return usage_t55xx_detect();\r

        \r
        \r

-       if (strlen(Cmd)==0) {\r
-               password = param_get32ex(Cmd, 0, 0, 16);\r
-               //if (param_getchar(Cmd, 1) =='o' ) override = true;\r
+       if ( !useGB) {\r
+               if ( !AquireData(T55x7_PAGE0, T55x7_CONFIGURATION_BLOCK, usepwd, password) )\r
+                       return 0;\r

        }\r
        }\r

-\r
-       if ( !AquireData(T55x7_PAGE0, T55x7_CONFIGURATION_BLOCK, usepwd, password) )\r
-               return 0;\r
-               \r
+       \r

        if ( !tryDetectModulation() )\r
                PrintAndLog("Could not detect modulation automatically. Try setting it manually with \'lf t55xx config\'");\r
 \r
        if ( !tryDetectModulation() )\r
                PrintAndLog("Could not detect modulation automatically. Try setting it manually with \'lf t55xx config\'");\r
 \r


@@ -1242,7 +1257,7 @@ void t55x7_create_config_block( int tagtype ){
        static char buf[60];\r
        char *retStr = buf;\r
        \r
        static char buf[60];\r
        char *retStr = buf;\r
        \r

-       switch (id){\r
+       switch (tagtype){\r

                case 0: snprintf(retStr, sizeof(buf),"%08X - T55X7 Default", T55X7_DEFAULT_CONFIG_BLOCK); break;\r
                case 1: snprintf(retStr, sizeof(buf),"%08X - T55X7 Raw", T55X7_RAW_CONFIG_BLOCK); break;\r
                default:\r
                case 0: snprintf(retStr, sizeof(buf),"%08X - T55X7 Default", T55X7_DEFAULT_CONFIG_BLOCK); break;\r
                case 1: snprintf(retStr, sizeof(buf),"%08X - T55X7 Raw", T55X7_RAW_CONFIG_BLOCK); break;\r
                default:\r


@@ -1292,16 +1307,15 @@ int CmdT55xxWipe(const char *Cmd) {
        return 0;\r
 }\r
 \r
        return 0;\r
 }\r
 \r

-static command_t CommandTable[] =\r
-{\r
+static command_t CommandTable[] = {\r

   {"help",   CmdHelp,           1, "This help"},\r
   {"config", CmdT55xxSetConfig, 1, "Set/Get T55XX configuration (modulation, inverted, offset, rate)"},\r
   {"help",   CmdHelp,           1, "This help"},\r
   {"config", CmdT55xxSetConfig, 1, "Set/Get T55XX configuration (modulation, inverted, offset, rate)"},\r

-  {"detect", CmdT55xxDetect,    0, "[1] Try detecting the tag modulation from reading the configuration block."},\r
+  {"detect",   CmdT55xxDetect,    1, "[1] Try detecting the tag modulation from reading the configuration block."},\r

   {"read",     CmdT55xxReadBlock, 0, "b <block> p [password] [o] [1] -- Read T55xx block data. Optional [p password], [override], [page1]"},\r
   {"resetread",CmdResetRead,      0, "Send Reset Cmd then lf read the stream to attempt to identify the start of it (needs a demod and/or plot after)"},\r
   {"write",    CmdT55xxWriteBlock,0, "b <block> d <data> p [password] [1] -- Write T55xx block data. Optional [p password], [page1]"},\r
   {"read",     CmdT55xxReadBlock, 0, "b <block> p [password] [o] [1] -- Read T55xx block data. Optional [p password], [override], [page1]"},\r
   {"resetread",CmdResetRead,      0, "Send Reset Cmd then lf read the stream to attempt to identify the start of it (needs a demod and/or plot after)"},\r
   {"write",    CmdT55xxWriteBlock,0, "b <block> d <data> p [password] [1] -- Write T55xx block data. Optional [p password], [page1]"},\r

-  {"trace",    CmdT55xxReadTrace, 0, "[1] Show T55x7 traceability data (page 1/ blk 0-1)"},\r
-  {"info",     CmdT55xxInfo,      0, "[1] Show T55x7 configuration data (page 0/ blk 0)"},\r
+  {"trace",    CmdT55xxReadTrace, 1, "[1] Show T55x7 traceability data (page 1/ blk 0-1)"},\r
+  {"info",     CmdT55xxInfo,      1, "[1] Show T55x7 configuration data (page 0/ blk 0)"},\r

   {"dump",     CmdT55xxDump,      0, "[password] [o] Dump T55xx card block 0-7. Optional [password], [override]"},\r
   {"special", special,          0, "Show block changes with 64 different offsets"},\r
   {"wakeup", CmdT55xxWakeUp,    0, "Send AOR wakeup command"},\r
   {"dump",     CmdT55xxDump,      0, "[password] [o] Dump T55xx card block 0-7. Optional [password], [override]"},\r
   {"special", special,          0, "Show block changes with 64 different offsets"},\r
   {"wakeup", CmdT55xxWakeUp,    0, "Send AOR wakeup command"},\r


@@ -1309,14 +1323,12 @@ static command_t CommandTable[] =
   {NULL, NULL, 0, NULL}\r
 };\r
 \r
   {NULL, NULL, 0, NULL}\r
 };\r
 \r

-int CmdLFT55XX(const char *Cmd)\r
-{\r
+int CmdLFT55XX(const char *Cmd) {\r

   CmdsParse(CommandTable, Cmd);\r
   return 0;\r
 }\r
 \r
   CmdsParse(CommandTable, Cmd);\r
   return 0;\r
 }\r
 \r

-int CmdHelp(const char *Cmd)\r
-{\r
+int CmdHelp(const char *Cmd) {\r

   CmdsHelp(CommandTable);\r
   return 0;\r
 }\r
   CmdsHelp(CommandTable);\r
   return 0;\r
 }\r

diff --git a/client/cmdlfviking.c b/client/cmdlfviking.c
index ef3c962977bc144da4b57b46e705a3a2455a1dca..a338d5a3eed63a6d819016fe4555b4bae4b8cd14 100644 (file)
--- a/client/cmdlfviking.c
+++ b/client/cmdlfviking.c
@@ -1,3 +1,11 @@
+//-----------------------------------------------------------------------------
+//
+// 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 Viking tag commands
+//-----------------------------------------------------------------------------

 #include <stdio.h>
 #include <string.h>
 #include <inttypes.h>
 #include <stdio.h>
 #include <string.h>
 #include <inttypes.h>


@@ -15,76 +23,111 @@ static int CmdHelp(const char *Cmd);
 
 int usage_lf_viking_clone(void){
        PrintAndLog("clone a Viking AM tag to a T55x7 tag.");
 
 int usage_lf_viking_clone(void){
        PrintAndLog("clone a Viking AM tag to a T55x7 tag.");

-       PrintAndLog("Usage: lf viking clone <Card ID 16 bytes of hex number>");
+       PrintAndLog("Usage: lf viking clone <Card ID - 8 hex digits> <Q5>");
+       PrintAndLog("Options :");
+       PrintAndLog("  <Card Number>  : 8 digit hex viking card number");
+       PrintAndLog("  <Q5>           : specify write to Q5 (t5555 instead of t55x7)");
+       PrintAndLog("");
+       PrintAndLog("Sample  : lf viking clone 1A337 Q5");

        return 0;
 }
 
        return 0;
 }
 

+int usage_lf_viking_sim(void) {
+       PrintAndLog("Enables simulation of viking card with specified card number.");
+       PrintAndLog("Simulation runs until the button is pressed or another USB command is issued.");
+       PrintAndLog("Per viking format, the card number is 8 digit hex number.  Larger values are truncated.");
+       PrintAndLog("");
+       PrintAndLog("Usage:  lf viking sim <Card-Number>");
+       PrintAndLog("Options :");
+       PrintAndLog("  <Card Number>   : 8 digit hex viking card number");
+       PrintAndLog("");
+       PrintAndLog("Sample  : lf viking sim 1A337");
+       return 0;
+}
+
+// calc checksum
+uint64_t getVikingBits(uint32_t id) {
+       uint8_t checksum = (id>>24) ^ ((id>>16) & 0xFF) ^ ((id>>8) & 0xFF) ^ (id & 0xFF) ^ 0xF2 ^ 0xA8;
+       uint64_t ret = (uint64_t)0xF2 << 56;
+       ret |= (id << 8);
+       ret     |= checksum;
+       return ret;
+}

 //by marshmellow
 //see ASKDemod for what args are accepted
 //by marshmellow
 //see ASKDemod for what args are accepted

-int CmdVikingDemod(const char *Cmd)
-{
-       //CmdLFRead("s");
-       //getSamples("30000",false);
-       
-       if (!ASKDemod(Cmd, false, false, 1)) {
-               if (g_debugMode) PrintAndLog("ASKDemod failed");
-               return 0;
-       }
-       size_t size = DemodBufferLen;
-
-       int ans = VikingDemod_AM(DemodBuffer, &size);
-       if (ans < 0) {
-               if (g_debugMode) PrintAndLog("Error Viking_Demod %d", ans);
-               return 0;
-       }
-       //got a good demod
-       uint32_t raw1 = bytebits_to_byte(DemodBuffer+ans, 32);
-       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("Raw: %08X%08X", raw1,raw2);
-       setDemodBuf(DemodBuffer+ans, 64, 0);
-       return 1;
+int CmdVikingRead(const char *Cmd) {
+       // read lf silently
+       CmdLFRead("s");
+       // get samples silently
+       getSamples("30000",false);
+       // demod and output viking ID   
+       return CmdVikingDemod(Cmd);

 }
 
 }
 

-int CmdVikingClone(const char *Cmd)
-{
-    uint32_t b1,b2;
-    // get the tag number 64 bits (8 bytes) in hex
-    uint8_t id[8];
- 
+int CmdVikingClone(const char *Cmd) {
+       uint32_t id = 0;
+       uint64_t rawID = 0;
+       bool Q5 = false;

        char cmdp = param_getchar(Cmd, 0);
        if (strlen(Cmd) < 0 || cmdp == 'h' || cmdp == 'H') return usage_lf_viking_clone();
        
        char cmdp = param_getchar(Cmd, 0);
        if (strlen(Cmd) < 0 || cmdp == 'h' || cmdp == 'H') return usage_lf_viking_clone();
        

-       if (param_gethex(Cmd, 0, id, 16) == 1)
-               return usage_lf_viking_clone();
+       id = param_get32ex(Cmd, 0, 0, 16);
+       if (id == 0) return usage_lf_viking_clone();

        
        

-    b1 = bytes_to_num(id, sizeof(uint32_t));
-    b2 = bytes_to_num(id + sizeof(uint32_t), sizeof(uint32_t));
-    UsbCommand c = {CMD_VIKING_CLONE_TAG,{b1,b2}};
+       cmdp = param_getchar(Cmd, 1);
+       if ( cmdp == 'Q' || cmdp == 'q')
+               Q5 = true;
+
+       rawID = getVikingBits(id);
+
+       UsbCommand c = {CMD_VIKING_CLONE_TAG,{rawID >> 32, rawID & 0xFFFF, Q5}};

        clearCommandBuffer();
     SendCommand(&c);
        clearCommandBuffer();
     SendCommand(&c);

-       //check for ACK?
+       //check for ACK
+       WaitForResponse(CMD_ACK,NULL);

     return 0;
 }
 
     return 0;
 }
 

-static command_t CommandTable[] =
-{
+int CmdVikingSim(const char *Cmd) {
+       uint32_t id = 0;
+       uint64_t rawID = 0;
+       uint8_t clk = 32, encoding = 1, separator = 0, invert = 0;
+
+       char cmdp = param_getchar(Cmd, 0);
+       if (strlen(Cmd) < 0 || cmdp == 'h' || cmdp == 'H') return usage_lf_viking_sim();
+
+       id = param_get32ex(Cmd, 0, 0, 16);
+       if (id == 0) return usage_lf_viking_sim();
+
+       rawID = getVikingBits(id);
+
+       uint16_t arg1, arg2;
+       size_t size = 64;
+       arg1 = clk << 8 | encoding;
+       arg2 = invert << 8 | separator;
+
+       UsbCommand c = {CMD_ASK_SIM_TAG, {arg1, arg2, size}};
+       PrintAndLog("preparing to sim ask data: %d bits", size);
+       num_to_bytebits(rawID, 64, c.d.asBytes);
+       clearCommandBuffer();
+       SendCommand(&c);
+       return 0;
+}
+
+static command_t CommandTable[] = {

     {"help",   CmdHelp,                1, "This help"},
     {"help",   CmdHelp,                1, "This help"},

-    {"demod",  CmdVikingDemod, 1, "Extract tag data"},
-    {"clone",  CmdVikingClone, 1, "<16 digits card data>  clone viking tag"},
+       {"read",        CmdVikingRead,  0, "Attempt to read and Extract tag data"},
+       {"clone",       CmdVikingClone, 0, "<8 digit ID number> clone viking tag"},
+       {"sim",         CmdVikingSim,   0, "<8 digit ID number> simulate viking tag"},

     {NULL, NULL, 0, NULL}
 };
 
     {NULL, NULL, 0, NULL}
 };
 

-int CmdLFViking(const char *Cmd)
-{
+int CmdLFViking(const char *Cmd) {

     CmdsParse(CommandTable, Cmd);
     return 0;
 }
 
     CmdsParse(CommandTable, Cmd);
     return 0;
 }
 

-int CmdHelp(const char *Cmd)
-{
+int CmdHelp(const char *Cmd) {

     CmdsHelp(CommandTable);
     return 0;
 }
     CmdsHelp(CommandTable);
     return 0;
 }

diff --git a/client/cmdlfviking.h b/client/cmdlfviking.h
index 469a2b7b17d76e57ea9545bcdf0e66cb2dd0512c..2e8ac4795dd6e6da764a23e6c215f753eeec03b3 100644 (file)
--- a/client/cmdlfviking.h
+++ b/client/cmdlfviking.h
@@ -1,7 +1,16 @@
+//-----------------------------------------------------------------------------
+//
+// 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 T55xx commands
+//-----------------------------------------------------------------------------

 #ifndef CMDLFVIKING_H__
 #define CMDLFVIKING_H__
 int CmdLFViking(const char *Cmd);
 #ifndef CMDLFVIKING_H__
 #define CMDLFVIKING_H__
 int CmdLFViking(const char *Cmd);

-int CmdVikingDemod(const char *Cmd);
+int CmdVikingRead(const char *Cmd);

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

+int CmdVikingSim(const char *Cmd);

 #endif
 
 #endif
 

diff --git a/client/util.c b/client/util.c
index 79744d1eb42ce807600a4c3c7217b969223f1347..118912339bcd212072e25dbc2fa5d42200c17ab6 100644 (file)
--- a/client/util.c
+++ b/client/util.c
@@ -159,6 +159,13 @@ uint64_t bytes_to_num(uint8_t* src, size_t len)
        return num;
 }
 
        return num;
 }
 

+void num_to_bytebits(uint64_t  n, size_t len, uint8_t *dest) {
+       while (len--) {
+               dest[len] = n & 1;
+               n >>= 1;
+       }
+}
+

 // aa,bb,cc,dd,ee,ff,gg,hh, ii,jj,kk,ll,mm,nn,oo,pp
 // to
 // hh,gg,ff,ee,dd,cc,bb,aa, pp,oo,nn,mm,ll,kk,jj,ii
 // aa,bb,cc,dd,ee,ff,gg,hh, ii,jj,kk,ll,mm,nn,oo,pp
 // to
 // hh,gg,ff,ee,dd,cc,bb,aa, pp,oo,nn,mm,ll,kk,jj,ii


@@ -445,7 +452,7 @@ void binarraytobinstring(char *target, char *source,  int length)
 }
 
 // return parity bit required to match type
 }
 
 // return parity bit required to match type

-uint8_t GetParity( char *bits, uint8_t type, int length)
+uint8_t GetParity( uint8_t *bits, uint8_t type, int length)

 {
     int x;
 
 {
     int x;
 


@@ -457,7 +464,7 @@ uint8_t GetParity( char *bits, uint8_t type, int length)
 }
 
 // add HID parity to binary array: EVEN prefix for 1st half of ID, ODD suffix for 2nd half
 }
 
 // add HID parity to binary array: EVEN prefix for 1st half of ID, ODD suffix for 2nd half

-void wiegand_add_parity(char *target, char *source, char length)
+void wiegand_add_parity(uint8_t *target, uint8_t *source, uint8_t length)

 {
     *(target++)= GetParity(source, EVEN, length / 2);
     memcpy(target, source, length);
 {
     *(target++)= GetParity(source, EVEN, length / 2);
     memcpy(target, source, length);

diff --git a/client/util.h b/client/util.h
index a9ae831318b013a0240c21224b1fdd3f75cf03e5..eead10ec3770342caf2af7f94be746bdeb64e3c5 100644 (file)
--- a/client/util.h
+++ b/client/util.h
@@ -43,6 +43,7 @@ char * sprint_bin_break(const uint8_t *data, const size_t len, const uint8_t bre
 
 void num_to_bytes(uint64_t n, size_t len, uint8_t* dest);
 uint64_t bytes_to_num(uint8_t* src, size_t len);
 
 void num_to_bytes(uint64_t n, size_t len, uint8_t* dest);
 uint64_t bytes_to_num(uint8_t* src, size_t len);

+void num_to_bytebits(uint64_t  n, size_t len, uint8_t *dest);

 char * printBits(size_t const size, void const * const ptr);
 uint8_t *SwapEndian64(const uint8_t *src, const size_t len, const uint8_t blockSize);
 
 char * printBits(size_t const size, void const * const ptr);
 uint8_t *SwapEndian64(const uint8_t *src, const size_t len, const uint8_t blockSize);
 


@@ -62,8 +63,8 @@ int param_getstr(const char *line, int paramnum, char * str);
  int hextobinstring( char *target,  char *source);
  int binarraytohex( char *target,  char *source,  int length);
 void binarraytobinstring(char *target,  char *source,  int length);
  int hextobinstring( char *target,  char *source);
  int binarraytohex( char *target,  char *source,  int length);
 void binarraytobinstring(char *target,  char *source,  int length);

-uint8_t GetParity( char *string, uint8_t type,  int length);
-void wiegand_add_parity(char *target, char *source, char length);
+uint8_t GetParity( uint8_t *string, uint8_t type,  int length);
+void wiegand_add_parity(uint8_t *target, uint8_t *source, uint8_t length);

 
 void xor(unsigned char * dst, unsigned char * src, size_t len);
 int32_t le24toh (uint8_t data[3]);
 
 void xor(unsigned char * dst, unsigned char * src, size_t len);
 int32_t le24toh (uint8_t data[3]);

diff --git a/common/lfdemod.c b/common/lfdemod.c
index 537c796209ca7ad60015ff6091549fa65e6c0cbc..5766c3b6e17b23a9fd88df6e7f3b0c1af0ecf0c6 100644 (file)
--- a/common/lfdemod.c
+++ b/common/lfdemod.c
@@ -13,17 +13,18 @@
 #include "lfdemod.h"
 #include "common.h"
 
 #include "lfdemod.h"
 #include "common.h"
 

-/* //un_comment to allow debug print calls when used not on device
+//un_comment to allow debug print calls when used not on device

 void dummy(char *fmt, ...){}
 
 #ifndef ON_DEVICE
 #include "ui.h"
 void dummy(char *fmt, ...){}
 
 #ifndef ON_DEVICE
 #include "ui.h"

+#include "cmdparser.h"
+#include "cmddata.h"

 #define prnt PrintAndLog
 #else 
 #define prnt PrintAndLog
 #else 

-
+       uint8_t g_debugMode=0;

 #define prnt dummy
 #endif
 #define prnt dummy
 #endif

-*/

 
 uint8_t justNoise(uint8_t *BitStream, size_t size)
 {
 
 uint8_t justNoise(uint8_t *BitStream, size_t size)
 {


@@ -66,6 +67,81 @@ uint8_t parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType)
        return (ans == pType);
 }
 
        return (ans == pType);
 }
 

+//by marshmellow
+// takes a array of binary values, start position, length of bits per parity (includes parity bit),
+//   Parity Type (1 for odd; 0 for even; 2 Always 1's), and binary Length (length to run) 
+size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t pType, size_t bLen)
+{
+       uint32_t parityWd = 0;
+       size_t j = 0, bitCnt = 0;
+       for (int word = 0; word < (bLen); word+=pLen){
+               for (int bit=0; bit < pLen; bit++){
+                       parityWd = (parityWd << 1) | BitStream[startIdx+word+bit];
+                       BitStream[j++] = (BitStream[startIdx+word+bit]);
+               }
+               j--; // overwrite parity with next data
+               // if parity fails then return 0
+               if (pType == 2) { // then marker bit which should be a 1
+                       if (!BitStream[j]) return 0;
+               } else {
+                       if (parityTest(parityWd, pLen, pType) == 0) return 0;                   
+               }
+               bitCnt+=(pLen-1);
+               parityWd = 0;
+       }
+       // if we got here then all the parities passed
+       //return ID start index and size
+       return bitCnt;
+}
+
+// by marshmellow
+// takes a array of binary values, length of bits per parity (includes parity bit),
+//   Parity Type (1 for odd; 0 for even; 2 Always 1's), and binary Length (length to run)
+size_t addParity(uint8_t *BitSource, uint8_t *dest, uint8_t sourceLen, uint8_t pLen, uint8_t pType)
+{
+       uint32_t parityWd = 0;
+       size_t j = 0, bitCnt = 0;
+       for (int word = 0; word < sourceLen; word+=pLen-1) {
+               for (int bit=0; bit < pLen-1; bit++){
+                       parityWd = (parityWd << 1) | BitSource[word+bit];
+                       dest[j++] = (BitSource[word+bit]);
+               }
+               // if parity fails then return 0
+               if (pType == 2) { // then marker bit which should be a 1
+                       dest[j++]=1;
+               } else {
+                       dest[j++] = parityTest(parityWd, pLen-1, pType) ^ 1;
+               }
+               bitCnt += pLen;
+               parityWd = 0;
+       }
+       // if we got here then all the parities passed
+       //return ID start index and size
+       return bitCnt;
+}
+
+uint32_t bytebits_to_byte(uint8_t *src, size_t numbits)
+{
+       uint32_t num = 0;
+       for(int i = 0 ; i < numbits ; i++)
+       {
+               num = (num << 1) | (*src);
+               src++;
+       }
+       return num;
+}
+
+//least significant bit first
+uint32_t bytebits_to_byteLSBF(uint8_t *src, size_t numbits)
+{
+       uint32_t num = 0;
+       for(int i = 0 ; i < numbits ; i++)
+       {
+               num = (num << 1) | *(src + (numbits-(i+1)));
+       }
+       return num;
+}
+

 //by marshmellow
 //search for given preamble in given BitStream and return success=1 or fail=0 and startIndex and length
 uint8_t preambleSearch(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t *size, size_t *startIdx)
 //by marshmellow
 //search for given preamble in given BitStream and return success=1 or fail=0 and startIndex and length
 uint8_t preambleSearch(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t *size, size_t *startIdx)


@@ -198,6 +274,7 @@ int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr
        if (*clk==0 || start < 0) return -3;
        if (*invert != 1) *invert = 0;
        if (amp==1) askAmp(BinStream, *size);
        if (*clk==0 || start < 0) return -3;
        if (*invert != 1) *invert = 0;
        if (amp==1) askAmp(BinStream, *size);

+       if (g_debugMode==2) prnt("DEBUG: clk %d, beststart %d", *clk, start);

 
        uint8_t initLoopMax = 255;
        if (initLoopMax > *size) initLoopMax = *size;
 
        uint8_t initLoopMax = 255;
        if (initLoopMax > *size) initLoopMax = *size;


@@ -210,6 +287,7 @@ int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr
        size_t errCnt = 0;
        // if clean clipped waves detected run alternate demod
        if (DetectCleanAskWave(BinStream, *size, high, low)) {
        size_t errCnt = 0;
        // if clean clipped waves detected run alternate demod
        if (DetectCleanAskWave(BinStream, *size, high, low)) {

+               if (g_debugMode==2) prnt("DEBUG: Clean Wave Detected");

                errCnt = cleanAskRawDemod(BinStream, size, *clk, *invert, high, low);
                if (askType) //askman
                        return manrawdecode(BinStream, size, 0);        
                errCnt = cleanAskRawDemod(BinStream, size, *clk, *invert, high, low);
                if (askType) //askman
                        return manrawdecode(BinStream, size, 0);        


@@ -551,28 +629,6 @@ int ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, ui
        return (int)startIdx;
 }
 
        return (int)startIdx;
 }
 

-uint32_t bytebits_to_byte(uint8_t* src, size_t numbits)
-{
-       uint32_t num = 0;
-       for(int i = 0 ; i < numbits ; i++)
-       {
-               num = (num << 1) | (*src);
-               src++;
-       }
-       return num;
-}
-
-//least significant bit first
-uint32_t bytebits_to_byteLSBF(uint8_t *src, size_t numbits)
-{
-       uint32_t num = 0;
-       for(int i = 0 ; i < numbits ; i++)
-       {
-               num = (num << 1) | *(src + (numbits-(i+1)));
-       }
-       return num;
-}
-

 int IOdemodFSK(uint8_t *dest, size_t size)
 {
        if (justNoise(dest, size)) return -1;
 int IOdemodFSK(uint8_t *dest, size_t size)
 {
        if (justNoise(dest, size)) return -1;


@@ -622,33 +678,6 @@ int VikingDemod_AM(uint8_t *dest, size_t *size) {
        return (int) startIdx;
 }
 
        return (int) startIdx;
 }
 

-// by marshmellow
-// takes a array of binary values, start position, length of bits per parity (includes parity bit),
-//   Parity Type (1 for odd; 0 for even; 2 Always 1's), and binary Length (length to run) 
-size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t pType, size_t bLen)
-{
-       uint32_t parityWd = 0;
-       size_t j = 0, bitCnt = 0;
-       for (int word = 0; word < (bLen); word+=pLen){
-               for (int bit=0; bit < pLen; bit++){
-                       parityWd = (parityWd << 1) | BitStream[startIdx+word+bit];
-                       BitStream[j++] = (BitStream[startIdx+word+bit]);
-               }
-               j--; // overwrite parity with next data
-               // if parity fails then return 0
-               if (pType == 2) { // then marker bit which should be a 1
-                       if (!BitStream[j]) return 0;
-               } else {
-                       if (parityTest(parityWd, pLen, pType) == 0) return 0;                   
-               }
-               bitCnt+=(pLen-1);
-               parityWd = 0;
-       }
-       // if we got here then all the parities passed
-       //return ID start index and size
-       return bitCnt;
-}
-

 // Ask/Biphase Demod then try to locate an ISO 11784/85 ID
 // BitStream must contain previously askrawdemod and biphasedemoded data
 int FDXBdemodBI(uint8_t *dest, size_t *size)
 // Ask/Biphase Demod then try to locate an ISO 11784/85 ID
 // BitStream must contain previously askrawdemod and biphasedemoded data
 int FDXBdemodBI(uint8_t *dest, size_t *size)


@@ -756,7 +785,7 @@ int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low)
                        minClk = i - startwave;
        }
        // set clock
                        minClk = i - startwave;
        }
        // set clock

-       //prnt("minClk: %d",minClk);
+       if (g_debugMode==2) prnt("DEBUG ASK: detectstrongASKclk smallest wave: %d",minClk);

        for (uint8_t clkCnt = 0; clkCnt<7; clkCnt++) {
                if (minClk >= fndClk[clkCnt]-(fndClk[clkCnt]/8) && minClk <= fndClk[clkCnt]+1)
                        return fndClk[clkCnt];
        for (uint8_t clkCnt = 0; clkCnt<7; clkCnt++) {
                if (minClk >= fndClk[clkCnt]-(fndClk[clkCnt]/8) && minClk <= fndClk[clkCnt]+1)
                        return fndClk[clkCnt];


@@ -790,6 +819,7 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
        if (!clockFnd){
                if (DetectCleanAskWave(dest, size, peak, low)==1){
                        int ans = DetectStrongAskClock(dest, size, peak, low);
        if (!clockFnd){
                if (DetectCleanAskWave(dest, size, peak, low)==1){
                        int ans = DetectStrongAskClock(dest, size, peak, low);

+                       if (g_debugMode==2) prnt("DEBUG ASK: detectaskclk Clean Ask Wave Detected: clk %d",ans);

                        for (i=clkEnd-1; i>0; i--){
                                if (clk[i] == ans) {
                                        *clock = ans;
                        for (i=clkEnd-1; i>0; i--){
                                if (clk[i] == ans) {
                                        *clock = ans;


@@ -800,7 +830,6 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
                        }
                }
        }
                        }
                }
        }

-       

        uint8_t ii;
        uint8_t clkCnt, tol = 0;
        uint16_t bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000,1000};
        uint8_t ii;
        uint8_t clkCnt, tol = 0;
        uint16_t bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000,1000};


@@ -842,7 +871,7 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
                        }
                        //if we found no errors then we can stop here and a low clock (common clocks)
                        //  this is correct one - return this clock
                        }
                        //if we found no errors then we can stop here and a low clock (common clocks)
                        //  this is correct one - return this clock

-                                       //prnt("DEBUG: clk %d, err %d, ii %d, i %d",clk[clkCnt],errCnt,ii,i);
+                       if (g_debugMode == 2) prnt("DEBUG ASK: clk %d, err %d, startpos %d, endpos %d",clk[clkCnt],errCnt,ii,i);

                        if(errCnt==0 && clkCnt<7) { 
                                if (!clockFnd) *clock = clk[clkCnt];
                                return ii;
                        if(errCnt==0 && clkCnt<7) { 
                                if (!clockFnd) *clock = clk[clkCnt];
                                return ii;


@@ -864,8 +893,8 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
                                best = iii;
                        }
                }
                                best = iii;
                        }
                }

+               if (g_debugMode == 2) prnt("DEBUG ASK: clk %d, # Errors %d, Current Best Clk %d, bestStart %d",clk[iii],bestErr[iii],clk[best],bestStart[best]);

        }
        }

-       //if (bestErr[best] > maxErr) return -1;

        if (!clockFnd) *clock = clk[best];
        return bestStart[best];
 }
        if (!clockFnd) *clock = clk[best];
        return bestStart[best];
 }


@@ -892,7 +921,7 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock)
        uint16_t peaksdet[]={0,0,0,0,0,0,0,0,0};
        fc = countFC(dest, size, 0);
        if (fc!=2 && fc!=4 && fc!=8) return -1;
        uint16_t peaksdet[]={0,0,0,0,0,0,0,0,0};
        fc = countFC(dest, size, 0);
        if (fc!=2 && fc!=4 && fc!=8) return -1;

-       //prnt("DEBUG: FC: %d",fc);
+       if (g_debugMode==2) prnt("DEBUG PSK: FC: %d",fc);

 
        //find first full wave
        for (i=160; i<loopCnt; i++){
 
        //find first full wave
        for (i=160; i<loopCnt; i++){


@@ -913,7 +942,7 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock)
                        }
                }
        }
                        }
                }
        }

-       //prnt("DEBUG: firstFullWave: %d, waveLen: %d",firstFullWave,fullWaveLen);
+       if (g_debugMode ==2) prnt("DEBUG PSK: firstFullWave: %d, waveLen: %d",firstFullWave,fullWaveLen);

        
        //test each valid clock from greatest to smallest to see which lines up
        for(clkCnt=7; clkCnt >= 1 ; clkCnt--){
        
        //test each valid clock from greatest to smallest to see which lines up
        for(clkCnt=7; clkCnt >= 1 ; clkCnt--){


@@ -921,7 +950,7 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock)
                waveStart = 0;
                errCnt=0;
                peakcnt=0;
                waveStart = 0;
                errCnt=0;
                peakcnt=0;

-               //prnt("DEBUG: clk: %d, lastClkBit: %d",clk[clkCnt],lastClkBit);
+               if (g_debugMode == 2) prnt("DEBUG PSK: clk: %d, lastClkBit: %d",clk[clkCnt],lastClkBit);

 
                for (i = firstFullWave+fullWaveLen-1; i < loopCnt-2; i++){
                        //top edge of wave = start of new wave 
 
                for (i = firstFullWave+fullWaveLen-1; i < loopCnt-2; i++){
                        //top edge of wave = start of new wave 


@@ -934,7 +963,7 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock)
                                        waveLenCnt = waveEnd-waveStart;
                                        if (waveLenCnt > fc){ 
                                                //if this wave is a phase shift
                                        waveLenCnt = waveEnd-waveStart;
                                        if (waveLenCnt > fc){ 
                                                //if this wave is a phase shift

-                                               //prnt("DEBUG: phase shift at: %d, len: %d, nextClk: %d, ii: %d, fc: %d",waveStart,waveLenCnt,lastClkBit+clk[clkCnt]-tol,ii+1,fc);
+                                               if (g_debugMode == 2) prnt("DEBUG PSK: phase shift at: %d, len: %d, nextClk: %d, i: %d, fc: %d",waveStart,waveLenCnt,lastClkBit+clk[clkCnt]-tol,i+1,fc);

                                                if (i+1 >= lastClkBit + clk[clkCnt] - tol){ //should be a clock bit
                                                        peakcnt++;
                                                        lastClkBit+=clk[clkCnt];
                                                if (i+1 >= lastClkBit + clk[clkCnt] - tol){ //should be a clock bit
                                                        peakcnt++;
                                                        lastClkBit+=clk[clkCnt];


@@ -963,7 +992,7 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock)
                if (peaksdet[i] > peaksdet[best]) {
                        best = i;
                }
                if (peaksdet[i] > peaksdet[best]) {
                        best = i;
                }

-               //prnt("DEBUG: Clk: %d, peaks: %d, errs: %d, bestClk: %d",clk[iii],peaksdet[iii],bestErr[iii],clk[best]);
+               if (g_debugMode == 2) prnt("DEBUG PSK: Clk: %d, peaks: %d, errs: %d, bestClk: %d",clk[i],peaksdet[i],bestErr[i],clk[best]);

        }
        return clk[best];
 }
        }
        return clk[best];
 }


@@ -992,8 +1021,8 @@ int DetectStrongNRZClk(uint8_t *dest, size_t size, int peak, int low){
                        transition1 = i;
                }
        }
                        transition1 = i;
                }
        }

-       //prnt("DEBUG: LowestTrs: %d",lowestTransition);

        if (lowestTransition == 255) lowestTransition = 0;
        if (lowestTransition == 255) lowestTransition = 0;

+       if (g_debugMode==2) prnt("DEBUG NRZ: detectstrongNRZclk smallest wave: %d",lowestTransition);

        return lowestTransition;
 }
 
        return lowestTransition;
 }
 


@@ -1108,7 +1137,7 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock)
                } else if (peaksdet[iii] > peaksdet[best]){
                        best = iii;
                }
                } else if (peaksdet[iii] > peaksdet[best]){
                        best = iii;
                }

-               //prnt("DEBUG: Clk: %d, peaks: %d, maxPeak: %d, bestClk: %d, lowestTrs: %d",clk[iii],peaksdet[iii],maxPeak, clk[best], lowestTransition);
+               if (g_debugMode==2) prnt("DEBUG NRZ: Clk: %d, peaks: %d, maxPeak: %d, bestClk: %d, lowestTrs: %d",clk[iii],peaksdet[iii],maxPeak, clk[best], lowestTransition);

        }
 
        return clk[best];
        }
 
        return clk[best];


@@ -1269,7 +1298,6 @@ uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fc
        uint8_t rfHighest=15, rfHighest2=15, rfHighest3=15;
 
        for (i=0; i<15; i++){
        uint8_t rfHighest=15, rfHighest2=15, rfHighest3=15;
 
        for (i=0; i<15; i++){

-               //prnt("DEBUG: RF %d, cnts %d",rfLens[i], rfCnts[i]);

                //get highest 2 RF values  (might need to get more values to compare or compare all?)
                if (rfCnts[i]>rfCnts[rfHighest]){
                        rfHighest3=rfHighest2;
                //get highest 2 RF values  (might need to get more values to compare or compare all?)
                if (rfCnts[i]>rfCnts[rfHighest]){
                        rfHighest3=rfHighest2;


@@ -1281,12 +1309,13 @@ uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fc
                } else if(rfCnts[i]>rfCnts[rfHighest3]){
                        rfHighest3=i;
                }
                } else if(rfCnts[i]>rfCnts[rfHighest3]){
                        rfHighest3=i;
                }

+               if (g_debugMode==2) prnt("DEBUG FSK: RF %d, cnts %d",rfLens[i], rfCnts[i]);

        }  
        // set allowed clock remainder tolerance to be 1 large field clock length+1 
        //   we could have mistakenly made a 9 a 10 instead of an 8 or visa versa so rfLens could be 1 FC off  
        uint8_t tol1 = fcHigh+1; 
        
        }  
        // set allowed clock remainder tolerance to be 1 large field clock length+1 
        //   we could have mistakenly made a 9 a 10 instead of an 8 or visa versa so rfLens could be 1 FC off  
        uint8_t tol1 = fcHigh+1; 
        

-       //prnt("DEBUG: hightest: 1 %d, 2 %d, 3 %d",rfLens[rfHighest],rfLens[rfHighest2],rfLens[rfHighest3]);
+       if (g_debugMode==2) prnt("DEBUG FSK: most counted rf values: 1 %d, 2 %d, 3 %d",rfLens[rfHighest],rfLens[rfHighest2],rfLens[rfHighest3]);

 
        // loop to find the highest clock that has a remainder less than the tolerance
        //   compare samples counted divided by
 
        // loop to find the highest clock that has a remainder less than the tolerance
        //   compare samples counted divided by


@@ -1296,6 +1325,7 @@ uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fc
                if (rfLens[rfHighest] % clk[ii] < tol1 || rfLens[rfHighest] % clk[ii] > clk[ii]-tol1){
                        if (rfLens[rfHighest2] % clk[ii] < tol1 || rfLens[rfHighest2] % clk[ii] > clk[ii]-tol1){
                                if (rfLens[rfHighest3] % clk[ii] < tol1 || rfLens[rfHighest3] % clk[ii] > clk[ii]-tol1){
                if (rfLens[rfHighest] % clk[ii] < tol1 || rfLens[rfHighest] % clk[ii] > clk[ii]-tol1){
                        if (rfLens[rfHighest2] % clk[ii] < tol1 || rfLens[rfHighest2] % clk[ii] > clk[ii]-tol1){
                                if (rfLens[rfHighest3] % clk[ii] < tol1 || rfLens[rfHighest3] % clk[ii] > clk[ii]-tol1){

+                                       if (g_debugMode==2) prnt("DEBUG FSK: clk %d divides into the 3 most rf values within tolerance",clk[ii]);

                                        break;
                                }
                        }
                                        break;
                                }
                        }


@@ -1362,7 +1392,6 @@ uint16_t countFC(uint8_t *BitStream, size_t size, uint8_t fskAdj)
        uint16_t maxCnt1=0;
        // go through fclens and find which ones are bigest 2  
        for (i=0; i<15; i++){
        uint16_t maxCnt1=0;
        // go through fclens and find which ones are bigest 2  
        for (i=0; i<15; i++){

-               //prnt("DEBUG: FC %d, Cnt %d",fcLens[i],fcCnts[i]);    

                // get the 3 best FC values
                if (fcCnts[i]>maxCnt1) {
                        best3=best2;
                // get the 3 best FC values
                if (fcCnts[i]>maxCnt1) {
                        best3=best2;


@@ -1375,6 +1404,7 @@ uint16_t countFC(uint8_t *BitStream, size_t size, uint8_t fskAdj)
                } else if(fcCnts[i]>fcCnts[best3]){
                        best3=i;
                }
                } else if(fcCnts[i]>fcCnts[best3]){
                        best3=i;
                }

+               if (g_debugMode==2) prnt("DEBUG countfc: FC %u, Cnt %u, best fc: %u, best2 fc: %u",fcLens[i],fcCnts[i],fcLens[best1],fcLens[best2]);

        }
        if (fcLens[best1]==0) return 0;
        uint8_t fcH=0, fcL=0;
        }
        if (fcLens[best1]==0) return 0;
        uint8_t fcH=0, fcL=0;


@@ -1385,13 +1415,13 @@ uint16_t countFC(uint8_t *BitStream, size_t size, uint8_t fskAdj)
                fcH=fcLens[best2];
                fcL=fcLens[best1];
        }
                fcH=fcLens[best2];
                fcL=fcLens[best1];
        }

-       //prnt("DEBUG: dd %d > %d",(size-180)/fcH/3,fcCnts[best1]+fcCnts[best2]);
-       if ((size-180)/fcH/3 > fcCnts[best1]+fcCnts[best2]) return 0; //lots of waves not psk or fsk
-
+       if ((size-180)/fcH/3 > fcCnts[best1]+fcCnts[best2]) {
+               if (g_debugMode==2) prnt("DEBUG countfc: fc is too large: %u > %u. Not psk or fsk",(size-180)/fcH/3,fcCnts[best1]+fcCnts[best2]);
+               return 0; //lots of waves not psk or fsk
+       }

        // TODO: take top 3 answers and compare to known Field clocks to get top 2
 
        uint16_t fcs = (((uint16_t)fcH)<<8) | fcL;
        // TODO: take top 3 answers and compare to known Field clocks to get top 2
 
        uint16_t fcs = (((uint16_t)fcH)<<8) | fcL;

-       //prnt("DEBUG: Best %d  best2 %d best3 %d",fcLens[best1],fcLens[best2],fcLens[best3]);

        if (fskAdj) return fcs; 
        return fcLens[best1];
 }
        if (fskAdj) return fcs; 
        return fcLens[best1];
 }

diff --git a/common/lfdemod.h b/common/lfdemod.h
index 0e1e99adf72baf156a2abe2607d8655969179716..20eb6769502283d7972d438c6a44d5d6a245b14d 100644 (file)
--- a/common/lfdemod.h
+++ b/common/lfdemod.h
@@ -16,6 +16,7 @@
 #include <stdint.h>
 
 //generic
 #include <stdint.h>
 
 //generic

+size_t   addParity(uint8_t *BitSource, uint8_t *dest, uint8_t sourceLen, uint8_t pLen, uint8_t pType);

 int      askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr, uint8_t amp, uint8_t askType);
 int      BiphaseRawDecode(uint8_t * BitStream, size_t *size, int offset, int invert);
 uint32_t bytebits_to_byte(uint8_t* src, size_t numbits);
 int      askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr, uint8_t amp, uint8_t askType);
 int      BiphaseRawDecode(uint8_t * BitStream, size_t *size, int offset, int invert);
 uint32_t bytebits_to_byte(uint8_t* src, size_t numbits);