radiomanagement.c

基于MMA7260QR2的跌落检查程序

/************************************************************************************
* Radio Management implementation
*
* (c) Copyright 2006, Freescale, Inc.  All rights reserved.
*
* No part of this document must be reproduced in any form - including copied,
* transcribed, printed or by any electronic means - without specific written
* permission from Freescale.
*
* Last Inspected:
* Last Tested:
************************************************************************************/

#include "../Interface/RadioManagement.h"
#include "../Drivers/Interface/Delay.h"
#include "RadioMngmntWrapper.h"


#define PROCESS_TO_ENBLE


/************************************************************************************
*************************************************************************************
* Private macros
*************************************************************************************
************************************************************************************/
#define mStartclk_init_c    (0x00000080)
#define mCplclk_init_c      (0x00001E00)
#define mSftclk_init_c      (0x000001FE)

#define is_any_action_complete_evnt() \
                      ( is_tx_action_completed_evnt() || \
                        is_rx_action_completed_evnt() || \
                        is_action_completed_evnt() )

/************************************************************************************
*************************************************************************************
* Private prototypes
*************************************************************************************
************************************************************************************/
static FuncReturn_t process_tx_msg (void);
static FuncReturn_t process_rx_msg (void);
static FuncReturn_t process_ed_msg (void);
static FuncReturn_t process_to_msg (void);
static uint8_t calculate_ed_value (uint32_t);


static bool_t is_a_handled_message(message_t * msg);
const uint8_t gaRFSynVCODivI_c[16] = gaRFSynVCODivIVal_c;
const uint32_t gaRFSynVCODivF_c[16] = gaRFSynVCODivFVal_c;

/************************************************************************************
*************************************************************************************
* Private type definitions
*************************************************************************************
************************************************************************************/
#define MAX_NUM_MSG (4)
#define PROCESS_TIMEOUT  (0xffff)

#define _inc_msg(x) (((MAX_NUM_MSG-1) == x)? 0: x+1)

#ifdef PROCESS_TO_ENBLE
  #define _validate_processs_timeout(x) \
     do { \
       if(gNull_c == mProcess_timeout){ \
         (maMessage_Queu[current_msg])->u8Status.msg_state = x; \
         release_current_message(); \
         hw_rst_xcvr(); \
       } \
       else { \
         /* Do nothing */ \
       } \
    } while(FALSE)
#endif

/************************************************************************************
*************************************************************************************
* Private memory declarations
*************************************************************************************
************************************************************************************/
static uint8_t mRetries_timmer;

#ifdef PROCESS_TO_ENBLE
  static uint16_t mProcess_timeout;
#endif

static uint8_t current_msg;
static uint8_t next_msg_to_store;
static message_t* maMessage_Queu[MAX_NUM_MSG];
static uint32_t maMessageTO[MAX_NUM_MSG];

//static uint32_t mStartclk_offset = mStartclk_init_c;
static uint32_t mCplclk_offset   = mCplclk_init_c;
static uint32_t mSftclk_offset   = mSftclk_init_c;

#define _set_startclk_offset(x) (mStartclk_offset = x)
#define _set_cplclk_offset(x)   (mCplclk_offset = x)
#define _set_sftclk_offset(x)   (mSftclk_offset = x)


/* This constant must keep the same order than the msg_type_tag enumeration */
static const callback_t cbProcessMsg_c[MAX_MSG_TYPE] = {
          (callback_t)(process_tx_msg),
          (callback_t)(process_rx_msg),
          (callback_t)(process_ed_msg),
          (callback_t)(process_to_msg) };

static const uint8_t mAbortStates[MAX_MSG_TYPE] = {
          MSG_TX_RQST_ABORT,
          MSG_RX_RQST_ABORT,
          MSG_ED_RQST_ABORT,
          MSG_TO_RQST_ABORT };


/************************************************************************************
*************************************************************************************
* Public memory declarations
*************************************************************************************
************************************************************************************/
evnt_flags_t gRadioEvntFlags;
// when doing Tx MACA requires a valid pointer in maca_dmarx 
// in order to handle possible incoming ACK frames;
// this space can also be allocated dinamically;
uint32_t ackBox[10];

message_t Scan_msg;
vScanCallback_t vScanReqCallBack;
uint16_t u16ChannToScan;
uint8_t u8ScanValPerChann[TOTAL_CHANN];
uint8_t dataScan[1];
bool_t bScanReqFlag;


/************************************************************************************
*************************************************************************************
* Public functions
*************************************************************************************
************************************************************************************/
void process_scan_req(void);
channel_num_t get_next_chann_to_scan(channel_num_t);
extern FuncReturn_t MLMEEnergyDetect  (message_t *, channel_num_t);


/************************************************************************************
* abort_message
*
* This function aborts a message
*
************************************************************************************/
FuncReturn_t abort_message (message_t * msg){
  if(FALSE == is_a_handled_message(msg)){
    return gFailOutOfRange_c;
  }
  else{
    /* Do Nothing */
  }
  if(maMessage_Queu[current_msg] == msg){
    command_xcvr_abort();
  }
  else{
    /* Do Nothing */
  }
  msg->u8Status.msg_state = (mAbortStates[msg->u8Status.msg_type]);
  return gSuccess_c;
}

/************************************************************************************
* is_a_handled_message
*
* This function check if a given message is placed at the queu
*
************************************************************************************/
static bool_t is_a_handled_message(message_t * msg){
  uint8_t i;
  for(i=0; i<MAX_NUM_MSG; i++){
    if(maMessage_Queu[i] == msg){
      return TRUE;
    }
    else{
      /* Do Nothing */
    }
  }
  return FALSE;
}


/************************************************************************************
* change_current_message_state
*
* This function the current message state to the "mssg_state"
*
************************************************************************************/
void change_current_message_state (any_mssg_state_t mssg_state){
  if(NULL != maMessage_Queu[current_msg]){
    (maMessage_Queu[current_msg])->u8Status.msg_state = (mssg_state.any_type);
  }
  else{
    /* Do Nothing */
  }
}


/************************************************************************************
* change_current_message_state
*
* This function the callback assosiated with the current message
*
************************************************************************************/
void execute_current_message_callback (void){
  if(NULL != maMessage_Queu[current_msg]){
    if(NULL != ((maMessage_Queu[current_msg])->cbDataIndication)){
      (maMessage_Queu[current_msg])->cbDataIndication();
    }
    else {
      /* Do Nothing */
    }
  }
  else{
    /* Do Nothing */
  }
}

/************************************************************************************
* get_current_message
*
* This function returns a pointer to the message that is been processed, it will 
* return NULL if there is no message.
*
************************************************************************************/
message_t* get_current_message (void){
  return (maMessage_Queu[current_msg]);
}


/************************************************************************************
* handle_new_message
*
* This function link a new msg to the queu.
*
************************************************************************************/
FuncReturn_t handle_new_message (message_t * msg, uint32_t timeout){
  if(NULL != maMessage_Queu[next_msg_to_store]){
    return gFailNoResourcesAvailable_c;
  }
  else{
    msg->u8Status.msg_state = initial_state_c;
    maMessage_Queu[next_msg_to_store] = msg;
    maMessageTO[next_msg_to_store]= timeout;
    next_msg_to_store = _inc_msg(next_msg_to_store);
  }
  return gSuccess_c;
}


/************************************************************************************
* release_current_message
*
* This function releases a message from the queu.
*
************************************************************************************/
FuncReturn_t release_current_message (void){
  if(NULL != maMessage_Queu[current_msg]){
    maMessage_Queu[current_msg] = NULL;
    maMessageTO[current_msg] = 0;
    current_msg = _inc_msg(current_msg);
  }
  else{
    /* Do Nothing */
  }
  return gSuccess_c;
}


/************************************************************************************
* radio_manager_init
*
* This initializes all the variables involved in the radio management.
*
************************************************************************************/
FuncReturn_t radio_manager_init (void){
  uint8_t queu_count;
  for(queu_count=0; queu_count<MAX_NUM_MSG; queu_count++){
    maMessage_Queu[queu_count] = NULL;
    maMessageTO[queu_count] = 0;
  }
  current_msg = 0;
  next_msg_to_store = 0;
  clear_all_radio_events();
  bScanReqFlag = FALSE;
  MSG_INIT(Scan_msg, &dataScan, NULL);
  Scan_msg.u8Status.msg_state = MSG_ED_ACTION_COMPLETE_FAIL;
  Scan_msg.u8Status.msg_type = ED;
  u16ChannToScan = 0xFFFF;
  return gSuccess_c;
}

/************************************************************************************
* process_radio_msg
*
* This function process any TX/RX/EnergyDetect/Timeout pending msg.
*
************************************************************************************/
FuncReturn_t process_radio_msg (void){

  if(NULL != maMessage_Queu[current_msg]){
    if(MAX_MSG_TYPE > (maMessage_Queu[current_msg])->u8Status.msg_type){
      cbProcessMsg_c[(maMessage_Queu[current_msg])->u8Status.msg_type]();
      DelayUs(9);
    }
    else {
      /* Do Nothing */
    }
  }
  else {
    /* Do Nothing */
  }

  if(TRUE == bScanReqFlag)
  {
    process_scan_req();
  }

  return gSuccess_c;
}


/************************************************************************************
*************************************************************************************
* Private functions
*************************************************************************************
************************************************************************************/

/************************************************************************************
* process_tx_msg
*
* This function process any TX pending msg.
*
************************************************************************************/
static FuncReturn_t process_tx_msg (void){
  msg_tx_state_t state;
  state = (msg_tx_state_t)((maMessage_Queu[current_msg])->u8Status.msg_state);
  switch(state)
  {
    case MSG_TX_RQST:
      {
        clear_all_radio_events();
        mRetries_timmer = MAX_TX_RETRIES;

#ifdef PROCESS_TO_ENBLE
        mProcess_timeout = PROCESS_TIMEOUT;
#endif
        command_xcvr_tx();
        (maMessage_Queu[current_msg])->u8Status.msg_state = MSG_TX_PASSED_TO_DEVICE;
      }
      break;
    case MSG_TX_PASSED_TO_DEVICE:
      {
        if(is_action_started_evnt()){
          clear_action_started_evnt();
          (maMessage_Queu[current_msg])->u8Status.msg_state = MSG_TX_ACTION_STARTED;
        }
        else{
#ifdef PROCESS_TO_ENBLE
          _t_dec(mProcess_timeout);
#endif
        }
      }
      break;
    case MSG_TX_ACTION_STARTED:
      {
        if(is_tx_action_completed_evnt()){
          clear_tx_action_completed_evnt();
          if(is_tx_ac_success_evnt()) {
            clear_tx_ac_success_evnt();
            (maMessage_Queu[current_msg])->u8Status.msg_state = \
                                                       MSG_TX_ACTION_COMPLETE_SUCCESS;
            release_current_message();
          }
          else {
            if(gNull_c != mRetries_timmer){
              _t_dec(mRetries_timmer);
              clear_all_radio_events();
              command_xcvr_tx();
              (maMessage_Queu[current_msg])->u8Status.msg_state = \
                                                              MSG_TX_PASSED_TO_DEVICE;
            }
            else {
              (maMessage_Queu[current_msg])->u8Status.msg_state = \
                                                          MSG_TX_ACTION_COMPLETE_FAIL;
              release_current_message();
            }
          }
        }
        else {
#ifdef PROCESS_TO_ENBLE
          _t_dec(mProcess_timeout);
#endif
        }
      }
      break;
    case MSG_TX_RQST_ABORT:
      {
        (maMessage_Queu[current_msg])->u8Status.msg_state = MSG_TX_ABORTED;
        release_current_message();
      }
      break;
    case MSG_TX_ABORTED:
    case MSG_TX_ACTION_COMPLETE_SUCCESS:
    case MSG_TX_ACTION_COMPLETE_FAIL:
    default:
      {