interrupt.c

无线射频收发芯片cc1020的校准程序代码

/****************************************************************************/
/*                                                                          */
/* Reference design : CC1020 RF Modem                                       */
/*                                                                          */
/* File:    interrupt.c                                                     */
/*                                                                          */
/* Microcontroller:                                                         */
/*          Microchip PIC16F876                                             */
/*                                                                          */
/* Author:  Karl H. Torvmark, Field Applications Engineer, Chipcon          */
/*          Torgeir Sundet, FAE - Software, Chipcon                         */
/*                                                                          */
/* Contact: Chipcon AS [phone]                                      */
/*          [e-mail]                                            */
/****************************************************************************/

/****************************************************************************/
/* This file contains the interrupt handler, which handles the external,    */
/* UART, timer 2 and timer 1 interrupts. Communication with the main        */
/* program occurs via global variables.                                     */
/****************************************************************************/


/*                                                                           *
 * Revision history:                                                         *
 *                                                                           *
 * $Log: interrupt.c,v $
 * Revision 1.3  2005/11/21 16:36:30  tos
 * Optimised state machine + removed osbolete code (AGC freeze).
 *
 * Revision 1.2  2003/09/18 14:51:25  tos
 * Minor mod's:
 *  - Made AFC_CONTROL = 0x87 as default for 868/915 MHz band.
 *  - Made rf-packet extension as #define.
 *
 * Revision 1.1  2003/07/31 13:17:23  tos
 * Initial version in CVS.
 *
 *                                                                           *
 ****************************************************************************/


#include "io16f876.h"
#include "modemhw.h"
#include "main.h"
#include "configure.h"
#include <stdio.h>

#define INTERRUPT_VECTOR 0x04



#pragma vector=INTERRUPT_VECTOR 
__interrupt void InterruptHandler(void)
{ 
  // This function must execute as fast as possible.
  // Therefore, as much processing as possible is left
  // to the main program.

  switch (State) {
    case TX_STATE:
      // Write data to CC1020
      DIO=ShiftRegMSB;
      ShiftReg=ShiftReg<<1;
      BitCounter++;

      // If last data bit has been sent
      if(LastDataBit){
          // Remain in TX until last data bit has been sent on RF:
          if(BitCounter > RFPACKET_EXTENSION){
            BitCounter = 0;
            TXBufferIndex = 0;
            LastDataBit = FALSE;
            NextState=IDLE_STATE;
            break;
          }else{
          }
      // Else (not last data bit)
      }else{
        // Load new TX data and monitor end of packet:
        if(BitCounter==1){
          if(TXBufferIndex>BytesToSend){
            BitCounter = 0;
            LastDataBit = TRUE;
            ShiftReg = 0x00;
          }
        }
        if(BitCounter==8){
          BitCounter=0;
          ShiftReg=TXBuffer[TXBufferIndex++];
        }
      }

      break;

    case RX_STATE:
      // Read data from CC1020
      ShiftReg=ShiftReg<<1;
      ShiftRegLSB=DIO;   // Low-side LO (DIO not inverted)
      BitCounter++;

      // If received 8bits=1byte
      if(BitCounter==8){
        BitCounter=0;

        // Process received RF data:
        switch(ByteCounter){
          // Byte-0 = SOF part 1:
          case 0 :
            if(ShiftReg!=UI2){
              NextState=IDLE_STATE;
            }
            break;

          // Byte-1 = address:
          case 1 :
            // Addressing not implemented
            break;

          // Byte-2 = packet length/size:
          case 2 :
            BytesToReceive=ShiftReg;
            if(BytesToReceive>TX_BUFFER_SIZE){
              BytesToReceive=0;
            }
            break;

          // Rest of the packet is data, store it in the receive buffer  
          default :
            RXBuffer[RXBufferWriteIndex]=ShiftReg;
            //RXBufferWriteIndex=(RXBufferWriteIndex+1)%RX_BUFFER_SIZE;
            RXBufferWriteIndex++;
            RXBufferWriteIndex&=0x3F;
            break;
        }

        if(ByteCounter>=BytesToReceive+2){
          NextState=IDLE_STATE;
        }
        ByteCounter++;
      }
      break;

    case IDLE_STATE:
      // Read data from CC1020
      ShiftReg=ShiftReg<<1;
      ShiftRegLSB=DIO;   // Low-side LO (DIO not inverted)
      BitCounter++;

      // If preamble found, look for Start Of Frame (SOF)
      if(PreambleFound){
        // If first unique identifier found, enter RX mode
        if(ShiftReg==UI1){ 
          // Initialise RX processing state directly:
          // Avoid latency with background scheduler.
          SET_RXLED(ON);
          SET_TXLED(OFF);
          READY=1;  // HW Handshake : Not Ready
          BitCounter=0;
          ByteCounter=0;
          State = RX_STATE;
          NextState=RX_STATE;        
        // Else if we are still receiving preamble, do nothing
        }else if((ShiftReg==VALID_PREAMBLE_BYTE_1)||(ShiftReg==VALID_PREAMBLE_BYTE_2)){
        // Else if we are not receiving a correct preamble, declare an error
        }else if(PreambleError==0){
          PreambleError++;
        }else{
        }

        // If preamble error found, increase the error counter regardless of bits read
        if(PreambleError>0){
          PreambleError++;
        }

        // Once an error condition has occurred, a correct SOF must be found
        // within 9 bits (error counter is initially incremented by 2), otherwise
        // we abort and start looking for preamble again
        if(PreambleError>10){
          PreambleFound=FALSE;
        }
      // Else (preamble has not been found)
      }else{
        // If valid preamble, increase counter
        if ((ShiftReg==VALID_PREAMBLE_BYTE_1)||(ShiftReg==VALID_PREAMBLE_BYTE_2)) {
          PreambleCount++;
        // Else (not valid preamble), reset counter
        }else{
          PreambleCount=0;
        }
        // If required preamble reached, indicate preamble found
        if(PreambleCount>=PREAMBLE_REQ){
          PreambleFound=TRUE;
          PreambleError=0;
        }
      }

      break;

     default:
      // Enter known state in case something goes haywire
      NextState=IDLE_STATE;
      break;
  }
  INTF=0;  
}