Other Parts Discussed in Thread: TRF7960
i am useing trf7960 reader ic to detect rfid card . i have texas's rfid reader kit .useing my code (after additing only some port pin defination because i use other pin for iar and dataclk) i can detect card on texas refrence kit . but same logic i cant detect card on my board so what should be the problem???????//
here i attech my schemetic and code file..... please help me....
..
#include <MSP430x22x2.h>
#include "hardware.h"
// =======================================================================
#define BUF_LENGTH 100 //Number of characters in a frame
#define EnableInterrupts _EINT()
char rxdata; //RS232 RX data byte
unsigned char buf[BUF_LENGTH];
signed char RXTXstate; //used for transmit recieve byte count
unsigned char flags; //stores the mask value (used in anticollision)
unsigned char RXErrorFlag;
unsigned char RXflag; //indicates that data is in buffer
unsigned char i_reg; //interrupt register
unsigned char CollPoss;
unsigned char uid[10];
unsigned char i;
unsigned char RXdone;
unsigned char ENABLE;
unsigned char POLLING;
unsigned char Register[10];
unsigned char command[10];
#define BAUD0 0x3A //baud rate generator = 115200 for 6.78 MHz Clock
#define BAUD1 0x00
#define BAUD0EN 0x2B //baud rate for DCO = 4.9MHz
#define BAUD1EN 0x00
// =========================================================================
// Main function with init and an endless loop
//
//
void InventoryRequest(unsigned char *mask, unsigned char lenght);
void EnableSlotCounter(void);
void DisableSlotCounter(void);
void WriteSingle(unsigned char *pbuf, unsigned char lenght);
void WriteCont(unsigned char *pbuf, unsigned char lenght);
void ReadSingle(unsigned char *pbuf, unsigned char lenght);
void ReadCont(unsigned char *pbuf, unsigned char lenght);
void DirectCommand(unsigned char *pbuf);
void RAWwrite(unsigned char *pbuf, unsigned char lenght);
void delay_ms(unsigned int n_ms);
void CounterSet(void);
void PARset(void)
{
TRFDirOUT; /* P4 output */
TRFFunc;
TRFWrite = 0x00; /* P4 set to 0 - choose parallel inteface for the TRF796x */
clkOFF;
clkPOUTset; /* DATA_CLK on P3.3 */
irqPINset;
irqEDGEset; /* rising edge interrupt */
}
void InitialSettings(void)
{
/*~~~~~~~~~~~~~~~~~~~~~~~*/
unsigned char command[2];
/*~~~~~~~~~~~~~~~~~~~~~~~*/
command[0] = ModulatorControl;
command[1] = 0x20; //6.78 MHz
// command[1] = 0x31; //13.56 MHz
WriteSingle(command, 2);
}
void OSCsel(unsigned char mode)
{
unsigned int ii1;
if(mode == 0x00){ //select crystal oscilator
BCSCTL1 |= XTS + XT2OFF; // ACLK = LFXT1 HF XTAL
BCSCTL3 |= LFXT1S1+LFXT1S0; // 3 � 16MHz crystal or resonator
// turn external oscillator on
do
{
IFG1 &= ~OFIFG; // Clear OSCFault flag
for (ii1 = 0xFF; ii1 > 0; ii1--); // Time delay for flag to set
}
while ((IFG1 & OFIFG) == OFIFG); // OSCFault flag still set?
BCSCTL2 |= SELM1 + SELM0 + SELS; // MCLK = SMCLK = HF LFXT1 (safe)
return;
}
else{ //select DCO for main clock
DCOCTL |= DCO0 + DCO1 + DCO2;
BCSCTL1 |= XT2OFF + XTS + RSEL0 + RSEL1 + RSEL2;
// turn external oscillator on
// do
// {
// IFG1 &= ~OFIFG; // Clear OSCFault flag
// for (ii1 = 0xFF; ii1 > 0; ii1--); // Time delay for flag to set
// }
// while ((IFG1 & OFIFG) == OFIFG); // OSCFault flag still set?
BCSCTL2 &= ~(SELM1 + SELM0 + SELS + DCOR);
return;
}
//_BIC_SR(OSCOFF);
}
unsigned char FindTags(unsigned char protocol)
{
while(1)
{
// ISO15693 //
command[0] = ChipStateControl; // turn on RF driver
command[1] = 0x20;
command[2] = ISOControl; // set register 0x01 for ISO15693 operation
command[3] = 0x02;
WriteSingle(command, 4);
delay_ms(5);
flags = 0x06; // 16 slots
//flags = 0x26; //1 slot
command[0] = 0x00;
InventoryRequest(command, 0); // send Inventory request //
command[0] = ChipStateControl; // turn off RF driver //
command[1] = 0x01;
WriteSingle(command, 2);
delay_ms(1);
command[0] = IRQStatus;
command[1] = IRQMask;
ReadSingle(command, 1);
} /* while */
} /* FindTags */
void InventoryRequest(unsigned char *mask, unsigned char lenght) /* host command 0x14 */
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
/* 010800030414(req.packet)[00ff] */
unsigned char i = 1, j = 3, NoSlots;
unsigned char *PslotNo, slotNo[17];
unsigned char NewMask[8], NewLenght, masksize;
int size;
unsigned int k = 0;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//added code
buf[0] = ModulatorControl;
buf[1] = 0x20;
WriteSingle(buf, 2);
//end added code
slotNo[0] = 0x00;
if((flags & BIT5) == 0x00)
{ /* flag bit5 is the number of slots indicator */
NoSlots = 17; /* 16 slots if bit is cleared */
EnableSlotCounter();
}
else
NoSlots = 2; /* 1 slot if bit is set */
PslotNo = &slotNo[0]; /* slot number pointer */
masksize = (((lenght >> 2) + 1) >> 1); /* masksize is 1 for lenght = 4 or 8 */
/*
* masksize is 2 for lenght = 12 or 16 ;
* and so on
*/
size = masksize + 3; /* mask value + mask lenght + command code + flags */
buf[0] = 0x8f;
buf[1] = 0x91; /* send with CRC */
buf[2] = 0x3d; /* write continous from 1D */
buf[3] = (char) (size >> 8);
buf[4] = (char) (size << 4);
buf[5] = flags; /* ISO15693 flags */
buf[6] = 0x01; /* anticollision command code */
//optional AFI should be here
buf[7] = lenght; /* masklenght */
if(lenght > 0)
{
for(i = 0; i < masksize; i++) buf[i + 8] = *(mask + i);
} /* if */
command[0] = IRQStatus;
command[1] = IRQMask; //Dummy read
ReadCont(command, 1);
CounterSet(); /* TimerA set */
countValue = count1ms * 20; /* 20ms */
irqCLR; /* PORT2 interrupt flag clear */
irqON;
RAWwrite(&buf[0], masksize + 8); /* writing to FIFO */
i_reg = 0x01;
startCounter; /* start timer up mode */
LPM0; /* wait for end of TX interrupt */
for(i = 1; i < NoSlots; i++)
{ /* 1 or 16 available timeslots */
RXTXstate = 1; /* prepare the global counter */
/* the first UID will be stored from buf[1] upwards */
CounterSet(); /* TimerA set */
//countValue = count1ms * 20; /* 20ms */
countValue = 0x4E20;
startCounter; /* start timer up mode */
k = 0;
LPM0;
while(i_reg == 0x01)
{ /* wait for RX complete */
k++;
if(k == 0xFFF0)
{
i_reg = 0x00;
RXErrorFlag = 0x00;
break;
}
}
command[0] = RSSILevels; /* read RSSI levels */
ReadSingle(command, 1);
if(i_reg == 0xFF)
{ /* recieved UID in buffer */
for(j = 3; j < 11; j++)
{
//Put_byte(buf[j]);
}
i=0;
for(j=10; j>=3;j--)
{
uid[i]=buf[j];
i++;
}
}
else if(i_reg == 0x02)
{ /* collision occured */
PslotNo++;
*PslotNo = i;
}
else if(i_reg == 0x00)
{ /* timer interrupt */
}
else
;
command[0] = Reset; /* FIFO has to be reset before recieving the next response */
DirectCommand(command);
if((NoSlots == 17) && (i < 16))
{ /* if 16 slots used send EOF(next slot) */
command[0] = StopDecoders;
DirectCommand(command);
command[0] = RunDecoders;
DirectCommand(command);
//while(1)
// {
command[0] = TransmitNextSlot;
DirectCommand(command);
// }
}
else if((NoSlots == 17) && (i == 16))
{ /* at the end of slot 16 stop the slot counter */
DisableSlotCounter();
}
else if(NoSlots == 2)
break;
} /* for */
NewLenght = lenght + 4; /* the mask lenght is a multiple of 4 bits */
masksize = (((NewLenght >> 2) + 1) >> 1) - 1;
while((*PslotNo != 0x00) && (NoSlots == 17))
{
*PslotNo = *PslotNo - 1;
for(i = 0; i < 8; i++) NewMask[i] = *(mask + i); /* first the whole mask is copied */
if((NewLenght & BIT2) == 0x00) *PslotNo = *PslotNo << 4;
NewMask[masksize] |= *PslotNo; /* the mask is changed */
InventoryRequest(&NewMask[0], NewLenght); /* recursive call */
PslotNo--;
} /* while */
irqOFF;
} /* InventoryRequest */
void EnableSlotCounter(void)
{
buf[41] = IRQMask; /* next slot counter */
buf[40] = IRQMask;
ReadSingle(&buf[41], 1);
buf[41] |= BIT0; /* set BIT0 in register 0x01 */
WriteSingle(&buf[40], 2);
}
void DisableSlotCounter(void)
{
buf[41] = IRQMask; /* next slot counter */
buf[40] = IRQMask;
ReadSingle(&buf[41], 1);
buf[41] &= 0xfe; /* clear BIT0 in register 0x01 */
WriteSingle(&buf[40], 2);
}
/*
=======================================================================================================================
=======================================================================================================================
*/
void STOPcondition(void)
{
TRFWrite |= 0x80; /* stop condition */
clkON;
TRFWrite = 0x00;
clkOFF;
} /* STOPcondition */
/*
=======================================================================================================================
=======================================================================================================================
*/
void STOPcont(void)
{ /* stop condition for continous mode */
TRFWrite = 0x00;
TRFDirOUT;
TRFWrite = 0x80;
__no_operation();
TRFWrite = 0x00;
} /* STOPcond */
/*
=======================================================================================================================
=======================================================================================================================
*/
void STARTcondition(void)
{
TRFWrite = 0x00;
clkON;
TRFWrite = 0xff;
clkOFF;
} /* STARTcondition */
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
/*
=======================================================================================================================
Function writes only one register or a multiple number ;
of registers with specified addresses ;
=======================================================================================================================
*/
void WriteSingle(unsigned char *pbuf, unsigned char lenght)
{
STARTcondition();
while(lenght > 0)
{
*pbuf = (0x1f &*pbuf); /* register address */
/* address, write, single */
for(i = 0; i < 2; i++)
{
TRFWrite = *pbuf; /* send command and data */
clkON;
clkOFF;
pbuf++;
lenght--;
}
} /* while */
STOPcondition();
} /* WriteSingle */
/*
=======================================================================================================================
Function writes a specified number of registers from ;
a specified address upwards ;
=======================================================================================================================
*/
void WriteCont(unsigned char *pbuf, unsigned char lenght)
{
STARTcondition();
*pbuf = (0x20 | *pbuf); /* address, write, continous */
*pbuf = (0x3f &*pbuf); /* register address */
while(lenght > 0)
{
TRFWrite = *pbuf; /* send command */
clkON;
clkOFF;
pbuf++;
lenght--;
} /* while */
STOPcont();
} /* WriteCont */
/*
=======================================================================================================================
Function reads only one register ;
=======================================================================================================================
*/
void ReadSingle(unsigned char *pbuf, unsigned char lenght)
{
STARTcondition();
while(lenght > 0)
{
*pbuf = (0x40 | *pbuf); /* address, read, single */
*pbuf = (0x5f &*pbuf); /* register address */
TRFWrite = *pbuf; /* send command */
clkON;
clkOFF;
TRFDirIN; /* read register */
clkON;
__no_operation();
*pbuf = TRFRead;
clkOFF;
TRFWrite = 0x00;
TRFDirOUT;
pbuf++;
lenght--;
} /* while */
STOPcondition();
/**************************************************************/
} /* ReadSingle */
/*
=======================================================================================================================
Function reads specified number of registers from a ;
specified address upwards. ;
=======================================================================================================================
*/
void ReadCont(unsigned char *pbuf, unsigned char lenght)
{
STARTcondition();
*pbuf = (0x60 | *pbuf); /* address, read, continous */
*pbuf = (0x7f &*pbuf); /* register address */
TRFWrite = *pbuf; /* send command */
clkON;
clkOFF;
TRFDirIN; /* read register */
/*
* TRFWrite = 0x00;
*/
while(lenght > 0)
{
clkON;
/*
* TRFDirIN;
*/
__no_operation();
*pbuf = TRFRead;
/*
* TRFDirOUT;
*/
clkOFF;
pbuf++;
lenght--;
} /* while */
STOPcont();
} /* ReadCont */
/*
=======================================================================================================================
Function DirectCommand transmits a command to the reader chip
=======================================================================================================================
*/
void DirectCommand(unsigned char *pbuf)
{
STARTcondition();
*pbuf = (0x80 | *pbuf); /* command */
*pbuf = (0x9f &*pbuf); /* command code */
TRFWrite = *pbuf; /* send command */
clkON;
clkOFF;
STOPcondition();
} /* DirectCommand */
/*
=======================================================================================================================
Function used for direct writing to reader chip ;
=======================================================================================================================
*/
void RAWwrite(unsigned char *pbuf, unsigned char lenght)
{
STARTcondition();
while(lenght > 0)
{
TRFWrite = *pbuf; /* send command */
clkON;
clkOFF;
pbuf++;
lenght--;
} /* while */
STOPcont();
} /* RAWwrite */
/*
=======================================================================================================================
Direct mode (no stop condition) ;
=======================================================================================================================
*/
/*
=======================================================================================================================
=======================================================================================================================
*/
void InterruptHandlerReader(unsigned char *Register)
{
/*~~~~~~~~~~~~~~~~*/
/*
* char phello[20];
* //for testing
*/
unsigned char len;
/*~~~~~~~~~~~~~~~~*/
/*
* Register = Register & 0xF7;
* //set the parity flag to 0 ;
* parity is not used in 15693 and Tag-It
*/
if(*Register == 0xA0)
{ /* TX active and only 3 bytes left in FIFO */
i_reg = 0x00;
}
else if(*Register == BIT7)
{ /* TX complete */
i_reg = 0x00;
*Register = Reset; /* reset the FIFO after TX */
DirectCommand(Register);
//led1on;
P3OUT ^= BIT0;
delay_ms(1);
}
else if((*Register & BIT1) == BIT1)
{ /* collision error */
i_reg = 0x02; /* RX complete */
*Register = StopDecoders; /* reset the FIFO after TX */
DirectCommand(Register);
CollPoss = CollisionPosition;
ReadSingle(&CollPoss, 1);
len = CollPoss - 0x20; /* number of valid bytes if FIFO */
if((len & 0x0f) != 0x00) len = len + 0x10; /* add 1 byte if broken byte recieved */
len = len >> 4;
if(len != 0x00)
{
buf[RXTXstate] = FIFO; /* write the recieved bytes to the correct place of the
* buffer;
* */
ReadCont(&buf[RXTXstate], len);
RXTXstate = RXTXstate + len;
} /* if */
*Register = Reset;
DirectCommand(Register);
*Register = IRQStatus; /* IRQ status register address */
*(Register + 1) = IRQMask;
//ReadSingle(Register, 2); /* function call for single address read */
// ReadCont(Register, 2);
ReadSingle(Register, 1);
irqCLR;
}
else if(*Register == BIT6)
{ /* RX flag means that EOF has been recieved */
/* and the number of unread bytes is in FIFOstatus regiter */
if(RXErrorFlag == 0x02)
{
i_reg = 0x02;
return;
}
*Register = FIFOStatus;
ReadSingle(Register, 1); /* determine the number of bytes left in FIFO */
// ReadCont(Register, 1);
*Register = (0x0F &*Register) + 0x01;
buf[RXTXstate] = FIFO; /* write the recieved bytes to the correct place of the*/
ReadCont(&buf[RXTXstate], *Register);
RXTXstate = RXTXstate +*Register;
*Register = TXLenghtByte2; /* determine if there are broken bytes */
// ReadSingle(Register, 1); /* determine the number of bits */
ReadCont(Register, 1);
if((*Register & BIT0) == BIT0)
{
*Register = (*Register >> 1) & 0x07; /* mask the first 5 bits */
*Register = 8 -*Register;
buf[RXTXstate - 1] &= 0xFF << *Register;
} /* if */
*Register = Reset; /* reset the FIFO after last byte has been read out */
DirectCommand(Register);
i_reg = 0xFF; /* signal to the recieve funnction that this are the last bytes */
}
else if(*Register == 0x60)
{ /* RX active and 9 bytes allready in FIFO */
i_reg = 0x01;
buf[RXTXstate] = FIFO;
ReadCont(&buf[RXTXstate], 9); /* read 9 bytes from FIFO */
RXTXstate = RXTXstate + 9;
if(irqPORT & irqPIN)
{
*Register = IRQStatus; /* IRQ status register address */
*(Register + 1) = IRQMask;
//ReadSingle(Register, 2); /* function call for single address read */
//ReadCont(Register, 2);
ReadSingle(Register, 1);
irqCLR;
if(*Register == 0x40)
{ /* end of recieve */
*Register = FIFOStatus;
ReadSingle(Register, 1); /* determine the number of bytes left in FIFO */
//ReadCont(Register, 1);
*Register = 0x0F & (*Register + 0x01);
buf[RXTXstate] = FIFO; /* write the recieved bytes to the correct place of the*/
ReadCont(&buf[RXTXstate], *Register);
RXTXstate = RXTXstate +*Register;
*Register = TXLenghtByte2; /* determine if there are broken bytes */
ReadSingle(Register, 1); /* determine the number of bits */
//ReadCont(Register, 1);
if((*Register & BIT0) == BIT0)
{
*Register = (*Register >> 1) & 0x07; /* mask the first 5 bits */
*Register = 8 -*Register;
buf[RXTXstate - 1] &= 0xFF << *Register;
} /* if */
P1OUT |= BIT4;
i_reg = 0xFF; /* signal to the recieve funnction that this are the last bytes */
*Register = Reset; /* reset the FIFO after last byte has been read out */
DirectCommand(Register);
}
else if(*Register == 0x50)
{ /* end of recieve and error */
i_reg = 0x02;
}
}
else
{
Register[0] = IRQStatus;
Register[1] = IRQMask;
//ReadSingle(Register, 2); /* function call for single address read */
//ReadCont(Register, 2);
ReadSingle(Register, 1);
if(Register[0] == 0x00) i_reg = 0xFF;
}
}
else if((*Register & BIT4) == BIT4)
{ /* CRC error */
if((*Register & BIT5) == BIT5)
{
i_reg = 0x01; /* RX active */
RXErrorFlag = 0x02;
}
else
i_reg = 0x02; /* end of RX */
}
else if((*Register & BIT2) == BIT2)
{ /* byte framing error */
if((*Register & BIT5) == BIT5)
{
i_reg = 0x01; /* RX active */
RXErrorFlag = 0x02;
}
else
i_reg = 0x02; /* end of RX */
}
else if(*Register == BIT0)
{ /* No response interrupt */
i_reg = 0x00;
}
else
{ /* Interrupt register not properly set */
i_reg = 0x02;
*Register = StopDecoders; /* reset the FIFO after TX */
DirectCommand(Register);
*Register = Reset;
DirectCommand(Register);
*Register = IRQStatus; /* IRQ status register address */
*(Register + 1) = IRQMask;
//ReadSingle(Register, 2); /* function call for single address read */
//ReadCont(Register, 2);
ReadSingle(Register, 1);
irqCLR;
}
} /* InterruptHandlerReader */
/*
=======================================================================================================================
=======================================================================================================================
*/
void delay_ms(unsigned int n_ms) {
unsigned int ii1, ii0;
for(ii0=n_ms; ii0>0; ii0--) {
ii1 = 0x07FF; // Delay
do (ii1--);
while (ii1 != 0);
}
}
void CounterSet(void)
{
TACTL |= TACLR;
TACTL &= ~TACLR; //reset the timerA
TACTL |= TASSEL0 + ID1 + ID0; //ACLK, div 8, interrupt enable, timer stoped
TAR = 0x0000;
TACCTL0 |= CCIE; //compare interrupt enable
}//CounterSet()
void BaudSet(unsigned char mode)
{
if(mode == 0x00)
{
UCA0BR0 = BAUD0; /* baud rate register */
UCA0BR1 = BAUD1;
}
else
{
UCA0BR0 = BAUD0EN; /* baud rate register */
UCA0BR1 = BAUD1EN;
}
} /* BaudSet */
void main(void) {
// initialize peripherals
WDTCTL = WDTPW + WDTHOLD;
P3OUT &=~BIT0;
P3DIR |= BIT0;
P2OUT &=~BIT2;
P3OUT &=~0x06;
ledselect1;
ledselect2;
delay_ms(1);
PARset(); //Set Port Functions for Parallel Mode
InitialSettings(); // Set MCU Clock Frequency to 13.56 MHz and OOK Modulation
/*Now switch from DCO to external 13.56 MHz clock*/
OSCsel(0x00); //set the oscilator
EnableInterrupts; // General enable interrupts
delay_ms(10);
//set OOK port tristate P2.2 LOW
//ENABLE = 1;
//POLLING = 1;
FindTags(0x00);
}
// === end of main =====================================================
#pragma vector=TIMERA0_VECTOR
__interrupt void TimerAhandler(void)
{
unsigned char Register[2];
stopCounter;
Register[0] = IRQStatus; /* IRQ status register address */
Register[1] = IRQMask; //Dummy read
ReadCont(Register, 2);
uid[0]=*Register;
*Register = *Register & 0xF7; //set the parity flag to 0
if(*Register == 0x00 || *Register == 0x80) //added code
i_reg = 0x00;
else
i_reg = 0x01;
__low_power_mode_off_on_exit();
}//TimerAhandler
#pragma vector = PORT2_VECTOR
__interrupt void Port_B (void) /* interrupt handler */
{
P3OUT ^= BIT2;
stopCounter; /* stop timer mode */
do
{
irqCLR; /* PORT2 interrupt flag clear */
Register[0] = IRQStatus; /* IRQ status register address */
Register[1] = IRQMask; //Dummy read
// ReadSingle(Register, 2); /* function call for single address read */
ReadSingle(Register, 1); /* function call for single address read */
/* IRQ status register has to be read */
if(*Register == 0xA0)
{ /* TX active and only 3 bytes left in FIFO */
goto FINISH;
}
InterruptHandlerReader(&Register[0]);
} while((irqPORT & irqPIN) == irqPIN);
FINISH:
__low_power_mode_off_on_exit();
}