#include "pro_phy.h"
#include "pro_data.h"
#include "pro_hal.h"
#include "pro_memory.h"
#include "Pro_interface.h"
#include "timer.h"
#include "usart.h"
#include "led.h"
#include "bsp.h"
#include "md5.h"
#include "aes.h"

NODESTATUS NodeStatus;//节点状态
static HeartTable heart_table[MAX_NODE_NUM];
static RoutrTable route_table[MAX_NODE_NUM];
static PathTable path_table[MAX_NODE_NUM];
static LOST_CONNECTION lost_conn[MAX_NODE_NUM];
static HANDLEMULTIPACK IsHandle[DATA_BUF_COUNT];
static DATA_BUF DataBuf[DATA_BUF_COUNT];//数据缓冲,最大长度PAYLOAD_DATA_LEN
static u8 ThreadLock=0;
//static u8 node_type=NODE;
static u8 pipe1_mac[MAC_LEN]={0x00,0xB9,0x7F,0x55,0xB0};//通道1地址(本网络节点)
static u8 pipe2_mac[MAC_LEN]={0xFF,0xB9,0x7F,0x55,0xB0};//通道2地址(所有节点),分配地址
static HANDLERECECALLBACK RecvHandler=NULL;
static HANDLESENDCALLBACK SendHandler=NULL;

void NRF_Init(void)//初始化协议
{
	MemSet((BYTE *)&NodeStatus,0,sizeof(NODESTATUS));//初始化节点状态
	MemSet((BYTE *)&DataBuf,0,sizeof(DATA_BUF)*DATA_BUF_COUNT);//初始化缓冲区为空闲状态
	MemSet((BYTE *)&IsHandle,0,sizeof(HANDLEMULTIPACK)*DATA_BUF_COUNT);
	MemSet((BYTE *)&lost_conn,0,sizeof(LOST_CONNECTION)*MAX_NODE_NUM);
	MemSet((BYTE *)&heart_table,0,sizeof(HeartTable)*MAX_NODE_NUM);
	MemSet((BYTE *)&route_table,0,sizeof(RoutrTable)*MAX_NODE_NUM);
	NodeStatus.addr=0x01;//初始地址
	NodeStatus.channel=124;//初始信道124,可用信道0-124
	NodeStatus.pwd=Get_NetworkID();
	NRF_GetMacAddr(NodeStatus.node_mac,NodeStatus.addr);//获取mac地址(RX)
	NRF_Config(NodeStatus.node_mac,NodeStatus.channel);//硬件初始化
	NRF_SetPipe1Mac(pipe1_mac);
//	NRF_SetPipe2Mac(pipe2_mac);
	if(!NRF_Check())
	{
		SetLed(0xff,20,20);
		printf("\r\nNRF24L01+模块不存在或已损坏\r\n");
	}
}

void NRF_SetPipe1Mac(u8 *addr)
{
	NRF_CE = 0;
	NRF_GetMacAddr(addr,0xff);//生成MAC地址
	if(addr[0]==0xFF)
	{
		addr[0]-=1;
	}
	NRF_WriteBuf(RX_ADDR_P1, addr, MAC_LEN);//写通道1,RX地址
	NRF_WriteReg(CONFIG, 0x0B);//接收模式
	NRF_CE = 1;
}

//void NRF_SetPipe2Mac(u8 *addr)
//{
//	NRF_CE = 0;
//	NRF_WriteReg(RX_ADDR_P2, addr[0]);//写通道2,RX地址
//	NRF_WriteReg(CONFIG, 0x0B);//接收模式
//	NRF_CE = 1;
//}

void NRF_InitRoutrTable(void)//初始化路由表
{
	MemSet((BYTE *)&heart_table,0,sizeof(HeartTable)*MAX_NODE_NUM);
	MemSet((BYTE *)&route_table,0,sizeof(RoutrTable)*MAX_NODE_NUM);
}

void NRF_SetDefaultRecvHandler(HANDLERECECALLBACK pFun)
{
	RecvHandler=pFun;
}

void NRF_SetDefaultSendHandler(HANDLESENDCALLBACK pFun)
{
	SendHandler=pFun;
}

u8 NRF_GetThreadLockState(void)
{
	return ThreadLock;
}

void NRF_SetThreadLockState(u8 val)
{
	ThreadLock=val;
}

void NRF_CalcCols(u8 *col,u8 addr)
{
	u8 i;

	for(i = 5; i > 0; i--)
	{
		*col = (*col << 1) ^ addr;
		col++;
	}
}

void NRF_InvMixColumn(u8 *column,u8 addr)
{
	u8 r[5];

	r[0] = column[1] ^ column[2] ^ column[3] ^ column[4];
	r[1] = column[0] ^ column[2] ^ column[3] ^ column[4];
	r[2] = column[0] ^ column[1] ^ column[3] ^ column[4];
	r[3] = column[0] ^ column[1] ^ column[2] ^ column[4];
	r[4] = column[0] ^ column[1] ^ column[2] ^ column[3];

	NRF_CalcCols(column,addr);

	r[0] ^= column[0] ^ column[1];
	r[1] ^= column[1] ^ column[2];
	r[2] ^= column[2] ^ column[3];
	r[3] ^= column[3] ^ column[4];
	r[4] ^= column[4] ^ column[0];

	NRF_CalcCols(column,addr);

	r[0] ^= column[0] ^ column[2];
	r[1] ^= column[1] ^ column[3];
	r[2] ^= column[2] ^ column[4];
	r[3] ^= column[3] ^ column[0];
	r[4] ^= column[4] ^ column[1];

	NRF_CalcCols(column,addr);

	column[0] ^= column[1] ^ column[2] ^ column[3] ^ column[4];
	r[0] ^= column[0];
	r[1] ^= column[0];
	r[2] ^= column[0];
	r[3] ^= column[0];
	r[4] ^= column[0];
	
	column[0] = r[0];
	column[1] = r[1];
	column[2] = r[2];
	column[3] = r[3];
	column[4] = r[4];
}

void NRF_GetMacAddr(u8 *mac,const u8 addr)
{
	u8 str[5]={0};
	u8 str1[10]={0};
	u8 i;
	
	sprintf((char *)str1,"%d",NodeStatus.pwd);
	if(addr>0&&addr<0xFF)
	{
		for(i=0;i<10;i++)//异或加密
		{
			 str1[i] ^= addr;
		}
		if(addr>0&&addr<128)
		{
			str[1]=(str1[0]+str1[1])<<2;
			str[2]=(str1[2]+str1[3])<<2;
			str[3]=(str1[4]+str1[5])<<2;
			str[4]=(str1[6]+str1[7])<<2;
			str[0]=(str1[8]+str1[9])<<2;
		}
		if(addr>=128&&addr<0xFF)
		{
			str[1]=str1[0]+str1[1];
			str[2]=str1[2]+str1[3];
			str[3]=str1[4]+str1[5];
			str[4]=str1[6]+str1[7];
			str[0]=str1[8]+str1[9];
		}
		NRF_InvMixColumn(str,addr);
	}
	else 
	{
		if(addr==0xFF)
		{
			str[0]=cal_crc8(str1, 10);
			str[1]=0xB9;
			str[2]=0x7F;
			str[3]=0x55;
			str[4]=0xB0;
		}
		if(addr==0)
		{
			for(i=0;i<5;i++)
			{
				 str[i] = 0xFF;
			}
		}
	}
	//MemCopy((BYTE *)mac,(BYTE *)str,MAC_LEN);
	NRF_CopyMac(mac,str);
}

void NRF_SendData(const u8 dst_addr,const u8 type,const u8 *buf,HANDLESENDCALLBACK fun)//发送数据接口
{
	static u32 id=0;
	u8 idx;

	if(dst_addr!=NodeStatus.addr)
	{
		idx=NRF_MallocIdleDataBufId();
		if(0xFF==idx)
		{
			return;
		}
		DataBuf[idx].status=WAIT_SEND;
		DataBuf[idx].HandleCallBack=fun;
		DataBuf[idx].payload.header.PID=NodeStatus.pwd;
		DataBuf[idx].payload.header.SID=id++;//获取唯一的ID
		DataBuf[idx].payload.header.the_addr=NodeStatus.addr;
		DataBuf[idx].payload.header.src_addr=NodeStatus.addr;
		DataBuf[idx].payload.header.dst_addr=dst_addr;
		DataBuf[idx].payload.header.ass_addr=dst_addr;
		DataBuf[idx].payload.header.hop_addr=0;
		DataBuf[idx].payload.header.hop_count=0;
		DataBuf[idx].payload.header.pack_type=type;
		MemCopy((BYTE *)DataBuf[idx].payload.buf,(BYTE *)buf,PAYLOAD_DATA_LEN);
		if(CHECK_LINK==type) 
			NodeStatus.heart_status=1;
		if(0xFFFFFFFF==id)
		{
			id=0;
		}
	}
}

void NRF_SendCallBack(u8 src_addr,u8 dst_addr,u8 pack_type,u16 pwd,u8 *buf,u8 status)
{
	if(status)
	{
		printf("ID=%d src=%d dst=%d type=%d OK\r\n\r\n",pwd,src_addr,dst_addr,pack_type);
	}
	else
	{
		printf("ID=%d src=%d dst=%d type=%d FAIL\r\n\r\n",pwd,src_addr,dst_addr,pack_type);
	}
}

void NRF_HeartCallBack(u8 src_addr,u8 dst_addr,u8 pack_type,u16 pwd,u8 *buf,u8 status)
{
	NodeStatus.heart_status=0;
	if(status)
	{
		printf("ID=%d Heart To %d ok\r\n\r\n",pwd,dst_addr);
	}
	else
	{
		printf("ID=%d Heart To %d fail\r\n\r\n",pwd,dst_addr);
	}
}

u8 NRF_HeartTableFindValidNode(u8 node)//心跳表查找有效节点
{
	u8 i;
	
	for(i=0; i<MAX_NODE_NUM; i++)//节点列表
	{
		if(heart_table[i].addr==node)
		{
			return i;
		}
	}
	return 0xFF;
}

//返回0,列表已满或节点已存在; 返回1,添加成功
u8 NRF_AddNodeToHeartTable(u8 node)
{
	u8 i,idx;
	
	idx=NRF_HeartTableFindValidNode(node);
	if(0xFF==idx)//没有找到节点(不添加重复节点)
	{
		for(i=0; i<MAX_NODE_NUM; i++)//节点列表
		{
			if(!heart_table[i].addr)//心跳表查找空闲节点,添加到心跳表
			{
				heart_table[i].addr=node;
				heart_table[i].link_time=Get_RunTime();
				return TRUE;
			}
		}
		NRF_DelNodePath(node);//删除节点
		return FALSE;
	}
	return FALSE;
}

void NRF_UpdateHearTable(void)
{
	u8 i,j,k,pos=0;//pos变量用来标记循环里最后一次交换的位置

	for(i=0; i<MAX_NODE_NUM; i++)//遍历路由表
	{
		if(route_table[i].addr)//路由表查找有效节点
		{
			NRF_AddNodeToHeartTable(route_table[i].addr);
			for(j=0; j<MAX_HOP_NUM; j++)//遍历路径表
			{
				if(route_table[i].path[j])//查找有效地址
				{
					NRF_AddNodeToHeartTable(route_table[i].path[j]);
				}
			}
		}
	}
	//冒泡排序
	k=MAX_NODE_NUM-1;
	for(i=0;i<MAX_NODE_NUM-1;i++)//一共要排序n次  
	{  
		//每次遍历标志位都要先置为0，才能判断后面的元素是否发生了交换  
		u8 flag=0;  

		for(j=0;j<k;j++)//选出该趟排序的最大值往后移动
		{  
			if(heart_table[j].addr>heart_table[j+1].addr)
			{
				u32 time=heart_table[j].link_time;
				u8 tmp=heart_table[j].addr;

				heart_table[j].link_time=heart_table[j+1].link_time;
				heart_table[j+1].link_time=time;
				heart_table[j].addr=heart_table[j+1].addr;
				heart_table[j+1].addr=tmp;
				flag=1;//只要有发生了交换，flag就置为1
				pos=j;//循环里最后一次交换的位置j赋给pos
			}
		}
		k=pos;
		//判断标志位是否为0，如果为0，说明后面的元素已经有序，就直接return
		if(flag==0)
		{
			break;
		}
	}
	for(i=0; i<MAX_NODE_NUM; i++)//心跳表重新排序
	{
		if(!heart_table[i].addr)
		{
			for(j=i+1; j<MAX_NODE_NUM; j++)
			{
				if(heart_table[j].addr)//有地址的移到最前面
				{
					heart_table[i].addr=heart_table[j].addr;
					heart_table[i].link_time=heart_table[j].link_time;
					heart_table[j].addr=0;
					heart_table[j].link_time=0;
					break;
				}
			}
		}
	}
}

u8 NRF_UpdateHeartTime(u8 node)
{
	u8 id;

	id=NRF_HeartTableFindValidNode(node);
	if(0xFF!=id)
	{
		heart_table[id].link_time=Get_RunTime();
		return TRUE;
	}
	return FALSE;
}

u8 NRF_UpdateToRoutrTablePath(u8 idx,LPayload pPayLoad)//更新路径表
{
	u8 k;

	MemCopy((BYTE *)route_table[idx].path,(BYTE *)pPayLoad->buf,sizeof(pPayLoad->buf));
	if(pPayLoad->header.hop_addr)//上一跳地址有效
	{
		if(pPayLoad->header.hop_count<MAX_HOP_NUM)
		{
			for(k=0; k<MAX_HOP_NUM; k++)//遍历路径表
			{
				if(!route_table[idx].path[k])//找到空位
				{
					route_table[idx].path[k]=pPayLoad->header.hop_addr;//把上一跳地址添加到路径表最后
					return TRUE;
				}
			}
		}
	}
	return FALSE;
}

//返回0,列表已满; 返回1,添加成功;
u8 NRF_AddNodeToRoutrTable(LPayload pPayLoad)//添加1个节点到路由表
{
	u8 i;

	for(i=0; i<MAX_NODE_NUM; i++)//遍历路由表
	{
		if(route_table[i].addr==pPayLoad->header.the_addr)//节点已存在
		{
			NRF_UpdateToRoutrTablePath(i,pPayLoad);//更新路径表
			NRF_UpdateHearTable();
			return TRUE;
		}
	}
	for(i=0; i<MAX_NODE_NUM; i++)//没有找到地址
	{
		if(!route_table[i].addr)//找到空位
		{
			route_table[i].addr=pPayLoad->header.the_addr;//添加到路由表
			NRF_UpdateToRoutrTablePath(i,pPayLoad);//更新路径表
			NRF_UpdateHearTable();
			return TRUE;
		}
	}
	return FALSE;
}

void NRF_DelNodePath(u8 node)//删除节点
{
	u8 i,j,k;
	
	for(i=0; i<MAX_NODE_NUM; i++)//遍历路由表
	{
		if(route_table[i].addr)
		{
			if(route_table[i].addr==node)
			{
				MemSet((BYTE *)&route_table[i],0,sizeof(RoutrTable));//从路由表删除1个节点
			}
			else
			{
				for(j=0; j<MAX_HOP_NUM; j++)//从路径表删除1个节点
				{
					if(route_table[i].path[j]==node)//找到节点
					{
						route_table[i].path[j]=0;//删除节点
						for(k=j+1; k<MAX_HOP_NUM; k++)//从删除节点位置开始遍历路径表,后面的所有节点左移1位
						{
							route_table[i].path[k-1]=route_table[i].path[k];//左移
						}
					}
				}
			}
		}
	}
	for(i=0; i<MAX_NODE_NUM; i++)//路由表重新排序
	{
		if(!route_table[i].addr)
		{
			for(j=i+1; j<MAX_NODE_NUM; j++)//有地址的移到最前面
			{
				if(route_table[j].addr)
				{
					MemCopy((BYTE *)&route_table[i],(BYTE *)&route_table[j],sizeof(RoutrTable));
					MemSet((BYTE *)&route_table[j],0,sizeof(RoutrTable));//从路由表删除1个节点
					break;
				}
			}
		}
	}
	for(i=0; i<MAX_NODE_NUM; i++)//从心跳表删除1个节点
	{
		if(heart_table[i].addr==node)
		{
			u8 tmp=0;
			
			MemSet((BYTE *)&heart_table[i],0,sizeof(HeartTable));//删除节点

			/*******************统计掉线次数********************/
			for(k=0; k<MAX_NODE_NUM; k++)//查找列表是否有这个节点
			{
				if(lost_conn[k].addr==node)
				{
					tmp=node;
					break;
				}
			}
			if(tmp)//有这个节点
			{
				for(k=0; k<MAX_NODE_NUM; k++)//掉线次数+1
				{
					if(lost_conn[k].addr==tmp)
					{
						lost_conn[k].count++;
						if(lost_conn[k].count>=0xFE)
						{
							lost_conn[k].count=0xFE;
						}
						break;
					}
				}
			}
			else//没有这个节点，把节点保存到列表
			{
				for(k=0; k<MAX_NODE_NUM; k++)
				{
					if(!lost_conn[k].addr)
					{
						lost_conn[k].addr=node;
						lost_conn[k].count++;
						break;
					}
				}
			}
			/***************************************************/
		}
	}
	for(i=0; i<MAX_NODE_NUM; i++)//心跳表重新排序
	{
		if(!heart_table[i].addr)
		{
			for(j=i+1; j<MAX_NODE_NUM; j++)
			{
				if(heart_table[j].addr)//有地址的移到最前面
				{
					heart_table[i].addr=heart_table[j].addr;
					heart_table[i].link_time=heart_table[j].link_time;
					heart_table[j].addr=0;
					heart_table[j].link_time=0;
					break;
				}
			}
		}
	}
	NRF_SendData(node,DEL_NODE,(u8 *)"",SendHandler);//发送数据接口
}

u8 NRF_FindNodePath(u8 node)//查找节点最短路径
{
	u8 i,j,k,n,min,addr;

	MemSet((BYTE *)&path_table,0,sizeof(PathTable)*MAX_NODE_NUM);
	for(i=0; i<MAX_NODE_NUM; i++)//遍历节点列表
	{
		if(route_table[i].addr)//地址有效
		{
			if(route_table[i].addr==node)
			{
				return route_table[i].addr;//最短路径 立即返回
			}
			else
			{
				for(j=0; j<MAX_HOP_NUM; j++)//遍历路径表
				{
					if(route_table[i].path[j]==node)//在路径表找到地址
					{
						n=0;
						for(k=j+1; k<MAX_HOP_NUM; k++)//计算n值
						{
							if(route_table[i].path[k])//有地址
							{
								n++;//n值越大距离越远
							}
						}
						for(k=0; k<MAX_NODE_NUM; k++)//遍历路径索引表
						{
							if(!path_table[k].addr)//找到空位
							{
								path_table[k].idx=n;//保存n值
								path_table[k].addr=route_table[i].addr;//保存节点地址
								break;
							}
						}
						break;	
					}
				}
			}
		}
		else//退出循环
		{
			break;	
		}
	}
	if(!path_table[0].addr)//没有节点地址
		return 0xFF;
	min=path_table[0].idx;
	addr=path_table[0].addr;

	for(i=0; i<MAX_NODE_NUM; i++)//遍历路径索引表
	{
		if(path_table[i].addr)//有节点地址
		{
			if(path_table[i].idx<min)//查找最小索引号
			{
				min=path_table[i].idx;
				addr=path_table[i].addr;
			}
		}
	}
	return addr;//返回节点地址(下一跳地址)
}

static void NRF_SendHeartPack(void)//发送心跳包
{
	static u8 timer=0,cnt=0;
	static u8 nCnt=0;
	
	if(!NodeStatus.heart_status)
	{
		timer++;
		if(timer>=HEART_PACK_TIME)//(10毫秒*100)扫描1次;(1秒)
		{
			u32 heart_time;
			u8 i;

			timer=0;
			heart_time=Get_RunTime();
			for(i=0; i<MAX_NODE_NUM; i++)//节点列表
			{
				if(heart_table[i].addr)
				{
					cnt=0;
					nCnt=0;
					if(heart_time-heart_table[i].link_time>HEART_LINK_INTERVAL)
					{
						heart_table[i].link_time=heart_time;
						NRF_SendData(heart_table[i].addr,CHECK_LINK,(u8 *)"",NRF_HeartCallBack);
					}
				}
			}
			cnt++;
			if(cnt>=30)//没有节点,30秒
			{
				cnt=0;
				if(nCnt<3)//没有节点,验证3次
				{
					if(!NRF_CheckReg())//寄存器错误
					{
						NRF_Init();//初始化
					}
					nCnt++;
				}
				NRF_SendData(0xFF,0xFF,(u8 *)"",NULL);//30秒NRF发送1次数据
			}
		}
	}
}

static void NRF_NrfSendData(void)//根据缓冲区状态发送数据,发送前先检测干扰
{
	u8 index;
	
	index=NRF_SearchDataBuf(WAIT_SEND);
	if(0xFF==index)
	{
		index=NRF_SearchDataBuf(WAIT_RETRY);
	}
	if(0xFF==index)
	{
		index=NRF_SearchDataBuf(WAIT_SEND_RETRY);
	}
	if(0xFF!=index)
	{
		if(!NRF_DisturbanceDetect())//检测是否有其它节点在发送数据
		{
			u8 new_mac[MAC_LEN]={0};
			u8 dst_addr;
			
			dst_addr=NRF_FindNodePath(DataBuf[index].payload.header.dst_addr);//寻找路径
			if(0xFF==dst_addr)//路由表没有地址,广播
			{
				printf("node %d DISCONNECT\r\n",DataBuf[index].payload.header.dst_addr);
				DataBuf[index].isBroadcast=1;
			}
			else 
			{
				NRF_GetMacAddr(new_mac,dst_addr);//获取MAC地址
				printf("send-addr=%d\r\n",dst_addr);
			}
			NodeStatus.shift_failed_count=0;
			NodeStatus.shift_count++;
			if(!DataBuf[index].isBroadcast)
			{
				if(NRF_SendPayload(IS_ACK,new_mac,NodeStatus.channel,(u8* )&DataBuf[index].payload))//通道0发送数据
				{
					switch(DataBuf[index].payload.header.pack_type)
					{
						case CHECK_LINK:
							DataBuf[index].status=WAIT_ACK;
							break;
						default:
							DataBuf[index].status=SEND_SUCCESS;
							break;
					}
				}
				else
				{
					DataBuf[index].status=WAIT_SEND_RETRY;
					DataBuf[index].send_failed_count++;
				}
			}
			else//广播
			{
				switch(DataBuf[index].payload.header.pack_type)
				{
					case ASSIGN_ADDR:
						NRF_SendPayload(NO_ACK,pipe2_mac,NodeStatus.channel,(u8* )&DataBuf[index].payload);//通道2发送数据(向所有节点广播)
						break;
					default:
						NRF_SendPayload(NO_ACK,pipe1_mac,NodeStatus.channel,(u8* )&DataBuf[index].payload);//通道1发送数据(向本网络节点广播)
						break;
				}
				DataBuf[index].status=SEND_FAILED;
			}
			NRF_RxMode(NodeStatus.node_mac, NodeStatus.channel);
		}
		else
		{
			NodeStatus.shift_failed_count++;
			if(NodeStatus.shift_failed_count>300)
			{
				NodeStatus.shift_failed_count=0;
				//NRF_SetChannel(NRF_AppropriateChannelDetect());//检测拥挤程度最低的信道
				NRF_Init();
			}
		}
	}
}

static void NRF_RelayPackage(LPayload pPayLoad)//转发
{
	u8 idx;

	if(pPayLoad->header.PID==NodeStatus.pwd)//是本网络的ID
	{
		idx=NRF_MallocIdleDataBufId();
		if(0xFF!=idx)
		{
			DataBuf[idx].status=WAIT_SEND;
			MemCopy((BYTE*)&DataBuf[idx].payload,(BYTE *)pPayLoad,sizeof(Payload));
		}
		printf("***Relay-Package***\r\n");
	}
}

void NRF_RecvData(void)
{
	Payload tmp;
	u8 id,idx,status;
	u8 pipe_num;
	
	NRF_CE = 0;
	MemSet((BYTE *)&tmp,0,sizeof(Payload));
	status=NRF_ReadReg(STATUS);//读取status寄存器的值
	pipe_num=(status&RX_P_NO_MASK)>>1;//读取通道号(0-5)
	NRF_ReadBuf(R_RX_PAYLOAD, (u8 *)&tmp, PAYLOAD_LEN);//保存接收到的数据
	NodeStatus.recv_count++;
//	printf("Pipe%d-Recv\r\n",pipe_num);
	
//	printf("src=%d,dst=%d,type=%d\r\nnid==%d,sid=%d,data=%d\r\nID=%d\r\n",
//			tmp.header.src_addr,tmp.header.dst_addr,tmp.header.pack_type,
//			tmp.header.data_hp,tmp.header.data_hs,tmp.header.data_sd,tmp.header.ID);
	if(tmp.header.src_addr==NodeStatus.addr)//是自己发送的包,返回
	{
		NRF_RxMode(NodeStatus.node_mac, NodeStatus.channel);
		return;
	}
	if(NodeStatus.pwd==tmp.header.PID)//是本网络的ID
	{
		//10秒内处理过的包不再处理(在广播时会收到很多重复的包)
		if(!NRF_CmpMultiPack(tmp.header.src_addr,tmp.header.dst_addr,
							 tmp.header.pack_type,tmp.header.SID))
		{
			id=NRF_SearchHandlTimeoutId();
			if(0xFF!=id)
			{
				IsHandle[id].RID=tmp.header.SID;
				IsHandle[id].time=Get_RunTime();
				IsHandle[id].src_addr=tmp.header.src_addr;
				IsHandle[id].dst_addr=tmp.header.dst_addr;
				IsHandle[id].pack_type=tmp.header.pack_type;
				
				if(tmp.header.dst_addr==NodeStatus.addr)//目的地址是本节点
				{
					if(START_LINK==tmp.header.pack_type)
					{
						u8 path[MAX_HOP_NUM]={0};//空的路径表
						
						NRF_AddNodeToRoutrTable(&tmp);//添加节点到路由表
						NRF_SendData(tmp.header.src_addr,BUILD_LINK,(u8 *)path,SendHandler);//发送数据接口
					}
					switch(tmp.header.pack_type)
					{
						case BUILD_LINK_ACK:
							NRF_UpdateHearTable();//更新心跳表
						break;
						case CHECK_LINK_ACK:
							NRF_UpdateHeartTime(tmp.header.src_addr);//根据地址更新心跳时间
							idx=NRF_SearchDataByPackType(tmp.header.src_addr,CHECK_LINK);//根据addr和type查找
							if(0xFF!=idx)
							{
								DataBuf[idx].status=SEND_SUCCESS;
							}
						break;
						case NODE_KEY_DATA:
						case ONE_DATA_ACK:
						case WAY_KEY_DATA_ACK:
							idx=NRF_MallocIdleDataBufId();
							if(0xFF!=idx)
							{
								MemCopy((BYTE*)&DataBuf[idx].payload,(BYTE *)&tmp,PAYLOAD_LEN);
								DataBuf[idx].retry_count=pipe_num;
								DataBuf[idx].status=WAIT_HANDLER;
							}
						break;
						default:break;
					}
				}
				else
				{
					NRF_RelayPackage(&tmp);
				}
			}
		}
	}
	NRF_RxMode(NodeStatus.node_mac, NodeStatus.channel);
}

void NRF_HandleBuf(void)//根据缓冲区状态处理缓冲区
{
	u8 i;
	
	for(i=0;i<DATA_BUF_COUNT;i++)
	{
		switch(DataBuf[i].status)
		{
			case WAIT_SEND_RETRY:
				if(DataBuf[i].send_failed_count>=MAX_FAILED_COUNT)//发送失败3次,转为广播包
				{
					DataBuf[i].isBroadcast=1;
				}
				break;
			case WAIT_ACK:
				DataBuf[i].time_count++;
				if(DataBuf[i].time_count>MAX_ACK_TIME)
				{
					DataBuf[i].time_count=0;
					DataBuf[i].send_failed_count=0;
					DataBuf[i].retry_count++;
					DataBuf[i].status=WAIT_RETRY;
					if(DataBuf[i].retry_count>MAX_RETRY_COUNT)
					{
						DataBuf[i].status=SEND_FAILED;
					}
				}
				break;
			case WAIT_HANDLER:
				//printf("Pipe%d-Recv\r\n",DataBuf[i].retry_count);
				if(RecvHandler)
				{
					RecvHandler(DataBuf[i].payload.header.src_addr,
								DataBuf[i].payload.header.dst_addr,
								DataBuf[i].payload.header.pack_type,
								DataBuf[i].payload.buf);
				}
				NRF_FreeDataBuf(i);
				break;	
			case SEND_SUCCESS:
				if(DataBuf[i].HandleCallBack)//发送完成回调
				{
					DataBuf[i].HandleCallBack(DataBuf[i].payload.header.src_addr,
												DataBuf[i].payload.header.dst_addr,
												DataBuf[i].payload.header.pack_type,
												DataBuf[i].payload.header.SID,
												DataBuf[i].payload.buf,PACKAGE_SUCCESS);
				}
				NRF_FreeDataBuf(i);
				break;
			case SEND_FAILED:
				if(CHECK_LINK==DataBuf[i].payload.header.pack_type)
				{
					NRF_DelNodePath(DataBuf[i].payload.header.dst_addr);//删除节点
				}
				if(DataBuf[i].HandleCallBack)//发送失败回调
				{
					DataBuf[i].HandleCallBack(DataBuf[i].payload.header.src_addr,
												DataBuf[i].payload.header.dst_addr,
												DataBuf[i].payload.header.pack_type,
												DataBuf[i].payload.header.SID,
												DataBuf[i].payload.buf,PACKAGE_FAILED);
				}
				NRF_FreeDataBuf(i);
				break;
		}
	}
}

u8 NRF_AppropriateChannelDetect(void)//检测拥挤程度最低的信道
{
	u8 channel,min_disturb_count=11,i,j;
	u8 disturb_count[125]={0};
	
	ThreadLock=1;
	//MemSet((BYTE *)disturb_count,0,125);
	channel=NRF_ReadChannel();
	for(i=0;i<10;i++)
	{
		for(j=0;j<125;j++)
		{
			NRF_SetChannel(i);
			if(NRF_DisturbanceDetect())
			{
				disturb_count[j]++;
			}
		}
	}
	NRF_SetChannel(channel);
	for(i=0;i<125;i++)
	{
		if(disturb_count[i]<min_disturb_count)
		{
			min_disturb_count=disturb_count[i];
			channel=i;
		}
	}
	NRF_ReadReg(FLUSH_RX);//清接收FIFO
	ThreadLock=0;
	return channel;
}

void NRF_Thread(void)//定时线程,执行协议
{
	NRF_SendHeartPack();
	NRF_NrfSendData();
	NRF_HandleBuf();
}

u8 NRF_MallocIdleDataBufId(void)//得到一个空闲DATABUF,并将其标记为待用
{
	u8 i;
	
	ThreadLock=1;//锁定
	for(i=0;i<DATA_BUF_COUNT;i++)
	{
		if(IDLE==DataBuf[i].status)
		{
			DataBuf[i].status=WAIT_USE;
			ThreadLock=0;//解锁
			return i;
		}
	}
	ThreadLock=0;//解锁
	return 0xFF;
}	

void NRF_FreeDataBuf(u8 id)//释放被使用的DataBuf,仅改变为空闲状态
{
	if(id>(DATA_BUF_COUNT-1)||id==0xFF)
	{
		return;
	}
	ThreadLock=1;//锁定
	MemSet((BYTE *)&DataBuf[id],0,sizeof(DATA_BUF));
	ThreadLock=0;//解锁
}

u8 NRF_SearchDataBuf(u8 status)//查找状态为status的DataBuf,返回索引
{
	u8 i=0;
	
	for(i=0;i<DATA_BUF_COUNT;i++)
	{
		if(status==DataBuf[i].status)
		{
			return i;
		}
	}
	return 0xFF;
}

u8 NRF_SearchDataByPackType(u8 addr,u8 type)//根据addr和type查找
{
	u8 i;
	
	for(i=0;i<DATA_BUF_COUNT;i++)
	{
		if(addr==DataBuf[i].payload.header.dst_addr&&
			type==DataBuf[i].payload.header.pack_type)
		{
			return i;
		}
	}
	return 0xFF;
}

u8 NRF_SearchHandlTimeoutId(void)
{
	u8 i;

	for(i=0;i<DATA_BUF_COUNT;i++)
	{
		if(Get_RunTime()-IsHandle[i].time>MULTI_PACK_INTERVAL)
		{
			return i;
		}
	}
	return 0xFF;
}

u8 NRF_CmpMultiPack(const u8 src_addr,const u8 dst_addr,const u8 pack_type,const u16 ID)
{
	u8 i;

	for(i=0;i<DATA_BUF_COUNT;i++)
	{
		if(Get_RunTime()-IsHandle[i].time<MULTI_PACK_INTERVAL)
		{
			if(ID==IsHandle[i].RID&&pack_type==IsHandle[i].pack_type&&
				src_addr==IsHandle[i].src_addr&&dst_addr==IsHandle[i].dst_addr)
			{
				return TRUE;
			}
		}
	}
	return FALSE;
}

u8 PrintRouteTable(void)
{
	u8 i,j,k=0,n=0;
	
	printf("\r\n======== Path List ========\r\n\r\n");
	for(i=0; i<MAX_NODE_NUM; i++)
	{
		if(route_table[i].addr)
		{
			k++;
			printf("node-%d:%d path ",i+1,route_table[i].addr);
			for(j=0; j<MAX_HOP_NUM; j++)//节点列表
			{
				if(route_table[i].path[j])
				{
					n++;
					printf("%d ",route_table[i].path[j]);
				}
			}
			printf("\r\n");
		}
	}
	if(!k)
	{
		printf("no node\r\n");
	}
	printf("\r\n===========================\r\n");
	return k+n;
}

u8 PrintNode(void)
{
	u8 i,j=0,k,tmp;
	
	printf("\r\n======= Node List =======\r\n\r\n");
	for(i=0; i<MAX_NODE_NUM; i++)
	{
		if(heart_table[i].addr)
		{
			tmp=0;
			for(k=0; k<MAX_NODE_NUM; k++)//统计掉线次数
			{
				if(lost_conn[k].addr==heart_table[i].addr)
				{
					tmp=lost_conn[k].count;
					break;
				}
			}
			printf("node-%02d:%03d lost_conn=%d\r\n",i+1,heart_table[i].addr,tmp);
			j++;
		}
	}
	if(!j)
	{
		printf("no node\r\n");
	}

	printf("\r\n=========================\r\n");
	return j;
}

u8 PrintLost(void)
{
	u8 j=0,k;
	
	printf("\r\n====== Lost List ======\r\n\r\n");

	for(k=0; k<MAX_NODE_NUM; k++)//统计掉线次数
	{
		if(lost_conn[k].addr)
		{
			printf("node-%03d lost_conn=%d\r\n",lost_conn[k].addr,lost_conn[k].count);
			j++;
		}
	}
	printf("\r\n=======================\r\n");
	
	return j;
}

u8 NRF_GetNodeNumber(void)
{
	u8 i,j=0;
	
	for(i=0; i<MAX_NODE_NUM; i++)//节点列表
	{
		if(heart_table[i].addr)
		{
			j++;
		}
	}
	return j;
}
