DLP-RF430BP: RF430BP: Interface issue

I am using launchpad MSP-EXP430G2 

Micro controller: M430G2553

Tested on example code shared by TI. 

---------------------------------------------------------

code

-----------------------------------------------------

/*
 * {main.c}
 *
 * {main application}
 *
 * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *
 * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the
 * distribution.
 *
 * Neither the name of Texas Instruments Incorporated nor the names of
 * its contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
//******************************************************************************
// RF430 NFC Booster Pack (Host/Master)
//
// RF430 User Address Map
// -----------------------------------------
// Address | Size | Description |
// -----------------------------------------
// 0xFFFE | 2B | Control Register |
// 0xFFFC | 2B | Status Register |
// 0xFFFA | 2B | Interrupt Enable |
// 0xFFF8 | 2B | Interrupt Flags |
// 0xFFF6 | 2B | CRC Result |
// 0xFFF4 | 2B | CRC Length |
// 0xFFF2 | 2B | CRC Start Address |
// 0xFFF0 | 2B | Comm WD Ctrl Reg |
// -----------------------------------------
// 0x0000 - | 2kB | NDEF App Memory |
// 0x07FF | | |
//
// Description: This demo demonstrates RF430 read/write accesses via the I2C bus.
// This is the code for the tester/host processor, which is the MASTER. This master
// can send read and write commands over I2C to access the data structure in the
// RF430 device. The following formats are used:
//
// Write Access:
// The master transmits a 2 byte address, then transmits N 16 bit values MSB first
// to be stored by RF430 in locations starting at this address and incrementing.
//
// Read Access:
// The master transmits a 2 byte address, then receives back from RF430
// the two bytes RF430 has stored at this location, MSB first.
//
// Continuous Read Access:
// The master receives the N bytes stored in RF430 starting at the next address
// (next address = the last accessed address + 2) and incrementing, MSB first.
//
//
// /|\ /|\ (Host/Tester)
// RF430 10k 10k MSP430G2553
// (Slave) | | Master
// _________________ | | _________________
// | SDA|<-|----+->|P1.7/UCB0SDA XIN|-+
// | | | I2C | |
// | SCL|<-+------>|P1.6/UCB0SCL XOUT|-
// | | | |
// GND<--|E(2-0) /RST|<---------|P1.3* | (* NOTE: Will be moved on next hardware revision.)
// | INTO|--------->|P2.7* |
// | | | P1.0|---->LED1
// | | | |
// |_________________| |_________________|
//
// Built with CCSv5.2
//******************************************************************************

#include "msp430.h"
#include "RF430_example.h"
#include "string.h"

unsigned char RF430_DEFAULT_DATA[] = {
		/*NDEF Tag Application Name*/
		0xD2, 0x76, 0x00, 0x00, 0x85, 0x01, 0x01,
		/*Capability Container ID*/
		0xE1, 0x03,
		0x00, 0x0F, /* CCLEN */
		0x20, /* Mapping version 2.0 */
		0x00, 0xF9, /* MLe (49 bytes); Maximum R-APDU data size */
		0x00, 0xF6, /* MLc (52 bytes); Maximum C-APDU data size */
		0x04, /* Tag, File Control TLV (4 = NDEF file) */
		0x06, /* Length, File Control TLV (6 = 6 bytes of data for this tag) */
		0xE1, 0x04, /* File Identifier */
		0x0B, 0xDF, /* Max NDEF size (3037 bytes of useable memory) */
		0x00, /* NDEF file read access condition, read access without any security */
		0x00, /* NDEF file write access condition; write access without any security */

		/* NDEF File ID */
		0xE1, 0x04,

		/* NDEF File for Hello World */
		0x00, 0x14, /* NLEN: NDEF length (20 byte long message, max. length for RF430CL) */

		/* NDEF Record (refer to NFC Data Exchange Format specifications)*/
		0xD1, /*MB(Message Begin), SR(Short Record) flags set, ME(Message End), IL(ID length field present) flags cleared; TNF(3bits) = 1; */ \
		0x01, 0x10, /*Type Length = 0x01; Payload Length = 0x10 */
		0x54, /* Type = T (text) */
		0x02, /* 1st payload byte: "Start of Text", as specified in ASCII Tables */
		0x65, 0x6E, /* 'e', 'n', (2nd, 3rd payload bytes*/

		/* 'Hello, world!' NDEF data*/
		/* 0x48, 0x65, 0x6C, 0x6C, 0x6f, 0x2c, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x21 */
		/* ACB NFC DEM0 */
		0x41, 0x43, 0x42, 0x20, 0x4E, 0x46, 0x43, 0x20, 0x44, 0x45, 0x4D, 0x4F, 0x20
}; /* End of data */

void Update_NDEF(void);
//RF430_DEFAULT_DATA
unsigned char NDEF_Application_Data[100];// = RF430_DEFAULT_DATA;

unsigned char test_data[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};

unsigned char CRC_Data[] = {1,2,3,4,5,6,7,8,9};

unsigned char Cmd = 0; //Command byte for SPI mode
unsigned char read_complete = 0;
unsigned char rx_byte_count = 0;
unsigned char tx_byte_count = 0;
unsigned int Results[11] = {0,0,0,0,0,0,0,0,0,0,0};


char string1[] = "ZXC Bacdefgh uioprtyg \n";
char para1[] = "X phase :";
char para2[] = "Y Phase :";
char para3[] = "Z Phase :";


#define FixValue 1000
unsigned int val = FixValue;
unsigned char CTRatio = 1;
unsigned int temp_val = 0;
unsigned int temp_val_shift = 0;
unsigned int buff = 0;

char cnt = 0 ;
unsigned int Total_length = 0;
unsigned int size = 0 ;


/*
char val1[] = 1000";
char val2[] = "1000";
char val3[] = "1000";

#define SIZE1 strlen(string1)
#define SIZE1 strlen(string1) + strlen(para1)
 */
/****************************************************************************/
/* Code-binary that opens on ETW and re-trims LF oscillator to below 280kHz */
/****************************************************************************/
unsigned char func_retrim_osc[] = {
		0xB2, 0x40, 0x11, 0x96, 0x10, 0x01,
		0xB2, 0x40, 0x60, 0x03, 0x18, 0x01,
		0x30, 0x41
};

unsigned int temp = 0;
unsigned char into_fired = 0;

unsigned char read_data[200];

void main (void)
{
	volatile unsigned int test = 0;
	unsigned int flags = 0;
	unsigned int temp = 0;
	//unsigned char read_data[200];

	WDTCTL = WDTPW + WDTHOLD; // Turn off Watch Dog

	if (CALBC1_8MHZ==0xFF) // If calibration constant erased
	{
		while(1); // Do not load, trap CPU!!
	}
	BCSCTL1 = CALBC1_8MHZ; // Set range
	DCOCTL = CALDCO_8MHZ; // SMCLK = MCLK = DCO = 8 MHz ACLK = LF oscillator

	// Configure pins for I2C
	PORT_I2C_SEL0 |= (SCL + SDA); // Selecting I2C pin function
	PORT_I2C_SEL1 |= (SCL + SDA);

	//configure USCI for I2C
	UCB0CTL1 |= UCSWRST; // Software reset enabled
	UCB0CTL0 |= UCMODE_3 + UCMST + UCSYNC; // I2C mode, Master mode, sync
	UCB0CTL1 |= UCSSEL_3 + UCTR; // SMCLK = 8MHz, transmitter
	UCB0BR0 = 80; // Baudrate = SMLK/80 = 100kHz
	UCB0I2CSA = 0x0028; // slave address - determined by pins E0, E1, and E2 on the RF430CL330H
	UCB0CTL1 &= ~UCSWRST; // Software reset released


	// RST RF430 (in case board remained powered but the MSP430 reset for some reason - MSP430 RST button pushed for example)
	PORT_RST_SEL0 &= ~RST; // Setting as GPIO pin functionality
	PORT_RST_SEL1 &= ~RST;
	PORT_RST_OUT &= ~RST;
	PORT_RST_DIR |= RST; // RF430CL330H device in Reset
	__delay_cycles(1000);
	PORT_RST_OUT |= RST; // Release the RF430CL330H from Reset

	//configure LED1
	PORT_LED_SEL0 &= ~LED1; // Confirming GPIO pin functionality
	PORT_LED_SEL1 &= ~LED1;
	PORT_LED_DIR |= LED1; // Set as Output
	PORT_LED_OUT &= ~LED1; // Start LED off


	//configure P1.1
	PORT_LED_SEL0 &= ~BIT1; // Confirming GPIO pin functionality
	PORT_LED_SEL1 &= ~BIT1;
	PORT_LED_DIR |= BIT1; // Set as Output
	//PORT_LED_OUT &= ~BIT1; // Start LED off
	PORT_LED_OUT |= BIT1;


	//configure pin for INTO interrupt
	PORT_INTO_SEL0 &= ~INTO; // Confirming GPIO pin functionality
	PORT_INTO_SEL1 &= ~INTO;
	PORT_INTO_DIR &= ~INTO; // Set as Input
	PORT_INTO_OUT |= INTO; // Set output register high
	PORT_INTO_REN |= INTO; // Internal pull-up resistor
	PORT_INTO_IFG &= ~INTO; // Clear interrupt flag
	PORT_INTO_IES |= INTO; // Set interrupt trigger as high-to-low transition, since INTO will be setup active low below



	//__delay_cycles(4000000); // Leave time for the RF430CL33H to get itself initialized; should be 20ms or greater
	__delay_cycles(160000); // Leave time for the RF430CL33H to get itself initialized; should be 20ms or greater


	while(!(Read_Register(STATUS_REG) & READY)); // Wait until READY bit has been set

	/****************************************************************************/
	/* This code is used to change data rate capability */
	/****************************************************************************/

	// Write_Register(TEST_MODE_REG, TEST_MODE_KEY); //unlock test mode
	// Write_Register(CONTROL_REG, TEST430_ENABLE); //enable test mode, now have to use actual addresses
	// Write_Register(0x2a7C, 0xF7); //the bit rate capability setting, 0xF7=848kbits
	// Write_Register(0x2814, 0); //exit test mode (CONTROL_REG is at real address 0x2814)
	// Write_Register(TEST_MODE_REG, 0); //exiting this mode, RF is disabled as Control register is set to 0


	/****************************************************************************/
	/* Configure RF430CL330H for Typical Usage Scenario */
	/****************************************************************************/


	for(cnt= 0; cnt < 45;cnt++)
	{
		NDEF_Application_Data[cnt] = RF430_DEFAULT_DATA[cnt];
	}

	Update_NDEF();
	//write NDEF memory with Capability Container + NDEF message
	Write_Continuous(0, NDEF_Application_Data, 100);//48

	//Enable interrupts for End of Read and End of Write
	Write_Register(INT_ENABLE_REG, EOW_INT_ENABLE + EOR_INT_ENABLE);

	//Configure INTO pin for active low and enable RF
	Write_Register(CONTROL_REG, INT_ENABLE + INTO_DRIVE + RF_ENABLE);

	PORT_INTO_IFG &= ~INTO; //clear any pending flags
	PORT_INTO_IE |= INTO; //enable interrupt

	while (1)
	{


		PORT_LED_OUT &= ~BIT1; // Start LED off
		// PORT_LED_OUT |= BIT1;


		__bis_SR_register(LPM3_bits + GIE); //go to low power mode and enable interrupts. We are waiting for an NFC read or write of/to the RF430
		__no_operation();

		//device has woken up, check status
		if(into_fired)
		{
			//before we read/write to RF430CL330H we should disable RF
			Write_Register(CONTROL_REG, INT_ENABLE + INTO_DRIVE); //clear control reg to disable RF
			__delay_cycles(750000);
			flags = Read_Register(INT_FLAG_REG); //read the flag register to check if a read or write occurred
			Write_Register(INT_FLAG_REG, EOW_INT_FLAG + EOR_INT_FLAG); //ACK the flags to clear

			Write_Register(INT_ENABLE_REG, 0);


			PORT_LED_OUT &= ~LED1; //clear LEDs

			if(flags & EOW_INT_FLAG) //check if the tag was written
			{
				//tag was updated, so we should read out the new data
				//read out the data
				Read_Continuous(0, read_data, 200);
				__no_operation(); //breakpoint here to examine the data
				CTRatio = read_data[35]-48;
				if(CTRatio>9)
					CTRatio = 1;
				if(CTRatio==0)
					CTRatio = 1;
				buff = 0;
				val = FixValue * CTRatio;
				Update_NDEF();
				Write_Continuous(0, NDEF_Application_Data, 100);


				//show that tag was written by blinking LED 3 times
				for(temp = 0; temp < 3; temp++){
					PORT_LED_OUT |= LED1;
					__delay_cycles(3000000);
					PORT_LED_OUT &= ~LED1;//clear LED
					__delay_cycles(3000000);
				}
			}
			else if(flags & EOR_INT_FLAG) //check if the tag was read
			{
				__no_operation();

				//show that tag was read with LED by holding it on for 1 second
				PORT_LED_OUT |= LED1;
				__delay_cycles(8000000);
				PORT_LED_OUT &= ~LED1;//clear LED
				PORT_LED_OUT |= BIT1;
				// PORT_LED_OUT &= ~BIT1; // Start LED off
				// NDEF_Application_Data[47]= 65 + temp;
				if(buff>=50)
				{
					buff = 0;
					//val = FixValue * CTRatio;
				}
				else
					buff= buff+10;

				val = (FixValue * CTRatio) + buff;
				Update_NDEF();
				Write_Continuous(0, NDEF_Application_Data, 100);

			}

			flags = 0;
			into_fired = 0; //we have serviced INTO

			//Enable interrupts for End of Read and End of Write
			Write_Register(INT_ENABLE_REG, EOW_INT_ENABLE + EOR_INT_ENABLE);
			test = Read_Register(INT_ENABLE_REG);
			//Configure INTO pin for active low and re-enable RF
			Write_Register(CONTROL_REG, INT_ENABLE + INTO_DRIVE + RF_ENABLE);

			//re-enable INTO
			PORT_INTO_IFG &= ~INTO;
			PORT_INTO_IE |= INTO;

			__no_operation();
		}
	}
}

void Update_NDEF(void)
{
	//strcat(NDEF_Application_Data, RF430_DEFAULT_DATA);

	size = 35;
	for(cnt= 0; cnt < strlen(string1);cnt++)
	{
		NDEF_Application_Data[size+cnt] = string1[cnt];
	}

	size = size + strlen(string1) ;
	for(cnt= 0; cnt < strlen(para1);cnt++)
	{
		NDEF_Application_Data[size+cnt] = para1[cnt];
	}
	temp_val_shift = val;
	temp_val= (val%10);
	NDEF_Application_Data[size+cnt+3] = temp_val + 48;

	temp_val_shift= (temp_val_shift/10);
	temp_val= (temp_val_shift%10);
	NDEF_Application_Data[size+cnt+2] = temp_val + 48;

	temp_val_shift= (temp_val_shift/10);
	temp_val= (temp_val_shift%10);
	NDEF_Application_Data[size+cnt+1] = temp_val + 48;

	temp_val_shift= (temp_val_shift/10);
	temp_val= (temp_val_shift%10);
	NDEF_Application_Data[size+cnt] = temp_val + 48;



	NDEF_Application_Data[size+cnt+4] = '\n';

	size = size + strlen(para1)+ 5 ;
	for(cnt= 0; cnt < strlen(para2);cnt++)
	{
		NDEF_Application_Data[size+cnt] = para2[cnt];
	}

	temp_val_shift = val;
	temp_val= (val%10);
	NDEF_Application_Data[size+cnt+3] = temp_val + 48;

	temp_val_shift= (temp_val_shift/10);
	temp_val= (temp_val_shift%10);
	NDEF_Application_Data[size+cnt+2] = temp_val + 48;

	temp_val_shift= (temp_val_shift/10);
	temp_val= (temp_val_shift%10);
	NDEF_Application_Data[size+cnt+1] = temp_val + 48;

	temp_val_shift= (temp_val_shift/10);
	temp_val= (temp_val_shift%10);
	NDEF_Application_Data[size+cnt] = temp_val + 48;



	NDEF_Application_Data[size+cnt+4] = '\n';

	size = size + strlen(para2)+ 5 ;
	for(cnt= 0; cnt < strlen(para3);cnt++)
	{
		NDEF_Application_Data[size+cnt] = para3[cnt];
	}

	NDEF_Application_Data[size+cnt] = val>>4 ;//(val-(val/10)*10)+30;

	temp_val_shift = val;
	temp_val= (val%10);
	NDEF_Application_Data[size+cnt+3] = temp_val + 48;

	temp_val_shift= (temp_val_shift/10);
	temp_val= (temp_val_shift%10);
	NDEF_Application_Data[size+cnt+2] = temp_val + 48;

	temp_val_shift= (temp_val_shift/10);
	temp_val= (temp_val_shift%10);
	NDEF_Application_Data[size+cnt+1] = temp_val + 48;

	temp_val_shift= (temp_val_shift/10);
	temp_val= (temp_val_shift%10);
	NDEF_Application_Data[size+cnt] = temp_val + 48;



	//DEF_Application_Data[size+cnt] = (val-(val/10)*10)+30;

	NDEF_Application_Data[size+cnt+4] = '\n';


	Total_length = strlen(string1) + strlen(para1) + strlen(para2) + strlen(para3) + 15 ;

	NDEF_Application_Data[27] = Total_length+6;
	NDEF_Application_Data[30] = Total_length-4+6;

}
#pragma vector=PORT2_VECTOR
__interrupt void PORT2_ISR(void)
{
	//INTO interrupt fired
	if(PORT_INTO_IFG & INTO)
	{

		into_fired = 1;

		PORT_INTO_IE &= ~INTO; //disable INTO
		PORT_INTO_IFG &= ~INTO; //clear interrupt flag

		__bic_SR_register_on_exit(LPM3_bits); //wake up to handle INTO
	}
}

#pragma vector = PORT1_VECTOR,ADC10_VECTOR,WDT_VECTOR,NMI_VECTOR,TIMER0_A1_VECTOR, \
		TIMER0_A0_VECTOR, COMPARATORA_VECTOR, TIMER1_A1_VECTOR, TIMER1_A0_VECTOR, \
		USCIAB0TX_VECTOR, USCIAB0RX_VECTOR
__interrupt void ISR_trap(void)
{
	while(1); // IT'S A TRAP!!!
}

Hello Anil,

It looks like you made a number of customizations to the firmware. If you use the base firmware straight from the web, do you get any better results?

What app are you using on the Sony Xperia?

Can you read other tags/devices with the Sony Xperia (this would confirm NFC communication is on and working)?

Regarding the question from your original post about the Handshaking process, Figure 3 in our Target board user guide gives a high level view: http://www.ti.com/lit/ug/slou373a/slou373a.pdf If you want further details you need to look into ISO14443-3, ISO14443-4 Part B, and NFC Forum NDEF standards.

Note that our device is fully NFC compliant, and we passed certification with it: http://www.ti.com/lit/ml/slal211/slal211.pdf

Dear Jacobi,

Thanks for your reply. 

I am using "NFC tools" android application 

I would like to update you,

1. In Launchpad , If all EMULATION board jumpers (J3) are shorted : and communicating with smart phone  without usb power supply, It is not communicating. Why?

2. In Launchpad , If all EMULATION board jumpers (J3) are opened : and communicating with smart phone  without usb power supply, It is not communicating up to range 2-3 cm but response time is 2 to 10 sec (sometime its more higher) for 80-100 bytes data.  why?

3. What is role of line of sight during communication?

4. Can i perform read write operation sequentially in NDEF memory using smart phone android application? If yes then How?

The reason case 1 occurs for you is that the LaunchPad is messing with your setup. It's not well designed for such an application, and thus when the emulator circuit is connected via J3, the Emulation circuit is siphoning all the energy from the RF field, preventing the MSP430 from powering on!

1. what is the current consumption of emulator circuit?

2. can you suggest any device for my application ? 

Application: 

RFID transponder IC for NFC communication which

1. Can be powered up by any smart phone or active write read device.
2. Supporting range >5cm
3. Also please suggest the supporting Antenna which is capable to  transfer >100mW power from smart phone to passive device ( electronics  circuit board   + NFC tag).

For case 2, the issue you are facing now is that the example you are using, even after the modifications you made, is not in any way power optimized. To operate with Android smartphones, you need to have the MSP430 power optimized and minimize the current draw from the device by having it in low power mode as much as possible. We don't have an example on the LaunchPad which does that though, our examples for power optimization are for our TI designs which use FRAM MSP430's.

Can you share maximum power transfer data from smart phone to  development board (without USB power)?

For question 3, not sure I fully understand, but if you are talking about read range and/or orientation, HF RFID/NFC is based on magnetic fields, so communication requires good coupling between the antenna coils of the tag and the reader. Therefore aligning them in parallel and without large distance between them is important to get the best inductive coupling results.

Can you share any NFC standards regarding range and alignment ?

For question 4, I don't understand your question. I use NFC Tools app myself and it reads and writes just like it's supposed to, is there different behavior you want from it, or are you having a problem with just reading or writing?

while communicating the NFC launch pad with NFC TOOL (android application with Sony xperia M smart phone)  with usb supply , it is observed that

if i place NFC enabled smart phone near the  NFC device (TI NFC launchpad) then , upto 5 second , it is able to read data from NFC device. But at same time and same position using NFC tool application (I was using at the time of experiment), if i try to write any data to TI NFC launchpad then it is not writing.  But if i comes out from field and again send write command  from NFC tool and comes near the TI NFC launchpad then its write successfully. Why?