+
+/*
+ * Receive and decode the tag response, also log to tracebuffer
+ */
+int GetIso15693AnswerFromTag(uint8_t* response, uint16_t max_len, uint16_t timeout, uint32_t *eof_time) {
+
+ int samples = 0;
+ int ret = 0;
+
+ uint16_t dmaBuf[ISO15693_DMA_BUFFER_SIZE];
+
+ // the Decoder data structure
+ DecodeTag_t DecodeTag = { 0 };
+ DecodeTagInit(&DecodeTag, response, max_len);
+
+ // wait for last transfer to complete
+ while (!(AT91C_BASE_SSC->SSC_SR & AT91C_SSC_TXEMPTY));
+
+ // And put the FPGA in the appropriate mode
+ FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER | FPGA_HF_READER_SUBCARRIER_424_KHZ | FPGA_HF_READER_MODE_RECEIVE_AMPLITUDE);
+
+ // Setup and start DMA.
+ FpgaSetupSsc(FPGA_MAJOR_MODE_HF_READER);
+ FpgaSetupSscDma((uint8_t*) dmaBuf, ISO15693_DMA_BUFFER_SIZE);
+ uint32_t dma_start_time = 0;
+ uint16_t *upTo = dmaBuf;
+
+ for(;;) {
+ uint16_t behindBy = ((uint16_t*)AT91C_BASE_PDC_SSC->PDC_RPR - upTo) & (ISO15693_DMA_BUFFER_SIZE-1);
+
+ if (behindBy == 0) continue;
+
+ samples++;
+ if (samples == 1) {
+ // DMA has transferred the very first data
+ dma_start_time = GetCountSspClk() & 0xfffffff0;
+ }
+
+ uint16_t tagdata = *upTo++;
+
+ if(upTo >= dmaBuf + ISO15693_DMA_BUFFER_SIZE) { // we have read all of the DMA buffer content.
+ upTo = dmaBuf; // start reading the circular buffer from the beginning
+ if(behindBy > (9*ISO15693_DMA_BUFFER_SIZE/10)) {
+ Dbprintf("About to blow circular buffer - aborted! behindBy=%d", behindBy);
+ ret = -1;
+ break;
+ }
+ }
+ if (AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_ENDRX)) { // DMA Counter Register had reached 0, already rotated.
+ AT91C_BASE_PDC_SSC->PDC_RNPR = (uint32_t) dmaBuf; // refresh the DMA Next Buffer and
+ AT91C_BASE_PDC_SSC->PDC_RNCR = ISO15693_DMA_BUFFER_SIZE; // DMA Next Counter registers
+ }
+
+ if (Handle15693SamplesFromTag(tagdata, &DecodeTag)) {
+ *eof_time = dma_start_time + samples*16 - DELAY_TAG_TO_ARM; // end of EOF
+ if (DecodeTag.lastBit == SOF_PART2) {
+ *eof_time -= 8*16; // needed 8 additional samples to confirm single SOF (iCLASS)
+ }
+ if (DecodeTag.len > DecodeTag.max_len) {
+ ret = -2; // buffer overflow
+ }
+ break;
+ }
+
+ if (samples > timeout && DecodeTag.state < STATE_TAG_RECEIVING_DATA) {
+ ret = -1; // timeout
+ break;
+ }
+
+ }
+
+ FpgaDisableSscDma();
+
+ if (DEBUG) Dbprintf("samples = %d, ret = %d, Decoder: state = %d, lastBit = %d, len = %d, bitCount = %d, posCount = %d",
+ samples, ret, DecodeTag.state, DecodeTag.lastBit, DecodeTag.len, DecodeTag.bitCount, DecodeTag.posCount);
+
+ if (ret < 0) {
+ return ret;
+ }
+
+ uint32_t sof_time = *eof_time
+ - DecodeTag.len * 8 * 8 * 16 // time for byte transfers
+ - 32 * 16 // time for SOF transfer
+ - (DecodeTag.lastBit != SOF_PART2?32*16:0); // time for EOF transfer
+
+ if (DEBUG) Dbprintf("timing: sof_time = %d, eof_time = %d", sof_time, *eof_time);
+
+ LogTrace_ISO15693(DecodeTag.output, DecodeTag.len, sof_time*4, *eof_time*4, NULL, false);
+
+ return DecodeTag.len;
+}
+
+
+//=============================================================================
+// An ISO15693 decoder for reader commands.
+//
+// This function is called 4 times per bit (every 2 subcarrier cycles).
+// Subcarrier frequency fs is 848kHz, 1/fs = 1,18us, i.e. function is called every 2,36us
+// LED handling:
+// LED B -> ON once we have received the SOF and are expecting the rest.
+// LED B -> OFF once we have received EOF or are in error state or unsynced
+//
+// Returns: true if we received a EOF
+// false if we are still waiting for some more
+//=============================================================================
+
+typedef struct DecodeReader {
+ enum {
+ STATE_READER_UNSYNCD,
+ STATE_READER_AWAIT_1ST_FALLING_EDGE_OF_SOF,
+ STATE_READER_AWAIT_1ST_RISING_EDGE_OF_SOF,
+ STATE_READER_AWAIT_2ND_FALLING_EDGE_OF_SOF,
+ STATE_READER_AWAIT_2ND_RISING_EDGE_OF_SOF,
+ STATE_READER_AWAIT_END_OF_SOF_1_OUT_OF_4,
+ STATE_READER_RECEIVE_DATA_1_OUT_OF_4,
+ STATE_READER_RECEIVE_DATA_1_OUT_OF_256
+ } state;
+ enum {
+ CODING_1_OUT_OF_4,
+ CODING_1_OUT_OF_256
+ } Coding;
+ uint8_t shiftReg;
+ uint8_t bitCount;
+ int byteCount;
+ int byteCountMax;
+ int posCount;
+ int sum1, sum2;
+ uint8_t *output;
+} DecodeReader_t;
+
+
+static void DecodeReaderInit(DecodeReader_t* DecodeReader, uint8_t *data, uint16_t max_len)
+{
+ DecodeReader->output = data;
+ DecodeReader->byteCountMax = max_len;
+ DecodeReader->state = STATE_READER_UNSYNCD;
+ DecodeReader->byteCount = 0;
+ DecodeReader->bitCount = 0;
+ DecodeReader->posCount = 1;
+ DecodeReader->shiftReg = 0;
+}
+
+
+static void DecodeReaderReset(DecodeReader_t* DecodeReader)
+{
+ DecodeReader->state = STATE_READER_UNSYNCD;
+}
+
+
+static int inline __attribute__((always_inline)) Handle15693SampleFromReader(uint8_t bit, DecodeReader_t *restrict DecodeReader)
+{
+ switch (DecodeReader->state) {
+ case STATE_READER_UNSYNCD:
+ // wait for unmodulated carrier
+ if (bit) {
+ DecodeReader->state = STATE_READER_AWAIT_1ST_FALLING_EDGE_OF_SOF;
+ }
+ break;
+
+ case STATE_READER_AWAIT_1ST_FALLING_EDGE_OF_SOF:
+ if (!bit) {
+ // we went low, so this could be the beginning of a SOF
+ DecodeReader->posCount = 1;
+ DecodeReader->state = STATE_READER_AWAIT_1ST_RISING_EDGE_OF_SOF;
+ }
+ break;
+
+ case STATE_READER_AWAIT_1ST_RISING_EDGE_OF_SOF:
+ DecodeReader->posCount++;
+ if (bit) { // detected rising edge
+ if (DecodeReader->posCount < 4) { // rising edge too early (nominally expected at 5)
+ DecodeReader->state = STATE_READER_AWAIT_1ST_FALLING_EDGE_OF_SOF;
+ } else { // SOF
+ DecodeReader->state = STATE_READER_AWAIT_2ND_FALLING_EDGE_OF_SOF;
+ }
+ } else {
+ if (DecodeReader->posCount > 5) { // stayed low for too long
+ DecodeReaderReset(DecodeReader);
+ } else {
+ // do nothing, keep waiting
+ }
+ }
+ break;
+
+ case STATE_READER_AWAIT_2ND_FALLING_EDGE_OF_SOF:
+ DecodeReader->posCount++;
+ if (!bit) { // detected a falling edge
+ if (DecodeReader->posCount < 20) { // falling edge too early (nominally expected at 21 earliest)
+ DecodeReaderReset(DecodeReader);
+ } else if (DecodeReader->posCount < 23) { // SOF for 1 out of 4 coding
+ DecodeReader->Coding = CODING_1_OUT_OF_4;
+ DecodeReader->state = STATE_READER_AWAIT_2ND_RISING_EDGE_OF_SOF;
+ } else if (DecodeReader->posCount < 28) { // falling edge too early (nominally expected at 29 latest)
+ DecodeReaderReset(DecodeReader);
+ } else { // SOF for 1 out of 256 coding
+ DecodeReader->Coding = CODING_1_OUT_OF_256;
+ DecodeReader->state = STATE_READER_AWAIT_2ND_RISING_EDGE_OF_SOF;
+ }
+ } else {
+ if (DecodeReader->posCount > 29) { // stayed high for too long
+ DecodeReader->state = STATE_READER_AWAIT_1ST_FALLING_EDGE_OF_SOF;
+ } else {
+ // do nothing, keep waiting
+ }
+ }
+ break;
+
+ case STATE_READER_AWAIT_2ND_RISING_EDGE_OF_SOF:
+ DecodeReader->posCount++;
+ if (bit) { // detected rising edge
+ if (DecodeReader->Coding == CODING_1_OUT_OF_256) {
+ if (DecodeReader->posCount < 32) { // rising edge too early (nominally expected at 33)
+ DecodeReader->state = STATE_READER_AWAIT_1ST_FALLING_EDGE_OF_SOF;
+ } else {
+ DecodeReader->posCount = 1;
+ DecodeReader->bitCount = 0;
+ DecodeReader->byteCount = 0;
+ DecodeReader->sum1 = 1;
+ DecodeReader->state = STATE_READER_RECEIVE_DATA_1_OUT_OF_256;
+ LED_B_ON();
+ }
+ } else { // CODING_1_OUT_OF_4
+ if (DecodeReader->posCount < 24) { // rising edge too early (nominally expected at 25)
+ DecodeReader->state = STATE_READER_AWAIT_1ST_FALLING_EDGE_OF_SOF;
+ } else {
+ DecodeReader->posCount = 1;
+ DecodeReader->state = STATE_READER_AWAIT_END_OF_SOF_1_OUT_OF_4;
+ }
+ }
+ } else {
+ if (DecodeReader->Coding == CODING_1_OUT_OF_256) {
+ if (DecodeReader->posCount > 34) { // signal stayed low for too long
+ DecodeReaderReset(DecodeReader);
+ } else {
+ // do nothing, keep waiting
+ }
+ } else { // CODING_1_OUT_OF_4
+ if (DecodeReader->posCount > 26) { // signal stayed low for too long
+ DecodeReaderReset(DecodeReader);
+ } else {
+ // do nothing, keep waiting
+ }
+ }
+ }
+ break;
+
+ case STATE_READER_AWAIT_END_OF_SOF_1_OUT_OF_4:
+ DecodeReader->posCount++;
+ if (bit) {
+ if (DecodeReader->posCount == 9) {
+ DecodeReader->posCount = 1;
+ DecodeReader->bitCount = 0;
+ DecodeReader->byteCount = 0;
+ DecodeReader->sum1 = 1;
+ DecodeReader->state = STATE_READER_RECEIVE_DATA_1_OUT_OF_4;
+ LED_B_ON();
+ } else {
+ // do nothing, keep waiting
+ }
+ } else { // unexpected falling edge
+ DecodeReaderReset(DecodeReader);
+ }
+ break;
+
+ case STATE_READER_RECEIVE_DATA_1_OUT_OF_4:
+ bit = !!bit;
+ DecodeReader->posCount++;
+ if (DecodeReader->posCount == 1) {
+ DecodeReader->sum1 = bit;
+ } else if (DecodeReader->posCount <= 4) {
+ DecodeReader->sum1 += bit;
+ } else if (DecodeReader->posCount == 5) {
+ DecodeReader->sum2 = bit;
+ } else {
+ DecodeReader->sum2 += bit;
+ }
+ if (DecodeReader->posCount == 8) {
+ DecodeReader->posCount = 0;
+ if (DecodeReader->sum1 <= 1 && DecodeReader->sum2 >= 3) { // EOF
+ LED_B_OFF(); // Finished receiving
+ DecodeReaderReset(DecodeReader);
+ if (DecodeReader->byteCount != 0) {
+ return true;
+ }
+ }
+ if (DecodeReader->sum1 >= 3 && DecodeReader->sum2 <= 1) { // detected a 2bit position
+ DecodeReader->shiftReg >>= 2;
+ DecodeReader->shiftReg |= (DecodeReader->bitCount << 6);
+ }
+ if (DecodeReader->bitCount == 15) { // we have a full byte
+ DecodeReader->output[DecodeReader->byteCount++] = DecodeReader->shiftReg;
+ if (DecodeReader->byteCount > DecodeReader->byteCountMax) {
+ // buffer overflow, give up
+ LED_B_OFF();
+ DecodeReaderReset(DecodeReader);
+ }
+ DecodeReader->bitCount = 0;
+ DecodeReader->shiftReg = 0;
+ } else {
+ DecodeReader->bitCount++;
+ }
+ }
+ break;
+
+ case STATE_READER_RECEIVE_DATA_1_OUT_OF_256:
+ bit = !!bit;
+ DecodeReader->posCount++;
+ if (DecodeReader->posCount == 1) {
+ DecodeReader->sum1 = bit;
+ } else if (DecodeReader->posCount <= 4) {
+ DecodeReader->sum1 += bit;
+ } else if (DecodeReader->posCount == 5) {
+ DecodeReader->sum2 = bit;
+ } else {
+ DecodeReader->sum2 += bit;
+ }
+ if (DecodeReader->posCount == 8) {
+ DecodeReader->posCount = 0;
+ if (DecodeReader->sum1 <= 1 && DecodeReader->sum2 >= 3) { // EOF
+ LED_B_OFF(); // Finished receiving
+ DecodeReaderReset(DecodeReader);
+ if (DecodeReader->byteCount != 0) {
+ return true;
+ }
+ }
+ if (DecodeReader->sum1 >= 3 && DecodeReader->sum2 <= 1) { // detected the bit position
+ DecodeReader->shiftReg = DecodeReader->bitCount;
+ }
+ if (DecodeReader->bitCount == 255) { // we have a full byte
+ DecodeReader->output[DecodeReader->byteCount++] = DecodeReader->shiftReg;
+ if (DecodeReader->byteCount > DecodeReader->byteCountMax) {
+ // buffer overflow, give up
+ LED_B_OFF();
+ DecodeReaderReset(DecodeReader);
+ }
+ }
+ DecodeReader->bitCount++;
+ }
+ break;
+
+ default:
+ LED_B_OFF();
+ DecodeReaderReset(DecodeReader);
+ break;
+ }
+
+ return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Receive a command (from the reader to us, where we are the simulated tag),
+// and store it in the given buffer, up to the given maximum length. Keeps
+// spinning, waiting for a well-framed command, until either we get one
+// (returns len) or someone presses the pushbutton on the board (returns -1).
+//
+// Assume that we're called with the SSC (to the FPGA) and ADC path set
+// correctly.
+//-----------------------------------------------------------------------------
+
+int GetIso15693CommandFromReader(uint8_t *received, size_t max_len, uint32_t *eof_time) {
+ int samples = 0;
+ bool gotFrame = false;
+ uint8_t b;
+
+ uint8_t dmaBuf[ISO15693_DMA_BUFFER_SIZE];
+
+ // the decoder data structure
+ DecodeReader_t DecodeReader = {0};
+ DecodeReaderInit(&DecodeReader, received, max_len);
+
+ // wait for last transfer to complete
+ while (!(AT91C_BASE_SSC->SSC_SR & AT91C_SSC_TXEMPTY));
+
+ LED_D_OFF();
+ FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_SIMULATOR | FPGA_HF_SIMULATOR_NO_MODULATION);
+
+ // clear receive register and wait for next transfer
+ uint32_t temp = AT91C_BASE_SSC->SSC_RHR;
+ (void) temp;
+ while (!(AT91C_BASE_SSC->SSC_SR & AT91C_SSC_RXRDY)) ;
+
+ uint32_t dma_start_time = GetCountSspClk() & 0xfffffff8;
+
+ // Setup and start DMA.
+ FpgaSetupSscDma(dmaBuf, ISO15693_DMA_BUFFER_SIZE);
+ uint8_t *upTo = dmaBuf;
+
+ for (;;) {
+ uint16_t behindBy = ((uint8_t*)AT91C_BASE_PDC_SSC->PDC_RPR - upTo) & (ISO15693_DMA_BUFFER_SIZE-1);
+
+ if (behindBy == 0) continue;
+
+ b = *upTo++;
+ if (upTo >= dmaBuf + ISO15693_DMA_BUFFER_SIZE) { // we have read all of the DMA buffer content.
+ upTo = dmaBuf; // start reading the circular buffer from the beginning
+ if (behindBy > (9*ISO15693_DMA_BUFFER_SIZE/10)) {
+ Dbprintf("About to blow circular buffer - aborted! behindBy=%d", behindBy);
+ break;
+ }
+ }
+ if (AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_ENDRX)) { // DMA Counter Register had reached 0, already rotated.
+ AT91C_BASE_PDC_SSC->PDC_RNPR = (uint32_t) dmaBuf; // refresh the DMA Next Buffer and
+ AT91C_BASE_PDC_SSC->PDC_RNCR = ISO15693_DMA_BUFFER_SIZE; // DMA Next Counter registers
+ }
+
+ for (int i = 7; i >= 0; i--) {
+ if (Handle15693SampleFromReader((b >> i) & 0x01, &DecodeReader)) {
+ *eof_time = dma_start_time + samples - DELAY_READER_TO_ARM; // end of EOF
+ gotFrame = true;
+ break;
+ }
+ samples++;
+ }
+
+ if (gotFrame) {
+ break;
+ }
+
+ if (BUTTON_PRESS()) {
+ DecodeReader.byteCount = -1;
+ break;
+ }
+
+ WDT_HIT();
+ }
+
+ FpgaDisableSscDma();
+
+ if (DEBUG) Dbprintf("samples = %d, gotFrame = %d, Decoder: state = %d, len = %d, bitCount = %d, posCount = %d",
+ samples, gotFrame, DecodeReader.state, DecodeReader.byteCount, DecodeReader.bitCount, DecodeReader.posCount);
+
+ if (DecodeReader.byteCount > 0) {
+ uint32_t sof_time = *eof_time
+ - DecodeReader.byteCount * (DecodeReader.Coding==CODING_1_OUT_OF_4?128:2048) // time for byte transfers
+ - 32 // time for SOF transfer
+ - 16; // time for EOF transfer
+ LogTrace_ISO15693(DecodeReader.output, DecodeReader.byteCount, sof_time*32, *eof_time*32, NULL, true);
+ }
+
+ return DecodeReader.byteCount;
+}
+
+
+// Encode (into the ToSend buffers) an identify request, which is the first
+// thing that you must send to a tag to get a response.
+static void BuildIdentifyRequest(void)
+{
+ uint8_t cmd[5];
+
+ uint16_t crc;
+ // one sub-carrier, inventory, 1 slot, fast rate
+ // AFI is at bit 5 (1<<4) when doing an INVENTORY
+ cmd[0] = (1 << 2) | (1 << 5) | (1 << 1);
+ // inventory command code
+ cmd[1] = 0x01;
+ // no mask
+ cmd[2] = 0x00;
+ //Now the CRC
+ crc = Iso15693Crc(cmd, 3);
+ cmd[3] = crc & 0xff;
+ cmd[4] = crc >> 8;
+
+ CodeIso15693AsReader(cmd, sizeof(cmd));
+}
+
+
+//-----------------------------------------------------------------------------
+// Start to read an ISO 15693 tag. We send an identify request, then wait
+// for the response. The response is not demodulated, just left in the buffer
+// so that it can be downloaded to a PC and processed there.
+//-----------------------------------------------------------------------------
+void AcquireRawAdcSamplesIso15693(void)
+{
+ LED_A_ON();
+
+ uint8_t *dest = BigBuf_get_addr();
+
+ FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
+ FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER);
+ LED_D_ON();
+ FpgaSetupSsc(FPGA_MAJOR_MODE_HF_READER);
+ SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
+
+ BuildIdentifyRequest();
+
+ // Give the tags time to energize
+ SpinDelay(100);
+
+ // Now send the command
+ uint32_t start_time = 0;
+ TransmitTo15693Tag(ToSend, ToSendMax, &start_time);
+
+ // wait for last transfer to complete
+ while (!(AT91C_BASE_SSC->SSC_SR & AT91C_SSC_TXEMPTY)) ;
+
+ FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER | FPGA_HF_READER_SUBCARRIER_424_KHZ | FPGA_HF_READER_MODE_RECEIVE_AMPLITUDE);
+
+ for(int c = 0; c < 4000; ) {
+ if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
+ uint16_t r = AT91C_BASE_SSC->SSC_RHR;
+ dest[c++] = r >> 5;