mac.c

该演示程序实现温度的采集与显示功能

    macSetTxBusy();
    //mac_pib.currentAckRetries = mac_pib.macMaxAckRetries;
    macTxFSM_status = LRWPAN_STATUS_MAC_INPROGRESS;

   a_phy_service.cmd = LRWPAN_SVC_PHY_TX_DATA;
   a_phy_service.status = LRWPAN_STATUS_PHY_INPROGRESS;
   phyState = PHY_STATE_COMMAND_START;
   phyFSM();
   return 1;
}



int xyz=0;
void macFSM(void)
{
  phyFSM(); //物理层发送数据包处理

  submacCurrentFrame.sub_type.Val=0xff;
  macRxFSM();//接收数据包处理

  /////////////////////////////////////////////////////////////////////////////////	
  #if 0
    if(submacCurrentFrame.sub_type.Val!=0xff)
    {
       	DEBUG_STRING(DBG_INFO,"MAC:Recv data packet, cmd:");
    	DEBUG_UINT8(DBG_TX,submacCurrentFrame.sub_type.Val);		
    	DEBUG_STRING(DBG_INFO,",");		
    	DEBUG_UINT16(DBG_TX,submacCurrentFrame.sub_source_addr.v[0]*256+submacCurrentFrame.sub_source_addr.v[1]);
    	DEBUG_STRING(DBG_INFO,"->");		
    	DEBUG_UINT16(DBG_TX,submacCurrentFrame.sub_dest_addr.v[0]*256+submacCurrentFrame.sub_dest_addr.v[1]);	
    	DEBUG_STRING(DBG_INFO,",len:");	
    	DEBUG_UINT8(DBG_TX,submacCurrentFrame.databytenum);		
    	DEBUG_STRING(DBG_TX,"\n");
    }

    if(xyz==0)
    {
        while (phyTxLocked()) ;
        phyGrabTxLock();		
        MACPutHeader(NULL, MAC_FRAME_DATA | MAC_SECURITY | MAC_FRAME_PENDING_NO | MAC_ACK_NO | MAC_INTRA_PAN_NO);				
        macFormatUserData(0);	
        MACFlush();

      	WirelessSendData(MSG_TAG_ISANYCAPTAINHERE);
      	P1_0=~P1_0;/**/

      	conPrintUINT32(halGetMACTimer());
    }
    xyz++;
    if(xyz>26000)xyz=0;
    #endif
////////////////////////////////////////////////////////////////////////////////////
}



static void macRxFSM(void){
  MACPKT *pkt;
  BYTE cmd,idx;
  BYTE *data;
  BYTE i,cs;


    if (macRxBuffEmpty()) return;   //no data, break
    pkt = macGetRxPacket();//buffer not empty, start decode
    if(pkt->CRC&0x80!=0x80)
    {
         //crc error
         DEBUG_STRING(DBG_INFO,"MAC: CRC error, discarding.\n");
         return;
    }
    if(pkt==NULL) return;

    if ((LRWPAN_IS_BCN(*(pkt->data+1))) && //信标帧
        !mac_pib.flags.bits.WaitingForBeaconResponse)
    {
        DEBUG_STRING(DBG_INFO,"MAC: Received BCN pkt, discarding.\n");
        macFreeRxPacket();
        return;
    }
	
    if (LRWPAN_IS_ACK(*(pkt->data+1))) //应答帧
    {
      DEBUG_STRING(DBG_INFO,"MAC: Received ACK pkt,discarding.\n");
      macFreeRxPacket();
      return;
    }
	
    a_mac_rx_data.orgpkt = pkt;
    macParseHdr(); //解析包头，指出数据在包中的位置(pload_offset)

    if (LRWPAN_IS_DATA(*(pkt->data+1)))//数据帧
    {
	idx=a_mac_rx_data.pload_offset;
	data=pkt->data+idx;

	submacCurrentFrame.CRC=pkt->CRC;
	submacCurrentFrame.RSSI=pkt->rssi;
		
	submacCurrentFrame.sub_type.Val=data[0];
	submacCurrentFrame.sub_dest_addr.v[0]=data[1];
	submacCurrentFrame.sub_dest_addr.v[1]=data[2];	
	submacCurrentFrame.sub_source_addr.v[0]=data[3];
	submacCurrentFrame.sub_source_addr.v[1]=data[4];
	submacCurrentFrame.databytenum=data[5]-1;	//- headcs
	cs=0;
	for(i=0;i<6;i++)
	    cs+=data[i];
	if(cs!=data[6])
	{
	    //head cs error
	    DEBUG_STRING(DBG_INFO,"MAC:head cs error XXXXXXXXXXxx\n");		
	    DEBUG_STRING(DBG_INFO,"error packet, cmd:");
      	    DEBUG_UINT8(DBG_TX,submacCurrentFrame.sub_type.Val);		
      	    DEBUG_STRING(DBG_INFO,",");		
       	    DEBUG_UINT16(DBG_TX,submacCurrentFrame.sub_source_addr.v[0]*256+submacCurrentFrame.sub_source_addr.v[1]);
      	    DEBUG_STRING(DBG_INFO,"->");		
       	    DEBUG_UINT16(DBG_TX,submacCurrentFrame.sub_dest_addr.v[0]*256+submacCurrentFrame.sub_dest_addr.v[1]);	
            DEBUG_STRING(DBG_INFO,",type:");	
      	    DEBUG_UINT8(DBG_TX,submacCurrentFrame.sub_type.Val);				
      	    DEBUG_STRING(DBG_INFO,",len:");	
      	    DEBUG_UINT8(DBG_TX,submacCurrentFrame.databytenum);		
      	    DEBUG_STRING(DBG_TX,"\n");
			
	    macFreeRxPacket();
	    submacCurrentFrame.sub_type.Val=0xff;
    	    return;
	}
		
	for(i=0;i<submacCurrentFrame.databytenum+9;i++)
	{
	    // DEBUG_UINT8(DBG_INFO,data[i]);
	    // DEBUG_STRING(DBG_INFO,",");		 	
	}
		
	//headCs=data[6];
	//submacCurrentFrame.data.Val=&data[6];

        cs=0;
	for(i=0;i<submacCurrentFrame.databytenum;i++)
	{
	    cs+=data[7+i];
  	    submacCurrentFrame.data[i]=data[7+i];
	}

	if(cs!=data[7+submacCurrentFrame.databytenum])
	{
	    //data cs error
	    DEBUG_STRING(DBG_INFO,"MAC:data cs error XXXXXXXXXXxx\n");	
            macFreeRxPacket();
	    submacCurrentFrame.sub_type.Val=0xff;
	    return;			
	}
		
        macFreeRxPacket();
        mac_pib.last_data_rx_time = halGetMACTimer();
	
    }
    else  //命令帧
    {
	 //at this point, we have a MAC command packet, lets do something with it.
	 DEBUG_STRING(DBG_INFO,"MAC: Received MAC cmd packet, proceeding.\n");	
	
	 cmd = *(a_mac_rx_data.orgpkt->data + a_mac_rx_data.pload_offset);	
	 DEBUG_STRING(DBG_INFO,"MAC: Received MAC CMD, discarding.\n");
	 DEBUG_STRING(DBG_INFO,"Cmd is: ");
	 DEBUG_UINT8(DBG_INFO,cmd);
	 DEBUG_STRING(DBG_INFO,"\n");
	 macFreeRxPacket();
    }
}

void macTxCallback(void) {
    if (LRWPAN_GET_ACK_REQUEST(*(phy_pib.currentTxFrm))) {
    mac_pib.flags.bits.ackPending = 1;  //we are requesting an ack for this packet
    //record the time of this packet
    mac_pib.tx_start_time = halGetMACTimer();
    }
}


void macRxCallback(BYTE *ptr, BYTE rssi) {


  if((*ptr == LRWPAN_ACKFRAME_LENGTH ) && LRWPAN_IS_ACK(*(ptr+1)))
  {
    if (*(ptr+3) == mac_pib.macDSN)
	{
      mac_pib.flags.bits.ackPending = 0;
      DEBUG_CHAR( DBG_ITRACE,DBG_CHAR_OURACK  );
    }
  }
  else
  {
    mac_pib.rxHead++;
     if (mac_pib.rxHead == MAC_RXBUFF_SIZE) mac_pib.rxHead = 0;
     //mac_pib.rxBuff[mac_pib.rxHead].data = ptr;     //save pointer
     mac_pib.rxBuff[mac_pib.rxHead].rssi = rssi;    //save RSSI value
  }
}

MACPKT *macRxGetBuffer()
{
     if(macRxBuffFull()) return NULL;
     mac_pib.rxHead++;
     if (mac_pib.rxHead == MAC_RXBUFF_SIZE) mac_pib.rxHead = 0;

     return &mac_pib.rxBuff[mac_pib.rxHead];

     //mac_pib.rxBuff[mac_pib.rxHead].rssi = rssi;    //save RSSI value
     //return mac_pib.rxBuff[mac_pib.rxHead].data;     //save pointer
}


BOOL macRxBuffFull(void){
    BYTE tmp;
    //if next write would go to where Tail is, then buffer is full
    tmp = mac_pib.rxHead+1;
    if (tmp == MAC_RXBUFF_SIZE) tmp = 0;
    return(tmp == mac_pib.rxTail);
}

BOOL macRxBuffEmpty(void){
  return(mac_pib.rxTail == mac_pib.rxHead);
}

//this does NOT remove the packet from the buffer
MACPKT *macGetRxPacket(void) {
    BYTE tmp;	
    if (mac_pib.rxTail == mac_pib.rxHead) return(NULL);
    tmp = mac_pib.rxTail+1;
    if (tmp == MAC_RXBUFF_SIZE) tmp = 0;
    return(&mac_pib.rxBuff[tmp]);
}

//frees the first packet in the buffer.
void macFreeRxPacket() {
    mac_pib.rxTail++;
    if (mac_pib.rxTail == MAC_RXBUFF_SIZE) mac_pib.rxTail = 0;
    //if (freemem) MemFree(mac_pib.rxBuff[mac_pib.rxTail].data);
}

//parse the header currently in a_mac_rx_data
//return the offset to the network header.

static void macParseHdr() {
  BYTE *ptr;
  BYTE len,i;
  BYTE srcmode, dstmode;

  ptr = a_mac_rx_data.orgpkt->data;

  //skip first byte since the first byte in the a_mac_rx_data.orgpkt is the
  //packet length
  len = 1;ptr++;


  a_mac_rx_data.fcflsb = *ptr; ptr++;
  a_mac_rx_data.fcfmsb = *ptr; ptr++;
  dstmode = LRWPAN_GET_DST_ADDR(a_mac_rx_data.fcfmsb);
  srcmode = LRWPAN_GET_SRC_ADDR(a_mac_rx_data.fcfmsb);

  //skip DSN
  ptr++;
  len = len +3;

  if (dstmode != LRWPAN_ADDRMODE_NOADDR){
    //get the DEST PANDID
    a_mac_rx_data.DestPANID = *ptr;
    ptr++;
    a_mac_rx_data.DestPANID += (((UINT16)*ptr) << 8);
    ptr++;
    len = len + 2;
  }
  //DST address
  if (dstmode == LRWPAN_ADDRMODE_SADDR) {
    a_mac_rx_data.DestAddr.saddr = *ptr;
    ptr++;
    a_mac_rx_data.DestAddr.saddr += (((UINT16)*ptr) << 8);
    ptr++;
    len = len + 2;

  }else if (dstmode == LRWPAN_ADDRMODE_LADDR) {
    for (i=0;i<8;i++) {
      a_mac_rx_data.DestAddr.laddr.bytes[i] = *ptr;
      ptr++;
    }
    len = len + 8;
  }

  if ( !LRWPAN_GET_INTRAPAN(a_mac_rx_data.fcflsb) &&
      srcmode != LRWPAN_ADDRMODE_NOADDR
        ) {
          //PANID present if INTRAPAN is zero, and src is nonzero
          a_mac_rx_data.SrcPANID = *ptr;
          ptr++;
          a_mac_rx_data.SrcPANID += (((UINT16)*ptr) << 8);
          ptr++;
          len = len + 2;
        }
  //SRC address
  if (srcmode == LRWPAN_ADDRMODE_SADDR) {
    a_mac_rx_data.SrcAddr.saddr = *ptr;
    ptr++;
    a_mac_rx_data.SrcAddr.saddr += (((UINT16)*ptr) << 8);
    ptr++;
    len = len + 2;

  }else if (srcmode == LRWPAN_ADDRMODE_LADDR) {
    for (i=0;i<8;i++) {
      a_mac_rx_data.SrcAddr.laddr.bytes[i] = *ptr;
      ptr++;
    }
    len = len + 8;
  }
  //save offset.
  a_mac_rx_data.pload_offset = len;
}