//-------------------------------------------------------------------- 
//  Interrupt based receive routine
//
//  Compiled using HiTech PIC C compiler v.7.93
//********************************************************************
#define CLOCK           4       // MHz
#define TE            400       // us
#define OVERSAMPLING    3       
#define PERIOD          TE/OVERSAMPLING*4/CLOCK

#define NBIT            65      // number of bit to receive -1(HCS300 66-1=65)

unsigned char B[9];             // receive buffer

static byte  RFstate;           // receiver state
static sbyte RFcount;           // timer counter
static byte  Bptr;              // receive buffer pointer
static byte  BitCount;          // received bits counter
word   XTMR;                    // 16 bit extended timer

volatile bit RFFull;            // buffer full
volatile bit RFBit;             // sampled RF signal

#define TRFreset    0
#define TRFSYNC     1
#define TRFUNO      2
#define TRFZERO     3

#define HIGH_TO     -10         // longest high Te
#define LOW_TO       10         // longest low  Te
#define SHORT_HEAD   20         // shortest Thead accepted 2,7ms
#define LONG_HEAD    45         // longest Thead accepted 6,2ms

//-----------------------------------------------------------------------------------
#pragma int_rtcc       // install as interrupt handler (comment for HiTech!)
void interrupt rxi(void)  //this routine gets called every time TMR0 overflows
{
    RFBit = RFIn;               // sampling RF pin verify!!!
    TMR0 -= PERIOD;             // reload
    T0IF = 0;

    XTMR++;                     // extended 16 long timer update
//-----------------------------------------------------------------
    if (RFFull)                 // avoid overrun
    {    return;}

    switch( RFstate)            // state machine main switch
    {
     
    case TRFUNO:
        if ( RFBit)
        { // while high 
            RFcount--;
            if ( RFcount < HIGH_TO)
                RFstate = TRFreset;      // reset if too long
        }
        else
        { // falling edge detected  ----+
          //                            |
          //                            +----
                RFstate= TRFZERO;
        }        
        break;
        
    case TRFZERO:
        if ( RFBit)
        { // rising edge detected     +----
          //                          |
          //                      ----+
            RFstate= TRFUNO;
            B[Bptr] >>= 1;              // rotate 
            if ( RFcount >= 0)
            {    B[Bptr]+=0x80; }       // shift in bit
            RFcount = 0;                // reset length counter
            
            if ( ( ++BitCount & 7) == 0)
            {    Bptr++;    }           // advance one byte
            if (BitCount == NBIT)  

            {
                RFstate = TRFreset;     // finished receiving 
                RFFull = TRUE;
            }    
        }
        else
        { // still low
            RFcount++;
            if ( RFcount >= LOW_TO)     // too long low
            {
                RFstate = TRFSYNC;      // fall back into RFSYNC state 
                Bptr = 0;               // reset pointers, while keep counting on 
                BitCount = 0;
            }
        }
        break;

    case TRFSYNC:
        if ( RFBit)
        { // rising edge detected  +---+                +---..
          //                       |   |     |   
          //                           +----------------+
            if ( ( RFcount < SHORT_HEAD) || ( RFcount >= LONG_HEAD))
            {
                RFstate = TRFreset;
                break;                  // too short/long, no header
            }
            else
            {
                RFcount =0;             // restart counter
                RFstate= TRFUNO;  //合适的长低电平信号出现
            }
        }
        else
        { // still low
            RFcount++;
        }
        break;

    case TRFreset:      //初始状态
    default:
        RFstate = TRFSYNC;          // reset state machine in all other cases
        RFcount = 0;
        Bptr = 0;
        BitCount = 0;
        break;
        
    } // switch
//-----------------------------------------------------------------
} // rxi

void InitReceiver()
{
    T0IF = 0;
    T0IE = 1;                   // TMR0 overflow interrupt
    GIE = 1;                    // enable interrupts
    RFstate = TRFreset;         // reset state machine in all other cases
    RFFull = 0;                 // start with buffer empty
    XTMR = 0;                   // start extende

}