CHG: @Marshmellow came up with some nifty nice ideas for the t55xx modulation detecti...

CHG: @Marshmellow added PSK1, PSK2, PSK3.   Almost complete now. Waiting for Biphase.
ADD: @Marshmellows lf- psk demod changes,
CHG: In "lf t55xx info" the manufacturerer name is now identified and printed.
CHG: In "lf t55xx info" the modell name is now identified and printed,  however it can only identify two models presently.

diff --git a/client/cmdlft55xx.c b/client/cmdlft55xx.c
index b33c165a283186588c17e3f0732a79630e14ca29..93d8f99ca419c8b109839b005bc4635df9219314 100644 (file)
--- a/client/cmdlft55xx.c
+++ b/client/cmdlft55xx.c
@@ -23,6 +23,7 @@
 #include "lfdemod.h"\r
 #include "../common/crc.h"\r
 #include "../common/iso14443crc.h"\r
 #include "lfdemod.h"\r
 #include "../common/crc.h"\r
 #include "../common/iso14443crc.h"\r

+#include "cmdhf14a.h"\r

 \r
 // Default configuration\r
 t55xx_conf_block_t config = { .modulation = DEMOD_ASK, .inversed = FALSE, .offset = 0x00, .block0 = 0x00};\r
 \r
 // Default configuration\r
 t55xx_conf_block_t config = { .modulation = DEMOD_ASK, .inversed = FALSE, .offset = 0x00, .block0 = 0x00};\r


@@ -31,7 +32,7 @@ int usage_t55xx_config(){
        PrintAndLog("Usage: lf t55xx config [d <demodulation>] [i 1] [o <offset>]");\r
        PrintAndLog("Options:        ");\r
        PrintAndLog("       h                        This help");\r
        PrintAndLog("Usage: lf t55xx config [d <demodulation>] [i 1] [o <offset>]");\r
        PrintAndLog("Options:        ");\r
        PrintAndLog("       h                        This help");\r

-       PrintAndLog("       d <FSK|ASK|PSK|NZ|BI>    Set demodulation FSK / ASK / PSK / NZ / Biphase");\r
+       PrintAndLog("       d <FSK|ASK|PSK1|PSK2|NZ|BI>    Set demodulation FSK / ASK / PSK / NZ / Biphase");\r

        PrintAndLog("       i [1]                    Inverse data signal, defaults to normal");\r
        PrintAndLog("       o [offset]               Set offset, where data should start decode in bitstream");\r
        PrintAndLog("");\r
        PrintAndLog("       i [1]                    Inverse data signal, defaults to normal");\r
        PrintAndLog("       o [offset]               Set offset, where data should start decode in bitstream");\r
        PrintAndLog("");\r


@@ -112,7 +113,7 @@ int CmdT55xxSetConfig(const char *Cmd){
        uint8_t offset = 0;\r
        bool errors = FALSE;\r
        uint8_t cmdp = 0;\r
        uint8_t offset = 0;\r
        bool errors = FALSE;\r
        uint8_t cmdp = 0;\r

-       char modulation[4] = {0x00};\r
+       char modulation[5] = {0x00};\r

        char tmp = 0x00;\r
        \r
        while(param_getchar(Cmd, cmdp) != 0x00 && !errors)\r
        char tmp = 0x00;\r
        \r
        while(param_getchar(Cmd, cmdp) != 0x00 && !errors)\r


@@ -127,11 +128,18 @@ int CmdT55xxSetConfig(const char *Cmd){
                        param_getstr(Cmd, cmdp+1, modulation);\r
                        cmdp += 2;\r
                        \r
                        param_getstr(Cmd, cmdp+1, modulation);\r
                        cmdp += 2;\r
                        \r

-                       if ( strcmp(modulation, "FSK" ) == 0)       config.modulation = DEMOD_FSK;\r
-                       else if ( strcmp(modulation, "ASK" ) == 0)  config.modulation = DEMOD_ASK;\r
-                       else if ( strcmp(modulation, "PSK" ) == 0)  config.modulation = DEMOD_PSK;\r
-                       else if ( strcmp(modulation, "NZ" ) == 0)       config.modulation = DEMOD_NZR;\r
-                       else if ( strcmp(modulation, "BI" ) == 0)       config.modulation = DEMOD_BI;\r
+                       if ( strcmp(modulation, "FSK" ) == 0)\r
+                               config.modulation = DEMOD_FSK;\r
+                       else if ( strcmp(modulation, "ASK" ) == 0)\r
+                               config.modulation = DEMOD_ASK;\r
+                       else if ( strcmp(modulation, "NRZ" ) == 0)\r
+                               config.modulation = DEMOD_NRZ;\r
+                       else if ( strcmp(modulation, "PSK1" ) == 0)\r
+                               config.modulation = DEMOD_PSK1;\r
+                       else if ( strcmp(modulation, "PSK2" ) == 0)\r
+                               config.modulation = DEMOD_PSK2;\r
+                       else if ( strcmp(modulation, "BI" ) == 0)\r
+                               config.modulation = DEMOD_BI;\r

                        else {\r
                                PrintAndLog("Unknown modulation '%s'", modulation);\r
                                errors = TRUE;\r
                        else {\r
                                PrintAndLog("Unknown modulation '%s'", modulation);\r
                                errors = TRUE;\r


@@ -152,9 +160,8 @@ int CmdT55xxSetConfig(const char *Cmd){
                        errors = TRUE;\r
                        break;\r
                }\r
                        errors = TRUE;\r
                        break;\r
                }\r

-               \r
-               PrintAndLog(" %c  %d  [%d]", param_getchar(Cmd, cmdp) , errors, cmdp);\r

        }\r
        }\r

+\r

        // No args\r
        if (cmdp == 0) {\r
                printConfiguration( config );\r
        // No args\r
        if (cmdp == 0) {\r
                printConfiguration( config );\r


@@ -163,7 +170,6 @@ int CmdT55xxSetConfig(const char *Cmd){
        //Validations\r
        if (errors)\r
                return usage_t55xx_config();\r
        //Validations\r
        if (errors)\r
                return usage_t55xx_config();\r

- \r

        config.block0 = 0;\r
        printConfiguration( config );\r
        return 0;\r
        config.block0 = 0;\r
        printConfiguration( config );\r
        return 0;\r


@@ -216,7 +222,7 @@ int CmdT55xxReadBlock(const char *Cmd)
 \r
 void DecodeT55xxBlock(){\r
        \r
 \r
 void DecodeT55xxBlock(){\r
        \r

-       char buf[6] = {0x00};\r
+       char buf[8] = {0x00};\r

        char *cmdStr = buf;\r
 \r
        // clearing the DemodBuffer.\r
        char *cmdStr = buf;\r
 \r
        // clearing the DemodBuffer.\r


@@ -224,24 +230,36 @@ void DecodeT55xxBlock(){
        \r
        // use the configuration\r
        switch( config.modulation ){\r
        \r
        // use the configuration\r
        switch( config.modulation ){\r

-               case 1:\r
+               case DEMOD_FSK:\r

                        sprintf(cmdStr,"0 %d", config.inversed );\r
                        FSKrawDemod(cmdStr, FALSE);\r
                        break;\r
                        sprintf(cmdStr,"0 %d", config.inversed );\r
                        FSKrawDemod(cmdStr, FALSE);\r
                        break;\r

-               case 2:\r
+               case DEMOD_ASK:\r

                        sprintf(cmdStr,"0 %d 1", config.inversed );\r
                        ASKmanDemod(cmdStr, FALSE, FALSE);\r
                        break;\r
                        sprintf(cmdStr,"0 %d 1", config.inversed );\r
                        ASKmanDemod(cmdStr, FALSE, FALSE);\r
                        break;\r

-               case 3:\r
+               case DEMOD_PSK1:\r

                        sprintf(cmdStr,"0 %d 1", config.inversed );\r
                        PSKDemod(cmdStr, FALSE);\r
                        break;\r
                        sprintf(cmdStr,"0 %d 1", config.inversed );\r
                        PSKDemod(cmdStr, FALSE);\r
                        break;\r

-               case 4:\r
+               case DEMOD_PSK2:\r
+                       sprintf(cmdStr,"0 %d 1", config.inversed );\r
+                       PSKDemod(cmdStr, FALSE);\r
+                       psk1TOpsk2(DemodBuffer, DemodBufferLen);\r
+                       break;\r
+               case DEMOD_PSK3:\r
+                       sprintf(cmdStr,"0 %d 1", config.inversed );\r
+                       PSKDemod(cmdStr, FALSE);\r
+                       psk1TOpsk2(DemodBuffer, DemodBufferLen);\r
+                       break;\r
+               case DEMOD_NRZ:\r

                        sprintf(cmdStr,"0 %d 1", config.inversed );\r
                        NRZrawDemod(cmdStr, FALSE);\r
                        break;\r
                        sprintf(cmdStr,"0 %d 1", config.inversed );\r
                        NRZrawDemod(cmdStr, FALSE);\r
                        break;\r

-               case 5:\r
-                       //BiphaseRawDecode("0",FALSE);\r
+               case DEMOD_BI:\r
+                       sprintf(cmdStr,"0 0 %d 1", config.inversed );\r
+                       // DEPENDS ON NEW CODE IN MARSHMELLOWS PULL REQUEST\r
+                       //ASKbiphDemod(cmdStr, FALSE);\r

                        break;\r
                default:\r
                return;\r
                        break;\r
                default:\r
                return;\r


@@ -284,68 +302,92 @@ int CmdT55xxDetect(const char *Cmd){
 bool tryDetectModulation(){\r
        \r
        uint8_t hits = 0;\r
 bool tryDetectModulation(){\r
        \r
        uint8_t hits = 0;\r

-       t55xx_conf_block_t tests[10];\r
+       t55xx_conf_block_t tests[11];\r

        \r
        if (GetFskClock("", FALSE, FALSE)){ \r
        \r
        if (GetFskClock("", FALSE, FALSE)){ \r

-               if ( FSKrawDemod("0 0", FALSE) && test()){\r
+               if ( FSKrawDemod("0 0", FALSE) && test(DEMOD_FSK, &tests[hits].offset)){\r

                        tests[hits].modulation = DEMOD_FSK;\r
                        tests[hits].inversed = FALSE;\r
                        ++hits;\r
                }\r
                        tests[hits].modulation = DEMOD_FSK;\r
                        tests[hits].inversed = FALSE;\r
                        ++hits;\r
                }\r

-               if ( FSKrawDemod("0 1", FALSE) && test()) {\r
+               if ( FSKrawDemod("0 1", FALSE) && test(DEMOD_FSK, &tests[hits].offset)) {\r

                        tests[hits].modulation = DEMOD_FSK;\r
                        tests[hits].inversed = TRUE;\r
                        ++hits;\r
                        }\r
     } else {\r
                        tests[hits].modulation = DEMOD_FSK;\r
                        tests[hits].inversed = TRUE;\r
                        ++hits;\r
                        }\r
     } else {\r

-               if ( ASKmanDemod("0 0 1", FALSE, FALSE) && test()) {\r
+               if ( ASKmanDemod("0 0 1", FALSE, FALSE) && test(DEMOD_ASK, &tests[hits].offset)) {\r

                        tests[hits].modulation = DEMOD_ASK;\r
                        tests[hits].inversed = FALSE;\r
                        ++hits;\r
                        }\r
 \r
                        tests[hits].modulation = DEMOD_ASK;\r
                        tests[hits].inversed = FALSE;\r
                        ++hits;\r
                        }\r
 \r

-               if ( ASKmanDemod("0 1 1", FALSE, FALSE)  && test()) {\r
+               if ( ASKmanDemod("0 1 1", FALSE, FALSE)  && test(DEMOD_ASK, &tests[hits].offset)) {\r

                        tests[hits].modulation = DEMOD_ASK;\r
                        tests[hits].inversed = TRUE;\r
                        ++hits;\r
                        }\r
                \r
                        tests[hits].modulation = DEMOD_ASK;\r
                        tests[hits].inversed = TRUE;\r
                        ++hits;\r
                        }\r
                \r

-               if ( NRZrawDemod("0 0 1", FALSE)  && test()) {\r
-                       tests[hits].modulation = DEMOD_NZR;\r
+               if ( NRZrawDemod("0 0 1", FALSE)  && test(DEMOD_NRZ, &tests[hits].offset)) {\r
+                       tests[hits].modulation = DEMOD_NRZ;\r

                        tests[hits].inversed = FALSE;\r
                        ++hits;\r
                }\r
 \r
                        tests[hits].inversed = FALSE;\r
                        ++hits;\r
                }\r
 \r

-               if ( NRZrawDemod("0 1 1", FALSE)  && test()) {\r
-                       tests[hits].modulation = DEMOD_NZR;\r
+               if ( NRZrawDemod("0 1 1", FALSE)  && test(DEMOD_NRZ, &tests[hits].offset)) {\r
+                       tests[hits].modulation = DEMOD_NRZ;\r

                        tests[hits].inversed = TRUE;\r
                        ++hits;\r
                        }\r
                \r
                        tests[hits].inversed = TRUE;\r
                        ++hits;\r
                        }\r
                \r

-               if ( PSKDemod("0 0 1", FALSE) && test()) {\r
-                       tests[hits].modulation = DEMOD_PSK;\r
+               if ( PSKDemod("0 0 1", FALSE) && test(DEMOD_PSK1, &tests[hits].offset)) {\r
+                       tests[hits].modulation = DEMOD_PSK1;\r

                        tests[hits].inversed = FALSE;\r
                        ++hits;\r
                }\r
                \r
                        tests[hits].inversed = FALSE;\r
                        ++hits;\r
                }\r
                \r

-               if ( PSKDemod("0 1 1", FALSE) && test()) {\r
-                       tests[hits].modulation = DEMOD_PSK;\r
+               if ( PSKDemod("0 1 1", FALSE) && test(DEMOD_PSK1, &tests[hits].offset)) {\r
+                       tests[hits].modulation = DEMOD_PSK1;\r

                        tests[hits].inversed = TRUE;\r
                        ++hits;\r
                }\r
                        tests[hits].inversed = TRUE;\r
                        ++hits;\r
                }\r

-               //PSK2?\r
-               // if (!BiphaseRawDecode("0",FALSE)  && test()) {\r
-               //      tests[++hits].modulation = DEMOD_BI;\r
-               //      tests[hits].inversed = FALSE;\r
-               //}\r
-               // if (!BiphaseRawDecode("1",FALSE) && test()) {\r
-               //      tests[++hits].modulation = DEMOD_BI;\r
-               //      tests[hits].inversed = TRUE;\r
-               // }\r
+\r
+               //PSK2\r
+               if ( PSKDemod("0 0 1", FALSE)) {\r
+                       psk1TOpsk2(DemodBuffer, DemodBufferLen);\r
+                       if (test(DEMOD_PSK2, &tests[hits].offset)){\r
+                               tests[hits].modulation = DEMOD_PSK2;\r
+                               tests[hits].inversed = FALSE;\r
+                               ++hits;\r
+                       }\r
+               }\r
+               if ( PSKDemod("0 1 1", FALSE)) {\r
+                       psk1TOpsk2(DemodBuffer, DemodBufferLen);\r
+                       if (test(DEMOD_PSK2, &tests[hits].offset)){\r
+                               tests[hits].modulation = DEMOD_PSK2;\r
+                               tests[hits].inversed = TRUE;\r
+                               ++hits;\r
+                       }\r
+               }\r
+\r
+               /* DEPENDANT ON NEW CODE IN MARSHMELLOWS pull request\r
+               //biphase //offset, clock, invert, maxErr\r
+               if ( ASKbiphaseDemod("0 0 0 1", FALSE) && test(DEMOD_BI, &tests[hits].offset) ) {\r
+                       tests[hits].modulation = DEMOD_BI;\r
+                       tests[hits].inversed = FALSE;\r
+                       ++hits;\r
+               }\r
+               if ( ASKbiphaseDemod("0 0 1 1", FALSE) && test(DEMOD_BI, &tests[hits].offset) ) {\r
+                       tests[hits].modulation = DEMOD_BI;\r
+                       tests[hits].inversed = TRUE;\r
+                       ++hits;\r
+               }\r
+               */\r

        }               \r
        if ( hits == 1) {\r
                config.modulation = tests[0].modulation;\r
                config.inversed = tests[0].inversed;\r
        }               \r
        if ( hits == 1) {\r
                config.modulation = tests[0].modulation;\r
                config.inversed = tests[0].inversed;\r

+               config.offset = tests[0].offset;\r

                printConfiguration( config );\r
                return TRUE;\r
        }\r
                printConfiguration( config );\r
                return TRUE;\r
        }\r


@@ -360,30 +402,72 @@ bool tryDetectModulation(){
        return FALSE;\r
 }\r
 \r
        return FALSE;\r
 }\r
 \r

-bool test(){\r
+bool testModulation(uint8_t mode, uint8_t modread){\r
+       switch( mode ){\r
+               case DEMOD_FSK:\r
+                       if (modread > 3 && modread < 8) return TRUE;\r
+                       break;\r
+               case DEMOD_ASK:\r
+                       if (modread == 8) return TRUE;\r
+                       break;\r
+               case DEMOD_PSK1:\r
+                       if (modread == 1) return TRUE;\r
+                       break;\r
+               case DEMOD_PSK2:\r
+                       if (modread == 2) return TRUE;\r
+                       break;\r
+               case DEMOD_PSK3:\r
+                       if (modread == 3) return TRUE;\r
+                       break;\r
+               case DEMOD_NRZ:\r
+                       if (!modread) return TRUE;\r
+                       break;\r
+               case DEMOD_BI:\r
+                       if (modread == 16) return TRUE;\r
+                       break;\r
+               default:\r
+                       return FALSE;\r
+       }\r
+       return FALSE;\r
+}\r
+\r
+bool test(uint8_t mode, uint8_t *offset){\r

 \r
        if ( !DemodBufferLen) \r
 \r
        if ( !DemodBufferLen) \r

-               return false;\r
-       \r
+               return FALSE;\r

        if ( PackBits(0, 32, DemodBuffer) == 0x00 )\r
                return FALSE;\r
        if ( PackBits(0, 32, DemodBuffer) == 0x00 )\r
                return FALSE;\r

-       \r
-       uint8_t si = 0;\r
-       \r
-       uint8_t safer    = PackBits(si, 4, DemodBuffer); si += 4;       \r
-       uint8_t resv     = PackBits(si, 7, DemodBuffer); si += 7+3;\r
-       uint8_t extend   = PackBits(si, 1, DemodBuffer); si += 1;\r
+       for (uint8_t idx=1; idx<33; idx++){\r
+               uint8_t si = idx;\r
+               uint8_t safer    = PackBits(si, 4, DemodBuffer); si += 4;           //master key\r
+               uint8_t resv     = PackBits(si, 4, DemodBuffer); si += 4;     //was 7 & +=7+3 //should be only 4 bits if extended mode\r
+               uint8_t xtRate   = PackBits(si, 3, DemodBuffer); si += 3+3;   //new\r
+               //uint8_t bitRate  = PackBits(si, 3, DemodBuffer); si += 3;   //new  could check bit rate\r
+               uint8_t extend   = PackBits(si, 1, DemodBuffer); si += 1;     //bit 15 extended mode\r
+               uint8_t modread  = PackBits(si, 5, DemodBuffer); si += 5+2+1; //new\r
+               //uint8_t pskcr   = PackBits(si, 2, DemodBuffer); si += 2+1;  //new  could check psk cr\r
+               uint8_t nml01    = PackBits(si, 1, DemodBuffer); si += 1+5;   //bit 24 , 30, 31 could be tested for 0 if not extended mode\r
+               uint8_t nml02    = PackBits(si, 2, DemodBuffer); si += 2;\r
+               \r
+               bool extMode = FALSE;\r

 \r
        //PrintAndLog("test: %X %X %X ", safer, resv, extend);\r
        \r
        // 2nibble must be zeroed.\r
 \r
        //PrintAndLog("test: %X %X %X ", safer, resv, extend);\r
        \r
        // 2nibble must be zeroed.\r

-       if ( resv > 0x00) return FALSE;\r
+               if ( resv > 0x00) continue;\r

 \r
 \r

-       if ( safer == 0x6 || safer == 0x9){\r
-               if ( extend == 0x00)\r
+               //if extended mode\r
+               if ( (safer == 0x6 || safer == 0x9) && extend) extMode = TRUE;\r
+\r
+               if (!extMode){\r
+                       if (nml01 || nml02 || xtRate) continue;\r
+               }\r
+\r
+               //test modulation\r
+               if (!testModulation(mode, modread)) continue;\r
+               *offset = idx;\r

                        return TRUE;\r
        }\r
                        return TRUE;\r
        }\r

-       if ( resv== 0x00) return TRUE;\r

        return FALSE;\r
 }\r
 \r
        return FALSE;\r
 }\r
 \r


@@ -395,8 +479,8 @@ void printT55xxBlock(const char *demodStr){
        if ( !DemodBufferLen) \r
                return;\r
        \r
        if ( !DemodBufferLen) \r
                return;\r
        \r

-       if ( config.offset > DemodBufferLen){\r
-               PrintAndLog("The configured offset is to big. (%d > %d)", config.offset, DemodBufferLen);\r
+       if ( config.offset + 32 > DemodBufferLen){\r
+               PrintAndLog("The configured offset is too big. (%d > %d)", config.offset, DemodBufferLen);\r

                return;\r
        }\r
        \r
                return;\r
        }\r
        \r


@@ -505,8 +589,9 @@ int CmdT55xxReadTrace(const char *Cmd)
                return 2;\r
        \r
        RepaintGraphWindow();\r
                return 2;\r
        \r
        RepaintGraphWindow();\r

-\r
-       uint8_t si = config.offset;\r
+       uint8_t repeat = 0;\r
+       if (config.offset > 5) repeat = 32;\r
+       uint8_t si = config.offset+repeat;\r

        uint32_t bl0     = PackBits(si, 32, DemodBuffer);\r
        uint32_t bl1     = PackBits(si+32, 32, DemodBuffer);\r
        \r
        uint32_t bl0     = PackBits(si, 32, DemodBuffer);\r
        uint32_t bl1     = PackBits(si+32, 32, DemodBuffer);\r
        \r


@@ -526,8 +611,8 @@ int CmdT55xxReadTrace(const char *Cmd)
        PrintAndLog("-- T55xx Trace Information ----------------------------------");\r
        PrintAndLog("-------------------------------------------------------------");\r
        PrintAndLog(" ACL Allocation class (ISO/IEC 15963-1)  : 0x%02X (%d)", acl, acl);\r
        PrintAndLog("-- T55xx Trace Information ----------------------------------");\r
        PrintAndLog("-------------------------------------------------------------");\r
        PrintAndLog(" ACL Allocation class (ISO/IEC 15963-1)  : 0x%02X (%d)", acl, acl);\r

-       PrintAndLog(" MFC Manufacturer ID (ISO/IEC 7816-6)    : 0x%02X (%d)", mfc, mfc);\r
-       PrintAndLog(" CID                                     : 0x%02X (%d)", cid, cid);\r
+       PrintAndLog(" MFC Manufacturer ID (ISO/IEC 7816-6)    : 0x%02X (%d) - %s", mfc, mfc, getTagInfo(mfc));\r
+       PrintAndLog(" CID                                     : 0x%02X (%d) - %s", cid, cid, GetModelStrFromCID(cid));\r

        PrintAndLog(" ICR IC Revision                         : %d",icr );\r
        PrintAndLog(" Manufactured");\r
        PrintAndLog("     Year/Quarter : %d/%d",year, quarter );\r
        PrintAndLog(" ICR IC Revision                         : %d",icr );\r
        PrintAndLog(" Manufactured");\r
        PrintAndLog("     Year/Quarter : %d/%d",year, quarter );\r


@@ -536,8 +621,8 @@ int CmdT55xxReadTrace(const char *Cmd)
        PrintAndLog("     Die Number   : %d", dw);\r
        PrintAndLog("-------------------------------------------------------------");\r
        PrintAndLog(" Raw Data - Page 1");\r
        PrintAndLog("     Die Number   : %d", dw);\r
        PrintAndLog("-------------------------------------------------------------");\r
        PrintAndLog(" Raw Data - Page 1");\r

-       PrintAndLog("     Block 0  : 0x%08X  %s", bl0, sprint_bin(DemodBuffer+5,32) );\r
-       PrintAndLog("     Block 1  : 0x%08X  %s", bl1, sprint_bin(DemodBuffer+37,32) );\r
+       PrintAndLog("     Block 0  : 0x%08X  %s", bl0, sprint_bin(DemodBuffer+config.offset+repeat,32) );\r
+       PrintAndLog("     Block 1  : 0x%08X  %s", bl1, sprint_bin(DemodBuffer+config.offset+repeat+32,32) );\r

        PrintAndLog("-------------------------------------------------------------");\r
        /*\r
        TRACE - BLOCK O\r
        PrintAndLog("-------------------------------------------------------------");\r
        /*\r
        TRACE - BLOCK O\r


@@ -637,7 +722,7 @@ int CmdT55xxInfo(const char *Cmd){
        PrintAndLog(" POR-Delay                 : %s", (por) ? "Yes":"No");\r
        PrintAndLog("-------------------------------------------------------------");\r
        PrintAndLog(" Raw Data - Page 0");\r
        PrintAndLog(" POR-Delay                 : %s", (por) ? "Yes":"No");\r
        PrintAndLog("-------------------------------------------------------------");\r
        PrintAndLog(" Raw Data - Page 0");\r

-       PrintAndLog("     Block 0  : 0x%08X  %s", bl0, sprint_bin(DemodBuffer+5,32) );\r
+       PrintAndLog("     Block 0  : 0x%08X  %s", bl0, sprint_bin(DemodBuffer+config.offset,32) );\r

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


@@ -769,6 +854,16 @@ char * GetModulationStr( uint32_t id){
        return buf;\r
 }\r
 \r
        return buf;\r
 }\r
 \r

+char * GetModelStrFromCID(uint32_t cid){\r
+               \r
+       static char buf[10];\r
+       char *retStr = buf;\r
+       \r
+       if (cid == 1) sprintf(retStr,"ATA5577M1");\r
+       if (cid == 2) sprintf(retStr,"ATA5577M2");      \r
+       return buf;\r
+}\r
+\r

 char * GetSelectedModulationStr( uint8_t id){\r
 \r
        static char buf[16];\r
 char * GetSelectedModulationStr( uint8_t id){\r
 \r
        static char buf[16];\r


@@ -781,11 +876,14 @@ char * GetSelectedModulationStr( uint8_t id){
                case DEMOD_ASK:         \r
                        sprintf(retStr,"ASK (%d)",id);\r
                        break;\r
                case DEMOD_ASK:         \r
                        sprintf(retStr,"ASK (%d)",id);\r
                        break;\r

-               case DEMOD_NZR:\r
+               case DEMOD_NRZ:\r

                        sprintf(retStr,"DIRECT/NRZ (%d)",id);\r
                        break;\r
                        sprintf(retStr,"DIRECT/NRZ (%d)",id);\r
                        break;\r

-               case DEMOD_PSK:\r
-                       sprintf(retStr,"PSK (%d)",id);\r
+               case DEMOD_PSK1:\r
+                       sprintf(retStr,"PSK1 (%d)",id);\r
+                       break;\r
+               case DEMOD_PSK2:\r
+                       sprintf(retStr,"PSK2 (%d)",id);\r

                        break;\r
                case DEMOD_BI:\r
                        sprintf(retStr,"BIPHASE (%d)",id);\r
                        break;\r
                case DEMOD_BI:\r
                        sprintf(retStr,"BIPHASE (%d)",id);\r

diff --git a/client/cmdlft55xx.h b/client/cmdlft55xx.h
index e4eca17cb18cf1a941c2cbb428ba94b01c665234..004154ff26e802a0158c5b8e55cdef64725f723c 100644 (file)
--- a/client/cmdlft55xx.h
+++ b/client/cmdlft55xx.h
@@ -12,18 +12,19 @@
 \r
 typedef struct {\r
        enum {\r
 \r
 typedef struct {\r
        enum {\r

-               DEMOD_FSK = 0x01,     \r
-               DEMOD_ASK = 0x02,\r
-               DEMOD_NZR = 0x03,    \r
-               DEMOD_PSK = 0x04,\r
-               DEMOD_BI  = 0x05,\r
+               DEMOD_NRZ  = 0x00,    \r
+               DEMOD_PSK1 = 0x01,\r
+               DEMOD_PSK2 = 0x02,\r
+               DEMOD_PSK3 = 0x03,\r
+               DEMOD_FSK  = 0x04,     \r
+               DEMOD_ASK  = 0x08,\r
+               DEMOD_BI   = 0x16,\r

        }  modulation;\r
        bool inversed;\r
        uint8_t offset;\r
        uint32_t block0;\r
 } t55xx_conf_block_t;\r
 \r
        }  modulation;\r
        bool inversed;\r
        uint8_t offset;\r
        uint32_t block0;\r
 } t55xx_conf_block_t;\r
 \r

-\r

 int CmdLFT55XX(const char *Cmd);\r
 int CmdT55xxSetConfig(const char *Cmd);\r
 int CmdT55xxReadBlock(const char *Cmd);\r
 int CmdLFT55XX(const char *Cmd);\r
 int CmdT55xxSetConfig(const char *Cmd);\r
 int CmdT55xxReadBlock(const char *Cmd);\r


@@ -35,6 +36,7 @@ int CmdT55xxDetect(const char *Cmd);
 char * GetBitRateStr(uint32_t id);\r
 char * GetSaferStr(uint32_t id);\r
 char * GetModulationStr( uint32_t id);\r
 char * GetBitRateStr(uint32_t id);\r
 char * GetSaferStr(uint32_t id);\r
 char * GetModulationStr( uint32_t id);\r

+char * GetModelStrFromCID(uint32_t cid);\r

 char * GetSelectedModulationStr( uint8_t id);\r
 uint32_t PackBits(uint8_t start, uint8_t len, uint8_t* bitstream);\r
 void printT55xxBlock(const char *demodStr);\r
 char * GetSelectedModulationStr( uint8_t id);\r
 uint32_t PackBits(uint8_t start, uint8_t len, uint8_t* bitstream);\r
 void printT55xxBlock(const char *demodStr);\r


@@ -42,6 +44,6 @@ void printConfiguration( t55xx_conf_block_t b);
 \r
 void DecodeT55xxBlock();\r
 bool tryDetectModulation();\r
 \r
 void DecodeT55xxBlock();\r
 bool tryDetectModulation();\r

-bool test();\r
+bool test(uint8_t mode, uint8_t *offset);\r

 int special(const char *Cmd);\r
 #endif\r
 int special(const char *Cmd);\r
 #endif\r