hh_phy.c

zigbee子节点源代码

#include "include.h"

//volatile PHYTxFrameInfo gPHYTxFrameInfo;
//volatile PHYRxFrameInfo gPHYRxFrameInfo;
PHYTxFrameInfo gPHYTxFrameInfo;
PHYRxFrameInfo gPHYRxFrameInfo;
UINT64 kkk;
BYTE HHY_FLAG;

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);
    while (!SFD_IS_1);
    P1OUT |= BIT0+BIT1+BIT2+BIT3;	   
    
    gPHYTxFrameInfo.psduStatus = FALSE;
    ENABLE_GLOBAL_INT();
        
    if(txOption == MAC_TXOPTION_ACKTRANSMISSION)
    {
      
          while (SFD_IS_1);
          P1OUT &= 0xf0;


          //gMACRxFrameInfo.ackReceived = FALSE;
          //while(!gMACRxFrameInfo.ackReceived);          
          status = PHY_SUCCESS;
          gMACRxFrameInfo.ackReceived = FALSE;

          //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
{
     
    // BYTE spiStatusByte;
    // FASTSPI_UPD_STATUS(spiStatusByte);
     if(P2IFG&BIT3)
     {
        P2IFG&=~BIT3;
        kkk = Timeinfo.specialtime;
	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 
        {
              gPHYRxFrameInfo.psduStatus = 0; 
              HHY_FLAG=1;
             /*  TXBUF0=0x22;
              while ((UTCTL0&0x01)==0); 
              _NOP(); 
             // HHY_FLAG=2;  //test
            while(gPHYRxFrameInfo.psduStatus);
    
	      gPHYRxFrameInfo.psduLength = psduLength;
	      FASTSPI_READ_FIFO_NO_WAIT(gPHYRxFrameInfo.psdu, psduLength);
	      //gPHYRxFrameInfo.psduStatus = TRUE;
              
              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();
              }	   */   
	 } 
     }
  
    //if (P2IFG&BM(SFD))
     if(P2IFG&BIT6)
     { 
            P2IFG&=~BIT6; 
          if (HHY_FLAG==1);
          else
          {
             Timelinearity.SFD_point_time = Timeinfo.specialtime;
             HHY_FLAG=0;
            /* 
             TXBUF0=Timelinearity.SFD_point_time>>8;
             while ((UTCTL0&0x01)==0); 
             TXBUF0=Timelinearity.SFD_point_time;
             while ((UTCTL0&0x01)==0); 
            
             if (receivedtimeinfo.n>=0&&receivedtimeinfo.n<10)
              {
                receivedtimeinfo.n++;//收到的时间计数用于线性回归计算
              }
            if(10<=receivedtimeinfo.n)
              {
                receivedtimeinfo.n=10;
              }*/
  
          }
        
     }
 
} // 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;
            }            
      }
}*/