CC430F5135 Interrupt Pending.

Hello everyone!

I changed my firmware according to the suggestions of the colleagues of the forum.
However I still have problems with the wireless system.

    I am using the kit EM430F6137RF900 boards. Where a teacher needs to receive and transmit information to several slaves. Slaves initiates communication and master receives a frame with a request and responds with the requested information.

The master works with an appreciable requncia requests, but when the master gets requests cease and no activity for a long time (hours). This fails to answer requests.

As the routines posted in my first post, I was wandering in the treatment of interruptions, but now I'm doing the treatment properly. As can be seen in the attached Code.

 This program receives data by radio (RF1A) and relays the UART. And on the contrary, the UART receives and transmits data received through the radio.

I'm really having problems getting the basics of the transceiver CC430Fxxxx work properly. I would like to help a fellow of the forum to solve this problem. What drives me crazy is the fact that the system works for a while and then stop working.

Thanks to all.

#pragma vector=CC1101_VECTOR
__interrupt void CC1101_ISR(void)
{
    switch(__even_in_range(RF1AIV,32))        // Prioritizing Radio Core Interrupt
    {
        case  0: break;                         // No RF core interrupt pending                                           
        case  2: break;                         // RFIFG0
        case  4: break;                         // RFIFG1
        case  6: break;                         // RFIFG2
        case  8: break;                         // RFIFG3
        case 10: break;                         // RFIFG4
        case 12: break;                         // RFIFG5
        case 14: break;                         // RFIFG6         
        case 16: break;                         // RFIFG7
        case 18: break;                         // RFIFG8
        case 20:                                // RFIFG9
        if(RF_RecebendoPacote)               // RX end of packet
        {
            // Read the length byte from the FIFO      
            RF_RxBufferLength = ReadSingleReg( RXBYTES );
            ReadBurstReg(RF_RXFIFORD, RF_RxBuffer, RF_RxBufferLength);
       
            // Stop here to see contents of RxBuffer
            __no_operation();

            // Check the CRC results
            if(RF_RxBuffer[CRC_LQI_IDX] & CRC_OK)
            {
                RF_PacoteRecebido=1;

            }
              
             RF1AIES |= BIT9;                          // Falling edge of RFIFG9
             RF1AIFG &= ~BIT9;                         // Clear a pending interrupt
             RF1AIE  |= BIT9;                          // Enable the interrupt
        }
        else if( RF_TransmitindoPacote)           // TX end of packet
        {
           RF1AIES |= BIT9;                          // Falling edge of RFIFG9
            RF1AIFG &= ~BIT9;                         // Clear a pending interrupt
            RF1AIE  |= BIT9;                          // Enable the interrupt                  // Disable TX end-of-packet interrupt
            RF_TransmitindoPacote=0;
       
        }
        else while(1);              // trap
        break;
        case 22: break;                         // RFIFG10
        case 24: break;                         // RFIFG11
        case 26: break;                         // RFIFG12
        case 28: break;                         // RFIFG13
        case 30: break;                         // RFIFG14
        case 32: break;                         // RFIFG15
    }

    RF1AIES |= BIT9;                          // Falling edge of RFIFG9
    RF1AIFG &= ~BIT9;                         // Clear a pending interrupt
    RF1AIE  |= BIT9;                          // Enable the interrupt

}

 
/**************************************************************************************
 * Função:
 *
 * Descrição:
 *
 * Parametros de entrada: Nenhum
 *
 * Parametrose de saída: Nenhum
 *
***************************************************************************************/
void Transmit(unsigned char *buffer, unsigned char length)
{
    RF1AIES |= BIT9;                         
    RF1AIFG &= ~BIT9;                         // Clear pending interrupts
    RF1AIE |= BIT9;                           // Enable TX end-of-packet interrupt

    WriteBurstReg(RF_TXFIFOWR, buffer, length);

    Strobe( RF_STX );                         // Strobe STX
    RF_PacoteTransmitido=0;
    RF_TransmitindoPacote=1;
}

/**************************************************************************************
 * Função:
 *
 * Descrição:
 *
 * Parametros de entrada: Nenhum
 *
 * Parametrose de saída: Nenhum
 *
***************************************************************************************/
void ReceiveOn(void)
{
  Strobe( RF_SRX );
  RF1AIES |= BIT9;                          // Falling edge of RFIFG9
  RF1AIFG &= ~BIT9;                         // Clear a pending interrupt
  RF1AIE  |= BIT9;                          // Enable the interrupt

RF_RecebendoPacote;

  // Radio is in IDLE following a TX, so strobe SRX to enter Receive Mode
  Strobe( RF_SRX );
}

void main(void) {
    // Stop watchdog timer to prevent time out reset
    WDTCTL = WDTPW + WDTHOLD;

    // Increase PMMCOREV level to 2 for proper radio operation
    SetVCore(2);
 
    ResetRadioCore();
    InitRadio();

    ReceiveOn();
    receiving = 1;
    UART_Config(1);

     __bis_SR_register( LPM3_bits + GIE );

    while(1)
    {

       
        if(RF_PacoteRecebido)//Recebido pacote pelo radio
        {
            RF_PacoteRecebido=0;
            UART_PutString(RF_RxBuffer,RF_RxBufferLength-2);

 
         ReceiveOff();       //FLUSH
         ReceiveOn();

        }

     if(UART_PacoteRecebido)//Recebido Pacote pela UART.
      {

      UART_PacoteRecebido=0;
        ReceiveOff();
        receiving = 0;

        RF_TransmitindoPacote=1;

        Transmit(UART_BUFFER,UART_BUFFER_LEN);
        while(RF_TransmitindoPacote);

        }
    }

}