macp.nc

IEEE802.15.4标准下的基于ZIGBEE协议栈的物理及链路层的代码

			
			/** put into SendCache **/
			call SendCache.putFull(pSendCache);
			break;
			
		/**
		 * associate request frame 
		 * FCF(2)+DSN(1)+DST_PANID(2)+DST_SADDR(2)+SOURCE_PANID(2,0xffff)+SOURCE_LADDR(8)+CMD_TYPE(1)+
		 * CAP_INFO(1)+|ZIGBEE_NUM(4)|+FCS(2)
		 * length = 1+1+4 = 6
		 **/		
		case MAC_CMD_TYPE_ASSOC_REQ:
			/** free this memory block **/			
		    	call Mem.free(pReceiveCache->psdu);	

			/** check length filed **/
			if(length != 6){
		    		call ReceiveCache.putFree(pReceiveCache);				
				post receiveTask();	
				return;
			}
			
			/** coordinator must be in established mode to handle this frame **/		    			
			#ifdef IS_COORD
			if(mac_state != S_ESTABLISHED){
		    		call ReceiveCache.putFree(pReceiveCache);				
				post receiveTask();	
				return;
			}
			#endif

			/** router must be in joined mode to handle this frame, be sure all node are FFD **/			
			#ifndef IS_COORD
	 		if(mac_state != S_JOINED){
		    		call ReceiveCache.putFree(pReceiveCache);	 				
				post receiveTask();	
				return;
	 		}
			#endif	
			
			/** get device capInfo **/ 
			capInfo = *p;
			p++;
			
			/** check ZIGBEE_NUM **/
			if( (*p != ZIGBEE_NUM_0) || (*(p+1) != ZIGBEE_NUM_1) || (*(p+2) != ZIGBEE_NUM_2) || 
			    (*(p+3) != ZIGBEE_NUM_3) ){
				call ReceiveCache.putFree(pReceiveCache);				
				post receiveTask();	
				return;
			}	
			
			/*** have receive right associate frame, notify next high layer ***/
			signal MlmeSap.joinControl(receiveHead.srcAddr.laddr, capInfo, &assignedAddr, &assocError);
			
			/** 
			 * generate association response frame and insert it into SendCache
			 * association response frame format:
 			 * FCF(2)+DSN(1)+DST_PANID(2)+DST_LADDR(8)+SOURCE_PANID(2)+SOURCE_LADDR(8)+
 			 * CMD_TYPE(1)+SADDR(2)+ASSOC_STATUS(1)
 			 * response frame length = 2+1+2+8+2+8+1+2+1 = 27
 			 **/
 			 
			/** malloc association response frame memory block and get a pointer to SendCache element  **/ 
			if( ( call Mem.malloc(&pSendPkt, ASSOC_RESPON_FRAME_LEN+PHY_HEAD_LEN) ) != SUCCESS ){
		    		call ReceiveCache.putFree(pReceiveCache);				
				post receiveTask();	
				return;
			}				
			if( ( ( pSendCache = call SendCache.fetchFree() ) == NULL ) ){
				call Mem.free(pSendPkt);
		    		call ReceiveCache.putFree(pReceiveCache);				
				post receiveTask();	
				return;
			}
			
			/** set p point at end of memory block **/
			p = (uint8_t*)pSendPkt + call Mem.getSize(pSendPkt);
			
			/** add ASSOC_STATUS **/
			p--;
			*p = assocError;
			
			/** add malloced address **/
			p -= 2;
			*(saddr_t*)p = assignedAddr;
			
			/** add mac cmd type **/
			p--;
			*p = MAC_CMD_TYPE_ASSOC_RESPON;
			
			/** add source long address **/
			
			p -= 8;
			for(i=0; i<8; i++){
				*(p+i) = macPib.pLongAddr->bytes[i];
			}
			
			/** add source pan id **/
			p -= 2;
			*(nxle_uint16_t*)p = *(macPib.pPanId);
			
			/** add destination long address **/
			p -= 8;
			for(i=0; i<8; i++){
				*(p+i) = receiveHead.srcAddr.laddr.bytes[i];
			}
			
			/** add destination pan id **/
			p -= 2;
			*(nxle_uint16_t*)p = *(macPib.pPanId);
			
			/** and mac dsn **/
			p--;
			*p = macPib.macDsn;
			
			/** set fcf field **/
			p -= 2;
			*(nxle_uint16_t*)p = ( (MAC_FRAME_TYPE_CMD << POS_MAC_FRAME_TYPE) |
							   (0 << POS_MAC_SECURITY) |
							   (0 << POS_MAC_FRAME_PENDING) |
							   (1 << POS_MAC_ACK_REQUEST) |
							   (0 << POS_MAC_INTRA_PAN) |
							   (MAC_ADDR_MODE_LONG << POS_MAC_DEST_ADDR_MODE) |
							   (MAC_ADDR_MODE_LONG << POS_MAC_SOURCE_ADDR_MODE) );
			call Mem.setCurrentPos(pSendPkt, (p-(uint8_t*)pSendPkt) );
			
			/** fill this SendCache element **/ 
			pSendCache->type = CMD_ASSOC_RESPON;
			pSendCache->isAckSend = TRUE;
			pSendCache->psdu = pSendPkt;			
			pSendCache->dsn = macPib.macDsn - 1;
				
			/** put into SendCache **/
			call SendCache.putFull(pSendCache);
			break;
		
		#ifndef IS_COORD	
		/**
		 * association response frame format: 
 		 * FCF(2)+DSN(1)+DST_PANID(2)+DST_LADDR(8)+SOURCE_PANID(2)+SOURCE_LADDR(8)+
 		 * CMD_TYPE(1)+SADDR(2)+ASSOC_STATUS(1)
 		 * length = 2+1+2+8+2+8+1+2+1 = 27 payload length = 1+2+1 = 4;
		 **/ 	
		case CMD_ASSOC_RESPON:
			if(mac_state != S_JOINING || length != 4){
				call Mem.free(pReceiveCache->psdu);	
		    		call ReceiveCache.putFree(pReceiveCache);				
				post receiveTask();	
				return;
			}	

			/** get assignedAddr **/
			joinAssignedAddr = *(nxle_uint16_t*)p;
			
			/** get associate status **/
			p += 2;
			joinDoneError = *p;
			
			if(joinDoneError == SUCCESS){
				call PlmeSap.setShortAddr(joinAssignedAddr);
				call PlmeSap.sync();
			}
			else{
				mac_state = S_SCAN_DONE;
				post joinDone_task();				
			}	
			
			/** stop associate wait timer **/
			call MacTimer.stop();			
			call Mem.free(pReceiveCache->psdu);
			break;	
		#endif															
		default:
			call Mem.free(pReceiveCache->psdu);
			break;	
		}
		break;														
	default:
		call Mem.free(pReceiveCache->psdu);
		break;	
	call ReceiveCache.putFree(pReceiveCache);	
	post receiveTask();	
	}				
}


#ifndef IS_RFD
command error_t MlmeSap.kickout(saddr_t intentAddr)
{
	/** add kickout code here **/
	return FAIL;
}
#endif




command error_t MlmeSap.leave()
{
	/** add leave code here **/
	return FAIL;
}



task void positiveScanDone_task()
{
	if(panDescriptorNum == 0){
		atomic mac_state = S_IDLE;
		signal MlmeSap.positiveScanDone(FAIL, (uint32_t)0, 0, (pan_descriptor_t*)NULL);
	}
	else{
		atomic mac_state = S_SCAN_DONE;
		signal MlmeSap.positiveScanDone(SUCCESS, (uint32_t)0, panDescriptorNum, panDescriptorTable);
	}
}


task void joinDone_task()
{
	#ifndef IS_COORD	
	signal MlmeSap.joinDone(joinAssignedAddr, joinDoneError);
	#endif
}



void generateBeacon(mem_head_t* pBeaconPkt)
{
	uint8_t* p;
	uint8_t i;
	
	p = (uint8_t*)pBeaconPkt + ( call Mem.getSize(pBeaconPkt) ); 
	
	/** set p at the start position of beacon payload **/
	p -= macPib.beaconPayloadLen;
	for(i=0; i<macPib.beaconPayloadLen; i++){
		*(p+i) = *(beaconPayload+i);
	}
	
	/**** add BEACON_INFO ****/
	p -= 2;
	#ifdef IS_COORD	
	*(nxle_uint16_t*)p =  ( 1 << MAC_POS_BEACON_INFO_COORD ) |
					  ( macPib.bits.macAssociationPermit << MAC_POS_BEACON_INFO_ASSOC_PERMIT);
	#endif
	#ifndef IS_COORD	
	*(nxle_uint16_t*)p =  ( 0 << MAC_POS_BEACON_INFO_COORD ) |
					  ( macPib.bits.macAssociationPermit << MAC_POS_BEACON_INFO_ASSOC_PERMIT);
	#endif	
	
	/** add source pan id field **/
	p -= 2;	
	*(nxle_uint16_t*)p = *(macPib.pPanId);
	
	/** add source address field **/
	p -= 2;
	*(saddr_t*)p = *(macPib.pShortAddr);
	
	/** add mac dsn field **/
	p--;
	*(uint8_t*)p = macPib.macDsn++;
	
	/** set mac fcf **/
	p -= 2;
	*(nxle_uint16_t*)p = ( MAC_FRAME_TYPE_BEACON	<< POS_MAC_FRAME_TYPE ) |
					 ( 0 << POS_MAC_SECURITY ) |
					 ( 0 << POS_MAC_FRAME_PENDING ) |
					 ( 0 << POS_MAC_ACK_REQUEST ) |
					 ( 0 << POS_MAC_INTRA_PAN ) |
					 ( MAC_ADDR_MODE_NONE << POS_MAC_DEST_ADDR_MODE ) |
					 ( MAC_ADDR_MODE_SHORT << POS_MAC_SOURCE_ADDR_MODE );
	call Mem.setCurrentPos( pBeaconPkt, (p - (uint8_t*)pBeaconPkt) );
}



/**
 * SECURITY = 0, FRAME_PENDING = 0, ACK_REQUEST = 0, INTRA_PAN = 0, 
 * DEST_ADDR_MODE = ADDR_MODE_NONE, SOURCE_ADDR_MODE = ADDR_MODE_SHORT.
 * FCF(2)+DSN(1)+SOURCE_PANID(2)+SOURCE_SADDR(2)+BEACON_INFO(2)+{|PROTOCOL_ID(1)+NWK_INFO(2)+IEEEADDR(8)|}
 * length =2+1+2+8 = 13
 **/
void handleBeacon(uint8_t length, uint8_t* pBuf, uint8_t lqi)
{
	uint8_t* p;
	pan_descriptor_t* pdt;	
	uint16_t info;
	uint8_t i;
	
	p = pBuf;
	/** receive wrong beacon **/
	if(length != 13){
		return;
	}
	
	/** panDescriptorTable full **/
	if( panDescriptorNum >= MAX_PAN_DESCRIPTOR_NUM){
		return;
	}
	
	/** get a free panDescriptorTable item **/
	pdt = &panDescriptorTable[panDescriptorNum++];
	
	/** check address field **/
	if( ( (receiveHead.fcf&MASK_MAC_INTRA_PAN) != 0 )	|| (receiveHead.dstAddrMode != MAC_ADDR_MODE_NONE) ||
	    (receiveHead.srcAddrMode != MAC_ADDR_MODE_SHORT) ){
		return;
	}	    	
	
	/** insert beacon info into panDescritorTable **/													 	
	pdt->lqi = lqi;

	/** get Superframe specification field (BEACON_INFO) **/
	info = *(nxle_uint16_t*)p;
	pdt->bits.isPanCoord = (info&MAC_MASK_BEACON_INFO_COORD) >> MAC_POS_BEACON_INFO_COORD;
	pdt->bits.assocPermit = (info&MAC_MASK_BEACON_INFO_ASSOC_PERMIT) >> MAC_POS_BEACON_INFO_ASSOC_PERMIT;
	
	/** get protocolId **/
	p += 2;
	pdt->protocolId = *(nxle_uint8_t*)p;
	
	/** get NWK_INFO and insert into panDescritorTable **/
	p++;
	info = *(nxle_uint16_t*)p;
	pdt->stackProfile = (info&MASK_NWK_INFO_STACK_PROFILE) >> POS_NWK_INFO_STACK_PROFILE;
	pdt->protocolVersion = (info&MASK_NWK_INFO_VERSION) >> POS_NWK_INFO_VERSION;
	pdt->bits.routeCap = (info&MASK_NWK_INFO_ROUTER_CAP) >> POS_NWK_INFO_ROUTER_CAP;
	pdt->bits.endDeviceCap = (info&MASK_NWK_INFO_END_DEVICE_CAP) >> POS_NWK_INFO_END_DEVICE_CAP;
	pdt->deviceDepth = (info&MASK_NWK_INFO_DEPTH) >> POS_NWK_INFO_DEPTH;
	
	/** get IEEEADDR **/
	p += 2;
	for(i=0; i<8; i++){
		pdt->extendedAddr.bytes[i] = *(p+i);
	}
}



void parseHead(mem_head_t* pMacPkt)
{
	uint8_t* p;
	uint8_t i;
	
	p = (uint8_t*)pMacPkt + call Mem.getCurrentPos(pMacPkt);
	receiveHead.fcf = *(nxle_uint16_t*)p;
	receiveHead.type = (receiveHead.fcf&MASK_MAC_FRAME_TYPE) >> POS_MAC_FRAME_TYPE;
	receiveHead.dstAddrMode = ( ( (receiveHead.fcf)&MASK_MAC_DEST_ADDR_MODE ) >> POS_MAC_DEST_ADDR_MODE );
	receiveHead.srcAddrMode = ( ( (receiveHead.fcf)&MASK_MAC_SOURCE_ADDR_MODE ) >> POS_MAC_SOURCE_ADDR_MODE );
	p += 2;
	
	/** get mac dsn **/
	receiveHead.dsn = *(nxle_uint8_t*)p;
	p++;
	
	/** get destination pan id **/
	if(receiveHead.dstAddrMode != MAC_ADDR_MODE_NONE){
		receiveHead.dstPanId = *(nxle_uint16_t*)p;
		p += 2;
	}
	
	/** get destination address **/
	if(receiveHead.dstAddrMode == MAC_ADDR_MODE_SHORT){
		receiveHead.dstAddr.saddr = *(nxle_uint16_t*)p;
		p += 2;
	}
	else if(receiveHead.dstAddrMode == MAC_ADDR_MODE_LONG){
		for(i=0; i<8; i++){
			receiveHead.dstAddr.laddr.bytes[i] = *p++;
		}
	}	
	
	/** get source pan id **/
	if( (receiveHead.fcf&MASK_MAC_INTRA_PAN) == 0 && receiveHead.srcAddrMode != MAC_ADDR_MODE_NONE ){
		/** this packet have source pan id **/
		receiveHead.srcPanId = *(nxle_uint16_t*)p;
		p += 2;
	}
	
	/** get source address **/
	if(receiveHead.srcAddrMode == MAC_ADDR_MODE_SHORT){
		receiveHead.srcAddr.saddr = *(nxle_uint16_t*)p;
		p += 2;
	}
	else if(receiveHead.srcAddrMode == MAC_ADDR_MODE_LONG){
		for(i=0; i<8; i++){
			receiveHead.srcAddr.laddr.bytes[i] = *p++;
		}		
	}	
	
	/** set position to mac frame payload **/
	call Mem.setCurrentPos( pMacPkt, (p-(uint8_t*)pMacPkt) );	  
}




/********* set and get macPib *******************/

command bool MlmeSap.getMacAssociationPermit()
{
	return macPib.bits.macAssociationPermit;
}



command void MlmeSap.setMacAssociationPermit(bool permit)
{
	atomic macPib.bits.macAssociationPermit = permit;

}



command uint8_t MlmeSap.getMacBeaconPayloadMaxLength()
{
	return BEACON_MAX_PAYLOAD_LEN;
}



command uint8_t MlmeSap.getMacBeaconPayloadLength()
{
	return macPib.beaconPayloadLen;
}




command uint8_t* MlmeSap.getMacBeaconPayloadHandle()
{
	return macPib.pBeaconPayload;
}



command error_t MlmeSap.setMacBeaconPayloadLength(uint8_t length)
{
	if(length > BEACON_MAX_PAYLOAD_LEN){
		return FAIL;
	}
	else{
		atomic macPib.beaconPayloadLen = length;
		return SUCCESS;
	}	
}



command uint16_t MlmeSap.getMacPanId()
{
	uint16_t panId = *(macPib.pPanId);
	return panId;
}



command saddr_t MlmeSap.getMacShortAddr()
{
	saddr_t shortAddr;
	shortAddr = *(macPib.pShortAddr);
	return shortAddr;
}





event void PlmeSap.directSetPanIdDone(error_t error){}
event void PlmeSap.rxControlDone(error_t error){}
event void PlmeSap.directSetCCAModeDone(error_t error){}
event void PlmeSap.directSetCurrentChannelDone(error_t error){}
event void PlmeSap.directSetTxPowerDone(error_t error){}

}