/*****************************************************
This program was produced by the
CodeWizardAVR V1.24.2 Standard
Automatic Program Generator
© Copyright 1998-2004 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.ro
e-mail:office@hpinfotech.ro

Project :
Version :
Date    : 9/23/2004
Author  : Theodore Johnson
Company : NY, USA
Comments:


Chip type           : ATmega8
Program type        : Application
Clock frequency     : 8.000000 MHz
Memory model        : Small
External SRAM size  : 0
Data Stack size     : 256
*****************************************************/

#include <mega8.h>

// Standard Input/Output functions
#include <stdio.h>
#include <delay.h>

#define IRIN PINC.1
//		IR reader using timer 0.

#define IR_DETECT_LED PORTB.0
#define IR_MSG_LED PORTD.7

//	out-of-band processing
#define MOTOR_RELAY PORTB.1


#define IRSTART 1
#define IRINIT 2
#define IRDIG0 3
#define IRDIGLO 4
#define IRDIGHI 5

#define IRbytes 6

unsigned char IRstate = IRSTART;  // state machine
unsigned char IRcnt = 0;		  // time in state
char IRresult[IRbytes];			  // store result
unsigned char IRbit;			  // next bit position.

//			Output vars
char IRvalue[IRbytes];			// output value
unsigned char IRlen;			// # bits in output.
unsigned char IRnew = 0;		// signal a new output.

char irerr = 0;
char err_cnt = 0;

//		8 us per clock tick
//		Params for General Instruments INRC-42
#define SAMPLE_RATE 231		// (256-231)*8us = .20 ms per interrupt.
//		Units are # of interrupts.
//		min, max length of initial zero pulse
#define MIN_IR_START_LO 20
#define MAX_IR_START_LO 30
//		min, max length of subsequent 1 pulse
#define MIN_IR_START_HI 7
#define MAX_IR_START_HI 15
//		Max len of inter-digit zero pulse
#define MAX_IR_LOW_DIG 10
//		min, threshold, and max length of 1 pulse
//		(if larger than max, transmission is complete).
#define MIN_IR_DIGHI 1
#define IR_DETECT0_CNT 8
#define MAX_IR_DIGHI 20



interrupt [TIM0_OVF] void timer0_ovf_isr(void){
	char IRval;
	char bitpos, bytepos;

	IRval = IRIN;
	switch(IRstate){
	case IRSTART: //  nothing happening.
		IRcnt = 0;
		if(!IRval)
			IRstate = IRINIT;
		break;
	case IRINIT:  // try to detect initial 0 pulse
		IRcnt++;
		if(IRval){
			if(IRcnt >= MIN_IR_START_LO){
				IRstate = IRDIG0;
			}else{
				IRstate = IRSTART;
				irerr = 1;
				err_cnt = IRcnt;
			}
			IRcnt = 0;
		}else{
			if(IRcnt > MAX_IR_START_LO){
				IRcnt = 0;
				IRstate = IRSTART;
				irerr = 2;
				err_cnt = IRcnt;
			}
		}
		break;
	case IRDIG0: // initial zero detected, look for initial 1.
		IRcnt++;
		if(!IRval){
			if(IRcnt <MIN_IR_START_HI){
				IRstate = IRSTART;
				irerr = 3;
				err_cnt = IRcnt;
			}else{
				IRstate = IRDIGLO;
				IRbit = 0;
				for(bytepos=0;bytepos<IRbytes;bytepos++)
					IRresult[bytepos] = 0;
			}
			IRcnt = 0;
		}else{
			if(IRcnt > MAX_IR_START_HI){
				IRcnt = 0;
				IRstate = IRSTART;
				irerr = 4;
				err_cnt = IRcnt;
			}
		}
		break;
	case IRDIGLO:
		IRcnt++;
		if(IRval){
			IRcnt = 0;
			IRstate = IRDIGHI;
		}else{
			if(IRcnt > MAX_IR_LOW_DIG){
				IRcnt = 0;
				IRstate = IRSTART;
				irerr = 5;
				err_cnt = IRcnt;
				IRlen = IRbit;
			}
		}
		break;
	case IRDIGHI:
		IRcnt++;
		if(! IRval){
			if(IRcnt >= MIN_IR_DIGHI && IRcnt <= IR_DETECT0_CNT){
				IRbit++;
				IRstate = IRDIGLO;
			}
			else if(IRcnt > IR_DETECT0_CNT && IRcnt <= MAX_IR_DIGHI){
				bitpos = IRbit & 0x07;
				bytepos = IRbit >> 3;
				IRresult[bytepos] |= (1 << bitpos);
				IRbit++;
				IRstate = IRDIGLO;
			} else{
				IRstate = IRSTART;
				irerr = 6;
				err_cnt = IRcnt;
				IRlen = IRbit;
			}
			IRcnt = 0;

//					Out of space : end detection.
			if(IRbit > 8*IRbytes){
				if(! IRnew){
				  IRnew = 1;
				  for(bytepos=0;bytepos<IRbytes;bytepos++)
					IRvalue[bytepos] = IRresult[bytepos];
				  IRlen = IRbit;
				}
				IRstate = IRSTART;
			}

		}else{
//				detection done on long high pulse.
			if(IRcnt >= MAX_IR_DIGHI){
				if(! IRnew){
				  IRnew = 1;
				  for(bytepos=0;bytepos<IRbytes;bytepos++)
					IRvalue[bytepos] = IRresult[bytepos];
				  IRlen = IRbit;
				}
				IRstate = IRSTART;
			}
		}
		break;
	default:
		IRstate = IRSTART;
		irerr = 7;
		break;
	}


	TCNT0=SAMPLE_RATE;
}

//		General Instruments INRC-42 codes
int detect_code(){
	unsigned int code;

	if(IRlen != 12) return -1;
    code = IRvalue[0];
    code = code << 8;
    code |= IRvalue[1];

	switch(code){
	case 0x2505:	// Sat/TV
		return 'a';
	case 0x060a: // timer
		return 'b';
	case 0x0b0e: // channel up
		return 'c';
	case 0x1005: // channel down
		return 'd';
	case 0x0709: // vol up
		return 'e';
	case 0x040c: // vol down
		return 'f';
	case 0x0f02: // 1
		return '1';
	case 0x1106: // 2
		return '2';
	case 0x1203: // 3
		return '3';
	case 0x170c: // 4
		return '4';
	case 0x190d: // 5
		return '5';
	case 0x1b0b: // 6
		return '6';
	case 0x0a0d: // 7
		return '7';
	case 0x0908: // 8
		return '8';
	case 0x0e01: // 9
		return '9';
	case 0x2406: // 0
		return '0';
	case 0x0206: // mute
		return 'g';
	case 0x180e: // last
		return 'h';
	case 0x1c02: // select
		return 'i';
	case 0x230f : // up
		return 'j';
	case 0x200a: // down
		return 'k';
	case 0x1d01: // left
		return 'l';
	case 0x0103: // right
		return 'm';
	case 0x0d04: // time
		return 'n';
	case 0x1409: // options
		return 'o';
	case 0x1e04: // guide
		return 'p';
	case 0x2600: // favorites
		return 'q';
	case 0x2703: // info
		return 'r';
	case 0x050f: // info
		return 's';
	default:
		return -1;
	}

	return -1;
}


void main(void)
{
char state = 0;
char b, c;
char mot = 1;


// Input/Output Ports initialization
// Port B initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTB=0x00;
DDRB=0x03;

// Port C initialization
// Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTC=0x00;
DDRC=0x00;

// Port D initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTD=0x00;
DDRD=0x80;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 125.000 kHz
TCCR0=0x03;	// 3=divide by 64
TCNT0=0x00;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer 1 Stopped
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
TCCR1A=0x00;
TCCR1B=0x00;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;

// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
MCUCR=0x00;

// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x01;

// USART initialization
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART Receiver: Off
// USART Transmitter: On
// USART Mode: Asynchronous
// USART Baud rate: 9600
UCSRA=0x00;
UCSRB=0x08;
UCSRC=0x86;
UBRRH=0x00;
UBRRL=0x33;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
// Analog Comparator Output: Off
ACSR=0x80;
SFIOR=0x00;

// Global enable interrupts
#asm("sei")

MOTOR_RELAY = mot;		// out-of-band processing

while(1){
      if(IRnew){
      	c = detect_code();
      	if(c != 0xff){
      		IR_MSG_LED = 1;

      		if(c == 'a' || c == 'b'){
      			mot=1-mot;
      			MOTOR_RELAY=mot;
      		}

      		printf("%c",c);
      		delay_ms(100);
      		IR_MSG_LED = 0;
      	}
      	IRnew = 0;
      }
}




while (1)
      {
      if(IRnew){
      		printf("b=%d", IRlen);
	      	for(b=0;8*b < IRlen;b++)
    	  		printf(" %x",IRvalue[b]);
      		printf(": %d (%c)\n",detect_code(), detect_code());
      		state = 1-state;
      		IR_MSG_LED = state;
      		delay_ms(1000);
      		IRnew=0;
      }
      if(irerr){
      	printf("err=%d cnt=%d len=%d\n",irerr,err_cnt,IRlen);
      	state = 1-state;
   		IR_MSG_LED = state;
      	irerr = 0;
      	delay_ms(1000);
      }
      IR_DETECT_LED = ! IRIN;
      };
}