/**
* IR receiver and transmitter driver.
*
* @date 2006-12-10
*
* @author Anders Runeson, Andreas Fritiofson
*
*/
/*-----------------------------------------------------------------------------
* Includes
*---------------------------------------------------------------------------*/
#include <config.h>
#include <drivers/mcu/pcint.h>
#include <drivers/ir/transceiver/irtransceiverMulti.h>
#include <drivers/ir/protocols.h>
#include <avr/io.h>
#include <avr/interrupt.h>
//#include <drivers/mcu/gpio.h>
/*-----------------------------------------------------------------------------
* Prerequisites
*---------------------------------------------------------------------------*/
#if defined(__AVR_ATmega8__) || defined(__AVR_ATmega16__) || defined(__AVR_ATmega32__)
#define TIMSK1 TIMSK
#define TIFR1 TIFR
#define ICIE1 TICIE1
#endif
#define IR_COMPARE_VECTOR TIMER1_COMPB_vect
#define IR_TIMEOUT_VECTOR TIMER1_COMPA_vect
#define IR_CAPTURE_VECTOR TIMER1_CAPT_vect
#define IR_TIMEOUT_REG OCR1A
#define IR_COMPARE_REG OCR1B
#define IR_CAPTURE_REG ICR1
#define IR_COUNT_REG TCNT1
#define IR_MODULATION_REG OCR0A
/*#define IR_TIMER_INIT() TCCR1A = 0; \
TCCR1B = (1<<ICNC1)|(2<<CS10);
*/
#define IR_TIMER_INIT() TCCR1A = 0; \
TCCR1B = (2<<CS10);
#define IR_MASK_COMPARE() TIMSK1 &= ~(1<<OCIE1B);
#define IR_UNMASK_COMPARE() TIFR1 = (1<<OCF1B); TIMSK1 |= (1<<OCIE1B);
#define IR_MASK_TIMEOUT() TIMSK1 &= ~(1<<OCIE1A);
#define IR_UNMASK_TIMEOUT() TIFR1 = (1<<OCF1A); TIMSK1 |= (1<<OCIE1A);
#define IR_MASK_CAPTURE() TIMSK1 &= ~(1<<ICIE1);
#define IR_UNMASK_CAPTURE() TIFR1 = (1<<ICF1); TIMSK1 |= (1<<ICIE1);
#define IR_CAPTURE_FALLING() TCCR1B &= ~(1<<ICES1); \
TIFR1 = (1<<ICF1);
#define IR_CAPTURE_RISING() TCCR1B |= (1<<ICES1); \
TIFR1 = (1<<ICF1);
//#define IR_OUTP_HIGH() TCCR0A |= (1<<COM0A0);
//#define IR_OUTP_LOW() TCCR0A &= ~(1<<COM0A0);
#if IR_TX_ACTIVE_LOW==1
#define IR_OUTP_HIGH() *drvIrTxChannel[channel].port &= ~drvIrTxChannel[channel].pinmask
#define IR_OUTP_LOW() *drvIrTxChannel[channel].port |= drvIrTxChannel[channel].pinmask
#else
#define IR_OUTP_HIGH() *drvIrTxChannel[channel].port |= drvIrTxChannel[channel].pinmask
#define IR_OUTP_LOW() *drvIrTxChannel[channel].port &= ~drvIrTxChannel[channel].pinmask
#endif
/*-----------------------------------------------------------------------------
* Globals
*---------------------------------------------------------------------------*/
#if IR_RX_ENABLE==1
struct {
uint8_t enable;
uint16_t timeout;
uint16_t *buf;
uint8_t len;
uint8_t index;
uint8_t storeEnable;
irRxCallback_t callback;
} drvIrRxChannel[3];
#endif
#if IR_TX_ENABLE==1
struct {
uint8_t enable;
uint16_t timeout;
uint8_t timeoutEnable;
uint16_t *buf;
uint8_t len;
uint8_t index;
irTxCallback_t callback;
volatile uint8_t *port;
uint8_t pinmask;
} drvIrTxChannel[3];
uint16_t drvIrTxModFreqkHz = 38; /* Default to 38kHz */
#endif
/*-----------------------------------------------------------------------------
* Interrupt Handlers
*---------------------------------------------------------------------------*/
/* TRANSMIT */
#if IR_TX_ENABLE==1
ISR(IR_COMPARE_VECTOR)
{
/* find which channel */
uint16_t time = IR_COMPARE_REG
; uint16_t diff;
uint8_t channel;
/* go through all channels and check which of thems have overflowed */
for (channel=0; channel < IR_SUPPORTED_NUM_CHANNELS; channel++)
{
/* if channel is waiting for an overflow */
if (drvIrTxChannel[channel].timeoutEnable==TRUE)
{
/* check if channel have overflowed or is about to overflow */
diff
= (time+50)-drvIrTxChannel
[channel
].
timeout; if (diff < IR_MAX_PULSE_WIDTH)
{
/* check what to output next */
if ((drvIrTxChannel[channel].index&1) == 1) { /* if odd, ir-pause */
IR_OUTP_LOW();
} else {
IR_OUTP_HIGH();
}
/* is there more to send */
if (drvIrTxChannel[channel].index < drvIrTxChannel[channel].len)
{
/* load next timeout value */
drvIrTxChannel[channel].timeout = IR_COMPARE_REG + drvIrTxChannel[channel].buf[drvIrTxChannel[channel].index++];
}
else
{
/* disable this channel */
drvIrTxChannel[channel].timeoutEnable = FALSE;
/* disable the overflow interrupt */
IR_MASK_COMPARE();
/* notify the application that a pulse train has been sent. */
drvIrTxChannel[channel].callback(channel);
}
}
}
}
channel = 0;
diff = 0xffff;
/* go through all channels and find the one that have the next overflow */
for (uint8_t i=0; i < IR_SUPPORTED_NUM_CHANNELS; i++)
{
/* if channel is waiting for an overflow */
if (drvIrTxChannel[i].timeoutEnable==TRUE)
{
if (drvIrTxChannel
[i
].
timeout - time < diff
) {
diff
= drvIrTxChannel
[i
].
timeout - time; channel = i;
}
/* enable overflow interrupt */
IR_UNMASK_COMPARE();
}
}
/* set compare value to the channel that have the next overflow */
IR_COMPARE_REG = drvIrTxChannel[channel].timeout;
}
#endif
#if IR_RX_ENABLE==1
/* RECEIVE */
/* When this timeout occurs a pulsetrain is complete */
ISR(IR_TIMEOUT_VECTOR)
{
#if IR_RX_CONTINUOUS_MODE==0
for (uint8_t i=0; i < IR_SUPPORTED_NUM_CHANNELS; i++)
{
/* If more than 2 edges were recevied */
if (drvIrRxChannel[i].storeEnable == TRUE && drvIrRxChannel[i].len > 2)
{
/* Notify the application that a pulse train has been received. */
drvIrRxChannel[i].callback(i, drvIrRxChannel[i].buf, drvIrRxChannel[i].len, drvIrRxChannel[i].index);
}
drvIrRxChannel[i].storeEnable = FALSE;
}
/* Disable ISR */
IR_MASK_TIMEOUT();
#endif
// gpio_toggle_pin(EXP_J);
}
#endif
/*-----------------------------------------------------------------------------
* Private Functions
*---------------------------------------------------------------------------*/
#if IR_RX_ENABLE==1
/* these wrapper functions are called from the pcint driver (callback) */
void IrTransceiver_Store_ch0(uint8_t id, uint8_t status)
{
IrTransceiver_Store(0);
}
void IrTransceiver_Store_ch1(uint8_t id, uint8_t status)
{
IrTransceiver_Store(1);
}
void IrTransceiver_Store_ch2(uint8_t id, uint8_t status)
{
IrTransceiver_Store(2);
}
///////////// DEBUG!!!!
//#include <drivers/mcu/gpio.h>
void IrTransceiver_Store(uint8_t channel)
{
static uint16_t prev_time[3];
uint16_t pulsewidth;
/* Read the timer counter register to get the current "time". */
uint16_t time = IR_COUNT_REG
;
/* Subtract the current measurement from the previous to get the pulse width. */
pulsewidth
= time - prev_time
[channel
]; prev_time
[channel
] = time;
#if IR_MIN_STARTPULSE_WIDTH>0
if ((pulsewidth <= IR_MIN_STARTPULSE_WIDTH) && (drvIrRxChannel[channel].storeEnable == TRUE) && (drvIrRxChannel[channel].len == 0))
{
IR_MASK_TIMEOUT();
return;
}
else
{
IR_UNMASK_TIMEOUT();
}
#endif
//gpio_toggle_pin(EXP_K);
#if IR_RX_CONTINUOUS_MODE==1
/* in continuous mode when short pulse arrives received len should be set to zero */
//TODO?
if ((pulsewidth < (IR_MIN_PULSE_WIDTH*CYCLES_PER_US/TIMER_PRESC)) && (drvIrRxChannel[channel].storeEnable == TRUE))
{
///////////// DEBUG!!!!
//gpio_toggle_pin(EXP_A);
drvIrRxChannel[channel].len = 0;
return;
}
else
{
}
#endif
//gpio_toggle_pin(EXP_A);
if (drvIrRxChannel[channel].storeEnable)
{
/* Store the measurement. */
drvIrRxChannel[channel].buf[drvIrRxChannel[channel].len++] = pulsewidth;
/* Disable future measurements if we've filled the buffer. */
//TODO: Report overflow to application
if (drvIrRxChannel[channel].len == MAX_NR_TIMES)
{
drvIrRxChannel[channel].len = MAX_NR_TIMES-1;
}
else
{
#if IR_RX_CONTINUOUS_MODE==0
/* Set the timeout for detection of the end of the pulse train. */
drvIrRxChannel
[channel
].
timeout = time + (IR_MAX_PULSE_WIDTH
*CYCLES_PER_US
/TIMER_PRESC
); IR_TIMEOUT_REG = drvIrRxChannel[channel].timeout;
#else
/* Notify the application that a pulse has been received. */
drvIrRxChannel[channel].callback(channel, drvIrRxChannel[channel].buf, drvIrRxChannel[channel].len, drvIrRxChannel[channel].index);
#endif
}
}
else if (drvIrRxChannel[channel].enable == TRUE)
{
/* The first edge of the pulse train has been detected. Enable the storage of the following pulsewidths. */
drvIrRxChannel[channel].storeEnable = TRUE;
drvIrRxChannel[channel].len = 0;
#if IR_RX_CONTINUOUS_MODE==0
/* Enable timeout interrupt for detection of the end of the pulse train. */
IR_TIMEOUT_REG
= time + (IR_MAX_PULSE_WIDTH
*CYCLES_PER_US
/TIMER_PRESC
); IR_UNMASK_TIMEOUT();
#endif
}
}
#endif
/* call this function like this:
IrTransceiver_InitRxChannel(channelnumber, buffer, callback, pcint-id, GPIO_D6);
buffer is a memory location
callback is a function to call when a receive/transmitt is complete
also call with IO port to use
*/
#if IR_RX_ENABLE==1
void IrTransceiver_InitRxChannel(uint8_t channel, uint16_t *buffer, irRxCallback_t callback, uint8_t pcint_id, volatile uint8_t* port, volatile uint8_t* pin, volatile uint8_t* ddr,uint8_t nr, uint8_t pcint)
{
if (channel == 0)
{
Pcint_SetCallback(pcint_id, pcint, &IrTransceiver_Store_ch0);
}
else if (channel == 1)
{
Pcint_SetCallback(pcint_id, pcint, &IrTransceiver_Store_ch1);
}
else if (channel == 2)
{
Pcint_SetCallback(pcint_id, pcint, &IrTransceiver_Store_ch2);
}
if (channel < 3)
{
/* Set port direction to input */
*ddr &= ~(1 << nr);
drvIrRxChannel[channel].buf = buffer;
drvIrRxChannel[channel].len = 0;
drvIrRxChannel[channel].storeEnable = FALSE;
drvIrRxChannel[channel].callback = callback;
drvIrRxChannel[channel].enable = TRUE;
}
}
/* call this function like this:
IrTransceiver_DeInitRxChannel(channelnumber, pcint-id, GPIO_D6);
*/
void IrTransceiver_DeInitRxChannel(uint8_t channel, uint8_t pcint_id, volatile uint8_t* port, volatile uint8_t* pin, volatile uint8_t* ddr,uint8_t nr, uint8_t pcint)
{
/* Deactivate interrupt */
Pcint_SetCallback(pcint_id, pcint, 0);
if (channel < 3)
{
/* Deactivate channel */
drvIrRxChannel[channel].enable = FALSE;
drvIrRxChannel[channel].len = 0;
drvIrRxChannel[channel].storeEnable = FALSE;
drvIrRxChannel[channel].callback = 0;
}
}
uint8_t IrTransceiver_GetStoreEnableRx(uint8_t channel)
{
return drvIrRxChannel[channel].storeEnable;
}
void IrTransceiver_DisableRx(uint8_t channel)
{
if (channel < 3)
{
/* Soft disable channel */
drvIrRxChannel[channel].enable = FALSE;
}
}
void IrTransceiver_EnableRx(uint8_t channel)
{
if (channel < 3)
{
/* Soft enable channel */
drvIrRxChannel[channel].enable = TRUE;
}
}
void IrTransceiver_ResetRx(uint8_t channel)
{
if (channel < 3)
{
/* Reset channel */
drvIrRxChannel[channel].len = 0;
drvIrRxChannel[channel].storeEnable = FALSE;
}
}
#endif
void IrTransceiver_Init(void)
{
IR_TIMER_INIT();
#if IR_RX_ENABLE==1
for (uint8_t i = 0; i < 3; i++)
{
drvIrRxChannel[i].storeEnable = FALSE;
drvIrRxChannel[i].len = 0;
}
#endif
#if IR_TX_ENABLE==1
/* Set up transmitter */
#if defined(__AVR_ATmega88__) || defined(__AVR_ATmega168__) || defined(__AVR_ATmega168P__) || defined(__AVR_ATmega328P__)
TCCR0A = (0<<COM0A1)|(0<<COM0A0)|(1<<WGM01)|(0<<WGM00);
TCCR0B = (0<<WGM02)|(1<<CS00)|(0<<CS01)|(0<<CS02);
/* Set up modulation frequency */
IR_MODULATION_REG = (((F_CPU / 2000) / drvIrTxModFreqkHz) - 1);
/* start pwm generator */
TCCR0A |= (1<<COM0A0);
#endif
#endif
}
#if IR_TX_ENABLE==1
void IrTransceiver_InitTxChannel(uint8_t channel, irTxCallback_t callback, volatile uint8_t *port, volatile uint8_t *pin, volatile uint8_t *ddr,uint8_t nr, uint8_t pcint)
{
if (channel < 3)
{
drvIrTxChannel[channel].port=port;
drvIrTxChannel[channel].pinmask=(1<<nr);
/* set up port as output */
*ddr |= (1<<nr);
IR_OUTP_LOW();
drvIrTxChannel[channel].callback = callback;
drvIrTxChannel[channel].enable = TRUE;
drvIrTxChannel[channel].timeoutEnable = FALSE;
}
}
int IrTransceiver_Transmit(uint8_t channel, uint16_t *buffer, uint8_t start, uint8_t length, uint16_t modfreqkHz)
{
if (modfreqkHz == 0) {
/* Invalid frequency. */
return -1;
}
if (length == 0) {
/* No data. */
return -2;
}
if (drvIrTxChannel[channel].timeoutEnable == TRUE) {
/* Channel busy. */
return -3;
}
/* New modulation frequency. */
if (modfreqkHz != drvIrTxModFreqkHz) {
/* Check that no transmissions are ongoing. */
for (uint8_t i = 0; i < IR_SUPPORTED_NUM_CHANNELS; i++) {
/* Channel is waiting for an overflow. */
if (drvIrTxChannel[i].timeoutEnable == TRUE) {
/* Transmission active. */
return -4;
}
}
}
/* Update modulation frequency. */
drvIrTxModFreqkHz = modfreqkHz;
/* Start new transmission. */
drvIrTxChannel[channel].timeoutEnable = TRUE;
drvIrTxChannel[channel].buf = buffer;
drvIrTxChannel[channel].len = start + length;
/* first value will be loaded directly to timer below, therefore index is set to 1 here */
drvIrTxChannel[channel].index = 1 + start;
drvIrTxChannel[channel].timeout = IR_COUNT_REG + drvIrTxChannel[channel].buf[start];
/* go through all channels and find the one that have the next overflow */
uint8_t nextChannel = 0;
uint16_t timeRemaining = 0xffff;
uint16_t timeNow = IR_COMPARE_REG;
for (uint8_t i = 0; i < IR_SUPPORTED_NUM_CHANNELS; i++)
{
/* channel is not waiting for an overflow */
if (drvIrTxChannel[i].timeoutEnable == FALSE) continue;
if (drvIrTxChannel[i].timeout - timeNow < timeRemaining) // || (timeout - time > 0xffff-IR_MAX_PULSE_WIDTH)
{
timeRemaining = drvIrTxChannel[i].timeout - timeNow;
nextChannel = i;
}
}
/* set compare value to the channel that have the next overflow */
IR_COMPARE_REG = drvIrTxChannel[nextChannel].timeout;
/* set up modulation frequency */
IR_MODULATION_REG = (((F_CPU / 2000) / drvIrTxModFreqkHz) - 1);
/* Start send on pin */
IR_OUTP_HIGH();
/* enable overflow interrupt */
IR_UNMASK_COMPARE();
return 1;
}
#endif