rc5.c

AVR Mega16 + Philips Remote Control >> C-Source code >> AVRStudio project

#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/signal.h>
#include <avr/interrupt.h>
#include <avr/delay.h>
#include <string.h>
#include <stdlib.h>

#ifndef F_CPU
	#define F_CPU	16000000   
#endif

#define K_DELAY_ms	F_CPU/1600

#define TRUE  1
#define FALSE 0

#define output  1
#define input   0

#define outp( val, port )  ( port ) = ( val )
#define inp( port )  ( port )
#define sbi( port, bit )  ( port ) |= ( 1 << (bit) )
#define cbi( port, bit )  ( port ) &= ~( 1 << (bit) )
#define chkbit( pin,bit )  (pin  & (0x00 | ( 1 << (bit) )))

#define NOP() asm volatile ("nop" ::)

#define USART_BAUD_RATE  9600
#define USART_BAUD_SELECT( baudRate, xtalCpu ) ( (F_CPU) / ( (baudRate) * 16l )-1 )

#define USART_RECEIVE_INTERRUPT   SIG_USART_RECV
#define USART_TRANSMIT_INTERRUPT  SIG_USART_DATA

#define USART_RX_BUFFER_SIZE 64   
#define USART_TX_BUFFER_SIZE 64   
#define CmdBuff 32

#define USART_RX_BUFFER_MASK ( USART_RX_BUFFER_SIZE - 1 )
#define USART_TX_BUFFER_MASK ( USART_TX_BUFFER_SIZE - 1 )

#define ATMEGA_USART
#define USART_RECEIVE_INTERRUPT   SIG_USART_RECV
#define USART_TRANSMIT_INTERRUPT  SIG_USART_DATA
#define USART_STATUS   UCSRA
#define USART_CONTROL  UCSRB
#define USART_DATA     UDR
#define USART_UDRIE    UDRIE

#define USART_FRAME_ERROR      0x0800              /* Framing Error by UART       */
#define USART_OVERRUN_ERROR    0x0400              /* Overrun condition by UART   */
#define USART_BUFFER_OVERFLOW  0x0200              /* receive ringbuffer overflow */
#define USART_NO_DATA          0x0100              /* no receive data available   */

const char welcome1[] PROGMEM = " Electoday AVR Project :: ATMega32 \n\r";
const char welcome2[] PROGMEM = " Sony Remote Control Decoder       \n\r";
const char welcome3[] PROGMEM = " Model :: RM-858 (RC5 protocol)    \n\r";
const char welcome4[] PROGMEM = " by [e-mail]             \n\r";
PGM_P welcomePointer[4] PROGMEM = {welcome1, welcome2,welcome3,welcome4};

static char hexDigits[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

static volatile unsigned int RC_BUFFER[12];

/* Static Variables */
static volatile unsigned char USART_RxBuf[ USART_RX_BUFFER_SIZE ];
static volatile unsigned char USART_RxHead;
static volatile unsigned char USART_RxTail;
static volatile unsigned char USART_TxBuf[ USART_TX_BUFFER_SIZE ];
static volatile unsigned char USART_TxHead;
static volatile unsigned char USART_TxTail;
static volatile unsigned int USART_READY;
static volatile unsigned char CommandBuffer[ 8 ];

/* Prototypes */
extern void USART_Init( unsigned int baudrate );
extern unsigned char USART_Receive( void );
extern void USART_Transmit( unsigned char data );
extern void usart_puts( const char *s );
extern void usart_putc( unsigned char data );
extern unsigned int usart_getc( void );
extern unsigned int usart_ready( void );
extern int DataInReceiveBuffer( void );

extern void usart_16bitHex(unsigned int hexIn);
extern void usart_SendBcd( unsigned char hexIn );
extern void usart_SendBin( unsigned char x );
extern void usart_SendDecDigit( unsigned long x );
extern void usart_SendDec( unsigned int x, unsigned char n, unsigned char fillch );
extern void usart_SendFloat( float usart_value,unsigned char usart_digit ,unsigned char usart_precision);
void usart_puts_p(const char *progmem_s );
extern void usart_SendInt(unsigned  int number );

extern void delay_ms(unsigned long  ms); 
extern void delay_us(unsigned int  us); 
extern void delayloop(unsigned long t);

extern void int0_initial(void);
unsigned char Int0_getKey(unsigned char IntKey);

//#define  ICP		PD6	 // Input Capture Pin
#define  rc5Delay   150  // 250 ms delay
static volatile unsigned int row_value0;
static volatile unsigned char count;
static volatile unsigned char Time1;
static volatile unsigned char ChkRC_bit9;
static volatile unsigned char T_temp;
static volatile unsigned char outData;




//*************************** End Captute ********************************//
int main (void)
{
    int tempPort;
	DDRB  = 0x00;
	PORTB = 0x00;	
 
	DDRA  = 0xFF;
	PORTA = 0x00;	
 
	DDRC  = 0xFF;
	PORTC = 0xFF;	
 
	DDRD  = 0b00100000;
	PORTD = 0b00000000;	
  
   
    USART_Init(USART_BAUD_SELECT(USART_BAUD_RATE,F_CPU));    
    sei();	
	
	usart_puts_p(welcomePointer[0]);
	usart_puts_p(welcomePointer[1]);
	usart_puts_p(welcomePointer[2]);
	usart_puts_p(welcomePointer[3]);
	usart_puts(" \n\r");
	
	outp(0xFF,PORTC);
	delay_ms(100);
	outp(0x00,PORTC);
	delay_ms(100);	
	
	
    sbi(PORTC,6);
 
	TCNT1 = 0x00;   
	TIMSK = (1<<TICIE1);	
	TCCR1B = (1<<ICNC1) | (0<<ICES1) | (0<<CS12) | (1<<CS11) | (0<<CS10);
	count = 0;

	while(1)
	{
	   PORTA = outData;
	   tempPort = inp(PORTB);
	   PORTC |= tempPort;
	}
 }
 
/**************  prototype deffination *******************/

void delayloop(unsigned long t) 
{
	unsigned int i;
	if (t==0) return;
	while (t--) for(i=0;i<K_DELAY_ms; i++);
}

void delay_ms(unsigned long  ms) 
{ 
    unsigned long i; 
    ms *= 1000; 
    for (i=0; i < ms; i++) 
    { 
        _delay_us(1); 
    } 
} 

void delay_us(unsigned int  us) 
{ 
    unsigned long i; 
	
    for (i=0; i < us; i++) 
    { 
        _delay_us(1); 
    } 
} 

void USART_Init( unsigned int baudrate )
{
	unsigned char x;
	UBRRH = (unsigned char) (baudrate>>8);                  
	UBRRL = (unsigned char) baudrate;
	UCSRB = ( ( 1 << RXCIE ) | ( 1 << RXEN ) | ( 1 << TXEN ) ); 
	UCSRC = (1<<URSEL) | (1<<USBS) | (1<<UCSZ1) | (1<<UCSZ0);  
	x = 0; 			    
	USART_RxTail = x;
	USART_RxHead = x;
	USART_TxTail = x;
	USART_TxHead = x;
}

SIGNAL(USART_RECEIVE_INTERRUPT)
{
	unsigned char data;
	unsigned char tmphead;

	data = UDR;                 
	tmphead = ( USART_RxHead + 1 ) & USART_RX_BUFFER_MASK;
	USART_RxHead = tmphead;     

	if ( tmphead == USART_RxTail )
	{
		;
	}
	
	USART_RxBuf[tmphead] = data; 
}

SIGNAL(USART_TRANSMIT_INTERRUPT)
{
	unsigned char tmptail;
	if ( USART_TxHead != USART_TxTail )
	{
		tmptail = ( USART_TxTail + 1 ) & USART_TX_BUFFER_MASK;
		USART_TxTail = tmptail;      
		UDR = USART_TxBuf[tmptail];  
	}
	else
	{
		UCSRB &= ~(1<<UDRIE);         
	}
}

unsigned char USART_Receive( void )
{
	unsigned char tmptail;	
	while ( USART_RxHead == USART_RxTail ) 
		;
	tmptail = ( USART_RxTail + 1 ) & USART_RX_BUFFER_MASK;
	USART_RxTail = tmptail;              
	return USART_RxBuf[tmptail];     
}

void USART_Transmit( unsigned char data )
{
	unsigned char tmphead;
	tmphead = ( USART_TxHead + 1 ) & USART_TX_BUFFER_MASK; 
	while ( tmphead == USART_TxTail );

	USART_TxBuf[tmphead] = data;       
	USART_TxHead = tmphead;           

	UCSRB |= (1<<UDRIE);             
}

void usart_puts(const char *s )
{
    while (*s) 
      USART_Transmit(*s++);
}

void usart_puts_p(const char *progmem_s )
{
    register char c;
    
    while ( (c = pgm_read_byte(progmem_s++)) ) 
      usart_putc(c);

} 

unsigned int usart_getc(void)
{    
    unsigned char tmptail;
    unsigned char data;
    if ( USART_RxHead == USART_RxTail ) {
        return USART_NO_DATA;  
    }
    tmptail = (USART_RxTail + 1) & USART_RX_BUFFER_MASK;
    USART_RxTail = tmptail; 
    data = USART_RxBuf[tmptail];
    return data;
}

void usart_putc(unsigned char data)
{
    unsigned char tmphead;
    tmphead  = (USART_TxHead + 1) & USART_TX_BUFFER_MASK;
    while ( tmphead == USART_TxTail ){
        ;
    }
    USART_TxBuf[tmphead] = data;
    USART_TxHead = tmphead;
    USART_CONTROL    |= _BV(USART_UDRIE);
}

int DataInReceiveBuffer( void )
{
	return ( USART_RxHead != USART_RxTail );
}

unsigned int  usart_ready(void)
{

	if ( USART_RxHead == USART_RxTail ) 
		return(FALSE);
	else
		return(TRUE);
}

void usart_SendBcd(unsigned char hexIn)
{
	unsigned char MSB_byte,LSB_byte;

	MSB_byte = hexDigits[hexIn >> 4];
	LSB_byte = hexDigits[hexIn & 0xF]; 
	usart_putc(MSB_byte);	
	usart_putc(LSB_byte);	   
	delay_us(1);
}

void usart_16bitHex(unsigned int hexIn)
{
	unsigned char B1,B2,B3,B4;

	B1 =  hexDigits[(hexIn & 0xF000) >> 12];
	B2 =  hexDigits[(hexIn & 0x0F00) >> 8]; 
	B3 =  hexDigits[(hexIn & 0x00F0) >> 4];
	B4 =  hexDigits[(hexIn & 0x000F)]; 

	usart_putc(B1);	
	usart_putc(B2);	   
	usart_putc(B3);	
	usart_putc(B4);	  
}

void usart_SendBin(unsigned char x)
{
	unsigned char i;
	for (i=128;i>0;i>>=1)
	{
		if ((x&i)==0) usart_puts("0");
		else usart_puts("1");
	}
}

void usart_SendFloat( float usart_value,unsigned char usart_digit ,unsigned char usart_precision)
{
	char usart_temp[15];
	unsigned char i;

	dtostrf(usart_value,usart_digit,usart_precision,usart_temp);
	
    i=0;
	
	while(usart_temp[i] != 0)
	{
		usart_putc(usart_temp[i]);
		i++;
	}		
	 
	for(unsigned char i=0;i<=15;i++)
	{
		usart_temp[i]=" ";
	}   
}

void usart_SendDec(unsigned int x, unsigned char n, unsigned char fillch)
{
    unsigned char i;
    unsigned char s[10];
    for (i = 0; i < n; i++) {
        s[n - i - 1] = '0' + (x % 10);
        x /= 10;
    }
    for (i=0; i<(n - 1); i++) {
        if (s[i] == '0') s[i] = fillch; else break;
    }
    for (i=0; i<n; i++) usart_putc(s[i]);
}

void usart_SendDecDigit(unsigned long x)
{
	unsigned int y;
	if (x<4294967297ul)
	{
	/*
		y=x/1000000000;usart_putc(y+0x30);x-=(y*1000000000);
		y=x/100000000;usart_putc(y+0x30);x-=(y*100000000);
		y=x/10000000;usart_putc(y+0x30);x-=(y*10000000);
		y=x/1000000;usart_putc(y+0x30);x-=(y*1000000);
		y=x/100000;usart_putc(y+0x30);x-=(y*100000);
		y=x/10000;usart_putc(y+0x30);x-=(y*10000);
	*/	
		y=x/1000;usart_putc(y+0x30);x-=(y*1000);
		y=x/100;usart_putc(y+0x30);x-=(y*100);
		y=x/10;usart_putc(y+0x30);x-=(y*10);
		usart_putc(x+0x30);
	}
	else usart_puts("Err");
}
  
void usart_SendInt(unsigned int number )
{
    unsigned char temp[15];
    itoa(number, temp, 10);
    usart_puts(temp);
}



void int0_initial(void)
{
    MCUCR = (1<<ISC01) | (1<<ISC00);		
    GICR = (1<<INT0);		
}

unsigned char Int0_getKey(unsigned char TntKey)
{
   Key_BUFFER[0] = TntKey;
   return 0;
}

//*******************************//

SIGNAL(SIG_INTERRUPT0) 
{
    unsigned char pressedButtonIndex;
//    unsigned char temp1, temp2,chkInt0;
//    unsigned int i;	
	
	GICR = (0<<INT0);
	
	pressedButtonIndex = (PINB & 0x0F);

    Int0_getKey(pressedButtonIndex);
 
	PORTA = Key_BUFFER[0];
	
 	//loop_until_bit_is_clear(PIND,PIND2);
	
	GICR = (1<<INT0);
	
	usart_SendInt(Key_BUFFER[0]);
}


SIGNAL(SIG_INPUT_CAPTURE1) 
{ 

	// ICP-Falling edge start Timer1
	if(TCCR1B == 0X82) 
	{ 
		cbi(PORTC,6);
	    TCNT1 = 0x00;
		TIMSK = (1<<TICIE1);		
		//TCCR1B = (1<<ICNC1) | (1<<ICES1) | (0<<CS12) | (1<<CS11) | (0<<CS10);		
		TCCR1B = 0XC2; 	
	} 

	//  ICP-Rising edge stop Timer1
	else if(TCCR1B == 0XC2) 
    { 
		sbi(PORTC,6);   
		row_value0 = ICR1;		
		
		//usart_SendInt(row_value0);
		//usart_puts(",");
		
		RC_BUFFER[count] = (unsigned int) (row_value0/1000);		

		Time1 = RC_BUFFER[0];
	   	if((count >= 0) && (count < 13) && (Time1 == 5))
		{	
		    TCNT1 = 0x00;
			TCCR1B = 0X82; 					
			count++; 
		}else	

	   	if((count==13) && (Time1 == 5))
		{
			T_temp = 0;		
			ChkRC_bit9 = (unsigned char) RC_BUFFER[8]; // cath RC_BUFFER[8] to ChkRC_bit9
			if((ChkRC_bit9 == 2) && (Time1 == 5))
			{
				cli();
				TCCR1B = 0X80;
				TIMSK = (0<<TICIE1);  // close interrupt
				
				outData=0;
				for(unsigned char i=1;i<=8;i++)
				{
					if (RC_BUFFER[i] == 1){
						outData |= (0 << (i-1));
					}else{ 
						outData |= (1 << (i-1));
					}
				}	   
				
				T_temp = outData;
				usart_puts("$");
				usart_SendInt(T_temp);
				//usart_SendBcd(T_temp);
				//usart_SendBin(T_temp);   // show data to RS232				
				usart_puts("#\n\r");
								
				for(unsigned char i=0;i<=12;i++)
				{
					RC_BUFFER[i]= 0;			
				}
				ChkRC_bit9 = 0;
				Time1 = 0;
				T_temp = 0;
				delay_ms(rc5Delay);  // re open interrupt
				sei();
			}
			count = 0;
			TCNT1 = 0x00;			
	        //TCCR1B = (1<<ICNC1) | (0<<ICES1) | (0<<CS12) | (1<<CS11) | (0<<CS10);			
			TCCR1B = 0X82;		// Restart ICP1 to Falling edge
			TIMSK = (1<<TICIE1);			
		}else{
			TCNT1 = 0x00;
	        //TCCR1B = (1<<ICNC1) | (0<<ICES1) | (0<<CS12) | (1<<CS11) | (0<<CS10);					
			TCCR1B = 0X82; 					
			count = 0; 
			for(unsigned char i=0;i<=12;i++)
			{
				RC_BUFFER[i] = 0;
			}
		}
 
	} 
} 


// ********************  END  ***************************  //