irrx/irrx_bitlength.c

Go to the documentation of this file.

#include "irrx.h"
#include "irrx_config.h"
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>

// *******************************************************************************
// *
// * Protocol definition
// *
// *******************************************************************************

#if defined(IRRX_PROTOCOL_NEC)
#define IRRX_BITLENGTH_STARTBIT_uS (2400L) 
#define IRRX_BITLENGTH_ZERO_uS (3600L) 
#define IRRX_BITLENGTH_ONE_uS (1800L)
#define IRRX_STARTBITS 2
#define IRRX_NORMAL_BITS 32
#define IRRX_RECEIVE_TIMEOUT_uS 200000L 
#define IRRX_RECEIVE_OK(_irrxbuffer) ((_irrxbuffer.bitbuffer.nec.addr ^ _irrxbuffer.bitbuffer.nec.addr) == 0xFF &&   \
                           (_irrxbuffer.bitbuffer.nec.command ^ _irrxbuffer.bitbuffer.nec.command_inv) == 0xFF)

#define IRRX_GETCODE(_irrxbuffer) ((_irrxbuffer.bitbuffer.nec.addr << 8) | _irrxbuffer.bitbuffer.nec.command) 
#define IRRX_MSB_FIRST 1
#define IRRX_LSB_FIRST 0

#elif defined(IRRX_PROTOCOL_SONY)

#define IRRX_BITLENGTH_STARTBIT_uS (2400L) 
#define IRRX_BITLENGTH_ZERO_uS (1200L) 
#define IRRX_BITLENGTH_ONE_uS (1800L)
#define IRRX_STARTBITS 1
#define IRRX_NORMAL_BITS 20L
#define IRRX_RECEIVE_TIMEOUT_uS 50000L 
#define IRRX_MSB_FIRST 0
#define IRRX_LSB_FIRST 1

#define IRRX_RECEIVE_OK(_irrxbuffer) (1) 
#define IRRX_GETCODE(_irrxbuffer) ((_irrxbuffer.bitbuffer.sony.addr << 12) | _irrxbuffer.bitbuffer.sony.command) 

#else
#error IRRX Protocol not defined
#endif 

// *******************************************************************************
// *
// * Internal macros
// *
// *******************************************************************************

#if defined(__AVR_AT90S4433__)
//PB0 is irrx input w/ pull-up. irrx power is directly from vcc
#define IRRX_INIT_PORTS()  {DDRB&=~_BV(PB0);PORTB &= ~_BV(PB0);}
#define IRRX_IS_LOW() (!(PINB & _BV(PB0)))
#define IRRX_POWER_ON() (void)(0)
#define IRRX_POWER_OFF() (void)(0)

#elif defined(__AVR_ATmega8__)
//PB0 is irrx input wo/ pull-up.
#define IRRX_INIT_PORTS()  {DDRB&=~_BV(PB0);PORTB &= ~_BV(PB0);}
#define IRRX_IS_LOW() (!(PINB & _BV(PB0)))
#define IRRX_POWER_ON()   PORTB|=_BV(PB7)
#define IRRX_POWER_OFF() PORTB&=~_BV(PB7)

#else
#error "Hardware not configured for IR. Add more CPU definitions."
#endif 

#if (0 || defined(IRRX_TRACE_))
#include <stdio.h>
#define IRRX_TRACE1_(str) fprintf(stdout,str);
#define IRRX_TRACE2_(str,p1) fprintf(stdout,str,p1);
#else 
#define IRRX_TRACE1_(str) (void)0
#define IRRX_TRACE2_(str,p1) (void)0 
#endif  

#define IRRX_STATIC_ASSERT(expr) extern char static_assert[ (!!(expr))*2 - 1]

#define IRRX_BIT_COUNT_COMPLETE_MASK 0x80

#define TIMER1_CRITICAL_SECTION_ENTER() { uint8_t saved_sreg = TIMSK; TIMSK &=~ (_BV(TICIE1) | _BV(TOIE1)); {

#define TIMER1_CRITICAL_SECTION_EXIT() } TIMSK = saved_sreg; }

#define IRRX_TIMER1_uS_TO_TICKS(_uS)  (((_uS) * (F_CPU / 1000000L)) / (64L))
#define IRRX_TIMER1_ENABLE_INTERRUPTS() TIMSK |= (_BV(TICIE1) | _BV(OCIE1A))
#define IRRX_TIMER1_ENABLE_ICP_RISING_EDGE() {TCCR1B |=_BV(ICES1); TIMSK |= _BV(TICIE1);}
#define IRRX_TIMER1_ENABLE_ICP_FALLING_EDGE() {TCCR1B &=~_BV(ICES1); TIMSK |= _BV(TICIE1);}
#define IRRX_TIMER1_DISABLE_ICP() {TIMSK &=~_BV(TICIE1);}

#define IRRX_TIMER1_START() TCCR1A = 0;TCCR1B |= _BV(ICNC1) | _BV(CS11) | _BV(CS10)
#define IRRX_TIMER1_STOP() TCCR1B &= ~ (_BV(CS12)|_BV(CS11)|_BV(CS10)
#define IRRX_TIMER1_CLEAR_ICP_FLAG() TIFR |=_BV(ICF1)
#define IRRX_TIMER1_RESET() TCNT1 = 0

#define IRRX_RECEIVE_TIMEOUT_TICKS IRRX_TIMER1_uS_TO_TICKS(IRRX_RECEIVE_TIMEOUT_uS)

#define IRRX_BITLENGTH_TICKS_ZERO  IRRX_TIMER1_uS_TO_TICKS(IRRX_BITLENGTH_ZERO_uS)
#define IRRX_BITLENGTH_TICKS_ONE   IRRX_TIMER1_uS_TO_TICKS(IRRX_BITLENGTH_ONE_uS)
#define IRRX_BITLENGTH_TICKS_STARTBIT   IRRX_TIMER1_uS_TO_TICKS(IRRX_BITLENGTH_STARTBIT_uS)

#define IRRX_BITLENGTH_TICKS_STARTBIT_MIN   (IRRX_BITLENGTH_TICKS_STARTBIT * 3 / 4)
#define IRRX_BITLENGTH_TICKS_STARTBIT_MAX   (IRRX_BITLENGTH_TICKS_STARTBIT * 5 / 4)

#define IRRX_BITLENGTH_TICKS_BIT_MIN (IRRX_BITLENGTH_TICKS_ZERO * 3 / 4)
#define IRRX_BITLENGTH_TICKS_BIT_MAX (IRRX_BITLENGTH_TICKS_ONE * 5 / 4)

#define IRRX_BITLENGTH_TICKS_BIT_AVG ((IRRX_BITLENGTH_TICKS_ONE + IRRX_BITLENGTH_TICKS_ZERO) / 2)

IRRX_STATIC_ASSERT(IRRX_BITLENGTH_TICKS_ZERO < IRRX_BITLENGTH_TICKS_ONE); //Code doesn't handle this case yet.


IRRX_STATIC_ASSERT(IRRX_LSB_FIRST + IRRX_MSB_FIRST == 1); //Need one and only one

IRRX_STATIC_ASSERT(IRRX_BITLENGTH_TICKS_ONE >= 10);
//If this fail the prescaler needs to be changed
IRRX_STATIC_ASSERT(IRRX_BITLENGTH_TICKS_ZERO < 6000);
//If this fail the prescaler needs to be changed
IRRX_STATIC_ASSERT(IRRX_BITLENGTH_TICKS_STARTBIT_MIN >= 10);
//If this fail the prescaler needs to be changed
IRRX_STATIC_ASSERT(IRRX_BITLENGTH_TICKS_STARTBIT_MAX < 6000);
//If this fail the prescaler needs to be changed
IRRX_STATIC_ASSERT(IRRX_RECEIVE_TIMEOUT_TICKS> 100);
//If this fail the prescaler needs to be changed
IRRX_STATIC_ASSERT(IRRX_RECEIVE_TIMEOUT_TICKS < 65000);
//If this fail the prescaler needs to be changed

typedef struct
{
  uint16_t ticks_one;
  uint16_t ticks_zero;
  uint16_t ticks_min;
  uint16_t ticks_max;
  uint16_t ticks_startbit_min;
  uint16_t ticks_startbit_max;
  uint16_t ticks_receive_timeout;
} irrx_settings_t;

#if defined(IRRX_DEBUG_PARAMETERS)
const irrx_settings_t irrx_settings PROGMEM  =
  { IRRX_BITLENGTH_TICKS_ONE, IRRX_BITLENGTH_TICKS_ZERO,
      IRRX_BITLENGTH_TICKS_BIT_MIN, IRRX_BITLENGTH_TICKS_BIT_MAX,
      IRRX_BITLENGTH_TICKS_STARTBIT_MIN,
      IRRX_BITLENGTH_TICKS_STARTBIT_MAX, IRRX_RECEIVE_TIMEOUT_TICKS };
#endif //#if defined(IRRX_DEBUG_PARAMETERS)

// *******************************************************************************
// *
// * Functions and ISRs
// *
// *******************************************************************************


static volatile irrx_code_t irrx_receivebuffer = 0;

enum
{
  irrx_bitcount_init = 0,
  irrx_bitcount_startbit1begin = irrx_bitcount_init,
  irrx_bitcount_startbit1end,
#if IRRX_STARTBITS == 1
  irrx_bitcount_startbit2begin = irrx_bitcount_startbit1begin,
  irrx_bitcount_startbit2end = irrx_bitcount_startbit1end,
#elif IRRX_STARTBITS == 2
  irrx_bitcount_startbit2begin,
  irrx_bitcount_startbit2end,
#endif
  irrx_bitcount_firstbit,
  irrx_bitcount_lastbit = irrx_bitcount_firstbit + IRRX_NORMAL_BITS
};
typedef uint8_t irrx_bitcount_t;

typedef struct
{
  irrx_bitcount_t bitcount;
  irrx_code_t last_received;
  union
  {
    uint32_t all;
#if defined(IRRX_PROTOCOL_NEC)
    struct
    {
      uint8_t addr;
      uint8_t addr_inv;
      uint8_t command;
      uint8_t command_inv;
    }nec;
#endif //#if defined(IRRX_PROTOCOL_NEC)
#if defined(IRRX_PROTOCOL_SONY)
    struct
    {
      uint16_t padding : 12;
      uint16_t addr : 9;
      uint16_t command : 11;
    } sony;
#endif //#if defined(IRRX_PROTOCOL_SONY)
  } bitbuffer;
} irrx_internal_t;

static irrx_internal_t irrx_internal;

IRRX_STATIC_ASSERT(sizeof(irrx_internal.bitbuffer) == sizeof(uint32_t));

ISR(TIMER1_COMPA_vect)
{
  if (irrx_internal.bitcount != irrx_bitcount_init)
  {
    IRRX_TRACE1_("k");
  }
  irrx_internal.bitcount = irrx_bitcount_init;
  //Set interrupt to detect start of start bit (falling edge because signal is inverted)
  IRRX_TIMER1_ENABLE_ICP_FALLING_EDGE();
}


ISR(TIMER1_CAPT_vect)
{
  uint16_t icr = ICR1;
  IRRX_TIMER1_RESET();
  IRRX_TIMER1_CLEAR_ICP_FLAG();
  //IRRX_TRACE2_("%d",icr);
  //Set timeout ticks for the end of reception (will trigger) 
  OCR1A = IRRX_RECEIVE_TIMEOUT_TICKS;
  if (irrx_internal.bitcount == irrx_bitcount_startbit1begin || 
    irrx_internal.bitcount == irrx_bitcount_startbit2begin)
  {
    //Set interrupt to detect rest of bits bit (rising edge because signal is inverted)
    IRRX_TIMER1_ENABLE_ICP_RISING_EDGE();
    IRRX_TRACE1_("A");
    irrx_internal.bitcount++;
    return;
  }
  else if (irrx_internal.bitcount == irrx_bitcount_startbit1end || 
      irrx_internal.bitcount == irrx_bitcount_startbit2end)
  {
    IRRX_TIMER1_ENABLE_ICP_FALLING_EDGE();
    if (IRRX_BITLENGTH_TICKS_STARTBIT_MIN < icr && icr < IRRX_BITLENGTH_TICKS_STARTBIT_MAX)
    {
      IRRX_TRACE1_("B");
      irrx_receivebuffer = IRRX_NO_CODE;
      irrx_internal.bitcount++;
      return;
    }
  }
  else {
    //Within a valid range?
    if (IRRX_BITLENGTH_TICKS_BIT_MIN < icr && icr < IRRX_BITLENGTH_TICKS_BIT_MAX)
    {
      irrx_internal.bitcount++;

      if (IRRX_LSB_FIRST) {       
        irrx_internal.bitbuffer.all >>= 1; //Make room for new bit
      }
      else if (IRRX_MSB_FIRST) {
        irrx_internal.bitbuffer.all <<= 1; //Make room for new bit
      }
      

      //0 or 1?
      if (icr > IRRX_BITLENGTH_TICKS_BIT_AVG)
      {
        if (IRRX_LSB_FIRST) {       
          irrx_internal.bitbuffer.all |= ((uint32_t)1L << (uint32_t)IRRX_NORMAL_BITS);
        }
        else if (IRRX_MSB_FIRST) {
          irrx_internal.bitbuffer.all |= 1;
        }
        IRRX_TRACE1_("x");
      }
      else
      {
        IRRX_TRACE1_("o");
      }

      //Last bit?
      if (irrx_internal.bitcount >= irrx_bitcount_lastbit)
      {
        IRRX_TRACE1_("s");

        //Check that ir code looks ok (not all protocol uses this function)
        if (IRRX_RECEIVE_OK(irrx_internal))
        {
          IRRX_TRACE1_("G");
          irrx_receivebuffer = IRRX_GETCODE(irrx_internal);
        }
        else
        {
          irrx_receivebuffer = IRRX_NO_CODE;
        }
        irrx_internal.bitcount = irrx_bitcount_init;
      }
      return;
    }
  }
  IRRX_TIMER1_ENABLE_ICP_FALLING_EDGE();
  irrx_internal.bitcount = irrx_bitcount_init;
  IRRX_TRACE1_("Y"); 
}
// *******************************************************************************
// *
// * External API
// *
// *******************************************************************************


void irrx_init(void)
{
  IRRX_INIT_PORTS();
  IRRX_POWER_OFF();
}
 
void irrx_power_on(void)
{
  irrx_internal.bitcount = irrx_bitcount_init;
  irrx_receivebuffer = IRRX_NO_CODE;
  IRRX_POWER_ON();
  IRRX_TIMER1_START();
  IRRX_TIMER1_ENABLE_INTERRUPTS();
  IRRX_TIMER1_ENABLE_ICP_FALLING_EDGE();
} 
  
void irrx_power_off(void)
{
  irrx_receivebuffer = IRRX_NO_CODE;
  IRRX_POWER_OFF();
}

irrx_code_t irrx_getcode(void)
{
  irrx_code_t result;
  TIMER1_CRITICAL_SECTION_ENTER()
  result = irrx_receivebuffer;
  TIMER1_CRITICAL_SECTION_EXIT()
  return result;
}

---