root/RF_BT_Tail/RF.c

// File: RF.c
//------------------------------------------------------------------------------
// Author: Giovanni de Sanctis
// Email: info@lateral-technologies.com
//------------------------------------------------------------------------------
// Date: Sep 2019
// RF remote decoder
//------------------------------------------------------------------------------



#include "RF.h"
#include "mcc_generated_files/tmr1.h"

#define CODE_LEN        24u     //Number of bits in the code (including start stop etc.; we don't care)
#define BUT_MASK        (0x000000FFul)
#define CODE_MASK       (0xFFFFFE00ul)
#define CODE1           (0x00430000ul)                          //RF code1 to match (433)
#define CODE2           (0x006AAA00ul)                          //RF code2 to match (315)
#define CODE3           (0x00011200ul)                          //RF code3 to match (new 315)

#define T_BASE_NS       500u                                            //T1 Clock in ns
#define T_START_MIN     (8000000u/T_BASE_NS)            //Min long space before code (8ms)

#define T_MARK0_MIN     ((0.8* 333333u)/T_BASE_NS)      //Min 0 mark
#define T_MARK0_MAX     ((1.8* 333333u)/T_BASE_NS)      //Max 0 mark

#define T_MARK1_MIN     ((0.8* 1000000u)/T_BASE_NS)     //Min 0 mark
#define T_MARK1_MAX     ((1.8*1000000u)/T_BASE_NS)      //Max 0 mark

#define T_MARK_TOL      80000u/T_BASE_NS                        //Tolerance +/- 0.08ms

#define N_LONG_PRESS  10                                                //# code matches for long press

#define RF_A1    0x50
#define RF_B1    0x48
#define RF_C1    0x44
#define RF_D1    0x42

#define RF_A2    0x18
#define RF_B2    0x80
#define RF_C2    0x06
#define RF_D2    0x60

#define RF_A3    0x81
#define RF_B3    0x82
#define RF_C3    0x84
#define RF_D3    0x88


uint8_t  bitPtr;                //Number of bits received
uint8_t  matches;               //Number of code matches (for button press length)
uint8_t  attempts;              //Number of restarts before code detected
uint8_t  waitingRelease;
uint32_t code;                  //Code being read
uint32_t lastCode1;             //Last code read
uint32_t lastCode2;             //2nd last code read
uint16_t tMark0min,tMark0max,tMark1min,tMark1max; //Current durations for 1 and 0 codes


void intHandler()
{
  uint16_t t;
  t = TMR1_ReadTimer();
  
  if (bitPtr==0)
  {
        TMR1G_Polarity(0);
        if (t>T_START_MIN)
        {
          code = 0;
          attempts++;
          bitPtr++;
          TMR1G_Polarity(1);                                    //Looking for marks now
        }
  }
  else 
  {
        if (bitPtr==1)
        {
          if ((t>T_MARK1_MIN) && (t<T_MARK1_MAX))
          {
                tMark0min = t/3-T_MARK_TOL;
                tMark0max = t/3+T_MARK_TOL;
                tMark1min = t-(3*T_MARK_TOL);
                tMark1max = t+(3*T_MARK_TOL);
          }
          else if ((t>T_MARK0_MIN) && (t<T_MARK0_MAX))
          {
            tMark0min = t-T_MARK_TOL;
                tMark0max = t+T_MARK_TOL;
                tMark1min = 3*t-(3*T_MARK_TOL);
                tMark1max = 3*t+(3*T_MARK_TOL);
          
          }
          else bitPtr=0;
        }
        
        if (bitPtr<CODE_LEN)
        {
          if ( ((t>tMark0min) && (t<tMark0max) ) || ((t>tMark1min)&&(t<tMark1max)) )
          {
                bitPtr++;
                code<<=1;
                if (t>tMark1min)
                {
                  code++;
                }
          }
          else
          {
                bitPtr=0;                                                       //If pulse too long or too short reset
          }
        }
        else 
        {
          bitPtr = 0;
          attempts = 0;
          if (lastCode1) lastCode2 = lastCode1;
          lastCode1 = code;
          if (lastCode1 == lastCode2) matches++;
        }
  }
  
  TMR1_WriteTimer(0x0000);
  TMR1_StartSinglePulseAcquisition();
  
}

void initRF()
{
  bitPtr=0;
  TMR1G_Polarity(0);
  TMR1G_SetInterruptHandler(intHandler);
  TMR1_StartSinglePulseAcquisition();
  matches = 0;
  code = 0;
  lastCode1 = 0;
  lastCode2 = 0;
  //waitingRelease = 0;
  attempts = 0;
}

uint8_t rfGetNewCode()
{
  uint8_t res;
  uint32_t maskedCode = lastCode2 & CODE_MASK;
  if (lastCode2 == 0) return 0;
  if ((maskedCode!=CODE1)&&(maskedCode!=CODE2)&&(maskedCode!=CODE3)) return 0;
  if (matches<2) return 0;
    
  res=lastCode1 & BUT_MASK; 
  
  switch (res) 
  {
        case RF_A1:
        case RF_A2:
        case RF_A3:
          res = RF_A;
          break;
          
        case RF_B1:
        case RF_B2:
        case RF_B3:
          res = RF_B;
          break;
          
        case RF_C1:
        case RF_C2:
        case RF_C3:
          res = RF_C;
          break;
          
        case RF_D1:
        case RF_D2:
        case RF_D3:
          res = RF_D;
          break;  
  }
  
  if (matches>N_LONG_PRESS)             //Passed long press time
  {
        if (waitingRelease == 0)        //..for the first time
        {
          waitingRelease = 1;
          return res|RF_LONG_MASK;
        }
        else res = 0;
  }
  
  if (attempts < 2) return 0;   //Button still pressed
  else 
  {
    lastCode1=lastCode2=code=0;
    matches = 0;
    waitingRelease = 0;
  }
  
  return res;
}

uint8_t isRFreceiving()
{
  return (matches>0 && attempts<1);
}