interrupt.c

msp430+无线芯片cc1020程序

#include "main.h"
#include "modemhw.h"






#pragma vector=PORT2_VECTOR
__interrupt void port2_ISR(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;
      if (ShiftRegMSB)
            TI_CC_GDO0_PxOUT |= TI_CC_GDO0_PIN;
      else
            TI_CC_GDO0_PxOUT &= ~ TI_CC_GDO0_PIN;

      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= ((TI_CC_GDO0_PxIN & TI_CC_GDO0_PIN)>>4);   // 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)
      ShiftRegLSB= ((TI_CC_GDO0_PxIN & TI_CC_GDO0_PIN)>>4);
      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
          */
          TI_CC_CTS_PxOUT |= TI_CC_CTS_PIN;     //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;
  P2IFG &= ~TI_CC_GDO2_PIN;
}