zmac.c

自己写的Zigbee MAC源码。包括zmac.c

#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h> 
#include "enum.h"
#include "zmac.h"
#include "zphy.c"	  

 main(ZIGBEE_PRIMITIVE inputPrimitive)//MACTasks 
{ 
       switch(inputPrimitive) 
       { 
           case MAC_enable: mac_enable();break;

           case MAC_disenable: mac_disenable();break;

           case MCPS_data_request: mcps_data_request();break;

           case MCPS_data_indication: mcps_data_indication();break;
           
	     case MCPS_purge_request:mcps_purge_request();break; 
                   
           case MLME_associate_request: mlme_associate_request();break;
           
           case MLME_associate_indication: mlme_associate_indication();break;

           case MLME_reset_request: mlme_reset_request();break; 

           case MLME_rx_enable_request:mlme_rx_enable_request();//break;                                  

           //case MLME_disassociate_request:mlme_disassociate_reponse();break;

           //case MLME_beacon_notify_indication:mlme_beacon_notify_indication();break;
          
           //case MLME_get_request: mlme_get_request();break;
        
           //case MLME_gte_request: mlme_gts_request();break;
  
           //case MLME_orphan_response: mlme_orphan_response();break;

           //case MLME_scan_request:mlme_scan_request();break; 

           //case MLME_comm_status_indication:mlme_comm_status_indication();break;
           
           //case MLME_set_request: mlme_set_request();break;   

           //case MLME_start_request: mlme_start_request();break;
           
           //case MLME_sync_request: mlme_sync_request();break;            

           //case MLME_poll_request: mlme_poll_request();
       }  
   return inputPrimitive; 
} 


void mac_enable()
{
 if(zmac_current_status.status==1) zmac_current_status.status=0;
 mlme_reset_request();
 return;
}

void mac_disenable()
{
 if(zmac_current_status.status==0) zmac_current_status.status=1;
 mlme_reset_request();
 return;
}

void mcps_data_request()
{
 ZIGBEE_STATUS csma_ca_status;
 ZIGBEE_PRIMITIVE  za,zb;
 int j;

 mlme_reset_request();//复位

 if(zmac_current_status.status==1) 
    { MCPS_DATA_confirm.status=zmacBUSY;    
      return;}
 else 
 {
         zmac_current_status.status=1;

// 这里需要判断当前信道状态是活动态还是休眠态

       mac_current_frame.frameStyle=1;// 构建数据帧
       mac_current_frame.sequenceNumber=MsduHadle;
       mac_current_frame.DstAddr=MCPS_DATA_request.DstAddr;
       mac_current_frame.SrcAddr=MCPS_DATA_request.SrcAddr;
       for(j=0;j<aNWKFrameSize;j++) mac_current_frame.msdu[j]=MCPS_DATA_request.msdu[j];
       za=zPHYTasks(PLME_cca_request);
    if(PLME_CCA_confirm.status == zphyIDLE)
     {
       csma_ca_status=csma_ca();//CAMA/CA机制,一次PHY传输包括建立起两个设备的间接  
       if(csma_ca_status==zmacSUCCESS)
         {  
           aMACFrameSize=aNWKFrameSize;
           PD_DATA_request.psdu=&mac_current_frame;
           PD_DATA_request.psduLength=aMACFrameSize;
           zb=zPHYTasks(PD_data_request);
                if(PD_DATA_confirm.status==zphySUCCESS) 
                     {
                 MCPS_DATA_confirm.status=zmacSUCCESS;
                 MCPS_DATA_confirm.msduHandle=MsduHadle;
                     }
                else MCPS_DATA_confirm.status=TX_ACTIVE;
       
         }
       else MCPS_DATA_confirm.status=CHANNEL_ACCESS_FAILURE;
      }
     
     zmac_current_status.status=0;
  }
 
                     
}        
                   

ZIGBEE_STATUS csma_ca()
{
  char NB,BE;
  char macMaxBE=5,macMaxCSMABackoff=4;
  int random,a=1,i;
  ZIGBEE_PRIMITIVE  za,zb,zc,zd;

  PLME_SET_TRX_STATE_request.status=zphyTX_ON;
  za=zPHYTasks(PLME_set_trx_state_request);
  if(PLME_SET_TRX_STATE_confirm.status==zphySUCCESS) 
   {
     NB=0;
     BE=3;
  
RM:  srand((int)time(0));                          //产生一个0到（2BE－1）的随机数
       for(i=0;i<BE;i++) a=a*2;   
     random=1+(int)((a-1)*rand()/(RAND_MAX));

     delay_1s(random);
     zc=zPHYTasks(PLME_cca_request);
     if(PLME_CCA_confirm.status == zphyIDLE)  zd=zmacSUCCESS;
       else
         {
         NB=NB+1;  
         BE= (macMaxBE>BE)?BE:macMaxBE;
         if(NB>=macMaxCSMABackoff) zd=CHANNEL_ACCESS_FAILURE;
         else goto RM;
         }
    }
   else 
   {MCPS_DATA_confirm.status=DISABLE_TRX_FAILURE;
    zd=CHANNEL_ACCESS_FAILURE;}
   PLME_SET_TRX_STATE_request.status=zphyTRX_OFF;
   zb=zPHYTasks(PLME_set_trx_state_request);
   return zd;
}

void delay_1s(int t)
{
int i;
for(i=0;i<t;i++) sleep(1);
}





void mcps_data_indication()
{
   if(mac_current_frame.frameStyle==1)//接受到的数据为数据帧
    {
    MCPS_DATA_indication.SrcAddr=mac_current_frame.SrcAddr;
    MCPS_DATA_indication.DstAddr=mac_current_frame.DstAddr;
    MCPS_DATA_indication.msduLength=strlen(&mac_current_frame.msdu);
    MCPS_DATA_indication.msdu=&mac_current_frame.msdu;
      //产生nwk_current_frame
    //nt=NWKTasks();
    }
   else if(mac_current_frame.frameStyle==2) 
    {
     if(mac_current_frame.DstAddr==MLME_ASSOCIATE_request.DirdAddress) assciate_ack=1;
     else assciate_ack=0;
    }
   else if(mac_current_frame.frameStyle==3)
     switch(mac_current_frame.SrcAddr)
       {
       case 1: mlme_associate_indication();break;
       case 2: mlme_associate_response();
       }    
return;
}


void mcps_purge_request()
{
 if(MCPS_DATA_request.msduHandle==MCPS_PURGE_request.msduHandle)
  {
    MCPS_DATA_confirm.status=zmacSUCCESS;//丢弃MSDU  注意这里需要进一步补充，让MCPS_DATA_request结束
    mac_disenable();
    MCPS_PURGE_confirm.msduHandle=MCPS_PURGE_request.msduHandle;
    MCPS_PURGE_confirm.status=zmacSUCCESS;
  }
  else MCPS_PURGE_confirm.status=INVALID_HANDLE;
return;
}

void mlme_associate_request()
{ 
  ZIGBEE_STATUS csma_ca_status,za,zc,zs;
  int ar;
  
  mlme_reset_request();//复位

 if(zmac_current_status.status==1) MCPS_DATA_confirm.status=zmacBUSY;    
 else 
 { zmac_current_status.status=1;

// 这里需要判断当前信道状态是活动态还是休眠态

   mac_current_frame.frameStyle=0x03;// 构建命令帧
   mac_current_frame.sequenceNumber=MsduHadle;
   mac_current_frame.DstAddr=MLME_ASSOCIATE_request.DirdAddress;
   mac_current_frame.SrcAddr=0x01;
   aMACFrameSize=4;
retries:zc=zPHYTasks(PLME_cca_request);
        if(PLME_CCA_confirm.status==zphyIDLE)
          {
           csma_ca_status=csma_ca(); 
           if(csma_ca_status==CHANNEL_ACCESS_FAILURE) MLME_ASSOCIATE_confirm.status=CHANNEL_ACCESS_FAILURE;
           else 
             {    
            PD_DATA_request.psdu=&mac_current_frame;
            PD_DATA_request.psduLength=aMACFrameSize;
            za=zPHYTasks(PD_data_request);    
            if(PD_DATA_confirm.status==zphySUCCESS) 
                {
              aMACFrameSize=3;
              zs=zphy_serial_rx(2);//接收ACK
              if(zs==zphyNULL||zs==zphyBUSY)
                      {
                 ar=ar+1;
                 if(ar<aMaxFrameRetries) goto retries;
                 else MLME_ASSOCIATE_confirm.status=NO_ACK;
                      }  
              else rx_response();
                 }    
              }    
           } 
        else MLME_ASSOCIATE_confirm.status=zmacBUSY;
  }
return; 
}            

void rx_response()
{
  ZIGBEE_STATUS zs;
    mcps_data_indication();//判断接受到的数据是否为ACK
    if(assciate_ack==1)
   {
    zs=zphy_serial_rx(aResponseWaitTime);//接收连接响应命令
    if(zs==zphySUCCESS) 
     {
     mcps_data_indication();//判断接受到的数据是否为连接响应命令
     if(MLME_ASSOCIATE_response.status==zmacSUCCESS)
        {
        MLME_ASSOCIATE_confirm.status=zmacSUCCESS;
        MLME_ASSOCIATE_confirm.AssocShortAddress=MLME_ASSOCIATE_request.SrcAddress;
         }
     else MLME_ASSOCIATE_confirm.status=NO_DATA;
      }
   }
   else MLME_ASSOCIATE_confirm.status=NO_ACK;
return;
}

  
void mlme_associate_indication()
{
  ZIGBEE_STATUS  za,zc,nt,zb,csma_ca_status;

  MLME_ASSOCIATE_indication.DeviceAddress=mac_current_frame.DstAddr;
  //发送ACK
  aMACFrameSize=3;
  mac_current_frame.frameStyle=0x02;// 构建应答帧
  mac_current_frame.sequenceNumber=MsduHadle;
  mac_current_frame.DstAddr=MLME_ASSOCIATE_indication.DeviceAddress;
  zc=zPHYTasks(PLME_cca_request);
  if(PLME_CCA_confirm.status == zphyIDLE)
    {
     csma_ca_status=csma_ca(); 
     if(csma_ca_status == CHANNEL_ACCESS_FAILURE) MLME_ASSOCIATE_confirm.status=CHANNEL_ACCESS_FAILURE;
     else 
      {PD_DATA_request.psdu=&mac_current_frame;
       PD_DATA_request.psduLength=aMACFrameSize;
       za=zPHYTasks(PD_data_request);}     
     }  

  //产生nwk_current_frame

  //nt=NWKTasks();

  nt=zmacSUCCESS;

  if(nt==zmacSUCCESS) 
    {
      aMACFrameSize=4; 
      mac_current_frame.frameStyle=0x03;// 构建连接响应命令帧
      mac_current_frame.sequenceNumber=MsduHadle;
      mac_current_frame.DstAddr=mac_current_frame.DstAddr;
      mac_current_frame.SrcAddr=0x02;
    
      zc=zPHYTasks(PLME_cca_request);
        if(PLME_CCA_confirm.status == zphyIDLE)
          {
           csma_ca_status=csma_ca(); 
           if(csma_ca_status = CHANNEL_ACCESS_FAILURE) MLME_ASSOCIATE_confirm.status=CHANNEL_ACCESS_FAILURE;
           else 
               {    
            PD_DATA_request.psdu=&mac_current_frame;
            PD_DATA_request.psduLength=aMACFrameSize;
            za=zPHYTasks(PD_data_request); 
               } 
          }  

    zb=zphy_serial_rx(10);
    if(zb==zphySUCCESS) MLME_ASSOCIATE_response.status=zmacSUCCESS;   
    else MLME_ASSOCIATE_response.status=NO_DATA;
   }
   return;
}


void mlme_associate_response()
 { 
  if(mac_current_frame.DstAddr==MLME_ASSOCIATE_request.DirdAddress) MLME_ASSOCIATE_response.status=zmacSUCCESS;
  return;           
 }   


void mlme_reset_request()
{ 
  int i;
 if(MLME_RESET_request.SetDefaultPIB==TRUE) 
 {
    mac_current_frame.frameStyle=0;
    mac_current_frame.sequenceNumber=0;
    mac_current_frame.DstAddr=0;
    mac_current_frame.SrcAddr=0;
    for(i=0;i<aMaxNWKPecketSize;i++) mac_current_frame.msdu[i]=0;
               
    MsduHadle=1;
    aMaxFrameRetries=5;
    aResponseWaitTime=10;
    assciate_ack=0;

    MLME_RESET_confirm.status = zmacSUCCESS; 
  } 
return;
}


void mlme_rx_enable_request()
{
 if(MLME_RX_ENABLE_request.RxOnDuration>0)
 {
  while(MLME_RX_ENABLE_request.RxOnDuration) MLME_RX_ENABLE_request.RxOnDuration--;
   MLME_RX_ENABLE_confirm.status=zmacSUCCESS;
  }
  return;
}

 




/*void mlme_orphan_indication()
{ 	          
}
void mlme_orphan_response()
{ 	          
}
void mlme_beacon_notify_indication()
{
}
void mlme_scan_request()
{ 
}   
void mlme_set_request()
{
}
void mlme_disassociate_request()
{			    
} 
void mlme_disassociate_indication()
{			    
}  
void mlme_disassociate_confirm()
{			    
} 
void mlme_get_request()
{
}
void mlme_gts_request()
{
}
void mlme_gts_confirm()
{
}
void mlme_gts_indication()
{
}
void mlme_sync_request()
{
}
void mlme_start_request()
{ 
} 
void mlme_start_confirm()
{ 
} 
void mlme_poll_request()
{ 
} */