trh031v1.c

This is a source of 13.560MHz RFID card reader for TRH031M as ATMEGA8-16AU MPU. The title is 3Alogi

// *********************************************** 
// project : RFID Reader V2.0
// Target : MEGA8-16AU
// Crystal: 16.000 Mhz
// Input : TRH031M RFID 13.56MHz
// Output : RS232C 115200,N,8,1
// Compiler : ICC-AVR V6.26C
//
// Pin configuration for ATMEGA8-16AU TQFP32
// #30 RXD <--- RXD (SP3232)
// #31 TXD ---> TXD (SP3232)

// #32 PD2/INT0 <--- INTR (TRH031M)
// # 1 PD3/INT1 ---> RST (TRH031M)

// # 2 PD4 ---> D4 (TRH031M)
// # 9 PD5 ---> D5 (TRH031M)
// #10 PD6 ---> D6 (TRH031M)
// #11 PD7 ---> D7 (TRH031M)

// #12 PB0 ---> D0 (TRH031M)
// #13 PB1 ---> D1 (TRH031M)
// #14 PB2 ---> D2 (TRH031M)
// #15 PB3 ---> D3 (TRH031M)
// #16 PB4 ---> CSB (TRH031M)
// #17 PB5 ---> LED

// #23 PC0 ---> A0 (TRH031M)
// #24 PC1 ---> A1 (TRH031M)
// #25 PC2 ---> A2 (TRH031M)
// #26 PC3 ---> ALE (TRH031M)
// #27 PC4 ---> /RD (TRH031M)
// #28 PC5 ---> /WR (TRH031M)

// *********************************************** 
#include <iom8v.h>  // Define for Mega8 MPU																 
#include <macros.h>	// Define for macro functions

// *********************************************** 
// Variables for System 
// *********************************************** 
#define t_idl 10							// 0.1 ms idle delay
#define t_rec	50							// 0.5 ms receive time
#define t_dly	100							// 1.0 ms after delay

unsigned char time_10us =0;
unsigned char time_1ms =0;

unsigned int	adc_buf =0;
unsigned char rxd_buf =0;
  
// *********************************************** 
// Initialize Variables for flags
// *********************************************** 
unsigned char flag_10us =0;    // timer 10 us	 
unsigned char flag_1ms =0;    // timer 1 ms	 

unsigned char flag_adc =0;	 	// end of adc conversion
unsigned char flag_rxd =0;	 	// serial received
unsigned char flag_err =0;	 	// header error
unsigned char flag_up	 =0;		// end of setup

// *********************************************** 
// Global variables for buffer
// *********************************************** 
char rf_buf[80];	 		 			// rf buffer  
char rf_buf_ptr =0;					// rf buffer pointer?
char rf_bit_ptr = 0;				// rf bit pointer

// *********************************************** 
// RFID variables
// *********************************************** 
char rf_state;
char card_wait;

// RFID buffer
char auto_mode;
char sel;
char rx_sel[8];

char b;
char bbb;
char mask1;
char mask2;
char det;

char length;
char suma;
char loop_cnt;

char cid[9];
char cid_buf[9];
char tx_buf[9];
char atqa[9];

// *********************************************** 
// Initialize Ports
// *********************************************** 
void port_init(void)
{
  PORTB = 0x3f;      	 // PB5=LED(1), PB4 =/CSB(1),
 	DDRB  = 0x3f;				 // PB3~PB0 =data bus low. 
 
 	PORTC = 0x38;				 // PC5 =/WR(1), PC4 =/RD(1), PC3 =ALE(1) 
 	DDRC  = 0x3f;		   	 // PC2~PC0 = A2~A0 (000) 

 	PORTD = 0xfC;			 	 // PD3 =RST(1), PD2/INT0 =INTR(1),
 	DDRD  = 0xf8;			 	 // PD7~PD4 =data bus high
}

// eeprom_init()
// Initialize internal eeprom
void eeprom_init(void)
{
	EECR = 0x00;					// Disable interrupts
}

// *********************************************** 
// ADC initialisation
// Conversion time: 104uS
// *********************************************** 
void adc_init(void)
{
  ADCSR = 0x00; 	   //disable adc
  ADMUX = 0x07; 	   //select adc input 7 only
  ACSR  = 0x80;
  ADCSR = 0xEF;
}

// *********************************************** 
// Interrupt handler for ADC
// conversion complete, read value (int) using...
// value=ADCL; Read 8 low bits first (important)
// value|=(int)ADCH << 8; 
// read 2 high bits and shift into top byte
// *********************************************** 
#pragma interrupt_handler adc_isr:15
void adc_isr(void)
{
  adc_buf =ADCL;	 	  	  			// get low byte only
  adc_buf |=(int)ADCH << 8;  		// get high byte and amke int
  flag_adc =1;	   	  	  			// end of adc convert
}

// *********************************************** 
// TIMER2 initialisation - prescale:8
// WGM: Normal
// desired value: 10uSec
// actual value: 10.000uSec (0.0%)
// *********************************************** 
// *********************************************** 
void timer2_init(void)
{
 	TCCR2 =0x00; 			// stop timer2
 	ASSR  =0x00; 			// set async mode
 	TCNT2 =0xEC; 			// setup time vlaue

 	TCCR2 =0x02; 			// start timer2  prescle =8
	TIMSK |= 0x40; 		// timer2 interrupt enable
}

// *********************************************** 
// Interrupt handler for TIMER2 1ms overflow
// *********************************************** 
#pragma interrupt_handler timer2_ovf_isr:5
void timer2_ovf_isr(void)
{
 	TCNT2 =0xEC; 			// setup time vlaue
	flag_10us =1;
	
	if (++time_10us >99)
	{
	  time_10us =0;
		time_1ms++;			// 1ms timer +1
  	flag_1ms =1;	  // flag_1ms =1
	}	
}

// *********************************************** 
// Delay for 10us
// *********************************************** 
void delay_10us(int dly)
{
 	unsigned int i;

	for (i=0; i <dly; i++)		// 1ms *N =N [ms]	
	{
	  while (flag_10us ==0)		// Stand by 10us
		{
		}
		flag_10us =0; 	 				// reset 10us timer		  
	} 
}
 
// *********************************************** 
// Delay for ms
// *********************************************** 
void delay_ms(int dly)
{
 	unsigned int i;

	for (i=0; i <dly; i++)		// 1ms *N =N [ms]	
	{
	  while (flag_1ms ==0)		// Stand by 1ms
	  {
		}
		flag_1ms =0; 	 				// reset 1 ms timer		  
	} 
}
 
// *********************************************** 
// UART initialize for 115200,N,8,1
// char size: 8 bit, parity: Disabled
// *********************************************** 
#define F_OSC 16000000	// oscillator-frequency in Hz
#define BAUD_RATE 57600	// 57600 x2 =115,200 bps
#define BAUD_CALC ((F_OSC)/((BAUD_RATE)*16l)-1)

void uart0_init(void)
{
  UCSRB = 0x00; //disable while setting baud rate
  UCSRA = 0x02; //double baud rate
  // 0x86 = asynchronous 8N1
  UCSRC = (1<<URSEL)|(3<<UCSZ0);
  // set baud rate
  UBRRH =BAUD_CALC >>8;
  UBRRL =BAUD_CALC;
  // 0x90 = Enable receiver and transmitter
	// enable RX interrupt
  UCSRB = (1<<RXEN)|(1<<TXEN)|(1<<RXCIE);
}

// *********************************************** 
// Interrupt handler for UART0 receiver
// *********************************************** 
#pragma interrupt_handler uart0_rx_isr:12
void uart0_rx_isr(void)
{
 //uart has received a character in UDR
  rxd_buf =UDR;
  flag_rxd =1;
}

// *********************************************** 
// String send to UART
// wait until UDR ready
// *********************************************** 
void uart_putc(char tx_byte)
{
  while(!(UCSRA & (1 << UDRE)));
  UDR = tx_byte;    // send character
}

// *********************************************** 
// CR+LF send to UART
// wait until UDR ready
// *********************************************** 
void uart_cr(void)
{
  while(!(UCSRA & (1 << UDRE)));
  UDR = 0x0d;    		 // send CR character

  while(!(UCSRA & (1 << UDRE)));
  UDR = 0x0a;    		 // send LF character
}

// *********************************************** 
// loop until *s != NULL
// *********************************************** 
void uart_puts (char *str)
{
  while (*str)
  {
    uart_putc(*str);
    str++;
  }
}

// *********************************************** 
// Fialure Message send to uart
// *********************************************** 
void uart_fail(char *str)
{
	if (auto_mode != 0xAF)
	{
	  while (*str)
		{
		  uart_putc(*str);
		  str++;
		}
		uart_puts(" read fail !!");
		uart_cr();
	}
}	
// *********************************************** 
// make ascii of 2 hexa
// and send to uart
// *********************************************** 
void uart_hex(char byte)
{
  char hex;
	
	hex =byte;		 							// get byte
	hex =(hex >>4);							
	hex &=0x0f;									// make low bcd
	
	if (hex <0x0a) hex +=0x30;  // make ascii 0~9
  else hex +=0x37; 	 					// make ascii A~F
	uart_putc(hex); 	 					// send hexa #1

	hex =byte;									// get byte
	hex &= 0x0f;								// make low bcd
	
	if (hex <0x0a) hex +=0x30;  // make ascii 0~9
  else hex +=0x37; 	 					// make ascii A~F
	uart_putc(hex); 	 					// send hexa #2

	uart_putc(0x20);						// seperator of byte
}

// *********************************************** 
// RFID define for TRH031M
// *********************************************** 
#define DATA_HI PORTD				// PD7 ~ PD4											 
#define DATA_LO	PORTB				// PB3 ~ PB0 
#define ADRS PORTC					// PC3 ~ PC0 =register address

#define RST 0x08						// PD3											 
#define INTR 0x04						// PD2

#define WRB	0x20						// PC5 = /write strobe 
#define RDB 0x10						// PC4 = /read strobe

#define ALE 0x08						// PC3 = address latch enable
#define RA2	0x04						// PC2 = register a2
#define RA1	0x02						// PC1 = register a1
#define RA0	0x01						// PC0 = register a0

#define LED 0x20						// PB5 = led indicator
#define CSB 0x10						// PB4 = /chip select

// *********************************************** 
// trh031m page select
// *********************************************** 
void rf_page(char page)	// ra =0, page =0
{
  char temp;
	
	page =((page & 0x38) >>3);	// make page number
	page |=0x80; 	 							// set page command 

	DATA_HI &= 0x0f; 					  // clear d7~d4
	DATA_LO &= 0xf0; 						// clear d3~d0
	ADRS &= ~0x07;							// page address =000

	temp =page;
	DATA_HI |=(temp & 0xf0);		// set page high
  temp =page;
	DATA_LO |=(temp & 0x0f);		// set page low

	PORTB &= ~CSB;							// make csb =0
	PORTC &= ~WRB;		 					// write =0

	asm("NOP");
	asm("NOP");
	asm("NOP");
	asm("NOP");
	PORTC |= WRB;								// write =1	 		  				 
	PORTB |= CSB;								// make csb =1
}

// *********************************************** 
// RFID Card Reader TRH031M write
// *********************************************** 
void rf_write(char adrs, char cmd)
{
  char temp;

	rf_page(adrs);							// ra =0, page =0

	DATA_HI &= 0x0f; 					  // clear d7~d4
	DATA_LO &= 0xf0; 						// clear d3~d0

	temp =cmd;
	DATA_HI |=(temp & 0xf0);		// set command high
  temp =cmd;
	DATA_LO |=(temp & 0x0f);		// set command low

	ADRS &= ~0x07;							// clear address =000
	ADRS |=adrs;								// set address =0~7

	PORTB &= ~CSB;							// make csb =0
	PORTC &= ~WRB;		 					// write =0

	asm("NOP");
	asm("NOP");
	asm("NOP");
	asm("NOP");
	PORTC |= WRB;								// write =1	 		  				 
	PORTB |= CSB;								// make csb =1
}

// *********************************************** 
// trh031m receive from data bus		
// *********************************************** 
char rf_read(char adrs)
{
  char data;

	rf_page(adrs);							// ra =0, page =0

	ADRS &= ~0x07;							// clear address
	ADRS |=adrs;		 						// set address

	PORTB &= ~CSB;							// make csb =0
	PORTC &= ~RDB;		 					// read =0

 	DDRD &=0x0f;			 	 				// PD7~PD4 =input
 	DDRB &=0xf0;				 				// PB3~PB0 =input 
	data =(PIND & 0xf0);				// read data high
	data |=(PINB & 0x0f);				// read data low

	PORTC |=RDB;								// read =1	 		  				 
	PORTB |=CSB;								// make csb =1

 	DDRD |=0xf0;			 	 				// PD7~PD4 =output
 	DDRB |=0x0f;				 				// PB3~PB0 =output 
	return data;								// return data byte
}

// *********************************************** 
// Update register bit
// *********************************************** 
void rf_bit_set(char adrs, char mask, char bit)
{
	char temp;
	
	temp = rf_read(adrs); 		 		 // read byte from address
	temp = ((temp & mask) | bit);  // bit set	 
	rf_write(adrs,temp);		 			 // byte re-write to address
}

void rf_bit_reset(char adrs, char mask, char bit)
{
	char temp;
	temp = rf_read(adrs);			 		// read byte from address	 
	temp = ((temp & mask) | bit); // bir clear
	rf_write(adrs,temp);					// byte re-write to address
}

// *********************************************** 
// RFID data save to rf_buf[64] 
// read data from fifo
// *********************************************** 
void rf_fifo_read(void)
{
	char i;

	length =rf_read(0x04);			// get length of fifo												 
	for(i=0; i <length; i++)		// loop count =length of fifo
	{
		rf_buf[i] =rf_read(0x02);	// save rf data from fifo
	}
	rf_buf[length] =0x00;				// save end of data =null				

	uart_puts("FIFO read = ");
	uart_hex(length);
	uart_puts("(Hex) bytes"); 
	uart_cr();			 		 				// end of string
	for(i=0; i <length; i++)		// loop count =length of fifo
	{
		uart_hex(rf_buf[i]);			// make 2 hexa for send to uart
	}
	uart_cr();			 		 				// end of string
}

// *********************************************** 
// RFID control
// *********************************************** 
void rf_on(void)
{
	rf_write(0x11, 0x5B); 			// TxControl Setting 5B -> On       
}

void rf_off(void)
{
	rf_write(0x11, 0x58); 			// TxControl Setting 58 -> Off        
}