simple_phy.c

用于WSN的PDA搜救器

/* Description : phy functions.
 *
 * $Author: 王琢玉
 * $Date: 2007/02/23 
 * $Name:  simple_phy.c 
 */
 
 
#define   SIMPLE_PHY_GLOBALS

#include "include.h"

/********************************************
Globals 
********************************************/


/************************************************************
Function:    void PHYInit(void)

Parameter:   

Return:      
             
Description: Init the PHY
************************************************************/
void PHYInit(void)
{

#ifdef  USE_EXT_CLK  
    MC13192Init();
    PLMESetMC13192ClockRate(2);  /* Set  CLKO speed  = 4 M */
    UseExternalClock();    /* switch clock sources  BUS CLOCK = 20 M */
#else
    UseMcuClock();
#endif

    InitMcuTimer2();//初时化MCU计时器
    
    PLMESetTrxStateRequest(IDLE_MODE);
    Zigbee_Flags.u8Val = 0;
    
    params.PD_DATA_request.psduLength = 0;
    
    params.PD_DATA_request.psdu = pTxData;
}

/************************************************************
Function:    void PHYTasks(void)

Parameter:   

Return:      
             
Description: check if there is any PHY task.
************************************************************/
void PHYTasks(void)
{
    if(Zigbee_Flags.bits.RFDataIndication == 1)
    {
        if(Zigbee_Flags.bits.RxBufferIsUsed) return;
        
        Zigbee_Flags.bits.RFDataIndication = 0;
        
        params.PD_DATA_indication.psduLength = RAMDrvReadRxFifo(RxBuffer,RX_BUFFER_SIZE);
        params.PD_DATA_indication.LIQ = (UINT8)(SPIDrvRead(CCA_RESULT_ADDR) >> 8); 
        PLMESetTrxStateRequest(RX_MODE);
        
        if(params.PD_DATA_indication.psduLength == 0)return;
        
        Zigbee_Flags.bits.RxBufferIsUsed = 1;
        
        params.PD_DATA_indication.psdu = RxBuffer;
        Zigbee_Flags.bits.PDDataIndication = 1;
    }
}       

/************************************************************
Function:    BYTE PHYGet(void)

Parameter:   

Return:      Returns one buffered data byte that was received
             by the transceiver.
             
Description: Get one buffered data byte 
************************************************************/
UINT8 PHYGet(void)       
{
    params.PD_DATA_indication.psduLength--;
    return *params.PD_DATA_indication.psdu++;
} 
                 
/************************************************************
Function:    UINT8 PDDataRequest(tTxPacket *psPacket)

Parameter:   *psPacket     packet pointer

Return:      Status
             
Description: Request to Tx one packet
************************************************************/
UINT8 PDDataRequest(void)
{
    UINT8 psduLength;
    UINT8 *psdu;
    
    UINT8 BackUpOfRTxMode = gu8RTxMode;
    
    psduLength = params.PD_DATA_request.psduLength;
    psdu = params.PD_DATA_request.psdu;
    
    if(psduLength > 127) return 0;
    
    RAMDrvWriteTxFifo(psdu,psduLength); /* Load the data into packet RAM */    
    
    PLMESetTrxStateRequest(TX_MODE);    /* transmit it */

    /* Wait for the state to return to idle. (finish transmitting) */
    while (gu8RTxMode != IDLE_MODE)
    {
        CLRWDT();
        MCU_LOW_POWER_WHILE();
    }
    
    PLMESetTrxStateRequest(BackUpOfRTxMode);
    
    params.PD_DATA_request.psdu = pTxData;
    
    return 1;
}

/************************************************************
Function:    UINT8 PLMEPAValueSet(UINT8 u8PAValue)

Parameter:   u8PAValue   Value of power

Return:      Status
             
Description: Adjust the MC13192s Output power.
************************************************************/
UINT8 PLMEPAValueSet(UINT8 u8PAValue)
{
    UINT16 u16Reg;
    
    switch(u8PAValue)
    {
      case  0:  u8PAValue = 0x00; break;
      case  1:  u8PAValue = 0x04; break;
      case  2:  u8PAValue = 0x08; break;
      case  3:  u8PAValue = 0x0c; break;
      
      case  4:  u8PAValue = 0x1c; break;
      case  5:  u8PAValue = 0x2c; break;
      case  6:  u8PAValue = 0x3c; break;
      case  7:  u8PAValue = 0x4c; break;
      
      case  8:  u8PAValue = 0x5c; break;
      case  9:  u8PAValue = 0x6c; break;
      case 10:  u8PAValue = 0x7c; break;
      case 11:  u8PAValue = 0x8c; break;
      
      case 12:  u8PAValue = 0x9c; break;
      case 13:  u8PAValue = 0xac; break;
      case 14:  u8PAValue = 0xbc; break;
      case 15:  u8PAValue = 0xcc; break;
      
      case 16:  u8PAValue = 0xdc; break;
      case 17:  u8PAValue = 0xec; break;
      case 18:  u8PAValue = 0xfc; break;
      case 19:  u8PAValue = 0xfd; break;
      
      case 20:  u8PAValue = 0xfe; break;
      case 21:  u8PAValue = 0xff; break;
      
      default:  return 0;
    }
    
    u16Reg = SPIDrvRead(PA_ADJUST_ADDR);    /* Read the current value of GAIN 
                                             * Register 
                                             */
    u16Reg &= 0xFF00;
    u16Reg |= u8PAValue;

    SPIDrvWrite(PA_ADJUST_ADDR, u16Reg);
    return 1;
}

/************************************************************
Function:    UINT8 PLMESetChannelRequest(UINT8 u8Channel)

Parameter:   u8Channel   Channel number

Return:      Status
             
Description: Set the MC13192 operating channel.
************************************************************/
void PLMESetChannelRequest(UINT8 u8Channel)
{
    UINT8   channel;
    
    channel = u8Channel & 0x0f;
    
    switch (channel)
    {
      case 0x00:
        SPIDrvWrite(LO1_IDIV_ADDR,0x0F95);
        SPIDrvWrite(LO1_NUM_ADDR,0x5000);
        break;
      case 0x01:
        SPIDrvWrite(LO1_IDIV_ADDR,0x0F95);
        SPIDrvWrite(LO1_NUM_ADDR,0xA000); 
        break;
      case 0x02:
        SPIDrvWrite(LO1_IDIV_ADDR,0x0F95);
        SPIDrvWrite(LO1_NUM_ADDR,0xF000); 
        break;
      case 0x03:
        SPIDrvWrite(LO1_IDIV_ADDR,0x0F96);
        SPIDrvWrite(LO1_NUM_ADDR,0x4000); 
        break;
      case 0x04:
        SPIDrvWrite(LO1_IDIV_ADDR,0x0F96);
        SPIDrvWrite(LO1_NUM_ADDR,0x9000); 
        break;
      case 0x05:
        SPIDrvWrite(LO1_IDIV_ADDR,0x0F96);
        SPIDrvWrite(LO1_NUM_ADDR,0xE000); 
        break;
      case 0x06:
        SPIDrvWrite(LO1_IDIV_ADDR,0x0F97);
        SPIDrvWrite(LO1_NUM_ADDR,0x3000); 
        break;
      case 0x07:
        SPIDrvWrite(LO1_IDIV_ADDR,0x0F97);
        SPIDrvWrite(LO1_NUM_ADDR,0x8000); 
        break;
      case 0x08:
        SPIDrvWrite(LO1_IDIV_ADDR,0x0F97);
        SPIDrvWrite(LO1_NUM_ADDR,0xD000); 
        break;
      case 0x09:
        SPIDrvWrite(LO1_IDIV_ADDR,0x0F98);
        SPIDrvWrite(LO1_NUM_ADDR,0x2000); 
        break;
      case 0x0A:
        SPIDrvWrite(LO1_IDIV_ADDR,0x0F98);
        SPIDrvWrite(LO1_NUM_ADDR,0x7000); 
        break;
      case 0x0B:
        SPIDrvWrite(LO1_IDIV_ADDR,0x0F98);
        SPIDrvWrite(LO1_NUM_ADDR,0xC000); 
        break;
      case 0x0C:
        SPIDrvWrite(LO1_IDIV_ADDR,0x0F99);
        SPIDrvWrite(LO1_NUM_ADDR,0x1000); 
        break;
      case 0x0D:
        SPIDrvWrite(LO1_IDIV_ADDR,0x0F99);
        SPIDrvWrite(LO1_NUM_ADDR,0x6000); 
        break;
      case 0x0E:
        SPIDrvWrite(LO1_IDIV_ADDR,0x0F99);
        SPIDrvWrite(LO1_NUM_ADDR,0xB000); 
        break;
      case 0x0F:
        SPIDrvWrite(LO1_IDIV_ADDR,0x0F9A);
        SPIDrvWrite(LO1_NUM_ADDR,0x0000); 
        break;
    }
}

/************************************************************
Function:    void PLMESetTrxStateRequest(UINT8 u8ReqMode)

Parameter:   u8ReqMode   Operational mode

Return:     
             
Description: Set the MC13192 transceive operation.
************************************************************/
void PLMESetTrxStateRequest(UINT8 u8ReqMode)
{
    UINT16 u16Reg;
    
    RTXENDeAssert(); 
    u16Reg = SPIDrvRead(MODE_ADDR);
    u16Reg &= 0xFFF8;                           /* Clear mode. */
    switch (u8ReqMode)
    {
      
      case IDLE_MODE:                         /* Write Idle */
        u16Reg |= IDLE_MODE;
        gu8RTxMode = IDLE_MODE;
        SPIDrvWrite(MODE_ADDR, u16Reg);
        break;

      case RX_MODE:                           /* Write RX */
        gu8RTxMode = RX_MODE;
        u16Reg |= RX_MODE;
        SPIDrvWrite(MODE_ADDR, u16Reg);
        RTXENAssert(); 
        break;
        
      case TX_MODE:               /* Write Tx. Note: force LO lock not used */
        u16Reg |= TX_MODE;
        gu8RTxMode = TX_MODE;
        SPIDrvWrite(MODE_ADDR, u16Reg);
        RTXENAssert();
        break;
    }
}

/************************************************************
Function:    void PLMESetMC13192ClockRate(UINT8 u8Freq)

Parameter:   u8Freq     Output Frequency
               0           16MHz (Recommended default)
               1            8MHz
               2            4MHz
               3            2MHz
               4            1MHz
               5            62.5kHz
               6            32.786kHz
               7            16.393kHz 
Return:     
             
Description: Set MC13192 CLKo frequency.
************************************************************/
void PLMESetMC13192ClockRate(UINT8 u8Freq)
{
    UINT16 u16CurrentValue;
    
    u16CurrentValue = SPIDrvRead(CLKS_ADDR); /* Read register and re-write */
    u16CurrentValue &= 0xFFF8;
    u16CurrentValue |= u8Freq;
    SPIDrvWrite(CLKS_ADDR, u16CurrentValue);
}

/************************************************************
Function:    void InitSymbolTimer(void)

Parameter:   

Return:      
             
Description: Init the symboltick of zigbee
************************************************************/
void InitSymbolTick(void)
{
    UINT16  u16Reg;
    
    u16Reg = SPIDrvRead(TIMER_PRESCALE);   //设置时间时钟    62.5kHz
    u16Reg &= 0xfff8;
    u16Reg |= 0x0005;
    SPIDrvWrite(TIMER_PRESCALE, u16Reg);
    
    u16Reg = SPIDrvRead(MODE2_ADDR);      // time load off
    u16Reg &= 0x7fff;
    SPIDrvWrite(MODE2_ADDR, u16Reg);     
    
    SPIDrvWrite(T1_HI_ADDR, 0x0000);
    SPIDrvWrite(T1_LO_ADDR, 0x0000);
    
    u16Reg |= 0x8000;
    SPIDrvWrite(MODE2_ADDR, u16Reg);   // 时间清零
    
    tickExtension = 0;
}

/************************************************************
Function:    TICK TickGet(void)

Parameter:   

Return:      current TICK 
             
Description: get current tick
************************************************************/
TICK TickGet(void)
{
    TICK currentTick;
    UINT16 u16Reg;
     
    SaveStatusReg();
    
    currentTick.Byte.b3 = tickExtension;    
    currentTick.Byte.b2 = (UINT8)(SPIDrvRead(TIMESTAMP_HI_ADDR));    
    u16Reg = SPIDrvRead(TIMESTAMP_LO_ADDR); 
       
    RestoreStatusReg();
    
    currentTick.Byte.b0 = (UINT8)(u16Reg);
    currentTick.Byte.b1 = (UINT8)(u16Reg>>8);
    
    return currentTick;
}