unet.c

Zigbee模块的详细电路原理图和C代码.rar

			UnetSys.JoinParent = NNParent;
			return SELF_HEAL_SUCCESS;
		} 

		Depth--;
		Retry--;
		NParent = NNParent;
	}

	return SELF_HEAL_FAILED;
	//unet_tx_rebpan(); // Coordinator is not available, rebuild pan
	
}

/*******************************************************************************

	MAC PROCESS FUNCTION
					
********************************************************************************/

INT8 unet_queue_proc(UINT8 frequency, MSG_QUEUE *QueuePtr)
{
	unsigned int ReadPtr;       //-------------by hongyan.feng
//	UINT8 *MsgPtr;//----------by hongyan
	void *MsgPtr;
	UINT8 MsgLength,i;
//	MCP_ADDR_LIST_REQ *AddrPtr;
	UINT16 DstAddr;
	
	while(frequency >0)
	{

		if((ReadPtr = MSG_Fetch(QueuePtr)) == QUEUE_EMPTY) 
              	break;

		MsgPtr = QueuePtr->Msg[ReadPtr].MsgPtr;
		MsgLength = QueuePtr->Msg[ReadPtr].Length;

		switch(QueuePtr->Msg[ReadPtr].MsgType)
		{ // Issue Msg to each handler function
			case MT_ASSO_REQ:
				if( UnetSys.Coordinator == 1 )
				{
					unet_rx_asso_req((MCP_ASSO_REQ *)MsgPtr);
				}
				break;
			case MT_ASSO_RSP:
				if(!UnetSys.Flag.JoinNetwork){unet_rx_asso_rsp((MCP_ASSO_RSP *)MsgPtr);}
				break;
			case MT_BEACON_REQ:
				if( UnetSys.Coordinator == 1 )
				{
					unet_tx_bcn();
				}
				break;
			//case MT_DATA_REQ:
			//	break;
			case MT_DATA_IND:
				if(UnetSys.Flag.JoinNetwork){unet_rx_data_ind((MAC_DATA_PKT *)MsgPtr, MsgLength);}
				break;
			case MT_BCN_IND:
				unet_rx_bcn_ind((MAC_BCN_PKT *) MsgPtr, MsgLength);
				break;
			case MT_DISASSO_NTF:
				if(UnetSys.Flag.JoinNetwork){unet_rx_disasso((MAC_CMD_PKT *) MsgPtr);}
				break;
			case MT_IPOP:
				if(UnetSys.Flag.JoinNetwork){unet_rx_ipop((MCP_IPOP *) MsgPtr);}
				break;
			case MT_PBACK:
				if(UnetSys.Flag.JoinNetwork){unet_rx_pback((MCP_PBACK *) MsgPtr);}
				break;
			case MT_CBACK:
				if(UnetSys.Flag.JoinNetwork){unet_rx_cback((MCP_CBACK *) MsgPtr);}
				break;
				
			case MT_ADDR_LIST_REQ:
				if( UnetSys.Coordinator == 1 )
				{
					DstAddr = ((MCP_ADDR_LIST_REQ *)MsgPtr)->SrcAddr;
					for(i=0;i<stAddrList.ucAddrCont;i++)
					{
						if( DstAddr == stAddrList.MACAddress[i] )
						{
							stAddrList.LifeTime[i] = 20000;
						}
					}
					SendAddrList(DstAddr);
				}
				break;
			case MT_ADDR_LIST_RSP:
				if(UnetSys.Flag.JoinNetwork){unet_rx_addrlist_rsp((MCP_ADDR_LIST_RSP *) MsgPtr);}
				break;
			default:	
				break;
		}

		MSG_Free((void *)QueuePtr->Msg[ReadPtr].MsgPtr);
		QueuePtr->Msg[ReadPtr].DataFlag = false;
		QueuePtr->QueueDataCount--; // Decreaase Queue Data Count

		frequency--; // Decrease Handle frequency
	
	}

	return SUCCESS;

}


void unet_proc(void){
	unet_queue_proc(5, &CommQueue);
	unet_queue_proc(MSG_MAX_QUEUE_SIZE, &DataQueue);
}

/*******************************************************************************

	Rx Msg Process Function (for ISR)
					
********************************************************************************/
/*
void unet_msg_fetch(void){
	UINT8 RXLEN;
	void *MsgPtr, *New;

	if(UnetSys.RxCnt < 5){ // Rx Max Buffer 15 packets

		spi_rd_rx_fifo(RF_RX_BUFF, &RXLEN);
		
		if((MsgPtr = malloc(RXLEN+2)) == NULL) //2: LQI, RSSI
			return; 
	
		if((New = malloc(sizeof(struct _rx_frame_list_))) == NULL)
			goto DISCARD_LABEL;

		if(UnetSys.RxHead == NULL)
			UnetSys.RxHead = (struct _rx_frame_list_ *) New;
		else
			UnetSys.RxTail->Next = (struct _rx_frame_list_ *) New;
		

		UnetSys.RxTail = (struct _rx_frame_list_ *) New;
		
		MSG_Copy(MsgPtr, RF_RX_BUFF, RXLEN+2);

		UnetSys.RxTail->Length = RXLEN;
		UnetSys.RxTail->Msg = MsgPtr;
		UnetSys.RxTail->Next = NULL;
		UnetSys.RxCnt += 1;
		
	}else{
		UzRxFlush();
	}

	return;
	
DISCARD_LABEL:
	
	free(MsgPtr); 
	return;
}

*/

/*
UINT8 unet_msg_dispatch(UINT8 frequency){
	struct _rx_frame_list_ *TmPtr;
	MAC_FC *FcPtr;
	MSG_QUEUE *Qptr;
	UINT8 MsgType, HEADLEN = 3;

	while(frequency > 0 && UnetSys.RxCnt >0){
		TmPtr = UnetSys.RxHead; // Head->Next

		FcPtr = (MAC_FC *) TmPtr->Msg;
		
		if(FcPtr->bit.FrmType == FRM_TYPE_BCN){
			MsgType = MT_BCN_IND;
			Qptr = &CommQueue;
		}else if(FcPtr->bit.FrmType == FRM_TYPE_COMM){       
			if(FcPtr->bit.SrcMod == 2){
				HEADLEN += 4; // pan id + short address
			}else if(FcPtr->bit.SrcMod == 3){
				HEADLEN += 10; // pan id + long address
			}
		
			if(FcPtr->bit.DstMod == 2){ //16
				HEADLEN += 4; // pan id + short address
			}else if(FcPtr->bit.DstMod == 3){
				HEADLEN += 10; // pan id + long address
			}
		
			MsgType = *(TmPtr->Msg + HEADLEN);
			Qptr = &CommQueue;
		}else if(FcPtr->bit.FrmType == FRM_TYPE_DATA){      
			MsgType = MT_DATA_IND;
			Qptr = &DataQueue;
		}else{
			MSG_Free((void *) TmPtr->Msg);
			goto DISCARD_LABLE;
		}

		if(MSG_Add((void *) TmPtr->Msg, MsgType , Qptr, TmPtr->Length) != SUCCESS)
			break;
			
DISCARD_LABLE:

		DisInt();
		UnetSys.RxHead = TmPtr->Next;
		free((void *) TmPtr); // Free Head
		UnetSys.RxCnt --;
		EnabInt();
		DBG_val(UnetSys.RxCnt, UnetSys.RxCnt);
		
		frequency--;
	}

	return SUCCESS;

}
*/

void unet_msg_dispatch()
{
	void *Temp;
	MAC_FC *FcPtr;
	MSG_QUEUE *Qptr;
	UINT8 MsgType, RXLEN, HEADLEN = 3;

	spi_rd_rx_fifo(RF_RX_BUFF, &RXLEN);

//	SendStringByASCII(RF_RX_BUFF, RXLEN);
	
	if((Temp = malloc(RXLEN+2)) == NULL) //2: LQI, RSSI
		return; 

	FcPtr = (MAC_FC *) RF_RX_BUFF;
		
	if(FcPtr->bit.FrmType == FRM_TYPE_BCN)
	{
		MsgType = MT_BCN_IND;
		Qptr = &CommQueue;
	}
	else if(FcPtr->bit.FrmType == FRM_TYPE_COMM)
	{       
		if(FcPtr->bit.SrcMod == 2)
		{
			HEADLEN += 4; // pan id + short address
		}
		else if(FcPtr->bit.SrcMod == 3)
		{
			HEADLEN += 10; // pan id + long address
		}
		
		if(FcPtr->bit.DstMod == 2)
		{ //16
			HEADLEN += 4; // pan id + short address
		}
		else if(FcPtr->bit.DstMod == 3)
		{
			HEADLEN += 10; // pan id + long address
		}
	
		MsgType = RF_RX_BUFF[HEADLEN];
		Qptr = &CommQueue;
	}
	else if(FcPtr->bit.FrmType == FRM_TYPE_DATA)
	{      
		MsgType = MT_DATA_IND;
		Qptr = &DataQueue;
	}
	else
	{
		free(Temp);
		return;
	}

	MSG_Copy(Temp, RF_RX_BUFF, RXLEN+2);

	if(MSG_Add(Temp, MsgType , Qptr, RXLEN) != SUCCESS)
	{
		free(Temp);
	}

	return;

}

/*******************************************************************************

	Table Function
					
********************************************************************************/


void clear_table(void **HeadAddr){
	void *Temp;

	while(*HeadAddr != NULL){
		Temp = *HeadAddr;
		MSG_Copy(HeadAddr, Temp, sizeof(Temp)); // Head = Temp->Next
		MSG_Free(Temp);
	}
}

/****************************************************************************************
*  	Function: 
*  	Description: 申请一块新的存储空间
*  	Syntax: 
*	Modify: 
*	parameter:  无
*  	Returns:    无
*  	Notes: 
*	Date: 2007-04-04
*	Author: ZijianWang
****************************************************************************************/
void *insert_node(void **HeadAddr, void **TailAddr, UINT8 Type)
{
	void *New;
	UINT8 i,ucsize;

	switch(Type)
	{
		case CHILD:
		{
			ucsize = sizeof(CHILD_LIST);
			New = MSG_Alloc( ucsize );
			if( New == NULL )
				return NULL;
			for(i=0;i<ucsize;i++)
			{
				*((UINT8 *)New+i) = 0;
			}
			if(*HeadAddr == NULL)
			{
                *HeadAddr = New;
                *TailAddr = New;
			}
			else
			{
				((CHILD_LIST *)*TailAddr)->Next = New;
				*TailAddr = New;
			}
		}
		break;
		case BEACON:
		{
			ucsize = sizeof(BEACON_LIST);
			New = MSG_Alloc(sizeof(BEACON_LIST));
			if( New == NULL )
				return NULL;
			for(i=0;i<ucsize;i++)
			{
				*((UINT8 *)New+i) = 0;
			}
			if(*HeadAddr == NULL)
			{
                *HeadAddr = New;
                *TailAddr = New;
			}
			else
			{
				((BEACON_LIST *)*TailAddr)->Next = (void *)New;
				*TailAddr = New;
			}
		}
		break;
		case BROADCAST:
		{
			ucsize = sizeof(BROAD_LIST);
			New = MSG_Alloc(sizeof(BROAD_LIST));
			if( New == NULL )
				return NULL;
			for(i=0;i<ucsize;i++)
			{
				*((UINT8 *)New+i) = 0;
			}
			if(*HeadAddr == NULL)
			{
                *HeadAddr = New;
                *TailAddr = New;
			}
			else
			{
				((BROAD_LIST *)*TailAddr)->Next = New;
				*TailAddr = New;
			}
		}
		case DATA:
		{
			ucsize = sizeof(DATA_LIST);
			New = MSG_Alloc(sizeof(DATA_LIST));
			if( New == NULL )
				return NULL;
			for(i=0;i<ucsize;i++)
			{
				*((UINT8 *)New+i) = 0;
			}
			if(*HeadAddr == NULL)
			{
                *HeadAddr = New;
                *TailAddr = New;
			}
			else
			{
				((DATA_LIST *)*TailAddr)->Next = New;
				*TailAddr = New;
			}
		}
		break;
		default:	break;
	}
	return New;
	
	
//	if((New = MSG_Alloc(TypeSize)) == NULL)
//		return NULL; 
//
//	if(*HeadAddr == NULL)
//                *HeadAddr = New;
//	else
//		MSG_Copy(*TailAddr, &New, sizeof(New));		//
//
//	return(*TailAddr = New);
}

/*
void delete_node(void *Tail, UINT8 TypeSize){
	void *Head;

	MSG_Copy(&Head, Tail, sizeof(Head)); // Buffer Tail->Next (Head)
	MSG_Copy(Tail, Head, sizeof(Head)); // Tail->Next = Head->Next
	MSG_Free(Head); // Free Head

	return;
}
*/

/*******************************************************************************

	Other Function
					
********************************************************************************/

UINT16 compute_Cskip(INT8 depth){
	INT16 Cm, Rm, Lm, RmT;
	UINT8 i;

	Cm = UNET_MAX_CHILD;
	Rm = UNET_MAX_ROUTER;
	Lm = UNET_MAX_DEPTH;

	if(Rm ==1){
		return (1 + Cm*(Lm -depth -1));
	}

	RmT = Rm;
	
	for(i = 0; i < ((Lm - depth -1) -1) ; i++){
		RmT *= Rm;
	}
	
	return (((1 + Cm - Rm) - (Cm*RmT)) / (1 -Rm));
}

UINT16 compute_Parent(INT8 depth, UINT16 Parent){
	UINT16 i = 0;
	UINT16 cSkip;

	// (UpParent + 1) + I*cSkip(d-2) = CurrentParent 

	cSkip = compute_Cskip(depth-2);

	while(i < Parent) 
		i += cSkip;

	i -= cSkip;

	if(i == Parent){
		return Parent - 1;
	}else{
		return Parent -i - 1;
	}
}
/*
UINT16 compute_Child(INT8 depth, UINT16 Parent){
	UINT16 i = 0;
	UINT16 cSkip;

	// (UpParent + 1) + I*cSkip(d-2) = CurrentParent 

	cSkip = compute_Cskip(depth-2);

	while(i < Parent) 
		i += cSkip;

	i -= cSkip;

	if(i == Parent){
		return Parent - 1;
	}else{
		return Parent -i - 1;
	}
}
*/