From d4a97eb4c71876830be9e858cf7f47a2035ccbf6 Mon Sep 17 00:00:00 2001 From: Dom Date: Fri, 30 Mar 2018 14:29:15 +0100 Subject: [PATCH] Timing analysis now starts when first bit is received. --- armsrc/iso14443a.c | 67 +++++++++++++++++++++++++++---------- client/scripts/myscript.lua | 2 +- 2 files changed, 50 insertions(+), 19 deletions(-) diff --git a/armsrc/iso14443a.c b/armsrc/iso14443a.c index cd1529c4..945a5b9a 100644 --- a/armsrc/iso14443a.c +++ b/armsrc/iso14443a.c @@ -88,6 +88,9 @@ uint8_t trigger = 0; // the block number for the ISO14443-4 PCB static uint8_t iso14_pcb_blocknum = 0; +int manchester_recv_started = 0; +int recorded = 0; + // // ISO14443 timing: // @@ -292,12 +295,12 @@ static void UartInit(uint8_t *data, uint8_t *parity) // use parameter non_real_time to provide a timestamp. Set to 0 if the decoder should measure real time static RAMFUNC bool MillerDecoding(uint8_t bit, uint32_t non_real_time) { - + //Dbprintf("Miller decoding now!"); Uart.fourBits = (Uart.fourBits << 8) | bit; - if (Uart.state == STATE_UNSYNCD) { // not yet synced + if (Uart.state == STATE_UNSYNCD) { // not yet synced - Uart.syncBit = 9999; // not set + Uart.syncBit = 9999; // not set // The start bit is one ore more Sequence Y followed by a Sequence Z (... 11111111 00x11111). We need to distinguish from // Sequence X followed by Sequence Y followed by Sequence Z (111100x1 11111111 00x11111) // we therefore look for a ...xx11111111111100x11111xxxxxx... pattern @@ -463,6 +466,7 @@ static void DemodInit(uint8_t *data, uint8_t *parity) } // use parameter non_real_time to provide a timestamp. Set to 0 if the decoder should measure real time +// Input *bit* to the Manchester decoding is four bytes (32 bits) which are read from the RHR. static RAMFUNC int ManchesterDecoding(uint8_t bit, uint16_t offset, uint32_t non_real_time) { @@ -470,7 +474,7 @@ static RAMFUNC int ManchesterDecoding(uint8_t bit, uint16_t offset, uint32_t non if (Demod.state == DEMOD_UNSYNCD) { - if (Demod.highCnt < 2) { // wait for a stable unmodulated signal + if (Demod.highCnt < 2) { // wait for a stable unmodulated signal if (Demod.twoBits == 0x0000) { Demod.highCnt++; } else { @@ -494,14 +498,18 @@ static RAMFUNC int ManchesterDecoding(uint8_t bit, uint16_t offset, uint32_t non } } - } else { - - if (IsManchesterModulationNibble1(Demod.twoBits >> Demod.syncBit)) { // modulation in first half - if (IsManchesterModulationNibble2(Demod.twoBits >> Demod.syncBit)) { // ... and in second half = collision + } else { //Demod.state == DEMOD_MANCHESTER_DATA + //Determine the modulation details for each nibble (4 bits) separately + if (IsManchesterModulationNibble1(Demod.twoBits >> Demod.syncBit)) { // if modulation in first half + if (IsManchesterModulationNibble2(Demod.twoBits >> Demod.syncBit)) { // ... and in second half, that specifies collision + //Save the collision position and treat as Sequence D if (!Demod.collisionPos) { Demod.collisionPos = (Demod.len << 3) + Demod.bitCount; } - } // modulation in first half only - Sequence D = 1 + } + if(!recorded) + manchester_recv_started = 1; //specify that the data transfer has begun + // modulation in first half only - Sequence D = 1. Demod.bitCount++; Demod.shiftReg = (Demod.shiftReg >> 1) | 0x100; // in both cases, add a 1 to the shiftreg if(Demod.bitCount == 9) { // if we decoded a full byte (including parity) @@ -516,7 +524,7 @@ static RAMFUNC int ManchesterDecoding(uint8_t bit, uint16_t offset, uint32_t non } } Demod.endTime = Demod.startTime + 8*(9*Demod.len + Demod.bitCount + 1) - 4; - } else { // no modulation in first half + } else { // if no modulation in first half if (IsManchesterModulationNibble2(Demod.twoBits >> Demod.syncBit)) { // and modulation in second half = Sequence E = 0 Demod.bitCount++; Demod.shiftReg = (Demod.shiftReg >> 1); // add a 0 to the shiftreg @@ -532,7 +540,7 @@ static RAMFUNC int ManchesterDecoding(uint8_t bit, uint16_t offset, uint32_t non } } Demod.endTime = Demod.startTime + 8*(9*Demod.len + Demod.bitCount + 1); - } else { // no modulation in both halves - End of communication + } else { // no modulation in both halves - End of communication if(Demod.bitCount > 0) { // there are some remaining data bits Demod.shiftReg >>= (9 - Demod.bitCount); // right align the decoded bits Demod.output[Demod.len++] = Demod.shiftReg & 0xff; // and add them to the output @@ -1289,6 +1297,8 @@ static void TransmitFor14443a(const uint8_t *cmd, uint16_t len, uint32_t *timing // clear TXRDY AT91C_BASE_SSC->SSC_THR = SEC_Y; + Dbprintf("Sending bytes to the PICC."); + uint16_t c = 0; for(;;) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) { @@ -1579,6 +1589,10 @@ int EmSendPrecompiledCmd(tag_response_info_t *response_info) { static int GetIso14443aAnswerFromTag(uint8_t *receivedResponse, uint8_t *receivedResponsePar, uint16_t offset) { uint32_t c; + uint32_t start_ts = GetCountSspClk(); + uint32_t end_ts = 0; + manchester_recv_started = 0; + recorded = 0; // Set FPGA mode to "reader listen mode", no modulation (listen // only, since we are receiving, not transmitting). @@ -1586,22 +1600,39 @@ static int GetIso14443aAnswerFromTag(uint8_t *receivedResponse, uint8_t *receive LED_D_ON(); FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_LISTEN); - // Now get the answer from the card + /* Now, get the answer from the card. + 32-bit registers used on the AT91: + SSC_RHR = Receive Holding Register + SSC_SR = Status Register (contains RXRDY, which is one bit. 0 is RHR is empty, or 1 if RHR has 32 bits of data in it) + */ + DemodInit(receivedResponse, receivedResponsePar); - // clear RXRDY: + + // clear RXRDY by reading the contents of RHR. uint8_t b = (uint8_t)AT91C_BASE_SSC->SSC_RHR; c = 0; for(;;) { - WDT_HIT(); + WDT_HIT(); //Watchdog Timer - if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { - b = (uint8_t)AT91C_BASE_SSC->SSC_RHR; + if(AT91C_BASE_SSC->SSC_SR & AT91C_SSC_RXRDY) { + b = (uint8_t)AT91C_BASE_SSC->SSC_RHR; //read in 4 bytes of data from the RHR + if(manchester_recv_started){ + end_ts = GetCountSspClk(); + manchester_recv_started = 0; + recorded = 1; + } + + //Perform the manchester decoding on the 4 bytes just received. if(ManchesterDecoding(b, offset, 0)) { NextTransferTime = MAX(NextTransferTime, Demod.endTime - (DELAY_AIR2ARM_AS_READER + DELAY_ARM2AIR_AS_READER)/16 + FRAME_DELAY_TIME_PICC_TO_PCD); + uint32_t cycle_count = end_ts - start_ts; + Dbprintf("Finished decoding (Manchester). Value of c=%d. Cycle count (for one bit) = %d", c, cycle_count); return true; } else if (c++ > iso14a_timeout && Demod.state == DEMOD_UNSYNCD) { + //we reach here only if we time out (i.e. receiving the data from the PICC takes too long) + Dbprintf("Timed out while waiting for PICC response (c = %d)!", c); return false; } } @@ -2095,8 +2126,8 @@ void ReaderIso14443a(UsbCommand *c) start_ts = GetCountSspClk(); //started just after we send all our bytes to the PICC arg0 = ReaderReceive(buf, par); end_ts = GetCountSspClk(); //ended just after we have received all the response bytes from the PICC. - uint32_t cycles_taken = end_ts - start_ts; - Dbprintf("Cycles taken to receive response from sending those bytes = %d", cycles_taken); + uint32_t cycle_count = end_ts - start_ts; + Dbprintf("Cycle count (all bytes) = %d", cycle_count); LED_B_ON(); cmd_send(CMD_ACK,arg0,0,0,buf,sizeof(buf)); diff --git a/client/scripts/myscript.lua b/client/scripts/myscript.lua index 1949f4a7..88a15f96 100644 --- a/client/scripts/myscript.lua +++ b/client/scripts/myscript.lua @@ -255,7 +255,7 @@ function main(args) --writePerso() --commitPerso() - --getVersion() + getVersion() proximityCheck() --commandString = VERIFYPC .. "186EFDE8DDC7D30B"