/*
rc5dec.c 0.2.0 - Interrupt driven RC5 decoder for Atmel AVR \u013eC's.
Website: http://markh.de/rc5dec/
Copyright (C) 2003 Mark Haemmerling <rc5(at)markh.de>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Preconfigured for INT1 (PD3) and Timer/Counter0.
*/
#include <inttypes.h>
//#include <avr/signal.h>
#include <avr/interrupt.h>
#include <avr/io.h>
// set your clock speed here
#define XTAL 8000000
// you may have to experiment a little with this
// in case of heavy disturbance, try values around 60
// try to use odd values (for symmetrical level detection)
#define RC5RESAMPLE 25
// this autoconfigures all timer values:
#if XTAL < 285000
# define PRESCALEDIV 1
# define TIMERCR (1<<CS00)
#elif XTAL < 2300000
# define PRESCALEDIV 8
# define TIMERCR (1<<CS01)
#elif XTAL < 18000000
# define PRESCALEDIV 32//64
# define TIMERCR (1<<CS01) | (1<<CS00)
#else
# define PRESCALEDIV 256
# define TIMERCR (1<<CS02)
#endif
#define RC5TIMERFIRST 0x100-((uint8_t) (XTAL/PRESCALEDIV*0.0008890))
#define RC5TIMERSECOND 0x100-((uint8_t) (XTAL/PRESCALEDIV*0.0004445))
#define RC5TIMERCANCEL 0x100-((uint8_t) (XTAL/PRESCALEDIV*0.0008890))
volatile uint16_t rc5_code = 0;
volatile uint8_t rc5_first_half;
//SIGNAL (SIG_INTERRUPT1) {
ISR(INT1_vect) {
/* external interrupt handler
edge from IR receiver detected.
this is assumed to be the middle of a bit.
*/
uint8_t i;
PORTD ^= ( 1 << PD7);
// resample to filter out spikes
if (MCUCR & (1<<ISC10)) {
// we were waiting for a rising edge, so cancel if we sample low
for (i = RC5RESAMPLE; i; i--) if (!(PIND & (1<<PIND3))) return;
} else {
// vice versa...
for (i = RC5RESAMPLE; i; i--) if ((PIND & (1<<PIND3))) return;
}
TCNT0 = RC5TIMERSECOND; // preset timer to sample (ovf int) at second half (3/4 bit time)
rc5_first_half = 0; // next sample will be in the second half
TIMSK |= ( 1 << TOIE0);
GICR &= ~( 1 << INT1);
//sbi(TIMSK, TOIE0); // enable timer ovf int
//cbi(GICR, INT1); // disable ext int (this handler)
}
//SIGNAL (SIG_OVERFLOW0) {
ISR(TIMER0_OVF_vect) {
/* timer overflow handler
sample the present level of the interrupt line.
*/
static uint16_t rc5_shift, rc5_temp;
static uint8_t rc5_bit = 0, level, first_level = 1;
uint8_t i = 0, temp;
// resample to filter out spikes
for (temp = RC5RESAMPLE; temp; temp--) if (PIND & (1<<PIND3)) i++;
level = (i > ((uint8_t) (RC5RESAMPLE/2)));
if (rc5_first_half == 2) {
// this is a timeout, cancel operation
goto rc5_cancel;
} else if (rc5_first_half == 1) {
// this sample is taken in the first half of the bit (1/4 bit time)
first_level = level; // save current level
if (level) MCUCR &= ~( 1 << ISC10);// cbi(MCUCR, ISC10); // currently at high level, wait for falling edge
else MCUCR |= ( 1 << ISC10);//sbi(MCUCR, ISC10); // currently at low level, wait for rising edge
rc5_first_half = 2; // special code, means: next ovf int is a timeout
GICR |= ( 1 << INT1);//sbi(GICR, INT1); // much better: wait for edge ;)
TCNT0 = RC5TIMERCANCEL; // at timer ovf (in around 1/2 bit time) we should get a timeout
} else {
// this sample is taken in the second half of the bit (3/4 bit time)
TCNT0 = RC5TIMERFIRST; // next sample at first half (1/4 bit time) of next bit
rc5_first_half = 1;
if (first_level != level) {
// levels differ -> valid manchester encoded bit detected
if (!rc5_bit) {
// this is the first bit, reset values
rc5_temp = 0;
rc5_shift = 0x8000;
}
if (!level) rc5_temp |= rc5_shift; // low level (low-active) so store a '1'
else if (rc5_bit < 2) goto rc5_cancel; // high level ('0' bit) as startbit -> error
if (++rc5_bit == 14) {
// reception complete, stop operation
rc5_code = rc5_temp;
goto rc5_cancel;
}
if (rc5_shift == 0x0100) rc5_shift = 0x0020;
else rc5_shift >>= 1;
} else {
// error in manchester stream -> cancel operation
goto rc5_cancel;
}
}
return;
rc5_cancel:
MCUCR &= ~( 1 << ISC10); //cbi(MCUCR, ISC10); // falling edge
GICR |= ( 1 << INT1); //sbi(GICR, INT1); // ext. int. enabled
GIFR = (1<<INTF1); // clear an eventually set ext. int. flag
TIMSK &= ~( 1 << TOIE0); //cbi(TIMSK, TOIE0); // disable timer int.
first_level = 1; // as the next ext. int. appears at the falling edge, assume the first level as high
rc5_bit = 0;
}
void rc5_init(void) {
/* init for ext. int. and timer.
call this once to activate the rc5 decoder.
*/
TCCR0 = TIMERCR;
DDRD &= ~( 1 << PD3); //cbi(DDRD, PD3); // pin is input
PORTD &= ~( 1 << PD3); //cbi(PORTD, PD3); // pullup disabled (receiver has defined output)
TIMSK &= ~( 1 << TOIE0); //cbi(TIMSK, TOIE0); // timer ovf disabled. gets enabled by ext. int.
MCUCR |= ( 1 << ISC11); //sbi(MCUCR, ISC11); // ext. int. activated by falling edge
MCUCR &= ~( 1 << ISC10); //cbi(MCUCR, ISC10);
GIFR = (1<<INTF1); // clear ext. int. flag
GICR |= ( 1 << INT1); //sbi(GICR, INT1); // enable ext. int.
}
int main(void) {
// example main program:
rc5_init(); // activate RC5 detection
DDRD |= ( 1 << PD7);
DDRB = 0xff; // PORTB is output
PORTB = 0x00; // all pins low
// start main loop
for (;;) {
if (rc5_code) {
// ...do some action here...
PORTB = (uint8_t) rc5_code; // output low-byte at PORTB
rc5_code = 0; // clear code
}
}
}