mac.c

无线单片机cc2430简化协议的无线收发程序

    }
				

    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);
}

/*
static void macTxData(void) {
  BYTE c;
  BYTE dstmode, srcmode;

    DEBUG_STRING(DBG_TX,"macTxData()\n");
//	
 // if (macTXIdle())
  if(  	phy_pib.flags.bits.txFinished == 1)
  {
    //first time we are sending this packet, format the header
    //used static space for header. If need to store, will copy it later
    //format the header
				
    dstmode = LRWPAN_GET_DST_ADDR(a_mac_tx_data.fcfmsb);
    srcmode = LRWPAN_GET_SRC_ADDR(a_mac_tx_data.fcfmsb);

    if (mac_pib.macPANID == 0xFFFE && srcmode == LRWPAN_ADDRMODE_SADDR)
    {
      //our short address is 0xFFFE, force srcmode to long address
      srcmode = LRWPAN_ADDRMODE_LADDR;
      //clear src mode
      a_mac_tx_data.fcfmsb = a_mac_tx_data.fcfmsb & ~LRWPAN_FCF_SRCMODE_MASK;
      //set to long address
      LRWPAN_SET_SRC_ADDR(a_mac_tx_data.fcfmsb,LRWPAN_ADDRMODE_LADDR);
    }

    //format src Address
    switch(srcmode)
	{
	    case LRWPAN_ADDRMODE_NOADDR:
			  break;
	    case LRWPAN_ADDRMODE_SADDR:
			  phy_pib.currentTxFrm--;
	                  *phy_pib.currentTxFrm = (BYTE)(a_mac_tx_data.SrcAddr >> 8);
	                  phy_pib.currentTxFrm--;
	                  *phy_pib.currentTxFrm = (BYTE)a_mac_tx_data.SrcAddr;				
	                  phy_pib.currentTxFlen=phy_pib.currentTxFlen+2;
	                  break;
	    case LRWPAN_ADDRMODE_LADDR:
			  //this has to be our own long address, get it
			  halGetProcessorIEEEAddress(phy_pib.currentTxFrm-8);
	                  phy_pib.currentTxFlen=phy_pib.currentTxFlen+8;
	                  phy_pib.currentTxFrm = phy_pib.currentTxFrm-8;
	                  break;
	    default:
			  break;
       }

    //format src PANID
    if ( !LRWPAN_GET_INTRAPAN(a_mac_tx_data.fcflsb) &&
        srcmode != LRWPAN_ADDRMODE_NOADDR
          )
    {
            phy_pib.currentTxFrm--;
            *phy_pib.currentTxFrm = (BYTE) (a_mac_tx_data.SrcPANID >> 8);
            phy_pib.currentTxFrm--;
            *phy_pib.currentTxFrm = (BYTE)a_mac_tx_data.SrcPANID;
            phy_pib.currentTxFlen=phy_pib.currentTxFlen+2;
    }

    //format dst Address
    switch(dstmode)
	{
          case LRWPAN_ADDRMODE_NOADDR:
           break;
		  case LRWPAN_ADDRMODE_SADDR:
                    phy_pib.currentTxFrm--;
                    *phy_pib.currentTxFrm = (BYTE)(a_mac_tx_data.DestAddr.saddr >> 8);
                    phy_pib.currentTxFrm--;
                    *phy_pib.currentTxFrm = (BYTE)a_mac_tx_data.DestAddr.saddr;
                    phy_pib.currentTxFlen=phy_pib.currentTxFlen+2;
                    break;
		  case LRWPAN_ADDRMODE_LADDR:
                    for(c=0;c<8;c++) {
                      phy_pib.currentTxFrm--;
                      *phy_pib.currentTxFrm = a_mac_tx_data.DestAddr.laddr.bytes[7-c];
                    }
                    phy_pib.currentTxFlen=phy_pib.currentTxFlen+8;
                    break;
		  default:
                    break;
    }

    //format dst PANID, will be present if both dst is nonzero
    if (dstmode != LRWPAN_ADDRMODE_NOADDR)
	{
      phy_pib.currentTxFrm--;
      *phy_pib.currentTxFrm = (BYTE) (a_mac_tx_data.DestPANID >> 8);
      phy_pib.currentTxFrm--;
      *phy_pib.currentTxFrm = (BYTE)a_mac_tx_data.DestPANID;					
      phy_pib.currentTxFlen=phy_pib.currentTxFlen+2;
    }

    //format dsn
    mac_pib.macDSN = halGetRandomByte();
    phy_pib.currentTxFrm--;
    *phy_pib.currentTxFrm = mac_pib.macDSN; //set DSN		

    //format MSB Fcontrol
    phy_pib.currentTxFrm--;
    *phy_pib.currentTxFrm = a_mac_tx_data.fcfmsb;

    //format LSB Fcontrol
    phy_pib.currentTxFrm--;
    *phy_pib.currentTxFrm = a_mac_tx_data.fcflsb;		

    phy_pib.currentTxFlen = phy_pib.currentTxFlen + 3; //DSN, FCFLSB, FCFMSB


    // at this point, we will attempt a TX
    mac_pib.flags.bits.ackPending = 0;


    //now send the data, ignore the GTS and INDIRECT bits for now
    //DEBUG_STRING(DBG_TX,"TX DSN: ");
    //DEBUG_UINT8(DBG_TX,mac_pib.macDSN);
    //DEBUG_STRING(DBG_TX,"\n");

    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();


}


*/




//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;
}