hh_phy.c

zigbee中心节点源代码

#include "include.h"

//volatile PHYTxFrameInfo gPHYTxFrameInfo;
//volatile PHYRxFrameInfo gPHYRxFrameInfo;
PHYTxFrameInfo gPHYTxFrameInfo;
PHYRxFrameInfo gPHYRxFrameInfo;



UINT8 PDDATA_request(BYTE txOption)
{
    UINT8 status;
    
    while (FIFOP_IS_1 || SFD_IS_1);
   
    DISABLE_GLOBAL_INT();
    FASTSPI_STROBE(CC2420_SFLUSHTX);

    BYTE statusByte;
    do {
          FASTSPI_UPD_STATUS(statusByte);
    } while (!(statusByte & BM(CC2420_RSSI_VALID)));

/*   
    ////////////////////////////////////////////////   
    UINT16 v1,v2,v3,v4;
    FASTSPI_GETREG(CC2420_MDMCTRL0,v1);
    FASTSPI_GETREG(CC2420_IOCFG0,v2);
    FASTSPI_GETREG(CC2420_RSSI,v3);
    v4=v1&v2&v3;    
    
    while(!CCA_IS_1);
    
    BYTE spiStatusByte;
    do {
	  FASTSPI_STROBE(CC2420_SFLUSHTX);
          FASTSPI_STROBE(CC2420_SFLUSHRX);
          FASTSPI_STROBE(CC2420_SFLUSHRX);
          FASTSPI_STROBE(CC2420_STXONCCA);
	  FASTSPI_UPD_STATUS(spiStatusByte);
	  halWait(2);
    } while (!(spiStatusByte & BM(CC2420_TX_ACTIVE)));
    ////////////////////////////////////////////////
*/   
    
//	  FASTSPI_STROBE(CC2420_SFLUSHTX);
//          FASTSPI_STROBE(CC2420_SFLUSHRX);
//          FASTSPI_STROBE(CC2420_SFLUSHRX);    
    FASTSPI_WRITE_FIFO((BYTE*)&gPHYTxFrameInfo.psduLength, 1);
    FASTSPI_WRITE_FIFO((BYTE*)gPHYTxFrameInfo.psdu, gPHYTxFrameInfo.psduLength);
    FASTSPI_STROBE(CC2420_STXONCCA);
    //UINT8 n,shortAddr=0x1212;
    //FASTSPI_WRITE_RAM_LE(Timeinfo.time, 0x050, 8, n);
    while (!SFD_IS_1);
    P1OUT |= BIT0+BIT1+BIT2+BIT3;	   
    
    gPHYTxFrameInfo.psduStatus = FALSE;
    ENABLE_GLOBAL_INT();
    //////////////////////////////等待发送结束////////////
      while (SFD_IS_1);
         P1OUT &= 0xf0;
         
    if(txOption == MAC_TXOPTION_ACKTRANSMISSION)
    {
      
          while (SFD_IS_1);
         P1OUT &= 0xf0;	
//          P1OUT |= BIT0+BIT2;	

      /* for(int i=0;i<2;i++)
          {                
                P1OUT ^=  BM(LED1);
                halWait(10000);
                P1OUT ^=  BM(LED2);
                halWait(10000);
                P1OUT ^=  BM(LED3);
                halWait(10000);
                P1OUT ^=  BM(LED4);
                halWait(10000); 
          } */

          //gMACRxFrameInfo.ackReceived = FALSE;
          //while(!gMACRxFrameInfo.ackReceived);          
          status = PHY_SUCCESS;
          gMACRxFrameInfo.ackReceived = FALSE;
       /*  for(int i=0;i<10;i++)
          {                
                P1OUT ^=  BM(LED1);
                halWait(10000);
                P1OUT ^=  BM(LED2);
                halWait(10000);
                P1OUT ^=  BM(LED3);
                halWait(10000);
                P1OUT ^=  BM(LED4);
                halWait(10000); 
          }
          */

          //MAC_macAckWaitDuration, MAC_aMaxFrameRetries          
          /*halWait((12 * RF_aSymbolPeriod) + (RF_aAckPeriod) + (2 * RF_aSymbolPeriod) + 100);
          if(gMACRxFrameInfo.ackReceived)
          {
                
                
                status = PHY_SUCCESS;
                gMACRxFrameInfo.ackReceived = FALSE;
          }
          else
          {
                status = MAC_NO_ACK;
          }*/
    }
    else
    {
          status = PHY_SUCCESS;
    }
    //DISABLE_GLOBAL_INT();
    //FASTSPI_STROBE(CC2420_SRFOFF);
    //ENABLE_GLOBAL_INT();
      
    return status;        
}

//ISR = void PDDATA_indication();
//-------------------------------------------------------------------------------------------------------
//  SIGNAL(SIG_INTERRUPT0) - CC2420 FIFOP interrupt service routine
//
//  DESCRIPTION:
//		When a packet has been completely received, this ISR will extract the data from the RX FIFO, put
//		it into the active BASIC_RF_RX_INFO structure, and call basicRfReceivePacket() (defined by the
//		application). FIFO overflow and illegally formatted packets is handled by this routine.
//
//      Note: Packets are acknowledged automatically by CC2420 through the auto-acknowledgment feature.
//-------------------------------------------------------------------------------------------------------

// IAR 3.2 C/C++ compiler for MSP430
#ifdef __ICC430__
#pragma vector=PORT2_VECTOR
__interrupt void fifo_rx (void)
// MSP430-GCC C/C++ compiler for MSP430
#elif defined(__MSP430__)
interrupt (PORT2_VECTOR) fifo_rx(void)
#endif
{ 
  //UINT8 aaa[8]={1,2,3,4,5,6,7,8};
  ///////////transmitt interupt at this time(whe SFD rise high ) we can get the solid dot time ///
   BYTE spiStatusByte;
   UINT8 n; 
  // ENABLE_GLOBAL_INT();//设想打开中断嵌套
   FASTSPI_UPD_STATUS(spiStatusByte);
 if (P2IFG &BIT6)
     {
        P2IFG &=~BIT6;
        if (spiStatusByte&BM(CC2420_TX_ACTIVE))//读取是否处在发射状态的中断，3.5.2008
        {
         convert_time_format8(Timeinfo.specialtime,Timeinfo.time);//在信标帧发送标志到来时提取时间点作为整个系统的时间参考点3.5.2008
         FASTSPI_WRITE_RAM_LE(Timeinfo.time, 0x023, 8, n);  ///在信标帧还没有发送结束前写入特定的帧位置例随信标帧一起发送各个节点作为参考点3.5.2008
        
     // get_local_time(Timeinfo.time);
     
       }
     }
  /////////////////////////////////////////////////////////
  ////////receive interupt///////////////
  if(P2IFG&BM(FIFO_P))
  {
	UINT8 psduLength;
	CLEAR_FIFOP_INT();
   
	if((FIFOP_IS_1) && (!(FIFO_IS_1)))
	{	   
	      FASTSPI_STROBE(CC2420_SFLUSHRX);
	      FASTSPI_STROBE(CC2420_SFLUSHRX);
	      return;
	}
	FASTSPI_READ_FIFO_BYTE(psduLength);
	psduLength &= 0x7f;
	if (psduLength < MAC_aAckFrameSize)
	{
    	      FASTSPI_READ_FIFO_GARBAGE(psduLength);        
        } 
        else 
        {
              while(gPHYRxFrameInfo.psduStatus);
    
	      gPHYRxFrameInfo.psduLength = psduLength;
	      FASTSPI_READ_FIFO_NO_WAIT(gPHYRxFrameInfo.psdu, psduLength);
	      //gPHYRxFrameInfo.psduStatus = TRUE;
             // FASTSPI_STROBE(CC2420_SFLUSHRX);
              WORD framecontrolfield;         
              framecontrolfield = (gPHYRxFrameInfo.psdu[1] << 8) | gPHYRxFrameInfo.psdu[0];
              BYTE dataseqnumber;
              dataseqnumber = gPHYRxFrameInfo.psdu[2];
              BYTE framecheckseq[2];        
              framecheckseq[0] = gPHYRxFrameInfo.psdu[gPHYRxFrameInfo.psduLength - 2];
              framecheckseq[1] = gPHYRxFrameInfo.psdu[gPHYRxFrameInfo.psduLength - 1];    
             
              if((gPHYRxFrameInfo.psduLength == MAC_aAckFrameSize) && (framecontrolfield == MAC_FCF_ACKNOWLEDGMENT) && (dataseqnumber == gPHYTxFrameInfo.psdu[2]))
              {
                    if(framecheckseq[1] & MAC_FCS_CRCOK)
                    {
                          gMACRxFrameInfo.ackReceived = TRUE;
                          gPHYRxFrameInfo.psduStatus = FALSE; 
                          
                          
                    }
                    else
                    {
                          gPHYRxFrameInfo.psduStatus = FALSE;      
                    }
              }
              else if(gPHYRxFrameInfo.psduLength < MAC_aDataFrameOverheadSize)
              {
                    gPHYRxFrameInfo.psduStatus = FALSE;
              }
              else
              {
                
                    MCPSDATA_indication();
                   
              }	      
	}
  }
  
      ///////////////////////////////////////////////////////////
  ///////////transmitt interupt at this time(whe SFD rise high ) we can get the solid dot time ///
  
} // SIGNAL(SIG_INTERRUPT0)

/*
UINT8 PLMESETTRXSTATE_request(UINT8 state)
{
      if (FIFOP_IS_1 || SFD_IS_1)
      {
            switch(state)
            {
                  case PHY_RX_ON:
                        DISABLE_GLOBAL_INT();
                        FASTSPI_STROBE(CC2420_SRXON);  
                        ENABLE_GLOBAL_INT();    
                        break;
                  case PHY_TRX_OFF:
                        DISABLE_GLOBAL_INT();
                        FASTSPI_STROBE(CC2420_SRFOFF);  
                        ENABLE_GLOBAL_INT();    
                        break;
                  case PHY_FORCE_TRX_OFF:
                        DISABLE_GLOBAL_INT();
                        FASTSPI_STROBE(CC2420_SRFOFF);   
                        ENABLE_GLOBAL_INT();   
                        break;
                  case PHY_TX_ON:
                        DISABLE_GLOBAL_INT();
                        FASTSPI_STROBE(CC2420_STXON);  
                        ENABLE_GLOBAL_INT();    
                        break;
                  default:
                        return PHY_INVALID_PARAMETER;
            }           
            return PHY_SUCCESS; 
      }
      else
      {
            if(state == PHY_FORCE_TRX_OFF)
            {
                  DISABLE_GLOBAL_INT();
                  FASTSPI_STROBE(CC2420_SRFOFF);      
                  ENABLE_GLOBAL_INT();
                  return PHY_SUCCESS; 
            }
            else
            {
                  return PHY_BUSY;
            }            
      }
}
*/