Time for read a block

It does seem a little slow but I dont have one to try out so nothing to compare to

What is the code your using to time the read, can you please provide in here

Thanks

It does seem a little slow but I dont have one to try out so nothing to compare to

What is the code your using to time the read, can you please provide in here

Thanks

/*
*  RFID/NFC Modul for Arduino 
*  Read a block 
*/


uint8_t dataRX[35];//Receive buffer.
uint8_t dataTX[35];//Transmit buffer.
uint8_t _UID[4];// stores the UID (unique identifier) of a card.
uint8_t keyAccess[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF } ;// stores the key or password.
uint8_t address = 0x04;//Address to read.
uint8_t ATQ[2];//Answer to request
uint8_t state;//state of the process
uint8_t aux[16];//Auxiliar buffer.
unsigned long time;


void setup()
{
  //Start serial port 115200 bps:
  Serial.begin(115200);
  delay(100);
  Serial.print("RFID/NFC @ 13.56 MHz module started");
  delay(1000);
  //!It is needed to launch a simple command to sycnchronize
  getFirmware();
  configureSAM();
}


void loop()
{
  Serial.print("\n");
        Serial.print("Ready to read...");
  /////////////////////////////////////////////////////////////
  //Get the UID Identifier
  init(_UID, ATQ);
  Serial.print("\n");
  Serial.print( "The UID : ");
  print(_UID , 4);
        time = millis();//prints time since program started
        Serial.print("Time:");
        Serial.print(time);
        Serial.print(" ");
        Serial.write("ms");
        ////////////////////////////////////////////////////////////
  //Auntenticate a block with his keyAccess
  state = authenticate(_UID, address, keyAccess);
  Serial.print("\n");


  if ( state == 0) {
  Serial.println("Authentication block OK");
                time = millis();//prints time since program started
                Serial.print("Time:");
                Serial.print(time);
                Serial.print(" ");
                Serial.write("ms");
                } else {
  Serial.println("Authentication failed");
      }
        /////////////////////////////////////////////////////////////
  //Read from address after authentication
  state = readData(address, aux);
  Serial.print("\n");


  if (state == 0) {
  Serial.println("Read block OK");
  } else {
  Serial.println("Read failed");
  }


  Serial.print("\n");
  Serial.print("Data readed : ");
  print(aux , 16);
  Serial.print("\n");
        time = millis();//prints time since program started
        Serial.print("Time:");
        Serial.print(time);
        Serial.print(" ");
        Serial.write("ms");
        delay(2000);
}
//**********************************************************************
//!The goal of this command is to detect as many targets (maximum MaxTg)
// as possible in passive mode.
uint8_t init(uint8_t *UID , uint8_t *ATQ)   //! Request InListPassive
{
  Serial.flush();


  dataTX[0] = 0x04; // Length
  lengthCheckSum(dataTX); // Length Checksum
  dataTX[2] = 0xD4;
  dataTX[3] = 0x4A; // Code
  dataTX[4] = 0x01; //MaxTarget
  dataTX[5] = 0x00; //BaudRate = 106Kbps
  dataTX[6] = 0x00; // Clear checkSum position
  checkSum(dataTX); 


  sendTX(dataTX , 7 ,23);


  for (int i = 17; i < (21) ; i++){
  _UID[i-17] = dataRX[i];
  UID[i-17] = _UID[i-17];
  }


  ATQ[0] = dataRX[13];
  ATQ[1] = dataRX[14];


  if ((dataRX[9]== 0xD5) & (dataRX[10] == 0x4B) & (dataRX[11] == 0x01)) {
  return 0;
  } else {
  return 1;
  }
}
//**********************************************************************
//!A block must be authenticated before read and write operations
uint8_t authenticate(uint8_t *UID, uint8_t blockAddress, uint8_t *keyAccess)
{
  dataTX[0] = 0x0F;
  lengthCheckSum(dataTX);
  dataTX[2] = 0xD4;
  dataTX[3] = 0x40; // inDataEchange
  dataTX[4] = 0x01; //Number of targets
  dataTX[5] = 0x60; // Authentication code
  dataTX[6] = blockAddress;
  for (int i = 0; i < 6 ; i++) {
  dataTX[i + 7] = keyAccess[i];
  }
  dataTX[13] = UID[0];  dataTX[14] = UID[1];
  dataTX[15] = UID[2];  dataTX[16] = UID[3];
  dataTX[17] = 0x00;
  checkSum(dataTX);
  sendTX(dataTX , 18 ,14);


  if ((dataRX[9]== 0xD5) & (dataRX[10] == 0x41) & (dataRX[11] == 0x00)) {
  return 0;
  } else {
  return 1;
  }
}
//**********************************************************************
//!Write 16 bytes in address .
uint8_t writeData(uint8_t address, uint8_t *blockData)  //!Writing
{
  Serial.print("                ");
  dataTX[0] = 0x15;
  lengthCheckSum(dataTX); // Length Checksum
  dataTX[2] = 0xD4;
  dataTX[3] = 0x40;//inDataEchange CODE
  dataTX[4] = 0x01;//Number of targets
  dataTX[5] = 0xA0;//Write Command
  dataTX[6] = address; //Address


  for (int i = 0; i < 16; i++) {
  dataTX[i+7] = blockData[i];
  }


  dataTX[23] = 0x00;
  checkSum(dataTX);
  sendTX(dataTX , 24 ,14);


  if ((dataRX[9]== 0xD5) & (dataRX[10] == 0x41) & (dataRX[11] == 0x00)) {
  return 0;
  } else {
  return 1;
  }
}
//**********************************************************************
//!Read 16 bytes from  address .
uint8_t readData(uint8_t address, uint8_t *readData) //!Reading
{
  Serial.print("                ");


  dataTX[0] = 0x05;
  lengthCheckSum(dataTX); // Length Checksum
  dataTX[2] = 0xD4; // Code
  dataTX[3] = 0x40; // Code
  dataTX[4] = 0x01; // Number of targets
  dataTX[5] = 0x30; //ReadCode
  dataTX[6] = address;  //Read address
  dataTX[7] = 0x00;
  checkSum(dataTX);
  sendTX(dataTX , 8, 30);
  memset(readData, 0x00, 16);  


  if ((dataRX[9]== 0xD5) & (dataRX[10] == 0x41) & (dataRX[11] == 0x00)) {
  for (int i = 12; i < 28; i++) {
  readData[i-12] = dataRX[i];
  }
  return 0;
  } else {
  return 1;
  }
}
//**********************************************************************
//!The PN532 sends back the version of the embedded firmware.
bool getFirmware(void)  //! It is needed to launch a simple command to sycnchronize
{
  Serial.print("                ");


  memset(dataTX, 0x00, 35);
  dataTX[0] = 0x02; // Length
  lengthCheckSum(dataTX); // Length Checksum
  dataTX[2] = 0xD4; // CODE
  dataTX[3] = 0x02; //TFI
  checkSum(dataTX); //0x2A; //Checksum   


  sendTX(dataTX , 5 , 17);
  Serial.print("\n");
  Serial.print("Your Firmware version is : ");


  for (int i = 11; i < (15) ; i++){
  Serial.print(dataRX[i], HEX);
  Serial.print(" ");
  }
  Serial.print("\n");
}


//**********************************************************************
//!Print data stored in vectors .
void print(uint8_t * _data, uint8_t length)
{
  for (int i = 0; i < length ; i++){
  Serial.print(_data[i], HEX);
  Serial.print(" ");
  }
  Serial.print("\n");
}
//**********************************************************************
//!This command is used to set internal parameters of the PN532,
bool configureSAM(void)//! Configure the SAM
{
  Serial.print("               ");


  dataTX[0] = 0x05; //Length
  lengthCheckSum(dataTX); // Length Checksum
  dataTX[2] = 0xD4;
  dataTX[3] = 0x14;
  dataTX[4] = 0x01; // Normal mode
  dataTX[5] = 0x14; // TimeOUT
  dataTX[6] = 0x00; // IRQ
  dataTX[7] = 0x00; // Clean checkSum position
  checkSum(dataTX);


  sendTX(dataTX , 8, 13);
}
//**********************************************************************
//!Send data stored in dataTX
void sendTX(uint8_t *dataTX, uint8_t length, uint8_t outLength)
{
  Serial.print(char(0x00));
  Serial.print(char(0x00));
  Serial.print(char(0xFF)); 


  for (int i = 0; i < length; i++) {
  Serial.print(char(dataTX[i]));
  }


  Serial.print(char(0x00));
  getACK();
  waitResponse();// Receive response
  getData(outLength);
}
//**********************************************************************
//!Wait for ACK response and stores it in the dataRX buffer
void getACK(void)
{
  delay(5);
  waitResponse();
  for (int i = 0; i < 5 ; i++) {
  dataRX[i] = Serial.read();
  }
}
//**********************************************************************
//!Wait the response of the module
void waitResponse(void)
{
  int val = 0xFF;
  int cont = 0x00;
  while(val != 0x00) { //Wait for 0x00 response
  val = Serial.read();
  delay(5);
  cont ++;
  }
}
//**********************************************************************
//!Get data from the module
void getData(uint8_t outLength)
{
  for (int i=5; i < outLength; i++) {
  dataRX[i] = Serial.read();//read data from the module.
  }
}
//**********************************************************************
//!Calculates the checksum and stores it in dataTX buffer
void checkSum(uint8_t *dataTX)
{
  for (int i = 0; i < dataTX[0] ; i++) {
  dataTX[dataTX[0] + 2] += dataTX[i + 2];
  }
  byte(dataTX[dataTX[0] + 2]= - dataTX[dataTX[0] + 2]);
}
//**********************************************************************
//!Calculates the length checksum and sotres it in the buffer.
uint8_t lengthCheckSum(uint8_t *dataTX)
{
  dataTX[1] = byte(0x100 - dataTX[0]);
}

ok, try this

/*
*  RFID/NFC Modul for Arduino
*  Read a block
*/

uint8_t dataRX[35];//Receive buffer. 
uint8_t dataTX[35];//Transmit buffer. 
uint8_t _UID[4];// stores the UID (unique identifier) of a card. 
uint8_t keyAccess[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };// stores the key or password. 
uint8_t address = 0x04;//Address to read. 
uint8_t ATQ[2];//Answer to request 
uint8_t state;//state of the process 
uint8_t aux[16];//Auxiliar buffer. 
unsigned long time;
unsigned long loop_time; // less the 2 second delay... dont forget
unsigned long function_time;

void setup()
{
  //Start serial port 115200 bps: 
  Serial.begin(115200);
  delay(100);
  Serial.println("RFID/NFC @ 13.56 MHz module started");
  delay(1000);
  //!It is needed to launch a simple command to sycnchronize 
  getFirmware();
  configureSAM();
}

void loop()
{
  Serial.print("\nReady to read..."); // optimise the prints by putting the new lines in the same print as the actual print
  loop_time = 0; // reset the loop timer

  ///////////////////////////////////////////////////////////// 
  //Get the UID Identifier 
  function_time = millis(); // we already had a one second delay in setup that is not part of the timeing so lets start with a clean count
  init(_UID, ATQ);
  time = millis() - function_time; //prints time to get the UID  
  loop_time += time;
  Serial.print("\nThe UID : ");
  print(_UID, 4);
  Serial.print("Time:");
  Serial.print(time);
  Serial.println(" ms"); // dont need the space and the ms on seperate prints, just do it in one, also by using println you get the new line at the end automatically

  //////////////////////////////////////////////////////////// 
  //Auntenticate a block with his keyAccess 
  function_time = millis();
  state = authenticate(_UID, address, keyAccess);
time = millis() - function_time;//time the call 
  loop_time += time; // add this call to the overall time
  Serial.print("\n");
  if (state == 0) {
  Serial.println("Authentication block OK");
  Serial.print("Time:");
  Serial.print(time);
  Serial.println(" ms");
  }
  else {
  Serial.println("Authentication failed");
  }
  ///////////////////////////////////////////////////////////// 
  //Read from address after authentication 
  function_time = millis();
  state = readData(address, aux);
time = millis() - function_time; // time the call
  loop_time += time; // add this call to the overall time
  Serial.print("\n");




  if (state == 0) {
  Serial.println("Read block OK");
  }
  else {
  Serial.println("Read failed");
  }


  Serial.print("\nData readed : ");
  print(aux, 16);
  Serial.print("\nTime:");
  Serial.print(time);
  Serial.println(" ms");


  Serial.print("\nTotal call time : ");
  Serial.print(loop_time);
  Serial.println(" ms");
  delay(2000); // wait 2 seconds before we loop again
}
//********************************************************************** 
//!The goal of this command is to detect as many targets (maximum MaxTg) 
// as possible in passive mode. 
uint8_t init(uint8_t *UID, uint8_t *ATQ)   //! Request InListPassive 
{
  Serial.flush();




  dataTX[0] = 0x04; // Length 
  lengthCheckSum(dataTX); // Length Checksum 
  dataTX[2] = 0xD4;
  dataTX[3] = 0x4A; // Code 
  dataTX[4] = 0x01; //MaxTarget 
  dataTX[5] = 0x00; //BaudRate = 106Kbps 
  dataTX[6] = 0x00; // Clear checkSum position 
  checkSum(dataTX);




  sendTX(dataTX, 7, 23);




  for (int i = 17; i < (21); i++) {
  _UID[i - 17] = dataRX[i];
  UID[i - 17] = _UID[i - 17];
  }




  ATQ[0] = dataRX[13];
  ATQ[1] = dataRX[14];




  if ((dataRX[9] == 0xD5) & (dataRX[10] == 0x4B) & (dataRX[11] == 0x01)) {
  return 0;
  }
  else {
  return 1;
  }
}
//********************************************************************** 
//!A block must be authenticated before read and write operations 
uint8_t authenticate(uint8_t *UID, uint8_t blockAddress, uint8_t *keyAccess)
{
  dataTX[0] = 0x0F;
  lengthCheckSum(dataTX);
  dataTX[2] = 0xD4;
  dataTX[3] = 0x40; // inDataEchange 
  dataTX[4] = 0x01; //Number of targets 
  dataTX[5] = 0x60; // Authentication code 
  dataTX[6] = blockAddress;
  for (int i = 0; i < 6; i++) {
  dataTX[i + 7] = keyAccess[i];
  }
  dataTX[13] = UID[0];  dataTX[14] = UID[1];
  dataTX[15] = UID[2];  dataTX[16] = UID[3];
  dataTX[17] = 0x00;
  checkSum(dataTX);
  sendTX(dataTX, 18, 14);




  if ((dataRX[9] == 0xD5) & (dataRX[10] == 0x41) & (dataRX[11] == 0x00)) {
  return 0;
  }
  else {
  return 1;
  }
}
//********************************************************************** 
//!Write 16 bytes in address . 
uint8_t writeData(uint8_t address, uint8_t *blockData)  //!Writing 
{
  Serial.print("                ");
  dataTX[0] = 0x15;
  lengthCheckSum(dataTX); // Length Checksum 
  dataTX[2] = 0xD4;
  dataTX[3] = 0x40;//inDataEchange CODE 
  dataTX[4] = 0x01;//Number of targets 
  dataTX[5] = 0xA0;//Write Command 
  dataTX[6] = address; //Address 


  for (int i = 0; i < 16; i++) {
  dataTX[i + 7] = blockData[i];
  }

  dataTX[23] = 0x00;
  checkSum(dataTX);
  sendTX(dataTX, 24, 14);

  if ((dataRX[9] == 0xD5) & (dataRX[10] == 0x41) & (dataRX[11] == 0x00)) {
  return 0;
  }
  else {
  return 1;
  }
}
//********************************************************************** 
//!Read 16 bytes from  address . 
uint8_t readData(uint8_t address, uint8_t *readData) //!Reading 
{
  Serial.print("                ");

  dataTX[0] = 0x05;
  lengthCheckSum(dataTX); // Length Checksum 
  dataTX[2] = 0xD4; // Code 
  dataTX[3] = 0x40; // Code 
  dataTX[4] = 0x01; // Number of targets 
  dataTX[5] = 0x30; //ReadCode 
  dataTX[6] = address;  //Read address 
  dataTX[7] = 0x00;
  checkSum(dataTX);
  sendTX(dataTX, 8, 30);
  memset(readData, 0x00, 16);

  if ((dataRX[9] == 0xD5) & (dataRX[10] == 0x41) & (dataRX[11] == 0x00)) {
  for (int i = 12; i < 28; i++) {
  readData[i - 12] = dataRX[i];
  }
  return 0;
  }
  else {
  return 1;
  }
}
//********************************************************************** 
//!The PN532 sends back the version of the embedded firmware. 
bool getFirmware(void)  //! It is needed to launch a simple command to sycnchronize 
{
  Serial.print("                ");

  memset(dataTX, 0x00, 35);
  dataTX[0] = 0x02; // Length 
  lengthCheckSum(dataTX); // Length Checksum 
  dataTX[2] = 0xD4; // CODE 
  dataTX[3] = 0x02; //TFI 
  checkSum(dataTX); //0x2A; //Checksum    
  sendTX(dataTX, 5, 17);
  Serial.print("Your Firmware version is : ");


  for (int i = 11; i < (15); i++) {
  Serial.print(dataRX[i], HEX);
  Serial.print(" ");
  }
  Serial.print("\n");
}

//********************************************************************** 
//!Print data stored in vectors . 
void print(uint8_t * _data, uint8_t length)
{
  for (int i = 0; i < length; i++) {
  Serial.print(_data[i], HEX);
  Serial.print(" ");
  }
  Serial.print("\n");
}
//********************************************************************** 
//!This command is used to set internal parameters of the PN532, 
bool configureSAM(void)//! Configure the SAM 
{
  Serial.print("               ");
  dataTX[0] = 0x05; //Length 
  lengthCheckSum(dataTX); // Length Checksum 
  dataTX[2] = 0xD4;
  dataTX[3] = 0x14;
  dataTX[4] = 0x01; // Normal mode 
  dataTX[5] = 0x14; // TimeOUT 
  dataTX[6] = 0x00; // IRQ 
  dataTX[7] = 0x00; // Clean checkSum position 
  checkSum(dataTX);
  sendTX(dataTX, 8, 13);
}
//********************************************************************** 
//!Send data stored in dataTX 
void sendTX(uint8_t *dataTX, uint8_t length, uint8_t outLength)
{
  Serial.print(char(0x00));
  Serial.print(char(0x00));
  Serial.print(char(0xFF));
  for (int i = 0; i < length; i++) {
  Serial.print(char(dataTX[i]));
  }
  Serial.print(char(0x00));
  getACK();
  waitResponse();// Receive response 
  getData(outLength);
}
//********************************************************************** 
//!Wait for ACK response and stores it in the dataRX buffer 
void getACK(void)
{
  delay(5);
  waitResponse();
  for (int i = 0; i < 5; i++) {
  dataRX[i] = Serial.read();
  }
}
//********************************************************************** 
//!Wait the response of the module 
void waitResponse(void)
{
  int val = 0xFF;
  int cont = 0x00;
  while (val != 0x00) { //Wait for 0x00 response 
  val = Serial.read();
  delay(5);
  cont++;
  }
}
//********************************************************************** 
//!Get data from the module 
void getData(uint8_t outLength)
{
  for (int i = 5; i < outLength; i++) {
  dataRX[i] = Serial.read();//read data from the module. 
  }
}
//********************************************************************** 
//!Calculates the checksum and stores it in dataTX buffer 
void checkSum(uint8_t *dataTX)
{
  for (int i = 0; i < dataTX[0]; i++) {
  dataTX[dataTX[0] + 2] += dataTX[i + 2];
  }
  byte(dataTX[dataTX[0] + 2] = -dataTX[dataTX[0] + 2]);
}
//********************************************************************** 
//!Calculates the length checksum and sotres it in the buffer. 
uint8_t lengthCheckSum(uint8_t *dataTX)
{
  dataTX[1] = byte(0x100 - dataTX[0]);
}

I took out some redundent print statements (Or not necessary as they can be optimised into single line), I hope this did not break the code

The main mistake you where doing is this

the main loop has a 2 second delay in it, you where not eliminating this from your timeing, second you had a one second delay in startup, this was also included in your time, then you also had all the print statements to the screen (Console) also included in your time

What I did and the main change in your code is introduce a seperate timer value "function_time" that is set to millis() just before a call to read the chips, then I subtract it from the new mills() once done, this tells us how long the function call actually took. The "loop_time" simply adds up all the funcrtion_time values to see what the total is without having to keep track with a calculator after a run

Hope this helps

It seems better

Thanks for reply.

Rita

good, that first one still seems a little slow but that may be its nature

Glad it helped

Peter

Hi Peter ,

is the first Time just to get the  UID?

what reason can I give,  that's the time so long is for UID ?

Regards ,

Rita

See http://electronics.howstuffworks.com/near-field-communication.htm . This explains some of what NFC does. To protect the transmission, a handshake is made to verify and encrypt later transmissions that will be made resulting in a UID. I can write a book here, but just say encryption is not cheap to set up both in processor and communication.

Clem