/***********************************************************************************
*               ПРОГРАММА ДЕКОДИРОВАНИЯ ПРОТОКОЛА  IR PHILIPS RC5                  *
************************************************************************************
* Для приемника RC5 с инверсным выходом (= активный выходной уровень низкий,)      *
* например, TSOP1736. Выход приемника RC5 подключен к выводу внешнего прерывания   *
* INT(RB0).                                                                        *
*                                                                                  *
************************************************************************************
*Алгоритм :                                                                        *
*~~~~~~~~~                                                                         *
* При каждом изменении входного сигнала от приемника RC5 генерируется прерывание.  *
* В обработчике измеряется время между двумя следующими друг за другом изменениями.*
* На основании измеренной разницы делается вывод: одиночный или двойной импульс.   *
* Если измеренное время находится вне допустимого интервала принятый код считается *
* недостоверным и обработчик переводит себя в исходное состояние. В стейт-машине   *
* используется три состояния: IDLE (СВОБОДЕН), DECODING (ДЕКОДИРОВАНИЕ) и          *
* COMPLETED (ЗАВЕРШЕНО).                                                           *
************************************************************************************
* Hardware config : 16F628A @ 4Mhz  + TSOP1736 + LED + LCD                         *
* -------------------------------------------------------------------------------- *
* LED on RA0 (active when port high)                                               *
* TSOP-1736 : Output pin connected to RB0 (active when low)                        *
* LCD : WH1602 on PORTB : bits 7..4 = DB7...DB4/bit 3 = EN/bit 2 = RS/ GND = RW    *
* Note : when using a different Crystal speed, you will need to change prescaler   *
* in the main program and potentially the counters in the definition section       *
***********************************************************************************/

//-----------------------------------------------------------------------------
// Hardware specific settings
//-----------------------------------------------------------------------------
#define LED_On()      (RA0_bit=1)
#define LED_Off()     (RA0_bit=0)
#define LED_Toggle()  (RA0_bit=~RA0_bit)

#define IR_PIN        (RB0_bit)

//-----------------------------------------------------------------------------
// Predefined constants
//------------------------------------------------------------------------------
#define RC5_NR_Bits   14

// Всего должно быть захвачено 14 RC5_Bits (первый "стартбит" уже есть
// при первом прерывании)
// Формат принимаемых бит:
// - 2 стартовых бита (оба "1")
// - 1 управляющий бит (изменяется всякий раз когда отправлена новая команда)
// - 5 системных бит, старшим битом вперед (номер системы)
// - 6 командных бит, старшим битом вперед (номер команды)
// Биты распознаются между 2-мя фронтами сигнала RC5:
// - "длинный" означает: принятый бит отличается от предыдущего
// - два "коротких" означает: принятый бит эквивалентен предыдущему биту,
//   первый стартовый бит всегда равен "1"

#define RC5_TIME_BOUNDARY       83  // граница, ниже 83 = короткий, выше = длинный (0.75 bittime)
#define RC5_TIME_TOO_SHORT      28  // (0.25 bittime)
#define RC5_TIME_TOO_LONG      140  // (1.25 bittime)

// 1 bit time = 1778 uS
//    "короткий" время = 1/2 bittime = 889 uS, = timer value 55.5 (= 889/16)
//    "длинный"  время = 1 bittime = 1778 uS,  = timer value 111.12 (=1778/16)

//-----------------------------------------------------------------------------
// Global variables
//-----------------------------------------------------------------------------
// LCD module connections
sbit LCD_RS at RB2_bit;
sbit LCD_EN at RB3_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D7 at RB7_bit;

sbit LCD_RS_Direction at TRISB2_bit;
sbit LCD_EN_Direction at TRISB3_bit;
sbit LCD_D4_Direction at TRISB4_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D7_Direction at TRISB7_bit;
// End LCD module connections

enum {
      RC5_IDLE,
      RC5_DECODING,
      RC5_COMPLETED
} RC5_state = RC5_IDLE ;

unsigned int   RC5_bits ;               // содержит принятые биты
unsigned char  RC5_bitCount ;           // счетчик обработанных битов
unsigned char  RC5_prevBit ;            // значение предыдущего бита
unsigned char  RC5_shortPulses ;        // число последовательных коротких бит

struct
{
    toggle   : 1 ;
    device   : 5 ;
    command  : 6 ;
    received : 1 ;
} IR ;

//-----------------------------------------------------------------------------
// Прототипы функций
//-----------------------------------------------------------------------------
void  Lcd_INT (int row, int col, int x, unsigned char len);

//------------------------------------------------------------------------------
// Обработчик прерывания
//------------------------------------------------------------------------------
void interrupt()
{
     unsigned char time;

     // прерывание по INT/RB0
     if (INTF_bit)
     {
       LED_Toggle () ;

       INTEDG_bit = 1-INTEDG_bit ; //переключение INTEDG (фронт-спад INT)
       INTF_bit = 0;

       time = TMR0;       // захват значения таймера
       TMR0 = 0;          // перезапуск таймера

       switch (RC5_state)
       {
           ////////// СВОБОДЕН. НИЧЕГО НЕ ПОЛУЧЕНО ////////////////////////////
           case RC5_IDLE :
                RC5_bits        = 1; // already 1 bit (with value "1") received
                RC5_bitCount    = 1;
                RC5_shortPulses = 0;
                RC5_prevBit     = 1;
                RC5_state       = RC5_DECODING;

                T0IF_bit = 0; // сброс флага переполнения TMR0
                T0IE_bit = 1; // разрешить прерывания TMR0
                break ;

           ////////// ЗАФИКСИРОВАННО ИЗМЕНЕНИЕ. НАЧИНАЕМ ОБРАБОТКУ БИТ /////////
           case RC5_DECODING :  // Execution time is about 52 uS at 4 Mhz CPU clock
                if ((time > RC5_TIME_TOO_SHORT) && (time < RC5_TIME_TOO_LONG))
                {
                     if (time < RC5_TIME_BOUNDARY) // обнаружен короткий импульс
                     {
                        RC5_shortPulses ++ ;
                        if (RC5_shortPulses == 2)
                        {
                           RC5_bits <<= 1;          // сохраняем принятый бит
                           RC5_bits |= RC5_PrevBit;
                           RC5_bitCount ++ ;
                           RC5_shortPulses = 0;
                        }
                     } else {    // обнаружен длинный импульс
                        RC5_prevBit = 1- RC5_prevBit;  // переключаем бит
                        RC5_bits <<= 1;                // сохраняем принятый бит
                        RC5_Bits |= RC5_PrevBit;
                        RC5_bitCount ++ ;
                        RC5_shortPulses = 0;
                     }

                     if (RC5_bitCount == RC5_NR_Bits)// если приняты все биты
                     {
                        RC5_state = RC5_COMPLETED;
                        INTEDG_bit = 0; // следующее прерывание по спаду
                        T0IE_bit = 0;   // отключить прерывания от TMR0
                     }
                } else { // что-то не правильно с временами
                     RC5_state = RC5_IDLE;  // начать сначала
                     INTEDG_bit = 0;        // следующее прерывание по спаду
                     T0IE_bit  = 0;         // отключить прерывания от TMR0
                }
                break ;

           /////////// ВСЕ БИТЫ ПРИНЯТЫ КОРРЕКТНО. Сохранение данных ///////////
           case RC5_COMPLETED :
                INTEDG_bit = 0; // следующее прерывание по спаду
                IR.toggle = ((RC5_bits>>11) & 0x01) ? 0 : 1 ;
                IR.device =  (RC5_bits>>6) & 0b00011111 ;
                IR.command=  (RC5_bits & 0b00111111) ;
                IR.received = 1 ;
                RC5_state = RC5_IDLE ;
                break ;

       } // end switch
     } // end INIF

     // Прерывание TMR0
     if (T0IF_bit)  // Переполнение TMR0, тайм-аут
     {
        if (RC5_state == RC5_DECODING) // что-то неправильно
        {
           RC5_state = RC5_IDLE;  // начать с начала
           LED_Off();
           INTEDG_bit = 0;        // следующее прерывание по спаду
           T0IE_bit  = 0;         // отключить прерывания TMR0
        }
     }

     T0IF_bit = 0; // всегда сбрасывать флаг переполнения TMR0

} // конец обработчика прерывания

//------------------------------------------------------------------------------
// MAIN PROGRAM
//------------------------------------------------------------------------------
void main ()
{
     unsigned int dev, cmd ;
     unsigned int repeat ;
     unsigned char last_toggle ;

     // инициализация стейт машины
     RC5_state = RC5_IDLE ;
 
    // инициализация регистров
    CMCON  = 0x07 ;         // отключить компараторы
    
    PORTA  = 0;
    TRISA = 0;
    
    PORTB = 0;
    TRISB = 0b00000001;     // PORTB D7-D1 = LCD  / D0 = IR приемник

    // Настройка TMR0  -->  Настройки зависят от кварца
    // Настройки TMR0  : Предделитель = 1:16 -  1 тик = 16 usec / 62.5 Khz
    OPTION_REG = 0x83;
    TMR0  = 0;  // предустановка TMR0

    T0IF_bit = 0;
    T0IE_bit = 0;      // отключить прерывания от TMR0

    // Enable external interrupt
    INTEDG_bit    = 0;            // начинаем со спада
    INTF_bit      = 0;            // сброс флага прерывания INT
    INTE_bit      = 1;            // разрешить прерывание INT
    GIE_bit       = 1;            // разрешить все прерывания

    // Инициализация LCD
    LCD_Init();
    Lcd_Cmd(_LCD_CURSOR_OFF);                  // Выключить курсор
    Lcd_Out (1, 1, "  Philips RC5") ;
    Lcd_Out (2, 1, "    Decoder  ") ;

    IR.received = 0 ;
    last_toggle = 2 ; // Невозможное значение

    // главный цикл программы

    while (1)
    {
          if (IR.received) {
             dev = IR.device ;
             cmd = IR.command;
             IR.received = 0 ;  // Команда обработана

             if (last_toggle == IR.toggle)
             {
                repeat ++ ;
             } 
             else
             {
                repeat = 0 ;
                last_toggle = IR.toggle;
             }

             LCD_Out (1, 1, "DEV CMD TOG CNT") ;
             LCD_INT (2, 1, dev, 3) ;
             LCD_Chr (2, 4, ' ');
             LCD_INT (2, 5, cmd, 3) ;
             LCD_Chr (2, 8, ' ');
             LCD_Out (2, 9, IR.toggle ? " T  ":"    ") ;
             LCD_INT (2, 13, repeat, 3) ;
          }
          Delay_ms (250) ;
    }
} // end main

//------------------------------------------------------------------------------
// ДОПОЛНИТЕЛЬНЫЕ ПОДПРОГРАММЫ
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
void  Lcd_INT (int row, int col, int x, unsigned char size)
{
      static char txt[7] ;
      int i ;

      IntToStr (x, txt) ;
      for (i=0; i<7; i++) if (txt[i] == ' ') txt[i] = '0' ;
      Lcd_Out(row, col, txt+(6-size)) ;
}

if(IR.received == 1) {
   switch(IR.command)
              {
               case 1: RA2_bit = ~RA2_bit; break; // на ПДУ нажата кнопка "1", переключить RA2
               case 2: RA3_bit = ~RA3_bit; break; // на ПДУ нажата кнопка "2", переключить RA3
       ......................
              }
  IR.received = 0;
}