/* * NFC.c * * Created on: Jan 19, 2020 * Author: avi */ #include #include #include //memset #include #include "datadef.h" #include #include "drivers/I2C_Communication/I2C.h" #include "drivers/I2C_Communication/RFID_NFC/I2C_IFS_Mux.h" #include #include "drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.h" #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h" #include #include #include #include #include #include #include uint8_t RFID_Discovery_TimeOut[3] = {RFID_Discovery_TimeOut_Limit,RFID_Discovery_TimeOut_Limit,RFID_Discovery_TimeOut_Limit}; bool RequestForDiscovery[3] = {false,false,false};//request from WHS logic bool DiscoverRFIDTagEvery100mSec[3] = {false,false,false}; RFID_TAG_State_Machine TagStage[3] = {Tag_Idle,Tag_Idle,Tag_Idle}; NxpNci_RfIntf_t tagInfo; RFID_STATUS RFID_Status_Words[Max_Readers]; bool Init_RFID_Reader(RFID_READER_ID Reader_ID)//0-2 { static bool firstTime = true; RFID_RETURN_CODE RFIDRetCode; if(firstTime) { InitFields(); firstTime = false; } RFIDRetCode = RFID_Connect(Reader_ID);//0-2 - > Active_RFID_Reader = Cart_ID;//1-3 - verify using scope/ fluke if(RFIDRetCode == SUCCESS) { return OK; } else { return ERROR; } } uint8_t RFID_Print_Errors(uint8_t readerID, RFID_RETURN_CODE Err_Code) { uint8_t Status = ERROR; switch(Err_Code) { case SUCCESS: Status = OK; break; case ERR_UNDEFINED_READER: LOG_ERROR (readerID, "RFID - ERR_UNDEFINED_READER"); break; case ERR_NOT_INITIALIZED: LOG_ERROR (readerID, "RFID - ERR_NOT_INITIALIZED"); break; case ERR_CONNECTION: LOG_ERROR (readerID, "RFID - ERR_CONNECTION"); break; case ERR_CONFIG_SETTINGS: LOG_ERROR (readerID, "RFID - ERR_CONFIG_SETTINGS"); break; case ERR_CONFIG_MODE: LOG_ERROR (readerID, "RFID - ERR_CONFIG_MODE"); break; case ERR_START_DISCOVERY: LOG_ERROR (readerID, "RFID - ERR_START_DISCOVERY"); break; case ERR_STOP_DISCOVERY: LOG_ERROR (readerID, "RFID - ERR_STOP_DISCOVERY"); break; case ERR_LENGTH: LOG_ERROR (readerID, "RFID - ERR_LENGTH"); break; case ERR_TAG_MEMORY_READ: LOG_ERROR (readerID, "RFID - ERR_TAG_MEMORY_READ"); break; case ERR_TAG_MEMORY_WRITE: LOG_ERROR (readerID, "RFID - ERR_TAG_MEMORY_WRITE"); break; case TAG_NOT_DETECTED: LOG_ERROR (readerID, "RFID - TAG_NOT_DETECTED"); break; case UNSUPPORTED_PROTOCOL: LOG_ERROR (readerID, "RFID - UNSUPPORTED_PROTOCOL"); break; default: LOG_ERROR (readerID, "RFID - ERR_UNKNOWN"); break; } return Status; } uint8_t uid[7] = {0}; RFID_RETURN_CODE RFID_Status = 0; uint8_t Connect_to_RFID_Reder(uint8_t readerID)//2 { RFID_RETURN_CODE RFIDRetValue; uint8_t Status = OK; /* bool isTagValid; uint32_t newPwd; uint32_t newPACK; uint32_t counter; int PwdRetVal; */ static uint32_t nop = 0; RFID_StartDiscovery(readerID); while(1)//only for testing - stub call the function { if(RFID_WaitForDiscoveryNotification(readerID, &tagInfo) == SUCCESS) { RFIDRetValue = getUID( readerID, &tagInfo, uid ); RFID_Status = RFIDRetValue; Status |= RFID_Print_Errors(readerID, RFIDRetValue); /* //password authentication PwdRetVal = checkPwd( newPwd, newPACK ); if(PwdRetVal == 1) { //OK } else if(PwdRetVal == -1) { LOG_ERROR (readerID, "RFID - checkPwd: wrong Pwd");//wrong value Status |= ERROR; } else if(PwdRetVal == -2) { LOG_ERROR (readerID, "RFID - checkPwd: wrong pack value");//wrong pack value Status |= ERROR; } counter = GetCounter (readerID, &tagInfo); isTagValid = IsTagValid(readerID, &tagInfo); */ break; } else { nop++; } //Task_sleep (1000); delayms(1000); } RFID_StopDiscovery(readerID); return Status; } NFC_Tag NFC_Tag_R[Max_Readers];//read NFC_Tag NFC_Tag_W[Max_Readers];//write (for testing / stub) NFC_Tag NFC_Tag_U[Max_Readers];//read with updates //NFCTag_t NFC_Tag_W_Struct; RFID_RETURN_CODE TagWriteData(RFID_READER_ID readerID) { //uint8_t index = 0; uint32_t dummy = 0; uint32_t Tuint32 = 0; //uint16_t Tuint16 = 0; //uint8_t Tuint8 = 0; RFID_RETURN_CODE RFIDRetValue; //NxpNci_RfIntf_t TagInfo; uint8_t tagMemory[256]; // uint8_t Serial[] = {'1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G'}; //RFID_READER_ID readerID = (RFID_READER_ID)(Active_RFID_Reader -1); // for(index = 0; index < sizeof(Serial); index++) // { // Serial[index] = 'a'+index; // } ///* // for(index = 0; index < sizeof(NFC_Tag_W_Struct.CartSN); index++) // { // NFC_Tag_W_Struct.CartSN[index] = 'M'+index; // } // // RFIDRetValue = WriteValue( readerID, &TagInfo, NFC_Tag_W_Struct.CartSN, 0, dummy ); // */ // /* // for(index = 0; index < sizeof(NFC_Tag_W[readerID].Struct.CartSN); index++) // { // NFC_Tag_W[readerID].Struct.CartSN[index] = 'c'+index; // } // // RFIDRetValue = WriteValue( readerID, &TagInfo, NFC_Tag_W[readerID].Struct.CartSN, 0, dummy ); // */ // RFIDRetValue = WriteValue( readerID, &tagInfo, Serial, 0, dummy ); //Serial strcpy(NFC_Tag_W[readerID].Struct.Serial, "123456789abcdefg"); RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.Serial, 0, dummy ); //factory id strcpy(NFC_Tag_W[readerID].Struct.factoryID, "FID"); RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.factoryID, 1, dummy ); /* ////////////////// //uint8_t fillingSystem[2] = {0xab, 0xcd}; uint16_t fillingSystem = 50;//50 -> write 0x3035 ASCII 35 00 //filling system //RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 2, fillingSystem ); RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 2, fillingSystem ); */ //filling system NFC_Tag_W[readerID].Struct.fillingSystem = 50; Tuint32 = NFC_Tag_W[readerID].Struct.fillingSystem; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 2, Tuint32 ); //work order strcpy(NFC_Tag_W[readerID].Struct.workOrder, "WORK-ORDER"); RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.workOrder, 3, dummy ); //color name strcpy(NFC_Tag_W[readerID].Struct.colorName, "-COLOR-NAME-"); RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.colorName, 4, dummy ); //category strcpy(NFC_Tag_W[readerID].Struct.catagory, "CY"); RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.catagory, 5, dummy ); //type NFC_Tag_W[readerID].Struct.type = 4321; Tuint32 = NFC_Tag_W[readerID].Struct.type; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 6, Tuint32 ); delayms(2); //cartSize NFC_Tag_W[readerID].Struct.cartSize = 8765; Tuint32 = NFC_Tag_W[readerID].Struct.cartSize; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 7, Tuint32 ); delayms(2); ///////////////// //inkVolume NFC_Tag_W[readerID].Struct.inkVolume = 9696; Tuint32 = NFC_Tag_W[readerID].Struct.inkVolume; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 8, Tuint32 ); delayms(2); //inkBatch strcpy(NFC_Tag_W[readerID].Struct.inkBatch, "-inkBatch-"); RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.inkBatch, 9, dummy ); delayms(2); //inkMfgDate strcpy(NFC_Tag_W[readerID].Struct.inkMfgDate, "inkMfgDa"); RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.inkMfgDate, 10, dummy ); delayms(2); //inkEolDate strcpy(NFC_Tag_W[readerID].Struct.inkEolDate, "31/12/21"); RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.inkEolDate, 11, dummy ); delayms(2); //CartFillDate strcpy(NFC_Tag_W[readerID].Struct.CartFillDate, "CarFDate"); RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.CartFillDate, 12, dummy ); delayms(2); //WasteFillDate strcpy(NFC_Tag_W[readerID].Struct.WasteFillDate, "WastDate"); RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.WasteFillDate, 13, dummy ); delayms(2); //Misc NFC_Tag_W[readerID].Struct.Misc = 1234; Tuint32 = NFC_Tag_W[readerID].Struct.Misc; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 14, Tuint32 ); delayms(2); //pluginCounter NFC_Tag_W[readerID].Struct.pluginCounter = 56; Tuint32 = NFC_Tag_W[readerID].Struct.pluginCounter; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 15, Tuint32 ); delayms(2); //inkFill NFC_Tag_W[readerID].Struct.inkFill = 7; Tuint32 = NFC_Tag_W[readerID].Struct.inkFill; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 16, Tuint32 ); delayms(2); //inkUsed NFC_Tag_W[readerID].Struct.inkUsed = 8; Tuint32 = NFC_Tag_W[readerID].Struct.inkUsed; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 17, Tuint32 ); delayms(2); //inkEmpty NFC_Tag_W[readerID].Struct.inkEmpty = 9; Tuint32 = NFC_Tag_W[readerID].Struct.inkEmpty; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 18, Tuint32 ); //wasteEmpty NFC_Tag_W[readerID].Struct.wasteEmpty = 1; Tuint32 = NFC_Tag_W[readerID].Struct.wasteEmpty; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 19, Tuint32 ); //wasteFilling NFC_Tag_W[readerID].Struct.wasteFilling = 2; Tuint32 = NFC_Tag_W[readerID].Struct.wasteFilling; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 20, Tuint32 ); //wasteFull NFC_Tag_W[readerID].Struct.wasteFull = 3; Tuint32 = NFC_Tag_W[readerID].Struct.wasteFull; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 21, Tuint32 ); //blocked NFC_Tag_W[readerID].Struct.blocked = TAG_NOT_BLOCKED; Tuint32 = NFC_Tag_W[readerID].Struct.blocked; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 22, Tuint32 ); //fail NFC_Tag_W[readerID].Struct.fail = 5; Tuint32 = NFC_Tag_W[readerID].Struct.fail; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 23, Tuint32 ); //wasteCounter NFC_Tag_W[readerID].Struct.wasteCounter = 0; Tuint32 = NFC_Tag_W[readerID].Struct.wasteCounter; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 24, Tuint32 ); //MachineIdInl strcpy(NFC_Tag_W[readerID].Struct.MachineIdInl, "MachineIdInl1234"); RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.MachineIdInl, 25, dummy ); //WasteFillDate strcpy(NFC_Tag_W[readerID].Struct.MachineIdWst, "MachineIdWst1234"); RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.MachineIdWst, 26, dummy ); //WasteFillDate strcpy(NFC_Tag_W[readerID].Struct.reserved, "reserved12345"); RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.reserved, 27, dummy ); //counter NFC_Tag_W[readerID].Struct.counter = 1;//5678; Tuint32 = NFC_Tag_W[readerID].Struct.counter; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 28, Tuint32 ); //tagValid NFC_Tag_W[readerID].Struct.tagValid = TAG_VALID; Tuint32 = NFC_Tag_W[readerID].Struct.tagValid; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 29, Tuint32 ); //hash calcHash( tagInfo.Info.NFC_VPP.ID, sizeof(tagInfo.Info.NFC_VPP.ID), NFC_Tag_W[readerID].Struct.HashValue );//read the UID, calculate Hash and write the hash RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.HashValue, 30, dummy ); //crc //crc_ccitt_init(); NFC_Tag_W[readerID].Struct.Checksum_CRC16 = crc_ccitt_update(NFC_Tag_W[readerID].Buf,(sizeof(NFC_Tag_W[readerID].Buf) - sizeof(NFC_Tag_W[readerID].Struct.Checksum_CRC16)));//calculate the crc without tag id and without crc fields Tuint32 = NFC_Tag_W[readerID].Struct.Checksum_CRC16; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 31, Tuint32 ); return RFIDRetValue; } //RFID_RETURN_CODE Read_Tag_All_Data() //{ // // // uint8_t index = 0; // uint32_t dummy = 0; // //uint8_t Tuint8 = 0; // //uint16_t Tuint16 = 0; // uint32_t Tuint32 = 0; // //uint64_t Tuint64 = 0; // //uint8_t Tuint8_buf10[10] = 0; // RFID_RETURN_CODE RFIDRetValue; // // //NxpNci_RfIntf_t TagInfo; // // uint8_t tagMemory[1024]; // // RFID_READER_ID readerID = (RFID_READER_ID)(Active_RFID_Reader -1); // // //serial // RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.Serial, 0, &dummy ); // //factory id // RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.factoryID, 1, &dummy ); // //filling system // //RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 2, NFC_Tag_R[readerID].Struct.fillingSystem ); // //RFIDRetValue = ReadValue( readerID, &tagInfo, &NFC_Tag_R[readerID].Struct.fillingSystem, 2, &dummy );//OK read hex (for writubg 50 read 0335 ASCII 0) // /*NFC_Tag_R[readerID].Struct.fillingSystem = ReadValue( readerID, &tagInfo, tagMemory, 2, &dummy );*/ // //RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 2, NFC_Tag_R[readerID].Struct.fillingSystem ); // /* working ok*/ // // // Tuint32=0; // RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 2, &Tuint32 ); // NFC_Tag_R[readerID].Struct.fillingSystem = (uint16_t)Tuint32; // // // //work order // RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.workOrder, 3, &dummy ); // //color name // RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.colorName, 4, &dummy ); // //category // RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.catagory, 5, &dummy ); // //type // Tuint32 = 0; // RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 6, &Tuint32 ); // NFC_Tag_R[readerID].Struct.type = Tuint32; // //cartSize // Tuint32 = 0; // RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 7, &Tuint32 ); // NFC_Tag_R[readerID].Struct.cartSize = Tuint32; // //inkVolume // Tuint32 = 0; // RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 8, &Tuint32 ); // NFC_Tag_R[readerID].Struct.inkVolume = Tuint32; // //inkBatch // RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.inkBatch, 9, &dummy ); // //inkMfgDate // RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.inkMfgDate, 10, &dummy ); // //inkEolDate // RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.inkEolDate, 11, &dummy ); // //CartFillDate // RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.CartFillDate, 12, &dummy ); // //WasteFillDate // RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.WasteFillDate, 13, &dummy ); // // // //Misc // Tuint32 = 0; // RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 14, &Tuint32 ); // NFC_Tag_R[readerID].Struct.Misc = Tuint32; // //pluginCounter // Tuint32 = 0; // RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 15, &Tuint32 ); // NFC_Tag_R[readerID].Struct.pluginCounter = (uint16_t)Tuint32; // // //inkFill // Tuint32 = 0; // RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 16, &Tuint32 );//FAIL // NFC_Tag_R[readerID].Struct.inkFill = (uint8_t)Tuint32; // // //inkUsed // Tuint32 = 0; // RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 17, &Tuint32 ); // NFC_Tag_R[readerID].Struct.inkUsed = (uint8_t)Tuint32; // // //inkEmpty // Tuint32 = 0; // RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 18, &Tuint32 );//FAIL // NFC_Tag_R[readerID].Struct.inkEmpty = (uint8_t)Tuint32; // //wasteEmpty // Tuint32 = 0; // RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 19, &Tuint32 ); // NFC_Tag_R[readerID].Struct.wasteEmpty = (uint8_t)Tuint32; // //wasteFilling // Tuint32 = 0; // RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 20, &Tuint32 ); // NFC_Tag_R[readerID].Struct.wasteFilling = (uint8_t)Tuint32; // //wasteFull // Tuint32 = 0; // RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 21, &Tuint32 ); // NFC_Tag_R[readerID].Struct.wasteFull = (uint8_t)Tuint32; // //blocked // Tuint32 = 0; // RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 22, &Tuint32 ); // NFC_Tag_R[readerID].Struct.blocked = (uint8_t)Tuint32; // //fail // Tuint32 = 0; // RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 23, &Tuint32 ); // NFC_Tag_R[readerID].Struct.fail = (uint8_t)Tuint32; // //wasteCounter // Tuint32 = 0; // RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 24, &Tuint32 ); // NFC_Tag_R[readerID].Struct.wasteCounter = (uint16_t)Tuint32; // //MachineIdInl // RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.MachineIdInl, 25, &dummy ); // //MachineIdWst // RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.MachineIdWst, 26, &dummy ); // //reserved // RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.reserved, 27, &dummy ); // //counter // Tuint32 = 0; // RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 28, &Tuint32 ); // NFC_Tag_R[readerID].Struct.counter = Tuint32; // //tagValid // Tuint32 = 0; // RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 29, &Tuint32 ); // NFC_Tag_R[readerID].Struct.tagValid = (uint8_t)Tuint32; // //hash // RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.HashValue, 30, &dummy ); // // // ////////////// // // return RFIDRetValue; // //} //-------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------- /* typedef union { uint8_t Byte[4]; uint32_t Word; }Word_to_Bytes; */ //typedef union //{ // uint8_t Byte[4]; // uint32_t Short; //}Short_to_Bytes; #define TagMaxFieldLength 16 // why 256? max is 16 #define Uartsize sizeof(NFC_Tag) void Init_NFC_Tag_Union(RFID_READER_ID readerID) { uint8_t i = 0; memset(NFC_Tag_R[readerID].Buf, 0, Uartsize); for(i=0;i<8;i++)//Copy UID { NFC_Tag_R[readerID].Struct.tagId[i] = tagInfo.Info.NFC_VPP.ID[i]; } //Padding fields: NFC_Tag_R[readerID].Struct.Padding_1_8bit = NFC_Tag_R[readerID].Struct.Paddind_2_8bit = NFC_Tag_R[readerID].Struct.Paddind_3_8bit = 0xFF; NFC_Tag_R[readerID].Struct.Paddind_1_16bit = NFC_Tag_R[readerID].Struct.Paddind_2_16bit = NFC_Tag_R[readerID].Struct.Paddind_3_16bit = NFC_Tag_R[readerID].Struct.Paddind_4_16bit = 0xFFFF; } RFID_RETURN_CODE Read_Tag_All_Data() { uint32_t dummy = 0; RFID_RETURN_CODE RFIDRetValue = SUCCESS; uint8_t tagMemory[256]; uint32_t valueNum = 0; uint8_t value[TagMaxFieldLength]; uint32_t BufferIndex = 8;//start with Serial field uint8_t valueIndex, i; Word_to_Bytes Word2Bytes; RFID_READER_ID readerID = (RFID_READER_ID)(Active_RFID_Reader -1); Init_NFC_Tag_Union(readerID); for(valueIndex = 0; valueIndex < NUMBER_OF_FIELDS; valueIndex++) { delayms(5);// need to check without it sometimes read wrong values (0xFF... in Serial, MachineIdInl at MachineIdWst) while((NFC_Tag_R[readerID].Buf[BufferIndex] != 0x00) && (BufferIndex < (Uartsize-1))) { NFC_Tag_R[readerID].Buf[BufferIndex] = 0; // reset the padding fields in order to calculate the crc BufferIndex++; //Skip padding fields } if (Fields[valueIndex].isNum == true )//Number { valueNum = 0; RFIDRetValue |= ReadValue( readerID, &tagInfo, tagMemory, valueIndex, &valueNum ); if(RFIDRetValue != SUCCESS) { RFIDRetValue = SUCCESS; delayms(5); RFIDRetValue |= ReadValue( readerID, &tagInfo, tagMemory, valueIndex, &valueNum );//try again } if(RFIDRetValue != SUCCESS) { RFIDRetValue = SUCCESS; delayms(5); RFIDRetValue |= ReadValue( readerID, &tagInfo, tagMemory, valueIndex, &valueNum );//try again } Word2Bytes.Word = valueNum; if(Fields[valueIndex].fieldLength == 1) { NFC_Tag_R[readerID].Buf[BufferIndex] = Word2Bytes.Byte[0]; BufferIndex+=1; } else if(Fields[valueIndex].fieldLength == 2) { for ( i = 0; i < 2; i++) { NFC_Tag_R[readerID].Buf[BufferIndex+i] = Word2Bytes.Byte[i]; } BufferIndex+=2; } else if(Fields[valueIndex].fieldLength == 4) { for ( i = 0; i < 4; i++) { NFC_Tag_R[readerID].Buf[BufferIndex+i] = Word2Bytes.Byte[i]; } BufferIndex+=4; } } else// ASCI text { RFIDRetValue |= ReadValue( readerID, &tagInfo, value, valueIndex, &dummy ); if(RFIDRetValue != SUCCESS) { RFIDRetValue = SUCCESS; delayms(5); RFIDRetValue |= ReadValue( readerID, &tagInfo, value, valueIndex, &dummy );//try again } if(RFIDRetValue != SUCCESS) { RFIDRetValue = SUCCESS; delayms(5); RFIDRetValue |= ReadValue( readerID, &tagInfo, value, valueIndex, &dummy );//try again } for ( i = 0; i < Fields[valueIndex].fieldLength; i++) { NFC_Tag_R[readerID].Buf[BufferIndex] = value[i]; BufferIndex+=1; } } } return RFIDRetValue; } //-------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------- RFID_RETURN_CODE TagReadData() { uint32_t dummy = 0; RFID_RETURN_CODE RFIDRetValue; RFID_READER_ID readerID = (RFID_READER_ID)(Active_RFID_Reader -1); RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.Serial, 0, &dummy ); return RFIDRetValue; } RFID_RETURN_CODE WriteWCounter(RFID_READER_ID readerID) { RFID_RETURN_CODE RFIDRetValue = SUCCESS; RFIDRetValue = incrementCounter( readerID, &tagInfo);//every time updating data return RFIDRetValue; } RFID_RETURN_CODE WriteCRCValue(RFID_READER_ID readerID) { uint32_t Tuint32 = 0; uint8_t tagMemory[256]; RFID_RETURN_CODE RFIDRetValue = SUCCESS; //RFIDRetValue = incrementCounter( readerID, &tagInfo);//every time updating data //crc_ccitt_init(); NFC_Tag_U[readerID].Struct.Checksum_CRC16 = crc_ccitt_update(NFC_Tag_U[readerID].Buf,(sizeof(NFC_Tag_U[readerID].Buf) - sizeof(NFC_Tag_U[readerID].Struct.Checksum_CRC16)));//calculate the crc without tag id and without crc fields Tuint32 = NFC_Tag_U[readerID].Struct.Checksum_CRC16; RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 31, Tuint32 ); return RFIDRetValue; } bool NFC_Check_CRC(RFID_READER_ID readerID)//after reading all data from tag { bool status = ERROR; uint32_t CRC; //crc_ccitt_init(); CRC = crc_ccitt_update(NFC_Tag_R[readerID].Buf,(sizeof(NFC_Tag_R[readerID].Buf) - sizeof(NFC_Tag_R[readerID].Struct.Checksum_CRC16))); if(NFC_Tag_R[readerID].Struct.Checksum_CRC16 == CRC) { status = OK; } return status; } uint8_t counterd_dis = 0; bool follow_stages[MAX_TAG_State_Machine] = {ERROR, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR}; uint32_t RFIDTagComm_StateMachine(RFID_READER_ID readerID, StateMachineMode Mode) { uint32_t Status = OK; RFID_RETURN_CODE RFIDRetValue; //RFID_READER_ID readerID = (RFID_READER_ID)(Active_RFID_Reader -1); uint8_t i = 0; //uint8_t ReadingCounter; int RetValue = 0; switch(TagStage[readerID]) { case Tag_Idle: //Tag Not Active follow_stages[TagStage[readerID]] = OK; break; case Tag_PrepareForDiscovery: RFIDRetValue = RFID_StartDiscovery(readerID); if(RFIDRetValue == SUCCESS) { follow_stages[TagStage[readerID]] = OK; RFID_Status_Words[readerID].errors.ReaderPreDiscovery = S_SUCCEEDED; if(Mode == Auto) TagStage[readerID] = Tag_Indetification; } else { follow_stages[TagStage[readerID]] = ERROR; RFID_Status_Words[readerID].errors.ReaderPreDiscovery = S_FAILED; } delayms(1); if(Mode == OneStep) { break; } case Tag_Indetification: //RFIDRetValue = RFID_WaitForDiscoveryNotification(readerID, &tagInfo); do { RFIDRetValue = RFID_WaitForDiscoveryNotification(readerID, &tagInfo); delayms(100); counterd_dis++; }while((RFIDRetValue != SUCCESS)&&(counterd_dis<10)); if(RFIDRetValue == SUCCESS) { follow_stages[TagStage[readerID]] = OK; RFID_Status_Words[readerID].errors.TagDiscovery = S_SUCCEEDED; if(Mode == Auto) TagStage[readerID] = Tag_GetUid; } else { follow_stages[TagStage[readerID]] = ERROR; RFID_Status_Words[readerID].errors.TagDiscovery = S_FAILED; TagStage[readerID] = Tag_Idle; } delayms(1); if(Mode == OneStep) { break; } case Tag_GetUid: RFIDRetValue = getUID( readerID, &tagInfo, uid ); if(RFIDRetValue == SUCCESS) { follow_stages[TagStage[readerID]] = OK; RFID_Status_Words[readerID].errors.TagGetUID = S_SUCCEEDED; if(Mode == Auto) TagStage[readerID] = Tag_WriteValue; } else { follow_stages[TagStage[readerID]] = ERROR; RFID_Status_Words[readerID].errors.TagGetUID = S_FAILED; //while(1); } // memset(NFC_Tag_R[readerID].Buf,0,sizeof(NFCTag_t)); // // for(i=0;i<8;i++)//Copy UID // { // NFC_Tag_R[readerID].Struct.tagId[i] = tagInfo.Info.NFC_VPP.ID[i]; // } delayms(1); if(Mode == OneStep) { break; } /* case Tag_CheckPwd: break; */ /* case Tag_InvalidLock: break;*/ #ifndef RFID_READ_ONLY case Tag_WriteValue: RFIDRetValue = TagWriteData(readerID); if(RFIDRetValue == SUCCESS) { follow_stages[TagStage[readerID]] = OK; RFID_Status_Words[readerID].errors.TagwriteData = S_SUCCEEDED; if(Mode == Auto) TagStage[readerID] = Tag_ReadValue; } else { follow_stages[TagStage[readerID]] = ERROR; RFID_Status_Words[readerID].errors.TagwriteData = S_FAILED; while(1); } delayms(1); if(Mode == OneStep) { break; } #endif case Tag_ReadValue: //RFIDRetValue = Read_Tag_All_Data();//TagReadData(); // /* ReadingCounter = 0; do { RFIDRetValue = Read_Tag_All_Data(); ReadingCounter++; } while ((NFC_Check_CRC() == ERROR) && (ReadingCounter < 1));//if the crc is wrong read the tag again (max 3 times) if(NFC_Check_CRC() == ERROR) { while(true); }*/ RFIDRetValue = Read_Tag_All_Data(); // if(RFIDRetValue == SUCCESS) { follow_stages[TagStage[readerID]] = OK; RFID_Status_Words[readerID].errors.TagReadData = S_SUCCEEDED; if(Mode == Auto) TagStage[readerID] = Tag_CheckUpdateBlocked; } else { follow_stages[TagStage[readerID]] = ERROR; RFID_Status_Words[readerID].errors.TagReadData = S_FAILED; } delayms(1); for(i = 0; i < sizeof(NFCTag_t); i++) { NFC_Tag_U[readerID].Buf[i] = NFC_Tag_R[readerID].Buf[i]; } if(Mode == OneStep) { break; } case Tag_CheckCRC: if(NFC_Check_CRC(readerID) != OK) { RFID_Status_Words[readerID].errors.TAgCheckDataCRC = S_FAILED; } else { RFID_Status_Words[readerID].errors.TAgCheckDataCRC = S_SUCCEEDED; } if(Mode == OneStep) { break; } case Tag_CheckUpdateBlocked: RFIDRetValue = IsTagBlocked(readerID);//check blocked bit if(RFIDRetValue == SUCCESS) { follow_stages[TagStage[readerID]] = OK; RFID_Status_Words[readerID].errors.TAgCheckBlockedField = S_SUCCEEDED; if(Mode == Auto) TagStage[readerID] = Tag_CheckHashValue; } else { follow_stages[TagStage[readerID]] = ERROR; RFID_Status_Words[readerID].errors.TAgCheckBlockedField = S_FAILED; } #warning Add here blacklist functionality //check black list // update block bit + checsum + block field for changing delayms(1); if(Mode == OneStep) { break; } case Tag_CheckHashValue: RetValue = checkHashValue( readerID, &tagInfo); if(RetValue == 1) { follow_stages[TagStage[readerID]] = OK; RFID_Status_Words[readerID].errors.TagCheckHash = S_SUCCEEDED; if(Mode == Auto) TagStage[readerID] = Tag_CheckValidity; } else { follow_stages[TagStage[readerID]] = ERROR; RFID_Status_Words[readerID].errors.TagCheckHash = S_FAILED; //while(1); } delayms(1); if(Mode == OneStep) { break; } case Tag_CheckValidity: RFIDRetValue = IsTagValid(readerID); if(RFIDRetValue == SUCCESS) { follow_stages[TagStage[readerID]] = OK; RFID_Status_Words[readerID].errors.TagCheckValidity = S_SUCCEEDED; if(Mode == Auto) TagStage[readerID] = Tag_CheckUpdateCounter; } else { follow_stages[TagStage[readerID]] = ERROR; RFID_Status_Words[readerID].errors.TagCheckValidity = S_FAILED; //while(1); } delayms(1); if(Mode == OneStep) { break; } #ifndef RFID_READ_ONLY case Tag_CheckUpdateCounter: RetValue = incrementCounterAndCompare( readerID, &tagInfo); if(RetValue == 1) { follow_stages[TagStage[readerID]] = OK; RFID_Status_Words[readerID].errors.TagCheckCounterLimit = S_SUCCEEDED; RFID_Status_Words[readerID].errors.TagUpdateCounters = S_SUCCEEDED; if(Mode == Auto) TagStage[readerID] = Tag_UpdateCheckSum; } else if(RetValue == -1) { follow_stages[TagStage[readerID]] = ERROR; RFID_Status_Words[readerID].errors.TagCheckCounterLimit = S_FAILED; } else if(RetValue == -2) { follow_stages[TagStage[readerID]] = ERROR; RFID_Status_Words[readerID].errors.TagUpdateCounters = S_FAILED; } delayms(1); if(Mode == OneStep) { break; } case Tag_UpdateWCounter: RFIDRetValue = WriteWCounter(readerID); if(RFIDRetValue == SUCCESS) { follow_stages[TagStage[readerID]] = OK; RFID_Status_Words[readerID].errors.TagUpdateWriteCounter = S_SUCCEEDED; } else { follow_stages[TagStage[readerID]] = ERROR; RFID_Status_Words[readerID].errors.TagUpdateWriteCounter = S_FAILED; } break; case Tag_UpdateCRC: /* RFIDRetValue = WriteCRCValue(readerID); if(RFIDRetValue == SUCCESS) { follow_stages[TagStage[readerID]] = OK; RFID_Status_Words[readerID].errors.TagUpdateCRC = S_SUCCEEDED; } else { follow_stages[TagStage[readerID]] = ERROR; RFID_Status_Words[readerID].errors.TagUpdateCRC = S_FAILED; } break; */ case Tag_UpdateCheckSum://after updating the counter RFIDRetValue = WriteCRCValue(readerID); if(RFIDRetValue == SUCCESS) { follow_stages[TagStage[readerID]] = OK; RFID_Status_Words[readerID].errors.TagUpdateCRC = S_SUCCEEDED; if(Mode == Auto) TagStage[readerID] = Tag_DisconnectComm; } else { follow_stages[TagStage[readerID]] = ERROR; RFID_Status_Words[readerID].errors.TagUpdateCRC = S_FAILED; //while(1); /---------------------------------------------------------------------------------------------- ERROR } if(Mode == OneStep) { break; } #endif case Tag_DisconnectComm: RFIDRetValue = RFID_StopDiscovery(readerID); if(RFIDRetValue == SUCCESS) { TagStage[readerID] = Tag_Idle; RFID_Status_Words[readerID].errors.TagDisconnect = S_SUCCEEDED; } else { follow_stages[TagStage[readerID]] = ERROR; RFID_Status_Words[readerID].errors.TagDisconnect = S_FAILED; //while(1); /---------------------------------------------------------------------------------------------- ERROR } break; default: break; } Status |= RFID_Print_Errors(readerID, RFIDRetValue); return Status; } /* //------------------------------------------------------------------------------- //every 1 sec void RFIDCycleEvery1Sec() { static RFID_READER_ID readerID; static bool FirstTime = true; for(readerID = READER_1; readerID < Max_Readers ; readerID++) { Active_RFID_Reader = readerID + 1; if ( (Is_Cartridge_Present(Active_RFID_Reader) == true) && (RFID_Status_Words[readerID].errors.ReaderInit == S_SUCCEEDED) && ( (FirstTime == true) || (RequestForDiscovery[readerID] == true) ) ) { if(RFID_Status_Words[readerID].errors.TagDiscovery == S_SUCCEEDED) { FirstTime = false; } else { Trigger_RFID_TestTask(readerID); } // if(RFID_Status_Words[readerID].errors.TagDiscovery != S_SUCCEEDED) // { // DiscoverRFIDTagEvery100mSec[readerID] = true; // RFID_Discovery_TimeOut[readerID] = RFID_Discovery_TimeOut_Limit; // } // else if(TagStage[readerID] < Tag_DisconnectComm) // { // DiscoverRFIDTagEvery100mSec[readerID] = true; // } // } // else if(Is_Cartridge_Present(Active_RFID_Reader) == false) // { // //Initial values // RFID_Status_Words[readerID].uint &= 0x000F;//Reset status except ReaderAvailability + ReaderInit // FirstTime = true; // RequestForDiscovery[readerID] = false; // DiscoverRFIDTagEvery100mSec[readerID] = false; // } else if (RFID_Status_Words[readerID].errors.TagDisconnect == S_SUCCEEDED) { FirstTime = false; } } // FirstTime = false; } //--------------------------------------------------------------------------------- //every 100 m sec void RFIDCallEvery100mSec(RFID_READER_ID readerID) { if ((RFID_Status_Words[readerID].errors.TagDiscovery != S_SUCCEEDED) && (RFID_Discovery_TimeOut[readerID] > 0)) { if(RFID_Status_Words[readerID].errors.ReaderPreDiscovery != S_SUCCEEDED) { //call ReaderPreDiscovery[i] TagStage[readerID] = Tag_PrepareForDiscovery; } else { //call TagDiscovery[i] TagStage[readerID] = Tag_Indetification; } RFIDTagComm_StateMachine(readerID, OneStep); RFID_Discovery_TimeOut[readerID]--; } else if( (RFID_Discovery_TimeOut[readerID] == 0) && (RFID_Status_Words[readerID].errors.TagDiscovery != S_SUCCEEDED) ) { //RFID_Discovery_TimeOut error DiscoverRFIDTagEvery100mSec[readerID] = false; } else if ((RFID_Status_Words[readerID].errors.TagDiscovery == S_SUCCEEDED) && (TagStage[readerID] < Tag_DisconnectComm)) { DiscoverRFIDTagEvery100mSec[readerID] = false; TagStage[readerID] = Tag_GetUid; //if(TagStage[readerID] < Tag_DisconnectComm) // TagStage[readerID]++; RFIDTagComm_StateMachine(readerID, Auto); } else { DiscoverRFIDTagEvery100mSec[readerID] = false; } } //------------------------------------------------------------ */ //------------------------------------------------------------------------------- //every 1 sec void RFIDCycleEvery1Sec() { static RFID_READER_ID readerID; //static bool FirstTime = true; if(Is_AnyCartridge_presence() == true)//at least one is presence { for(readerID = READER_1; readerID < Max_Readers ; readerID++) { Active_RFID_Reader = readerID + 1; if ( (Is_Cartridge_Present(Active_RFID_Reader) == true) && (RFID_Status_Words[readerID].errors.ReaderInit == S_SUCCEEDED) ) { //if(RFID_Status_Words[readerID].errors.ReaderPreDiscovery != S_SUCCEEDED) if(RFID_Status_Words[readerID].errors.ReaderPreDiscovery == S_NA) { DiscoverRFIDTagEvery100mSec[readerID] = false; Trigger_RFID_Prepare(readerID);//Send Commnd to start discovery //Trigger_RFID_TestTask(readerID); } else if(RFID_Status_Words[readerID].errors.ReaderPreDiscovery == S_FAILED) { //IFS Error - Reader error!!! } else // S_SUCCEEDED - recieve the start discovery command { if(RFID_Status_Words[readerID].errors.TagDiscovery == S_NA) { Trigger_RFID_Discovery(readerID);//check if discovery } else if(RFID_Status_Words[readerID].errors.TagDiscovery == S_FAILED) { //didn't find tag yet - TBD - Tag error after X cycles !!!! } else // S_SUCCEEDED { DiscoverRFIDTagEvery100mSec[readerID] = true; } } } else { if(RFID_Status_Words[readerID].errors.ReaderInit == S_FAILED) { //IFS Error - Reader error!!! } else if(Is_Cartridge_Present(Active_RFID_Reader) == false) { //Initial values RFID_Status_Words[readerID].uint64bit &= 0x000F;//Reset status except ReaderAvailability + ReaderInit DiscoverRFIDTagEvery100mSec[readerID] = false; } } } } } //--------------------------------------------------------------------------------- //every 100 m sec void RFIDCallEvery100mSec(RFID_READER_ID readerID) { static uint16_t Offset = 0; STATUS_ENUM Status = 0; if (Is_Cartridge_Present(Active_RFID_Reader) == true) { Status = (RFID_Status_Words[readerID].uint64bit & (0x0300 << Offset))>>(8 + Offset); switch(Status) { case S_NA: switch (Offset) { case 0x00: Trigger_RFID_GetUid(readerID); break; case 0x02: #ifdef RFID_NOTUSE_PASSWORD RFID_Status_Words[readerID].errors.TagCheckPassword = S_NOTINUSE; #else Trigger_RFID_GetPassword(readerID); #endif break; case 0x04: Trigger_RFID_ReadData(readerID); break; case 0x06: #ifdef RFID_NOTUSE_CRC RFID_Status_Words[readerID].errors.TAgCheckDataCRC = S_NOTINUSE; #else Trigger_RFID_CheckCRC(readerID); #endif break; case 0x08: #ifdef RFID_NOTUSE_HASHTABLE RFID_Status_Words[readerID].errors.TagCheckHash = S_NOTINUSE; #else Trigger_RFID_CheckHash(readerID); #endif break; case 0x0A: #ifdef RFID_NOTUSE_VALIDITY RFID_Status_Words[readerID].errors.TagCheckValidity = S_NOTINUSE; #else Trigger_RFID_CheckValid(readerID); #endif break; case 0x0C: #ifdef RFID_NOTUSE_COUNTER RFID_Status_Words[readerID].errors.TagCounterLimit = S_NOTINUSE; #else #ifdef RFID_FORCE_READER2 RFID_Check_EOL_Date(); #endif if(readerID != READER_1) { RFID_Update_Waste_Filled_Date(readerID); } else if(readerID == READER_1) { RFID_Check_EOL_Date(); } Trigger_RFID_CheckCounter(readerID); #endif break; case 0x0E: #ifdef RFID_NOTUSE_BLACKLIST RFID_Status_Words[readerID].errors.TAgCheckBlockedField = S_NOTINUSE; #else Trigger_RFID_CheckBlockedField(readerID); #endif break; case 0x10: //Trigger_RFID.. break; case 0x12: //Trigger_RFID.. break; default: break; } break; case S_FAILED: case 2: //Tag Error; break; case S_SUCCEEDED: case S_NOTINUSE: case 3: if(Offset < 0xC0000000) Offset = Offset + 2; break; } } else { DiscoverRFIDTagEvery100mSec[readerID] = false; } } /* void RFIDCallEvery100mSec(RFID_READER_ID readerID) { if (Is_Cartridge_Present(Active_RFID_Reader) == true) { if(RFID_Status_Words[readerID].errors.TagGetUID == S_NA) { Trigger_RFID_GetUid(readerID); } else if(RFID_Status_Words[readerID].errors.TagGetUID == S_FAILED) { //Tag error!!! } else // S_SUCCEEDED { if(RFID_Status_Words[readerID].errors.TagReadData == S_NA) { Trigger_RFID_ReadData(readerID);// + CRC } else if(RFID_Status_Words[readerID].errors.TagReadData == S_FAILED) { //Tag error!!! } else // TagReadData S_SUCCEEDED { #ifdef RFID_NOTUSE_CRC RFID_Status_Words[readerID].errors.TAgCheckDataCRC = S_NOTINUSE; #endif if((RFID_Status_Words[readerID].errors.TAgCheckDataCRC == S_SUCCEEDED) || (RFID_Status_Words[readerID].errors.TAgCheckDataCRC == S_NOTINUSE)) { if(RFID_Status_Words[readerID].errors.TagCheckHash == S_NA) { Trigger_RFID_CheckHash(readerID); } else if(RFID_Status_Words[readerID].errors.TagCheckHash == S_FAILED) { //Tag error!!! } else // S_SUCCEEDED { DiscoverRFIDTagEvery100mSec[readerID] = false; // temporaray - move to the next stage } } else { //Tag error!!! } } } } else { DiscoverRFIDTagEvery100mSec[readerID] = false; } } */ //------------------------------------------------------------ void UpdateWCounterCRC(RFID_READER_ID readerID)//Call after any change in the tag - to call from WriteValue function { Trigger_RFID_UpdateWCounter(readerID);//Counts writes to the tag (not include this counter and CRC) Trigger_RFID_UpdateCRC(readerID); }