//-------------------------------------------------------------------------------------------------------
//  void mrxHandleFifoUnderAndOverflow(void)
//
//  DESCRIPTION:
//      Flushes the RX FIFO if an overflow has occurred (FIFOP and FIFO are both low, when the polarity 
//      of FIFOP has been switched). This function is called by the reception routine in the final stage.
//-------------------------------------------------------------------------------------------------------
void mrxHandleFifoUnderAndOverflow(BOOL XDATA *result) 
{
    BYTE rfInternalState;

    *result = TRUE;
    rfInternalState = RFR_FSMSTATE;
    DisableInterrupts();

    if (rfInternalState == RF_RX_OVERFLOW)
    {
        WriteRfImmediateCommand(CC2430_ISFLUSHRX);
        *result = FALSE;
    }
    else if (rfInternalState == RF_TX_UNDERFLOW)
    {
        WriteRfImmediateCommand(CC2430_ISFLUSHRX);
        *result = FALSE;
    }

    EnableInterrupts();
} // mrxHandleFifoUnderAndOverflow


//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void DisableAcceptAckPackets (void)
{
    RFR_FSMTC1 &= ~ACCEPT_ACKPKT;
}


//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void EnableAcceptAckPackets (void)
{
    RFR_FSMTC1 |= ACCEPT_ACKPKT;
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
/*void ReadRfInterruptMaskRegister (BYTE XDATA *interruptMask)
{
    *interruptMask = RFIM;
}*/

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
/*void ReadRfInterruptRegister (BYTE XDATA *interruptValue)
{
    *interruptValue = RFIF;
}*/
/*
//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void WriteFrameToRf (FRAME XDATA *txFrame)
{
    BOOL XDATA                      ok;
    BYTE                            i;
    DMA_CHANNEL_CONFIGURATION XDATA *dmaChannelConfiguration;
    WORD                            address;

    AllocateDmaChannel3 (&ok);

    if (ok == TRUE)
    {
        FetchDmaChannelConfiguration (DMA_CHANNEL_NO_3, 
                                      &dmaChannelConfiguration);

        dmaChannelConfiguration->dmaMsbDestination = (BYTE)(((WORD) &X_RFD) >> 8);
        dmaChannelConfiguration->dmaLsbDestination = (BYTE) &X_RFD;               
        address = (WORD) txFrame;
        dmaChannelConfiguration->dmaMsbSource = (BYTE)(address >> 8);
        dmaChannelConfiguration->dmaLsbSource = (BYTE)(address);               
        dmaChannelConfiguration->dmaMsbLength = USE_FIRST_BYTE_AS_LEN;
        dmaChannelConfiguration->dmaLsbLength = aMaxPHYPacketSize + FRAME_LENGTH_SIZE;
        dmaChannelConfiguration->sizeAndTrigger = BYTE_TRANSFER + 
                                                  TRANSFER_MODE_BLOCK;
        dmaChannelConfiguration->channelSetUp = SRC_INC_ONE_BYTE +
                                                DST_INC_NONE + 
                                                DMA_IRQ_DISABLE + 
                                                DMA_8_BIT_TRANSFER_COUNT + 
                                                DMA_PRIORITY_HIGH;

		StartDma (DMA_CHANNEL_NO_3);
        DeallocateDmaChannel3 ();
    }
    else
    {
        for ( i = 0; i < txFrame->byte[0]; i++)
            X_RFD = txFrame->byte[i];
        
    }
}
*/

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
/*void WriteRfInterruptMaskRegister (BYTE interruptMask)
{
    RFIM = interruptMask;
}*/



//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void ResetAllInterrupts (void)
{
   IEN0 = 0;
   IEN1 = 0;
   IEN2 = 0;
   IRCON2 = 0;
   IRCON = 0;
   S1CON = 0;
   S0CON = 0;
   IE0 = 0;
   IE1 = 0;
   IEX9 = 0;
   IEX8 = 0;

}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void ReadTimer2DeltaCompare (BYTE XDATA *compareValue)
{
    *compareValue = T2TLD;
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void ReadTimer2Config (BYTE XDATA *configValue)
{
    *configValue = T2CNF;
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void ReadTimer2InterruptMask (BYTE XDATA *interruptMask)
{
    *interruptMask = T2PEROF2;
    *interruptMask = *interruptMask & TIMER2_INTERRUPT_MASK;
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void ReadTimer2Timer (WORD XDATA *timerValue)
{
    BYTE temp;

    temp = T2TLD;
    *timerValue = (WORD)temp;
    temp = T2THD;
    *timerValue = (WORD)(*timerValue + ((WORD)temp << 8));
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void WriteTimer2Config (BYTE configValue)
{
    T2CNF = configValue;
}

//-------------------------------------------------------------------------------------------------------
// Functions used to track received events
//-------------------------------------------------------------------------------------------------------

#define MAX_IN_RECEIVE_EVENTS    20
typedef enum
{
    RECEIVE_EVENT_DUMMY,
    RECEIVE_EVENT_ADDRESS_RECOGNITION,
    RECEIVE_EVENT_FRAME_RECEIVED,
    RECEIVE_EVENT_RECEIVE_ENGINE_CREATED,
    RECEIVE_EVENT_RECEIVE_ENGINE_START,
    RECEIVE_EVENT_RECEIVE_ENGINE_STOP,
    RECEIVE_EVENT_RECEIVE_ENGINE_CREATE_FAILED = 0xF0
}RECEIVE_EVENT;

typedef struct
{
    BYTE    next;
    BYTE    events[MAX_IN_RECEIVE_EVENTS];
}RECEIVE_EVENTS;

void StoreReceiveEvents (RECEIVE_EVENT    receiveEvent);
void InitializeStoreReceiveEvents (void);


RECEIVE_EVENTS  XDATA   receiveEvents;

void StoreReceiveEvents (RECEIVE_EVENT    receiveEvent)
{
    receiveEvents.events[receiveEvents.next] = receiveEvent;
    ++receiveEvents.next;

    if (receiveEvents.next > MAX_IN_RECEIVE_EVENTS)
        receiveEvents.next = 0;
}

void InitializeStoreReceiveEvents (void)
{
    memset (&receiveEvents, 
            0,
            sizeof (receiveEvents));
}