This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

Where could find iso15693 Reader Sample Project for dlptrf7970abp with Tiva-M4

Other Parts Discussed in Thread: CC3100, RF430FRL152H, RF430FRL152HEVM

My customer would like to use TRF7970 with Tiva TM4C129 to make a RFID Reader product, need ISO15693 Card Reader function.

However TivaWare seems only have sample project for P2P function. And although TivaWare have NFC LIB included iso15693.c, it does not provide any user guide or sample project for how to use iso15693.c to implement Card Reader function.

Do we have internal sample project for Card Reader function by using TRF7970 with Tiva TM4C?

  • Hello Terry,

    This TI Design includes firmware which handles the NFC Reader/Writer capabilities: www.ti.com/.../TIDM-TM4C129XNFC

    This is the best example we have available for that use case currently. There are extra bells and whistles on this though, such as WiFi with the CC3100 and Peer to Peer mode.
  • Hello Jacobi

    Thank you advice the nice TI Design. It is really a good example.

    I try get the all boards used in such TI Design and setup the full demo to do evaluation,  the original example sw include NFC P2P mode and 7816 R/W mode.

    I need to implement ISO15693 function, so I modify example sw as below to enable ISO15693 mode and set 15693 bitrates.  The complier process is successes, after sw download to board and run, it does not any respond when ISO15693 card put close. May I ask what addition modify need to support ISO15693 card R/W?  


     // Enable Reader Writer Supported Modes
     g_sRWSupportedModes.bits.bISO15693 = 1;

     // ISO15693 Bitrates
     g_sRWSupportedBitrates.bits.bISO15693_6_7kbps = 1; // Not supported
     g_sRWSupportedBitrates.bits.bISO15693_26_48kbps = 1;

  • Hello Terry,

    As stated by the comment, g_sRWSupportedBitrates.bits.bISO15693_6_7kbps is not supported, please try setting that to 0.

    The firmware design allows for support for lower bit rates to be added in the future, but right now they are not functional. This could be affecting the functionality for ISO15693, though in my initial test I didn't see that being the case. I still want to rule that out as a possibility for affecting this first.

    Which ISO15693 tag are you attempting to use, and how are you checking if the ISO15693 is detected or not?
  • Hi Jacobi

    I use RF430FRL152H board as ISO15693 tag to do the evaluation.

    I set a break point at T5T_stateMachine function in nfc_task.c, and check the g_pui8T5TRxBuf value which I think it should store the tag information.

                    else if(sRWMode.bits.bISO15693 == 1)
                    {
                        /* T5T Tag State Machine */
                        T5T_stateMachine();
                    } 

    when I put RF430FRL152H close to dlptrf7970abp, the firmware could stop at the break point, after continue running, however the g_pui8T5TRxBuf always no update value. Could you please help advice how could I read the NFC Tag information? 

    Another question, if I remove the CC3100 board, then the firmware will not stop at break point "T5T_stateMachine();", it seems firmware maybe suspend on WIFI some procedure and do not run NFC procedure. How could I modify the firmware to disable WIFI task and only run NFC task?

  • Hello Terry,

    Ah, thank you for providing that information. The behavior you see is what I would expect. The RF430FRL152H does not support NDEF messages natively, and that is exclusively what the TI application code is looking for 'out of the box'.

    I am attaching two application files which you should be able to use to read temperature data from the RF430FRL152HEVM. The .c file also includes detailed comments explaining the process.

    frl152h_app.c
    //*****************************************************************************
    //
    // t5t_app.c - Reader/Writer Type 5 Tag State Machine
    //
    // Copyright (c) 2015 Texas Instruments Incorporated.  All rights reserved.
    // TI Information - Selective Disclosure
    //
    //*****************************************************************************
    //	The Following NFC configuration were used for these tests:
    //------------------------------------------------------------------------------
    //	// Enable Reader Writer Supported Modes
    //	sRWSupportedModes.bits.bNfcA = 0;
    //	sRWSupportedModes.bits.bNfcB = 0;
    //	sRWSupportedModes.bits.bNfcF = 0;
    //	sRWSupportedModes.bits.bISO15693 = 1;
    //
    //	// NFC-A Bitrates
    //	sRWSupportedBitrates.bits.bNfcA_106kbps = 0;
    //	sRWSupportedBitrates.bits.bNfcA_212kbps = 0;
    //	sRWSupportedBitrates.bits.bNfcA_424kbps = 0;
    //	sRWSupportedBitrates.bits.bNfcA_848kbps = 0;
    //	// NFC-B Bitrates
    //	sRWSupportedBitrates.bits.bNfcB_106kbps = 0;
    //	sRWSupportedBitrates.bits.bNfcB_212kbps = 0;
    //	sRWSupportedBitrates.bits.bNfcB_424kbps = 0;
    //	sRWSupportedBitrates.bits.bNfcB_848kbps = 0;
    //	// NFC-F Bitrates
    //	sRWSupportedBitrates.bits.bNfcF_212kbps = 0;
    //	sRWSupportedBitrates.bits.bNfcF_424kbps = 0;
    //	// ISO15693 Bitrates
    //	sRWSupportedBitrates.bits.bISO15693_6_7kbps = 0;
    //	sRWSupportedBitrates.bits.bISO15693_26_7kbps = 1;
    //
    //	// Default Max number of WTX 2
    //	sRWSetupOptions.bits.ui3RWMaxWTX = 2;
    //	// Default Max number of ACK 2
    //	sRWSetupOptions.bits.ui3RWMaxACK = 2;
    //	// Default Max number of NACK 2
    //	sRWSetupOptions.bits.ui3RWMaxNACK = 2;
    //	// Default Max number of DSL 2
    //	sRWSetupOptions.bits.ui3RWMaxDSL = 2;
    //
    //	ui8IsoDepInitiatorDID = 0x00;
    //******************************************************************************
    
    #include "tag_header.h"
    #include "mcu.h"
    
    //******************************************************************************
    // Constants
    //******************************************************************************
    
    #define FRL15xH_POLL_BLOCK0_DELAY	 100
    
    static const uint8_t RF430FRL152H_Block_0_Config[8] = {0x01, 0x00, 0x03, 0x03, 0x01, 0x01, 0x00, 0x40};
    static const uint8_t RF430FRL152H_Block_2_Config[8] = {0x19, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
    static const uint8_t RF430FRL152H_Zeroes_Buffer[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
    
    //******************************************************************************
    // Local Variables
    //******************************************************************************
    
    static tFRL152HStateMachine g_eT5TState;
    
    static uint16_t g_ui16T5TBlockNumber;
    static uint16_t g_ui16T5TBlockCount;
    static uint16_t g_ui16T5TBlockSize;
    static uint8_t g_pui8T5TRxBuffer[30];
    
    static bool g_bT5TWaitForRsp;
    
    static uint8_t * g_pui8T5TBuffer;
    
    void FRL152H_init(uint8_t * pui8DataBuffer)
    {
    	// Initialize all global variables to known states
    	g_eT5TState = FRL152H_GET_SYS_INFO;		// Set Get Sys Info as the basic state machine state as the Inventory command is handled by initial tag detection from the NFC stack already
    	g_ui16T5TBlockNumber = 0;
    	g_ui16T5TBlockCount = 0;
    	g_bT5TWaitForRsp = false;
    
    	g_pui8T5TBuffer = pui8DataBuffer;
    }
    
    void FRL152H_stateMachine(void)
    {
    	uint8_t ui8RxLength;
    	uint8_t * pui8RxData;
    	tNfcRwT5TConnectionStatus eT5TStatus;
    	uint8_t * pui8TagUid;
    
    	// This state machine works on case statements to handle various states which are defined in tag_header.h under tFRL152HStateMachine
    	// Additional states can be added at any time, just add the state to that structure. There is already a "FRL152H_CUSTOM_COMMAND" which
    	// isn't even used just as an initial reference for that aspect.
    	//
    	// For any new state, the two core additions are
    	//
    	//   1. Add a case to the g_bT5TWaitForRsp == true which does the following:
    	//		* Set eT5TStatus by using a NFC_RW_T5T_get***Status(); command, the *** being for whatever ISO15693 command is being sent out in that state
    	//		* If a FAILURE occurs, use the same process as seen below, and if a Success occurs write your custom application code for it.
    	// 		* If needed, selects the next state in the process and also sets any block numbers/data up etc. for what needs to be sent out in that new state
    	//		* Once the application code is finished, then set g_bT5TWaitForRsp = false to allow for a command to be sent out.
    	//		The examples below also show to receive tag data properly from the NFC stack.
    	//
    	//   2. Add a case to the g_bT5TWaitForRsp == false which sends out a command
    	//		* Chances are all you will need to use in terms of commands are NFC_RW_T5T_sendWriteSingleCmd and NFC_RW_T5T_sendReadSingleCmd
    	//		* The WRITE_CONFIG state shows methods to customize what data is sent out inside of that part of the state machine.
    	//		* Make sure to use the same method of checking if a command sent returns STATUS_SUCCESS and then set g_bT5TWaitForRsp = true
    	//
    	// This is about all that needs to be followed to add new unique states to the state machine to cover customized applications
    
    	// Waiting for a response
    	if(g_bT5TWaitForRsp == true)
    	{
    		// Check current state of the system
    		switch(g_eT5TState)
    		{
    		case FRL152H_GET_SYS_INFO:
    			eT5TStatus = NFC_RW_T5T_getGetSysInfoStatus();		// Fetch information about Get Sys Info success/fail
    
    			if(eT5TStatus == NFC_RW_T5T_CONNECTION_GET_SYS_INFO_SUCCESS)
    			{
    				// When a success occurs for Get System Information, then the following information will be available:
    				//   * Tag UID
    				//   * Size of each Memory Block (in bytes)
    				//   * Number of Memory Blocks available
    				//
    				// Based on this information, it is possible to parse if a tag is from the RF430FRL15XH series by:
    				//   1. The Tag UID will have 0x07 for it's Manufacturer byte (Texas Instruments)
    				//   2. The Number of Blocks for any FRL15xH tag is equal to 0xF2
    				//   3. The Block Size of FRL15xH tags which are in 8 byte mode (default) will be equal to 8.
    				// The third check isn't really required, and can be removed if desired.
    
    				ui8RxLength = 8;	// Tag UID is equal to 8 bytes in length.
    				NFC_RW_T5T_getT5TUID(&pui8TagUid,&ui8RxLength);		// Fetch the tag UID and store it in a local buffer. It is only needed for this case statement.
    
    				g_ui16T5TBlockSize = NFC_RW_T5T_getVICCBlockSize() + 1;		// Fetch the block size. Block size returned by tags are 'block size - 1' per specs, so add 1 to get the proper size
    
    				g_ui16T5TBlockCount = NFC_RW_T5T_getVICCBlockCount();		// Fetch the total number of blocks for the tag
    
    				// Perform the check mentioned above to validate if a tag is an RF430FRL15xH series.
    				// If it is, proceed to the next state
    				if ((g_ui16T5TBlockCount == 0xF2) &&
    					(g_ui16T5TBlockSize == 8) &&
    					(pui8TagUid[6] == 0x07))
    				{
    					g_ui16T5TBlockNumber = 0x01;	// Set Block number to 0x01 in order to write Block 0x01 first
    													//  - See FRL152H_WRITE_CONFIG under "if(g_bT5TWaitForRsp == false)" section for further details
    					g_eT5TState = FRL152H_WRITE_CONFIG;		// Set the current state to Write_Config
    					g_bT5TWaitForRsp = false;				// Switch waiting for response to false
    
    					g_pui8T5TBuffer[0] = 0x00;				// Clear byte 0 of main.c buffer to indicate no data is ready
    															// This byte is being used as a flag to indicate when valid tag data has been read and
    															// is available for calculations to be processed. This approach is my own take on how
    															// signal the main application in main.c that the data is ready, but other methods can certainly be used instead.
    				}
    				else	// If the tag is not RF430FRL15xH, reset the state machine to Selected Idle
    				{
    					g_eT5TState = FRL152H_SELECTED_IDLE;
    					g_bT5TWaitForRsp = false;
    				}
    			}
    			else if(eT5TStatus == NFC_RW_T5T_CONNECTION_GET_SYS_INFO_FAIL)
    			{	// No response received, reset the state machine to Selected Idle
    				g_eT5TState = FRL152H_SELECTED_IDLE;
    				g_bT5TWaitForRsp = false;
    			}
    			break;
    		case FRL152H_WRITE_CONFIG:
    			eT5TStatus = NFC_RW_T5T_getWriteSingleStatus();		// Fetch information about Write Single success/fail
    
    			if(eT5TStatus == NFC_RW_T5T_CONNECTION_WRITE_SINGLE_SUCCESS)
    			{
    				// The current state machine setup is to write the configuration blocks in the following order:
    				// Block 1-7 and then Block 0
    				// This state handles the transitions for each block.
    				// The data being written is stored in Flash as const variables:
    				//   * RF430FRL152H_Block_0_Config
    				//   * RF430FRL152H_Block_2_Config
    				//   * RF430FRL152H_Zeroes_Buffer
    
    				// If the configuration data isn't pre-determined, then this state could also be used to
    				// update a global buffer with the correct values to write a specific block
    
    
    				// Check what the current block number is
    				if ((g_ui16T5TBlockNumber < 0x07) && (g_ui16T5TBlockNumber != 0x00))
    				{
    					g_ui16T5TBlockNumber++;			// When between Block 1 and Block 6, increment to next block. This will cover incrementing up to Block 7.
    					g_eT5TState = FRL152H_WRITE_CONFIG;
    				}
    				else if (g_ui16T5TBlockNumber == 0x07)
    				{
    					g_ui16T5TBlockNumber = 0x00;	// When equal to Block 7, then set the block number = 0x00 to write block 0.
    					g_eT5TState = FRL152H_WRITE_CONFIG;
    				}
    				else
    				{
    					// Otherwise, move onto next state
    					g_ui16T5TBlockNumber = 0x00;	// Set block number back to 0x00 to poll Block 0 for indication that a Conversion has been completed
    					g_eT5TState = FRL152H_POLL_DATA_READY;	// Set state to the Poll Data Ready state
    					MCU_delayMillisecond(300);		// Wait at least 300 ms to let the FRL15xH work on conversions before initial checks.
    													// This interval can be updated per application requirements.
    													// The benefit of the delay is to minimize power drain on the passive tag since it doesn't have to reply to RF commands.
    													// In the case of the TI Sensor Patch design, it takes at least 300 msec to make the conversation, so used that amount as the initial delay.
    				}
    				g_bT5TWaitForRsp = false;			// Always set wait for response to false
    			}
    			else if(eT5TStatus == NFC_RW_T5T_CONNECTION_WRITE_SINGLE_FAIL)
    			{	// No response received, reset the state machine to Selected Idle
    				g_eT5TState = FRL152H_SELECTED_IDLE;
    				g_bT5TWaitForRsp = false;
    			}
    			break;
    		case FRL152H_POLL_DATA_READY:
    			eT5TStatus = NFC_RW_T5T_getReadSingleStatus();		// Fetch information about Read Single success/fail
    
    			if(eT5TStatus == NFC_RW_T5T_CONNECTION_READ_SINGLE_SUCCESS)
    			{
    				// This state handles checking Block 0 of the RF430FRL15xH to see when a conversion has been completed by the ADC.
    				// Only once a conversion is complete will the resulting ADC data be read out
    
    				NFC_RW_T5T_getPacketStatus(&pui8RxData,&ui8RxLength);		// Fetch the pointers to buffers in the T5T application file which contains
    																			// the received data (RxData) and received data length (RxLength)
    				memcpy(g_pui8T5TRxBuffer,pui8RxData+1,ui8RxLength-1);		// Use the pointers to copy the received buffer data into this application file
    
    				// Check the lowest two bits of the second byte of the received response to see if it's equal to 0x02 using the mask of 0x03 to mask out other irrelevant bits
    				if ((g_pui8T5TRxBuffer[1] & 0x03) == 0x02)
    				{
    					// Confirmed that data is ready
    					g_ui16T5TBlockNumber = 0x09;	// Data will be stored in Block 9, so set block 9 to be the next block to be read
    					g_eT5TState = FRL152H_READ_TEMP_DATA;	// Set state to Read Temp Data
    				}
    				else if ((g_pui8T5TRxBuffer[1] & 0x03) == 0x03)
    				{
    					// If equal to 0x03 - an error occurred, break from sequence
    					g_eT5TState = FRL152H_SELECTED_IDLE;	// Reset the state machine to Selected Idle
    				}
    				else
    				{
    					// Otherwise, wait and then keep polling for data
    					MCU_delayMillisecond(FRL15xH_POLL_BLOCK0_DELAY);	// Poll at a configurable 'frequency' to let FRL15xH sensor engine run
    																		// How often the tag is read is application specific. Delay is set to 100ms right now, but it could omitted all together.
    																		// The benefit of the delay is to minimize power drain on the passive tag since it doesn't have to reply to RF commands.
    					g_eT5TState = FRL152H_POLL_DATA_READY;	// Keep state set to the Poll Data Ready state
    				}
    				g_bT5TWaitForRsp = false;			// Always set wait for response to false
    			}
    			else if(eT5TStatus == NFC_RW_T5T_CONNECTION_READ_SINGLE_FAIL)
    			{	// No response received, reset the state machine to Selected Idle
    				g_eT5TState = FRL152H_SELECTED_IDLE;
    				g_bT5TWaitForRsp = false;
    			}
    			break;
    		case FRL152H_READ_TEMP_DATA:
    			eT5TStatus = NFC_RW_T5T_getReadSingleStatus();		// Fetch information about Read Single success/fail
    
    			if(eT5TStatus == NFC_RW_T5T_CONNECTION_READ_SINGLE_SUCCESS)
    			{
    				// This state handles receiving the read out data from the RF430FRL15xH tag and processing it
    				// It also provides a location to pass the received data back to the main application where it can be used for other purposes
    				// such as calculations.
    
    				NFC_RW_T5T_getPacketStatus(&pui8RxData,&ui8RxLength);		// Fetch the pointers to buffers in the T5T application file which contains
    																			// the received data (RxData) and received data length (RxLength)
    				memcpy(g_pui8T5TRxBuffer,pui8RxData+1,ui8RxLength-1);		// Use the pointers to copy the received buffer data into this application file
    
    				g_pui8T5TBuffer[0] = 0xAA;	// Set byte 0 of main.c buffer equal to 0xAA to indicate a successful temperature data read
    											// This is done as a means to check in main.c that a temperature data read occurred and the data is ready for processing
    											// Other implementations could be done, but this was a simple way to illustrate this as an example
    											// Another possible and more robust way would be to have a global flag and then a "GetFlag" function
    
    				memcpy(&g_pui8T5TBuffer[1],&g_pui8T5TRxBuffer[0],g_ui16T5TBlockSize);		// Copy contents of tag read over to main function through pointers
    																							// Only one block of data is copied over in this case, but if multiple
    																							// blocks are needed, then use a similar process such as what is done
    																							// in FRL152H_WRITE_CONFIG to increment blocks and read through multiple
    																							// blocks, and then adjust the Index of the g_pui8T5TBuffer based on the current
    																							// block number being read
    				// Return to idle state
    				g_eT5TState = FRL152H_SELECTED_IDLE;
    				g_bT5TWaitForRsp = false;
    			}
    			else if(eT5TStatus == NFC_RW_T5T_CONNECTION_READ_SINGLE_FAIL)
    			{	// No response received, reset the state machine to Selected Idle
    				g_eT5TState = FRL152H_SELECTED_IDLE;
    				g_bT5TWaitForRsp = false;
    			}
    			break;
    		case FRL152H_INVENTORY:
    			eT5TStatus = NFC_RW_T5T_getInventoryStatus();		// Fetch information about Inventory success/fail
    			if(eT5TStatus == NFC_RW_T5T_CONNECTION_INVENTORY_SUCCESS)
    			{
    				// Successful inventory means a tag was detected, now use Get System Information to determine if the tag is an RF430FRL15xH
    				g_eT5TState = FRL152H_GET_SYS_INFO;
    				g_bT5TWaitForRsp = false;
    			}
    			else
    			{	// No response received, reset the state machine to Selected Idle
    				g_eT5TState = FRL152H_SELECTED_IDLE;
    				g_bT5TWaitForRsp = false;
    			}
    			break;
    		case FRL152H_SELECTED_IDLE:
    			g_bT5TWaitForRsp = false;
    			break;
    		}
    	}
    
    	// Sending a command
    	if(g_bT5TWaitForRsp == false)
    	{
    		switch(g_eT5TState)
    		{
    		case FRL152H_INVENTORY:
    			// Basic inventory command, no changes will ever needed
    			if(NFC_RW_T5T_sendInventoryCmd(0x26,0x00,false) == STATUS_SUCCESS)
    			{
    				g_bT5TWaitForRsp = true;
    			}
    			break;
    		case FRL152H_GET_SYS_INFO:
    			// Basic Get System Information command, no changes will ever be needed
    			if(NFC_RW_T5T_sendGetSysInfoCmd((T5T_REQ_FLAG_HIGH_DATA | T5T_REQ_FLAG_ADDRESSED),0x2B) == STATUS_SUCCESS)
    			{
    				g_bT5TWaitForRsp = true;
    			}
    			break;
    		case FRL152H_WRITE_CONFIG:
    			// Write Configuration state which handles sending different chunks of configuration data to the RF430FRL152H based on the block number.
    			// For Block 0 and Block 2, specific data needs to be written for configuration
    			// For Block 1, and Blocks 3-7, the data needs to be all zeroes.
    			// This is handled by using the if statements to check the current BlockNumber and then send the right data based on it.
    			// The NFC_RW_T5T_sendWriteSingleCmd requires the following:
    			//   1. Request Flags, always should be High Data Rate and Addressed for this application
    			//   2. Block Number
    			//   3. Tag data - in this case they are predefined buffers such as RF430FRL152H_Block_0_Config or RF430FRL152H_Zeroes_Buffer
    			// 		  * This is where customizations can be made, any buffer can be sent whether its predefined as a const or a variable global buffer
    			//		  * For the case of the TI Sensor Patch, the configuration data always is the same, so predefined buffers made the most sense.
    			//   4. Tag data length - use the stored value for the tag block count which is g_ui16T5TBlockSize
    
    			if (g_ui16T5TBlockNumber == 0x00)
    			{
    				// Send Block 0 Config data
    				if(NFC_RW_T5T_sendWriteSingleCmd((T5T_REQ_FLAG_HIGH_DATA | T5T_REQ_FLAG_ADDRESSED),g_ui16T5TBlockNumber,RF430FRL152H_Block_0_Config,g_ui16T5TBlockSize) == STATUS_SUCCESS)
    				{
    					g_bT5TWaitForRsp = true;
    				}
    				else
    				{
    					g_eT5TState = FRL152H_SELECTED_IDLE;
    				}
    			}
    			else if (g_ui16T5TBlockNumber == 0x02)
    			{
    				// Send Block 2 Config data
    				if(NFC_RW_T5T_sendWriteSingleCmd((T5T_REQ_FLAG_HIGH_DATA | T5T_REQ_FLAG_ADDRESSED),g_ui16T5TBlockNumber,RF430FRL152H_Block_2_Config,g_ui16T5TBlockSize) == STATUS_SUCCESS)
    				{
    					g_bT5TWaitForRsp = true;
    				}
    				else
    				{
    					g_eT5TState = FRL152H_SELECTED_IDLE;
    				}
    			}
    			else
    			{
    				// Write all zeroes to the block
    				if(NFC_RW_T5T_sendWriteSingleCmd((T5T_REQ_FLAG_HIGH_DATA | T5T_REQ_FLAG_ADDRESSED),g_ui16T5TBlockNumber,RF430FRL152H_Zeroes_Buffer,g_ui16T5TBlockSize) == STATUS_SUCCESS)
    				{
    					g_bT5TWaitForRsp = true;
    				}
    				else
    				{
    					g_eT5TState = FRL152H_SELECTED_IDLE;
    				}
    			}
    			break;
    		case FRL152H_POLL_DATA_READY:
    			// Basic Read Single command, no changes should be needed, the Block Number is defined in the states when the g_bT5TWaitForRsp is set to true, but it could be hard coded instead.
    			if(NFC_RW_T5T_sendReadSingleCmd((T5T_REQ_FLAG_HIGH_DATA | T5T_REQ_FLAG_ADDRESSED),g_ui16T5TBlockNumber) == STATUS_SUCCESS)
    			{
    				g_bT5TWaitForRsp = true;
    			}
    			break;
    		case FRL152H_READ_TEMP_DATA:
    			// Basic Read Single command, no changes should be needed, the Block Number is defined in the states when the g_bT5TWaitForRsp is set to true, but it could be hard coded instead.
    			if(NFC_RW_T5T_sendReadSingleCmd((T5T_REQ_FLAG_HIGH_DATA | T5T_REQ_FLAG_ADDRESSED),g_ui16T5TBlockNumber) == STATUS_SUCCESS)
    			{
    				g_bT5TWaitForRsp = true;
    			}
    			break;
    		case FRL152H_SELECTED_IDLE:
    			// Set state back to the Inventory - otherwise T5T application will kick into a presense check state and the tag won't be able to be read unless
    			// it is removed from the RF field and then placed back. This will prevent any issues with that occurring due to read errors etc.
    			g_eT5TState = FRL152H_INVENTORY;
    			break;
    		}
    	}
    }
    

    tag_header.h

  • Hi Ralph

    Thanks your advice. May I get your comment for another question: How could I modify the firmware to disable WIFI task and only run NFC task? Because in my customer project, they just need NFC function without WIFI requirement this time.

    Now when I test our firmware, if I remove the CC3100 board, then the firmware will not respond to NFC tag anymore, it seems firmware suspend on WIFI some procedure and do not run NFC procedure. I hope modify the firmware could run NFC function normally, even if without CC3100 board.

  • I notice function HttpServerTaskFxn(UArg arg0, UArg arg1) include many LOOP_FOREVER() routine in WIFI task. After I disable such function, the NFC function seems run well, even if remove CC3100 board. So the question should be closed, thanks.
  • Hi Ralph

    Sorry come back to you, I try to read a Customer ISO15693 Card, however always not correct data, could you help a look.

    1, Customer use MSP430 + TRF7970 demo to read their card, and will output correct card data as below picture,

    2, when use TIVAM4 + TRF7970 demo to read the same card, the "g_pui8T5TRxBuf" content is as below value but not card data. 

        what operation I do wrong? customer is urgently implement NFC reader prototype by M4 + 7970.

  • Hello Terry,

    The second screenshot doesn't tell me much. Can you convert the displayed data of the g_pui8T5TRxBuf to hex? I can't really tell what the data received is if it isn't in hex form.

  • Ralph

    Firstly the code execute "case T5T_READ_CC: " routine , the g_pui8T5TRxBuf value will change as below:

      

    Then the code will execute "case T5T_READ_DATA: " routine for 1st time, the g_pui8T5TRxBuf value will change as below:

    Next the code will execute "case T5T_READ_DATA:" routine for 2nd time,  the g_pui8T5TRxBuf value will change as below:

    Last the code will execute "case T5T_READ_DATA:" routine for 3th time,  the g_pui8T5TRxBuf value will change as below:

    After above, even the code will execute "case T5T_READ_DATA:" routine again and again,  the g_pui8T5TRxBuf value will clear to zero without any change.

    could you help teach me how to know the meaning for the data value?

  • Hello Fares,

    The application that is being run is for reading NDEF formatted ISO15693 tags. Is that what they are trying to do? It doesn't seem so.

    You mentioned the RF430FRL152H, which would not be an NDEF formatted ISO15693 tag. Is that what they are trying to interface with, or is it some other NFC tags?

    What I see from the Screenshots is that the firmware is attempting to read the Capability Container, but the data is not formatted correctly for NDEF, so it isn't able to pull out much data.

    Depending on their application, modifications will need to be made to the NFC T5T state machine. If they want to work with the RF430FRL152H, please use the state machine firmware I provided.

    If they want to do some proprietary ISO15693 application that doesn't use NDEF formatting, then you would take the existing state machine and modify it to match their needs.
  • Hi Ralph

    Customer is trying to interface with some other NFC tags which they buy from market. They tell me it is ISO15693 tag.

    And they also try to read the tag with MSP430+TRF7970 TI demo, and output data as below capture. Is it not a really ISO15693 tag?

    If it is a proprietary ISO15693 tag without NDEF formatting, any method or tools can help us check the proprietary flow so that we could modify T5T code according? 

  • Hello Terry,

    That screenshot shows the Tag UID being read, not any data. That occurs automatically when activating the tag and the UID can be accessed by using the NFC_RW_T5T_getT5TUID API. If you want to show them you can pull that same UID data out, then you can use that API to achieve that.

    For reading further data from the tag, there isn't a defined flow for reading proprietary ISO15693 tags... every application has to define what that looks like individually. From a command perspective, you would be using either Read Single Block, or if the tag supports it, Read Multiple Block ISO15693 commands. Which blocks need to be read and how much data needs to be read will depend on what and how data is stored. They can define that on both the tag and the reader side to customize their application.

    Per our Reader/Writer app note (www.ti.com/.../sloa227.pdf) about Type 5 Tag memory formats:
    "Type 5 tags have a block memory format where each block can contain either four or eight bytes of data.
    The blocks are numbered starting at Block 0. Blocks can be read with the Read Single Block command or
    with the Read Multiple Blocks command if the Type 5 tag supports that command."

    FYI - the lack of existing flow and the need for every application to be unique is a large reason as to why the NDEF format was eventually created. Since it defines how to pull different data types from tags including ISO15693, we are at least able to provide that example as a flow for pulling data out of ISO15693 tags. Text messages, URLs, and even MIME images are supported by this, so depending on what data they want to transfer with NFC, it might be worthwhile for them to use NDEF.

    You will need to discuss these details with the customer and find out what their application looks like.
  • Ralph

    Thanks your detail advice.

    I try to use NFC_RW_T5T_getT5TUID as your say, and read back the value as below picture, it seem not correct UID value, does I put API in wrong position?

    And I ask customer double confirm whether their NFC card is ISO15693. They feedback me it indeed is ISO15693 card, but maybe proprietary data flow. At present, they hope our sample code at least could read correct UID value, how I should use the "NFC_RW_T5T_getT5TUID" in the code?

  • Hello Terry,

    Certainly. Proving we can get the tag UID is a very reasonable request and we definitely can do this!

    I think you have the function in the right place, so I think this may be just a matter of getting CCS to display the data correctly.

    What I do is:

    • Put a breakpoint beyond that function call
    • Add pui8RxData to the Expressions tab
    • Right click pui8RxData in that tab and select 'Display as Array', choose a length of at least 8 bytes (8 byte UID)
    • Right click pui8RxData again and select Number Format -> Hex

    Then the data should be displayed in the Expressions tab, as long as it was received correctly.

    See below Screenshot (don't mind my CCS color scheme... customized it haha):

  • the card you showed being read out in the first screen shot is NXP ISO15693 card. You show the UID + the RSSI value (of the tag) returned by the TRF79xxA. in your case 0x6D means its pretty close to the antenna, as this value ranges between 0x40 and 0x7F.  

    it (the UID) is not being represented correctly in that GUI - the ISO15693 standard requires that the UID starts with 0xE0, next byte is the registered one byte manufacturer code (this is from ISO7816-6). this field being 0x04 indicates NXP (formerly Philips) and the attached document shows you the rest of the byte meanings - with our manufacturing byte shown (TI = 0x07)

    so to be clear, the correct representation of the UID of the tag you are using is: E00401505F8A4A2E

    UID Explained.pdf