Time for read a block

Question

Hello,

I have RFID 13.56 MHz / NFC Module for Arduino from Cooking Hacks , I want to know how much time need a full read in a block process ?

I tried with millis () function and I get this :

I get 2196 ms . is that right ? I think it's so much

Rita

Robert Peter Oakes · Accepted Answer

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("
Ready 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("
The 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("
");
 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("
");

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

Serial.print("
Data readed : ");
 print(aux, 16);
 Serial.print("
Time:");
 Serial.print(time);
 Serial.println(" ms");

Serial.print("
Total 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("
");
}

//********************************************************************** 
//!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("
");
}
//********************************************************************** 
//!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