CHG: `lf em` - added @marshmellow42 's changes

diff --git a/armsrc/lfops.c b/armsrc/lfops.c
index c8eed468c5ebd6e294556b1365f2b84f2c910601..a7b8d819109cee3c1baa89de8b803ce33c54644b 100644 (file)
--- a/armsrc/lfops.c
+++ b/armsrc/lfops.c
@@ -1690,7 +1690,7 @@ void EM4xLogin(uint32_t pwd) {
        len = Prepare_Cmd( FWD_CMD_LOGIN );
        len += Prepare_Data( pwd & 0xFFFF, pwd >> 16 );
        SendForward(len);
        len = Prepare_Cmd( FWD_CMD_LOGIN );
        len += Prepare_Data( pwd & 0xFFFF, pwd >> 16 );
        SendForward(len);

-       //WaitMS(20); - no wait for login command.
+       WaitMS(20); // no wait for login command.

        // should receive
        // 0000 1010 ok.
        // 0000 0001 fail
        // should receive
        // 0000 1010 ok.
        // 0000 0001 fail


@@ -1719,7 +1719,7 @@ void EM4xReadWord(uint8_t addr, uint32_t pwd, uint8_t usepwd) {
 
        SendForward(len);
 
 
        SendForward(len);
 

-       DoAcquisition_config(TRUE);
+       DoAcquisition_default(0, TRUE);

 
        FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
        cmd_send(CMD_ACK,0,0,0,0,0);
 
        FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
        cmd_send(CMD_ACK,0,0,0,0,0);


@@ -1752,8 +1752,12 @@ void EM4xWriteWord(uint32_t flag, uint32_t data, uint32_t pwd) {
 
        SendForward(len);
 
 
        SendForward(len);
 

-       //Wait 20ms for write to complete
-       WaitMS(20);
+       //Wait 20ms for write to complete?
+       WaitMS(10);
+
+       //Capture response if one exists
+       DoAcquisition_default(20, TRUE);
+       

        FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
        cmd_send(CMD_ACK,0,0,0,0,0);
        LED_A_OFF();
        FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
        cmd_send(CMD_ACK,0,0,0,0,0);
        LED_A_OFF();

diff --git a/client/cmdlfem4x.c b/client/cmdlfem4x.c
index 88d292ff61ec14c3f167e990f5b329fd105054db..c2e8b7b43896595770fffc5b4d2e19b612e14f7d 100644 (file)
--- a/client/cmdlfem4x.c
+++ b/client/cmdlfem4x.c
@@ -251,6 +251,48 @@ bool EM_ByteParityTest(uint8_t *BitStream, size_t size, uint8_t rows, uint8_t co
        return true;
 }
 
        return true;
 }
 

+
+//////////////// 4050 / 4450 commands
+int usage_lf_em4x50_dump(void) {
+       PrintAndLog("Dump EM4x50/EM4x69.  Tag must be on antenna. ");
+       PrintAndLog("");
+       PrintAndLog("Usage:  lf em 4x50dump [h] <pwd>");
+       PrintAndLog("Options:");
+       PrintAndLog("       h         - this help");
+       PrintAndLog("       pwd       - password (hex) (optional)");
+       PrintAndLog("samples:");
+       PrintAndLog("      lf em 4x50dump");
+       PrintAndLog("      lf em 4x50dump 11223344");
+       return 0;
+}
+int usage_lf_em4x50_read(void) {
+       PrintAndLog("Read EM 4x50/EM4x69.  Tag must be on antenna. ");
+       PrintAndLog("");
+       PrintAndLog("Usage:  lf em 4x50read [h] <address> <pwd>");
+       PrintAndLog("Options:");
+       PrintAndLog("       h         - this help");
+       PrintAndLog("       address   - memory address to read. (0-15)");
+       PrintAndLog("       pwd       - password (hex) (optional)");
+       PrintAndLog("samples:");
+       PrintAndLog("      lf em 4x50read 1");
+       PrintAndLog("      lf em 4x50read 1 11223344");
+       return 0;
+}
+int usage_lf_em4x50_write(void) {
+       PrintAndLog("Write EM 4x50/4x69.  Tag must be on antenna. ");
+       PrintAndLog("");
+       PrintAndLog("Usage:  lf em 4x50write [h] <address> <data> <pwd>");
+       PrintAndLog("Options:");
+       PrintAndLog("       h         - this help");
+       PrintAndLog("       address   - memory address to write to. (0-15)");
+       PrintAndLog("       data      - data to write (hex)");  
+       PrintAndLog("       pwd       - password (hex) (optional)");
+       PrintAndLog("samples:");
+       PrintAndLog("      lf em 4x50write 1 deadc0de");
+       PrintAndLog("      lf em 4x50write 1 deadc0de 11223344");
+       return 0;
+}
+

 uint32_t OutputEM4x50_Block(uint8_t *BitStream, size_t size, bool verbose, bool pTest)
 {
        if (size<45) return 0;
 uint32_t OutputEM4x50_Block(uint8_t *BitStream, size_t size, bool verbose, bool pTest)
 {
        if (size<45) return 0;


@@ -283,6 +325,8 @@ uint32_t OutputEM4x50_Block(uint8_t *BitStream, size_t size, bool verbose, bool
        }
        return code;
 }
        }
        return code;
 }

+
+

 /* Read the transmitted data of an EM4x50 tag from the graphbuffer
  * Format:
  *
 /* Read the transmitted data of an EM4x50 tag from the graphbuffer
  * Format:
  *


@@ -303,8 +347,7 @@ uint32_t OutputEM4x50_Block(uint8_t *BitStream, size_t size, bool verbose, bool
  * Word Read values. UID is stored in block 32.
  */
  //completed by Marshmellow
  * Word Read values. UID is stored in block 32.
  */
  //completed by Marshmellow

-int EM4x50Read(const char *Cmd, bool verbose)
-{
+int EM4x50Read(const char *Cmd, bool verbose) {

        uint8_t fndClk[] = {8,16,32,40,50,64,128};
        int clk = 0; 
        int invert = 0;
        uint8_t fndClk[] = {8,16,32,40,50,64,128};
        int clk = 0; 
        int invert = 0;


@@ -495,35 +538,21 @@ int EM4x50Read(const char *Cmd, bool verbose)
 }
 
 int CmdEM4x50Read(const char *Cmd) {
 }
 
 int CmdEM4x50Read(const char *Cmd) {

+       uint8_t ctmp = param_getchar(Cmd, 0);
+       if ( ctmp == 'H' || ctmp == 'h' ) return usage_lf_em4x50_read();        

        return EM4x50Read(Cmd, true);
 }
 
        return EM4x50Read(Cmd, true);
 }
 

-int usage_lf_em_read(void) {
-       PrintAndLog("Read EM 4x05/4x50/EM4x69.  Tag must be on antenna. ");
-       PrintAndLog("");
-       PrintAndLog("Usage:  lf em readword [h] <address> <pwd>");
-       PrintAndLog("Options:");
-       PrintAndLog("       h         - this help");
-       PrintAndLog("       address   - memory address to read. (0-15)");
-       PrintAndLog("       pwd       - password (hex) (optional)");
-       PrintAndLog("samples:");
-       PrintAndLog("      lf em readword 1");
-       PrintAndLog("      lf em readword 1 11223344");
+int CmdEM4x50Write(const char *Cmd){
+       uint8_t ctmp = param_getchar(Cmd, 0);
+       if ( ctmp == 'H' || ctmp == 'h' ) return usage_lf_em4x50_write();
+       PrintAndLog("no implemented yet");

        return 0;
 }
        return 0;
 }

-
-int usage_lf_em_write(void) {
-       PrintAndLog("Write EM 4x05/4x50/4x69.  Tag must be on antenna. ");
-       PrintAndLog("");
-       PrintAndLog("Usage:  lf em writeword [h] <address> <data> <pwd>");
-       PrintAndLog("Options:");
-       PrintAndLog("       h         - this help");
-       PrintAndLog("       address   - memory address to write to. (0-15)");
-       PrintAndLog("       data      - data to write (hex)");  
-       PrintAndLog("       pwd       - password (hex) (optional)");
-       PrintAndLog("samples:");
-       PrintAndLog("      lf em writeword 1");
-       PrintAndLog("      lf em writeword 1 deadc0de 11223344");
+int CmdEM4x50Dump(const char *Cmd){
+       uint8_t ctmp = param_getchar(Cmd, 0);
+       if ( ctmp == 'H' || ctmp == 'h' ) return usage_lf_em4x50_dump();
+       PrintAndLog("no implemented yet");

        return 0;
 }
 
        return 0;
 }
 


@@ -554,8 +583,8 @@ bool doPreambleSearch(size_t *startIdx){
        // skip first two 0 bits as they might have been missed in the demod 
        uint8_t preamble[EM_PREAMBLE_LEN] = {0,0,1,0,1,0};
        
        // skip first two 0 bits as they might have been missed in the demod 
        uint8_t preamble[EM_PREAMBLE_LEN] = {0,0,1,0,1,0};
        

-       // set size to 10 to only test first 4 positions for the preamble
-       size_t size = (10 > DemodBufferLen) ? DemodBufferLen : 10;
+       // set size to 15 to only test first 4 positions for the preamble
+       size_t size = (15 > DemodBufferLen) ? DemodBufferLen : 15;

        *startIdx = 0; 
        uint8_t found = 0;
        
        *startIdx = 0; 
        uint8_t found = 0;
        


@@ -579,13 +608,13 @@ bool doPreambleSearch(size_t *startIdx){
 bool detectFSK(){
        // detect fsk clock
        if (!GetFskClock("", FALSE, FALSE)) {
 bool detectFSK(){
        // detect fsk clock
        if (!GetFskClock("", FALSE, FALSE)) {

-               if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: FSK clock failed");
+               if (g_debugMode) PrintAndLog("DEBUG: Error - EM: FSK clock failed");

                return FALSE;
        }
        // demod
        int ans = FSKrawDemod("0 0", FALSE);
        if (!ans) {
                return FALSE;
        }
        // demod
        int ans = FSKrawDemod("0 0", FALSE);
        if (!ans) {

-               if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: FSK Demod failed");
+               if (g_debugMode) PrintAndLog("DEBUG: Error - EM: FSK Demod failed");

                return FALSE;
        }
        return TRUE;
                return FALSE;
        }
        return TRUE;


@@ -594,10 +623,24 @@ bool detectFSK(){
 bool detectPSK(){      
        int     ans = GetPskClock("", FALSE, FALSE);
        if (ans <= 0) {
 bool detectPSK(){      
        int     ans = GetPskClock("", FALSE, FALSE);
        if (ans <= 0) {

-               if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: PSK clock failed");
+               if (g_debugMode) PrintAndLog("DEBUG: Error - EM: PSK clock failed");

                return FALSE;
        }
                return FALSE;
        }

-       PrintAndLog("PSK response possibly found, run `data rawd p1` to attempt to demod");
+       //demod
+       //try psk1 -- 0 0 6 (six errors?!?)
+       ans = PSKDemod("0 0 6", FALSE);
+       if (!ans) {
+               if (g_debugMode) PrintAndLog("DEBUG: Error - EM: PSK1 Demod failed");
+
+               //try psk1 inverted
+               ans = PSKDemod("0 1 6", FALSE);
+               if (!ans) {
+                       if (g_debugMode) PrintAndLog("DEBUG: Error - EM: PSK1 inverted Demod failed");
+                       return FALSE;
+               }
+       }
+       // either PSK1 or PSK1 inverted is ok from here.
+       // lets check PSK2 later.

        return TRUE;
 }
 // try manchester - NOTE: ST only applies to T55x7 tags.
        return TRUE;
 }
 // try manchester - NOTE: ST only applies to T55x7 tags.


@@ -605,7 +648,7 @@ bool detectASK_MAN(){
        bool stcheck = FALSE;
        int ans = ASKDemod_ext("0 0 0", FALSE, FALSE, 1, &stcheck);
        if (!ans) {
        bool stcheck = FALSE;
        int ans = ASKDemod_ext("0 0 0", FALSE, FALSE, 1, &stcheck);
        if (!ans) {

-               if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: ASK/Manchester Demod failed");
+               if (g_debugMode) PrintAndLog("DEBUG: Error - EM: ASK/Manchester Demod failed");

                return FALSE;
        } 
        return TRUE;
                return FALSE;
        } 
        return TRUE;


@@ -613,11 +656,11 @@ bool detectASK_MAN(){
 bool detectASK_BI(){
        int ans = ASKbiphaseDemod("0 0 1", FALSE);
        if (!ans) { 
 bool detectASK_BI(){
        int ans = ASKbiphaseDemod("0 0 1", FALSE);
        if (!ans) { 

-               if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: ASK/biphase normal demod failed");
+               if (g_debugMode) PrintAndLog("DEBUG: Error - EM: ASK/biphase normal demod failed");

                
                ans = ASKbiphaseDemod("0 1 1", FALSE);
                if (!ans) {
                
                ans = ASKbiphaseDemod("0 1 1", FALSE);
                if (!ans) {

-                       if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: ASK/biphase inverted demod failed");
+                       if (g_debugMode) PrintAndLog("DEBUG: Error - EM: ASK/biphase inverted demod failed");

                        return FALSE;
                }
        }
                        return FALSE;
                }
        }


@@ -625,41 +668,136 @@ bool detectASK_BI(){
 }
 
 // param: idx - start index in demoded data.
 }
 
 // param: idx - start index in demoded data.

-int setDemodBufferEM(uint8_t bitsNeeded, size_t idx){
-       if ( bitsNeeded < DemodBufferLen) {
-               setDemodBuf(DemodBuffer + idx + EM_PREAMBLE_LEN, bitsNeeded, 0);
-               CmdPrintDemodBuff("x");
-               return 1;
+bool setDemodBufferEM(uint32_t *word, size_t idx){
+
+       //test for even parity bits.
+       size_t size = removeParity(DemodBuffer, idx + EM_PREAMBLE_LEN, 9, 0, 44);
+       if (!size) {
+               if (g_debugMode) PrintAndLog("DEBUG: Error -EM Parity not detected");
+               return FALSE;

        }
        }

-       return -1;
+
+       //todo test last 8 bits for even parity || (xor)
+       setDemodBuf(DemodBuffer, 40, 0);
+
+       *word = bytebits_to_byteLSBF(DemodBuffer, 32);
+
+       uint8_t lo  = (uint8_t) bytebits_to_byteLSBF(DemodBuffer     , 8);
+       uint8_t lo2 = (uint8_t) bytebits_to_byteLSBF(DemodBuffer +  8, 8);
+       uint8_t hi  = (uint8_t) bytebits_to_byteLSBF(DemodBuffer + 16, 8);
+       uint8_t hi2 = (uint8_t) bytebits_to_byteLSBF(DemodBuffer + 24, 8);
+       uint8_t cs  = (uint8_t) bytebits_to_byteLSBF(DemodBuffer + 32, 8);
+       uint8_t cs2 = lo ^ lo2 ^ hi ^ hi2;
+       if (g_debugMode) PrintAndLog("EM4x05/4x69 : %08X CS: %02X %s"
+                                               , *word
+                                               , cs
+                                               , (cs2==cs) ? "Passed" : "Failed"
+                                       );
+
+       return (cs2==cs);

 }
 
 // FSK, PSK, ASK/MANCHESTER, ASK/BIPHASE, ASK/DIPHASE 
 // should cover 90% of known used configs
 // the rest will need to be manually demoded for now...
 }
 
 // FSK, PSK, ASK/MANCHESTER, ASK/BIPHASE, ASK/DIPHASE 
 // should cover 90% of known used configs
 // the rest will need to be manually demoded for now...

-int demodEM4x05resp(uint8_t bitsNeeded) {
-       size_t startIdx = 0;    
+bool demodEM4x05resp(uint32_t *word) {
+       size_t idx = 0; 
+       
+       if (detectASK_MAN() && doPreambleSearch( &idx ))
+               return setDemodBufferEM(word, idx);

        
        

-       if (detectASK_MAN() && doPreambleSearch( &startIdx ))
-               return setDemodBufferEM(bitsNeeded, startIdx);
+       if (detectASK_BI() && doPreambleSearch( &idx ))
+               return setDemodBufferEM(word, idx);

        
        

-       if (detectASK_BI() && doPreambleSearch( &startIdx ))
-               return setDemodBufferEM(bitsNeeded, startIdx);
+       if (detectFSK() && doPreambleSearch( &idx ))
+               return setDemodBufferEM(word, idx);

        
        

-       if (detectFSK() && doPreambleSearch( &startIdx ))
-               return setDemodBufferEM(bitsNeeded, startIdx);
+       if (detectPSK()) {
+               if (doPreambleSearch( &idx ))
+                       return setDemodBufferEM(word, idx);
+               
+               psk1TOpsk2(DemodBuffer, DemodBufferLen);
+               if (doPreambleSearch( &idx ))
+                       return setDemodBufferEM(word, idx);
+       }
+       return FALSE;
+}
+
+//////////////// 4205 / 4305 commands
+int usage_lf_em4x05_dump(void) {
+       PrintAndLog("Dump EM4x05/EM4x69.  Tag must be on antenna. ");
+       PrintAndLog("");
+       PrintAndLog("Usage:  lf em 4x05dump [h] <pwd>");
+       PrintAndLog("Options:");
+       PrintAndLog("       h         - this help");
+       PrintAndLog("       pwd       - password (hex) (optional)");
+       PrintAndLog("samples:");
+       PrintAndLog("      lf em 4x05dump");
+       PrintAndLog("      lf em 4x05dump 11223344");
+       return 0;
+}
+int usage_lf_em4x05_read(void) {
+       PrintAndLog("Read EM4x05/EM4x69.  Tag must be on antenna. ");
+       PrintAndLog("");
+       PrintAndLog("Usage:  lf em 4x05read [h] <address> <pwd>");
+       PrintAndLog("Options:");
+       PrintAndLog("       h         - this help");
+       PrintAndLog("       address   - memory address to read. (0-15)");
+       PrintAndLog("       pwd       - password (hex) (optional)");
+       PrintAndLog("samples:");
+       PrintAndLog("      lf em 4x05read 1");
+       PrintAndLog("      lf em 4x05read 1 11223344");
+       return 0;
+}
+int usage_lf_em4x05_write(void) {
+       PrintAndLog("Write EM4x05/4x69.  Tag must be on antenna. ");
+       PrintAndLog("");
+       PrintAndLog("Usage:  lf em 4x05write [h] <address> <data> <pwd>");
+       PrintAndLog("Options:");
+       PrintAndLog("       h         - this help");
+       PrintAndLog("       address   - memory address to write to. (0-15)");
+       PrintAndLog("       data      - data to write (hex)");  
+       PrintAndLog("       pwd       - password (hex) (optional)");
+       PrintAndLog("samples:");
+       PrintAndLog("      lf em 4x05write 1 deadc0de");
+       PrintAndLog("      lf em 4x05write 1 deadc0de 11223344");
+       return 0;
+}
+
+int CmdEM4x05Dump(const char *Cmd) {
+       uint8_t addr = 0;
+       uint32_t pwd;
+       bool usePwd = false;
+       uint8_t ctmp = param_getchar(Cmd, 0);
+       if ( ctmp == 'H' || ctmp == 'h' ) return usage_lf_em4x05_dump();
+
+       // for now use default input of 1 as invalid (unlikely 1 will be a valid password...)
+       pwd = param_get32ex(Cmd, 0, 1, 16);

        
        

-       if (detectPSK() && doPreambleSearch( &startIdx )) 
-               return setDemodBufferEM(bitsNeeded, startIdx);
+       if ( pwd != 1 ) {
+               usePwd = true;
+       }
+       int success = 1;
+       for (; addr < 16; addr++) {
+               if (addr == 2) {
+                       if (usePwd) {
+                               PrintAndLog("PWD Address %02u | %08X",addr,pwd);
+                       } else {
+                               PrintAndLog("PWD Address 02 | cannot read");
+                       }
+               } else {
+                       //success &= EM4x05Read(addr, pwd, usePwd);
+               }
+       }

 
 

-       return -1;
+       return success;

 }
 
 }
 

-int CmdReadWord(const char *Cmd) {
+int CmdEM4x05Read(const char *Cmd) {

        int addr, pwd;
        bool usePwd = false;
        uint8_t ctmp = param_getchar(Cmd, 0);
        int addr, pwd;
        bool usePwd = false;
        uint8_t ctmp = param_getchar(Cmd, 0);

-       if ( strlen(Cmd) == 0 || ctmp == 'H' || ctmp == 'h' ) return usage_lf_em_read();
+       if ( strlen(Cmd) == 0 || ctmp == 'H' || ctmp == 'h' ) return usage_lf_em4x05_read();

 
        addr = param_get8ex(Cmd, 0, -1, 10);
        pwd =  param_get32ex(Cmd, 1, -1, 16);
 
        addr = param_get8ex(Cmd, 0, -1, 10);
        pwd =  param_get32ex(Cmd, 1, -1, 16);


@@ -693,18 +831,20 @@ int CmdReadWord(const char *Cmd) {
                return -1;
        }
 
                return -1;
        }
 

-       //attempt demod:
-       //need 32 bits from a read word
-       int result = demodEM4x05resp(44);
-       if (result == -1)
+       //attempt demod
+       uint32_t word = 0;
+       int isOk = demodEM4x05resp(&word);
+       if (isOk)
+               PrintAndLog("Got Address %02d | %08X",addr, word);
+       else

                PrintAndLog("Read failed");
        
                PrintAndLog("Read failed");
        

-       return result;
+       return isOk;

 }
 
 }
 

-int CmdWriteWord(const char *Cmd) {
+int CmdEM4x05Write(const char *Cmd) {

        uint8_t ctmp = param_getchar(Cmd, 0);
        uint8_t ctmp = param_getchar(Cmd, 0);

-       if ( strlen(Cmd) == 0 || ctmp == 'H' || ctmp == 'h' ) return usage_lf_em_write();
+       if ( strlen(Cmd) == 0 || ctmp == 'H' || ctmp == 'h' ) return usage_lf_em4x05_write();

        
        bool usePwd = false;            
        int addr = 16; // default to invalid address
        
        bool usePwd = false;            
        int addr = 16; // default to invalid address


@@ -732,7 +872,7 @@ int CmdWriteWord(const char *Cmd) {
        clearCommandBuffer();
        SendCommand(&c);
        UsbCommand resp;        
        clearCommandBuffer();
        SendCommand(&c);
        UsbCommand resp;        

-       if (!WaitForResponseTimeout(CMD_ACK, &resp, 1000)){
+       if (!WaitForResponseTimeout(CMD_ACK, &resp, 2000)){

                PrintAndLog("Error occurred, device did not respond during write operation.");
                return -1;
        }
                PrintAndLog("Error occurred, device did not respond during write operation.");
                return -1;
        }


@@ -744,24 +884,28 @@ int CmdWriteWord(const char *Cmd) {
        
        //attempt demod:
        //need 0 bits demoded (after preamble) to verify write cmd
        
        //attempt demod:
        //need 0 bits demoded (after preamble) to verify write cmd

-       int result = demodEM4x05resp(0);
-       if (result == 1)
+       uint32_t dummy = 0;
+       int isOk = demodEM4x05resp(&dummy);
+       if (isOk)

                PrintAndLog("Write Verified");
 
                PrintAndLog("Write Verified");
 

-       return result;
+       return isOk;

 }
 
 static command_t CommandTable[] = {
        {"help",                CmdHelp,                        1, "This help"},
 }
 
 static command_t CommandTable[] = {
        {"help",                CmdHelp,                        1, "This help"},

-       {"em410xdemod", CmdEMdemodASK,          0, "[findone] -- Extract ID from EM410x tag (option 0 for continuous loop, 1 for only 1 tag)"},  
-       {"em410xread",  CmdEM410xRead,          1, "[clock rate] -- Extract ID from EM410x tag in GraphBuffer"},
-       {"em410xsim",   CmdEM410xSim,           0, "<UID> -- Simulate EM410x tag"},
-       {"em410xwatch", CmdEM410xWatch,         0, "['h'] -- Watches for EM410x 125/134 kHz tags (option 'h' for 134)"},
-       {"em410xspoof", CmdEM410xWatchnSpoof, 0, "['h'] --- Watches for EM410x 125/134 kHz tags, and replays them. (option 'h' for 134)" },
-       {"em410xwrite", CmdEM410xWrite,         0, "<UID> <'0' T5555> <'1' T55x7> [clock rate] -- Write EM410x UID to T5555(Q5) or T55x7 tag, optionally setting clock rate"},
-       {"em4x50read",  CmdEM4x50Read,          1, "demod data from EM4x50 tag from the graphbuffer"},
-       {"readword",    CmdReadWord,            1, "read EM4x05/4x69 data"},
-       {"writeword",   CmdWriteWord,           1, "write EM405/4x69 data"},
+       {"410xdemod",   CmdEMdemodASK,          0, "[findone] -- Extract ID from EM410x tag (option 0 for continuous loop, 1 for only 1 tag)"},  
+       {"410xread",    CmdEM410xRead,          1, "[clock rate] -- Extract ID from EM410x tag in GraphBuffer"},
+       {"410xsim",             CmdEM410xSim,           0, "<UID> -- Simulate EM410x tag"},
+       {"410xwatch",   CmdEM410xWatch,         0, "['h'] -- Watches for EM410x 125/134 kHz tags (option 'h' for 134)"},
+       {"410xspoof",   CmdEM410xWatchnSpoof, 0, "['h'] --- Watches for EM410x 125/134 kHz tags, and replays them. (option 'h' for 134)" },
+       {"410xwrite",   CmdEM410xWrite,         0, "<UID> <'0' T5555> <'1' T55x7> [clock rate] -- Write EM410x UID to T5555(Q5) or T55x7 tag, optionally setting clock rate"},
+       {"4x05read",    CmdEM4x05Read,          0, "read word data from EM4205/4305"},
+       {"4x05write",   CmdEM4x05Write,         0, "write word data to EM4205/4305"},
+       {"4x05dump",    CmdEM4x05Dump,          0, "dump EM4205/4305 tag"},
+       {"4x50read",    CmdEM4x50Read,          0, "read word data from EM4x50"},
+       {"4x50write",   CmdEM4x50Write,         0, "write word data to EM4x50"},
+       {"4x50dump",    CmdEM4x50Dump,          0, "dump EM4x50 tag"},

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

diff --git a/common/lfdemod.c b/common/lfdemod.c
index 6f490106bf040359020d48494c52f63a40dfb16a..4b17c6fdaad5a245376b6a0c42ba57c2fa4a56a1 100644 (file)
--- a/common/lfdemod.c
+++ b/common/lfdemod.c
@@ -58,7 +58,7 @@ uint8_t parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType)
        for (uint8_t i = 0; i < bitLen; i++){
                ans ^= ((bits >> i) & 1);
        }
        for (uint8_t i = 0; i < bitLen; i++){
                ans ^= ((bits >> i) & 1);
        }

-       //prnt("DEBUG: ans: %d, ptype: %d",ans,pType);
+       if (g_debugMode) prnt("DEBUG: ans: %d, ptype: %d, bits: %08X",ans,pType,bits);

        return (ans == pType);
 }
 
        return (ans == pType);
 }
 


@@ -74,6 +74,8 @@ size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t p
                        parityWd = (parityWd << 1) | BitStream[startIdx+word+bit];
                        BitStream[j++] = (BitStream[startIdx+word+bit]);
                }
                        parityWd = (parityWd << 1) | BitStream[startIdx+word+bit];
                        BitStream[j++] = (BitStream[startIdx+word+bit]);
                }

+               if (word+pLen >= bLen) break;
+

                j--; // overwrite parity with next data
                // if parity fails then return 0
                switch (pType) {
                j--; // overwrite parity with next data
                // if parity fails then return 0
                switch (pType) {


@@ -480,19 +482,42 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow
        size_t preLastSample = 0;
        size_t LastSample = 0;
        size_t currSample = 0;
        size_t preLastSample = 0;
        size_t LastSample = 0;
        size_t currSample = 0;

-       // sync to first lo-hi transition, and threshold
+       if ( size < 1024 ) return 0; // not enough samples
+
+       // jump to modulating data by finding the first 4 threshold crossings (or first 2 waves)
+       // in case you have junk or noise at the beginning of the trace...
+       uint8_t thresholdCnt = 0;
+       size_t waveSizeCnt = 0;
+       bool isAboveThreshold = dest[idx++] >= threshold_value;
+       for (; idx < size-20; idx++ ) {
+               if(dest[idx] < threshold_value && isAboveThreshold) {
+                       thresholdCnt++;
+                       if (thresholdCnt > 2 && waveSizeCnt < fchigh+1) break;                  
+                       isAboveThreshold = false;
+                       waveSizeCnt = 0;
+               } else if (dest[idx] >= threshold_value && !isAboveThreshold) {
+                       thresholdCnt++;
+                       if (thresholdCnt > 2 && waveSizeCnt < fchigh+1) break;                  
+                       isAboveThreshold = true;
+                       waveSizeCnt = 0;
+               } else {
+                       waveSizeCnt++;
+               }
+               if (thresholdCnt > 10) break;
+       }
+       if (g_debugMode == 2) prnt("threshold Count reached at %u",idx);

 
        // Need to threshold first sample
 
        // Need to threshold first sample

-       // skip 160 samples to allow antenna/samples to settle
-       if(dest[160] < threshold_value) dest[0] = 0;
+       if(dest[idx] < threshold_value) dest[0] = 0;

        else dest[0] = 1;
        else dest[0] = 1;

+       idx++;

 
        size_t numBits = 0;
        // count cycles between consecutive lo-hi transitions, there should be either 8 (fc/8)
        // or 10 (fc/10) cycles but in practice due to noise etc we may end up with anywhere
        // between 7 to 11 cycles so fuzz it by treat anything <9 as 8 and anything else as 10
        //  (could also be fc/5 && fc/7 for fsk1 = 4-9)
 
        size_t numBits = 0;
        // count cycles between consecutive lo-hi transitions, there should be either 8 (fc/8)
        // or 10 (fc/10) cycles but in practice due to noise etc we may end up with anywhere
        // between 7 to 11 cycles so fuzz it by treat anything <9 as 8 and anything else as 10
        //  (could also be fc/5 && fc/7 for fsk1 = 4-9)

-       for(idx = 161; idx < size-20; idx++) {
+       for(; idx < size-20; idx++) {

                // threshold current value
 
                if (dest[idx] < threshold_value) dest[idx] = 0;
                // threshold current value
 
                if (dest[idx] < threshold_value) dest[idx] = 0;


@@ -507,13 +532,14 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow
                                //do nothing with extra garbage
                        } else if (currSample < (fchigh-1)) {           //6-8 = 8 sample waves  (or 3-6 = 5)
                                //correct previous 9 wave surrounded by 8 waves (or 6 surrounded by 5)
                                //do nothing with extra garbage
                        } else if (currSample < (fchigh-1)) {           //6-8 = 8 sample waves  (or 3-6 = 5)
                                //correct previous 9 wave surrounded by 8 waves (or 6 surrounded by 5)

-                               if (LastSample > (fchigh-2) && (preLastSample < (fchigh-1) || preLastSample     == 0 )){
+                               if (LastSample > (fchigh-2) && (preLastSample < (fchigh-1))){

                                        dest[numBits-1]=1;
                                }
                                dest[numBits++]=1;
 
                                        dest[numBits-1]=1;
                                }
                                dest[numBits++]=1;
 

-                       } else if (currSample > (fchigh) && !numBits) { //12 + and first bit = unusable garbage 
-                               //do nothing with beginning garbage
+                       } else if (currSample > (fchigh+1) && numBits < 3) { //12 + and first two bit = unusable garbage
+                               //do nothing with beginning garbage and reset..  should be rare..
+                               numBits = 0; 

                        } else if (currSample == (fclow+1) && LastSample == (fclow-1)) { // had a 7 then a 9 should be two 8's (or 4 then a 6 should be two 5's)
                                dest[numBits++]=1;
                        } else {                                        //9+ = 10 sample waves (or 6+ = 7)
                        } else if (currSample == (fclow+1) && LastSample == (fclow-1)) { // had a 7 then a 9 should be two 8's (or 4 then a 6 should be two 5's)
                                dest[numBits++]=1;
                        } else {                                        //9+ = 10 sample waves (or 6+ = 7)


@@ -1248,36 +1274,32 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock)
 // by marshmellow
 // convert psk1 demod to psk2 demod
 // only transition waves are 1s
 // by marshmellow
 // convert psk1 demod to psk2 demod
 // only transition waves are 1s

-void psk1TOpsk2(uint8_t *BitStream, size_t size)
-{
-       size_t i=1;
-       uint8_t lastBit=BitStream[0];
-       for (; i<size; i++){
-               if (BitStream[i]==7){
-                       //ignore errors
-               } else if (lastBit!=BitStream[i]){
-                       lastBit=BitStream[i];
-                       BitStream[i]=1;
+void psk1TOpsk2(uint8_t *bits, size_t size) {
+       uint8_t lastBit = bits[0];
+       for (size_t i = 1; i < size; i++){
+               //ignore errors         
+               if (bits[i] == 7) continue;
+                       
+               if (lastBit != bits[i]){
+                       lastBit = bits[i];
+                       bits[i] = 1;

                } else {
                } else {

-                       BitStream[i]=0;
+                       bits[i] = 0;

                }
        }
                }
        }

-       return;

 }
 
 // by marshmellow
 // convert psk2 demod to psk1 demod
 // from only transition waves are 1s to phase shifts change bit
 }
 
 // by marshmellow
 // convert psk2 demod to psk1 demod
 // from only transition waves are 1s to phase shifts change bit

-void psk2TOpsk1(uint8_t *BitStream, size_t size)
-{
-       uint8_t phase=0;
-       for (size_t i=0; i<size; i++){
-               if (BitStream[i]==1){
-                       phase ^=1;
+void psk2TOpsk1(uint8_t *bits, size_t size) {
+       uint8_t phase = 0;
+       for (size_t i = 0; i < size; i++){
+               if (bits[i] == 1){
+                       phase ^= 1;

                }
                }

-               BitStream[i]=phase;
+               bits[i] = phase;

        }
        }

-       return;

 }
 
 // redesigned by marshmellow adjusted from existing decode functions
 }
 
 // redesigned by marshmellow adjusted from existing decode functions


@@ -1538,7 +1560,7 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert)
 
        size_t numBits=0;
        uint8_t curPhase = *invert;
 
        size_t numBits=0;
        uint8_t curPhase = *invert;

-       size_t i, waveStart=1, waveEnd=0, firstFullWave=0, lastClkBit=0;
+       size_t i=0, waveStart=1, waveEnd=0, firstFullWave=0, lastClkBit=0;

        uint8_t fc=0, fullWaveLen=0, tol=1;
        uint16_t errCnt=0, waveLenCnt=0;
        fc = countFC(dest, *size, 0);
        uint8_t fc=0, fullWaveLen=0, tol=1;
        uint16_t errCnt=0, waveLenCnt=0;
        fc = countFC(dest, *size, 0);


@@ -1546,19 +1568,45 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert)
        //prnt("DEBUG: FC: %d",fc);
        *clock = DetectPSKClock(dest, *size, *clock);
        if (*clock == 0) return -1;
        //prnt("DEBUG: FC: %d",fc);
        *clock = DetectPSKClock(dest, *size, *clock);
        if (*clock == 0) return -1;

+       // jump to modulating data by finding the first 2 threshold crossings (or first 1 waves)
+       // in case you have junk or noise at the beginning of the trace...
+       uint8_t thresholdCnt = 0;
+       size_t waveSizeCnt = 0;
+       uint8_t threshold_value = 123; //-5
+       bool isAboveThreshold = dest[i++] >= threshold_value;
+       for (; i < *size-20; i++ ) {
+               if(dest[i] < threshold_value && isAboveThreshold) {
+                       thresholdCnt++;
+                       if (thresholdCnt > 2 && waveSizeCnt < fc+1) break;                      
+                       isAboveThreshold = false;
+                       waveSizeCnt = 0;
+               } else if (dest[i] >= threshold_value && !isAboveThreshold) {
+                       thresholdCnt++;
+                       if (thresholdCnt > 2 && waveSizeCnt < fc+1) break;                      
+                       isAboveThreshold = true;
+                       waveSizeCnt = 0;
+               } else {
+                       waveSizeCnt++;
+               }
+               if (thresholdCnt > 10) break;
+       }
+       if (g_debugMode == 2) prnt("DEBUG PSK: threshold Count reached at %u, count: %u",i, thresholdCnt);
+
+

        int avgWaveVal=0, lastAvgWaveVal=0;
        int avgWaveVal=0, lastAvgWaveVal=0;

+       waveStart = i+1;

        //find first phase shift
        //find first phase shift

-       for (i=0; i<loopCnt; i++){
+       for (; i<loopCnt; i++){

                if (dest[i]+fc < dest[i+1] && dest[i+1] >= dest[i+2]){
                        waveEnd = i+1;
                if (dest[i]+fc < dest[i+1] && dest[i+1] >= dest[i+2]){
                        waveEnd = i+1;

-                       //prnt("DEBUG: waveEnd: %d",waveEnd);
+                       if (g_debugMode == 2) prnt("DEBUG PSK: waveEnd: %u, waveStart: %u",waveEnd, waveStart);

                        waveLenCnt = waveEnd-waveStart;
                        waveLenCnt = waveEnd-waveStart;

-                       if (waveLenCnt > fc && waveStart > fc && !(waveLenCnt > fc+2)){ //not first peak and is a large wave but not out of whack
+                       if (waveLenCnt > fc && waveStart > fc && !(waveLenCnt > fc+3)){ //not first peak and is a large wave but not out of whack

                                lastAvgWaveVal = avgWaveVal/(waveLenCnt);
                                firstFullWave = waveStart;
                                fullWaveLen=waveLenCnt;
                                //if average wave value is > graph 0 then it is an up wave or a 1
                                lastAvgWaveVal = avgWaveVal/(waveLenCnt);
                                firstFullWave = waveStart;
                                fullWaveLen=waveLenCnt;
                                //if average wave value is > graph 0 then it is an up wave or a 1

-                               if (lastAvgWaveVal > 123) curPhase ^= 1;  //fudge graph 0 a little 123 vs 128
+                               if (lastAvgWaveVal > threshold_value) curPhase ^= 1;  //fudge graph 0 a little 123 vs 128

                                break;
                        } 
                        waveStart = i+1;
                                break;
                        } 
                        waveStart = i+1;