/*
#include <pic1687x.h> // uncomment for HiTech compiler

// **********************************************************************
//  Filename:   receiver.c
// *********************************************************************
//  Author:     skywang
//  Company:    cjae Technology
//  Revision:   Rev 1.00
//  Date:       08/07/07
//
//  Interrupt based receive routine
//
//  Compiled using HiTech PIC C compiler v.7.93
//  Compiled using CCS    PIC C compiler v.2.535
// ********************************************************************
#define CLOCK           4       // MHz
#define TE            400       // us
#define OVERSAMPLING    3       
#define PERIOD          TE/OVERSAMPLING*4/CLOCK   //133.3us

#define NBIT            65      // number of bit to receive -1

//byte 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!)
interrupt
rxi()
{
    // 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 == 0)
        { // falling edge detected  ----+
          //                            |
          //                            +----
                RFstate= TRFZERO;
        }
        else
        { // while high 
            RFcount--;
            if ( RFcount < HIGH_TO)
                RFstate = TRFreset;      // reset if too long
        }
        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) //receiver gradation  
                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  +---+                +---..
          //                       |   |  <-Theader->   |   
          //                           +----------------+
            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 extended timer
 }   */