application.cpp

OMNET++仿真三色算法的源码,三色算法是无线传感器中一个典型的分簇算法

				//scheduleAt(simTime() + exponential(ST3), HeadEvent);
				scheduleAt(simTime() + exponential(ST1), HeadEvent);//当前时间＋1秒立刻发送
	
				sprintf(tmpstr,"节点[%d]的度现在最大,邻接点[%d]个\n", parentModule()->id(), physic->nbList.items());
				Log(tmpstr);	
								
			}
			
			/* 产生ENDEVENT?询问节点是否已经加入到某个簇，是否作为是否结束的标志 */
			EndEvent = genEndMsg();
			scheduleAt(simTime()+ ST1 + ST2 + ST3 +exponential(ST3), EndEvent);

			break;
		case CAND:
			status = LOCK;
			break;
		case HEAD:
			break;
		case I_BAND:
			/*如果已经在某个节点IBAND 什么也不用做*/
			d("I_BAND");
			break;
		case O_BAND:
			/*如果已经在某个节点IBAND */
			d("O_BAND");
			break;
		default:
			d("ErrorStatus");	
	}

}

/* 处理心跳消息*/
void Application::handleHello(cMessage* msg)
{
	d("handleHello");
}

/* 处理Data 消息， 增加一条消息处理，这个PHYSIC 才能取得所有的邻接点信息，相当与报告ID*/
void Application::handleData(cMessage* msg)
{
	d("handleHello");
	char tmpstr[128];
	int i, sid, dg ; 
	cNeighbour* n = NULL;
	bool bl = false;
	
	dg = (int)msg->par("degree");
	sid = (int)msg->par("source");
	
	if(blFoundNB)
	{
		Log("handleData处理已经执行过DETECTNB\n");
		printNB();
		for(i=0;i<physic->nbList.items();i++)
		{
			n = (cNeighbour*)physic->nbList[i];

			 if(n->mobHost == sid)
			{
				n->degree = dg;
				n->status = UNCLUSTERED;

				sprintf(tmpstr, "handdata [%d] 已经detectNB，获得[%d] 度信息[%d] \n", parentModule()->id(), n->mobHost, n->degree );
				Log(tmpstr);
				break;
			}		
		}
	}
	else //如果还没有进行检查则从hosts中查找并先加入NBLIST中
	{
		//在这里发现一个错误，。。。。。不明原因，因为一个节点只能发送一次DATA信息，如果没有
		//发送DATA信息，而且本节点又没有detectNB的话，nbList中不可能有该节点信息
		//但是在程序中发现了该问题，在每次插入时，(here ,and detectNB) 增加检测一次
		Log("handleData处理没有执行过DETECTNB\n");
		printNB();

		for(i=0;i<physic->nbList.items();i++)
		{
			n = (cNeighbour*)physic->nbList[i];
			if(n->mobHost == sid)
			{
				bl= true;
				n->blClustered = false;
				n->status = UNCLUSTERED;
				n->degree = dg;
				n->gateIndex = -1;
				return;//为什么已经有了该数据? 不用在继续了，返回吧
			}
		}

		for(i=0;i<physic->hosts.items();i++)
		{
			n = (cNeighbour*)physic->hosts[i];
			if(n->mobHost == sid)
			{
				break;
			}
		}
		sprintf(tmpstr, "[%d]节点 没有start detect ，收到[%d] Data 信息 \n", parentModule()->id(), sid);	
		Log(tmpstr);

		if(n!=NULL)
		{
			n->blClustered = false;
			n->status = UNCLUSTERED;
			n->degree = dg;
			n->gateIndex = -1;

			physic->nbList.add(n);
			sprintf(tmpstr,"[%d]hand data 新加入[%d] 现在邻接点个数[%d]\n",  parentModule()->id(), n->mobHost, physic->nbList.items());
			Log(tmpstr);
			Log("则加入nblist后， 这里返回\n");			
		}

		printNB();
		return;
	}

	MAXD = physic->nbList.items();	
	bl = true;
	for(i=0;i<physic->nbList.items();i++)
	{
		n = (cNeighbour*)physic->nbList[i];
		
		sprintf(tmpstr, "×××节点[%d] ：邻接点[%d] 度： [%d]\n", parentModule()->id(),n->mobHost, n->degree);
		Log(tmpstr);
		if(n->degree < 0)
		{
			//不用比较了， 还有些度的信息没有收集上来，直接返回
			sprintf(tmpstr,"[%d] 还没有 获取【%d』 的度,等待下一个节点的DATA \n", parentModule()->id(), n->mobHost);
			Log(tmpstr);
			return;
		}
		if((n->status == UNCLUSTERED)||(n->status == HEAD))
		{
			//如果已经degree 不是最大，或者有相等的degree 节点，则比较ID不是最小
			if(MAXD < n->degree)
			{
				MAXD = n->degree; //不是最大度节点，等待加入其它节点吧
				bl = false;

				sprintf(tmpstr,"[%d][%d]不是最大度节点,比[%d][%d]小\n", parentModule()->id(),physic->nbList.items(), n->mobHost, n->degree);
				Log(tmpstr);
				return;//有度更大的节点，直接返回吧
			}
			else
			{
				if(MAXD == n->degree)
				{
					if(n->mobHost < parentModule()->id()) //注意，不要
					{
						bl=false;
						sprintf(tmpstr,"[%d][%d]是最大度节点,但ID比[%d]小[%d]\n", parentModule()->id(),physic->nbList.items(), n->mobHost, n->degree);
						Log(tmpstr);
						return; //度相等但是id 不是最小，直接返回吧
					}
				}
			}		
		}
		
	} //循环监测一遍

	//*检 查
	printNB();
	//经常出现 headEvent == NULL 情况，不知道为什么
	if(bl&&(HeadEvent == NULL)) //就是最大度的节点且在等度节点中ID最小，准备发送HEAD 信息
	//if(bl&&(!HeadEvent->isScheduled()) //没有设置
	//if(bl&&(!HeadEvent->isScheduled()))
	{
		sprintf(tmpstr, "%%%%%%handdata 产生HeadEvent[%d] 度[%d]\n", parentModule()->id(),physic->nbList.items());
		Log(tmpstr);		
		HeadEvent = genHeadMsg();
		scheduleAt(simTime()+exponential(ST1), HeadEvent);//3秒中后执行
		//scheduleAt(simTime()+exponential(ST3), HeadEvent);

		/* 产生ENDEVENT?询问节点是否已经加入到某个簇，是否作为是否结束的标志 */
		//EndEvent = genEndMsg();
		//scheduleAt(simTime()+2+exponential(IDLE_TIMEOUT*2), EndEvent);
	}
	else
	{
		if(!bl) Log("hand data 执行到这里了bl 不真\n");
		if(HeadEvent != NULL) Log(" HEADEVENT 不空\n");
		Log("UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU\n");
	}
	// ST1结束，所有的节点都已经发现了自己的邻接点， ST2结束，所有的节点都知道了邻接点的度

}
/* **********************************************************
处理程序启动消息， 该消息是发送给节点自己的所以收到后自行处理
在最小ID 和最大连通度算法中简化算法， 在这里直接计算，如果ID
最小则直接成为头节点，或者连通度最大直接成为头节点。

  本函数会获得所有节点中的最小ID  ， LID 全局变量
************************************************************/
void Application::handleStart(cMessage* msg)
{
	d("handleHello");
	int i, mod, ph, id;
	cNeighbour * n;

	bool b=true; // 默认本节点的ID最小
	char tmpstr[128];

	/* 获得所有的邻接节点，但是没有建立连接通道*/
	physic->detectNB();
	
	blFoundNB = true;

	/* For debug */
	sprintf(tmpstr, "********[%d]*HandleStart 已经获取邻接点信息,产生 DataEvent事件 \n", parentModule()->id());
	Log(tmpstr);
	printNB();
	/*******/
	
	DataEvent = genDataMsg();
	scheduleAt(simTime()+ST1+exponential(ST1), DataEvent); //1+(0--1)秒中后发送发送
	//scheduleAt(simTime()+2+exponential(ST2), DataEvent);

	//EndEvent = genEndMsg();
	//scheduleAt(simTime()+2+exponential(IDLE_TIMEOUT*2), EndEvent);

}

/* 处理end?询问消息 如果已经结束则什么也不作，等待结束，否则继续产生一条询问消息*/
void Application::handleEnd(cMessage* msg)
{
	d("handleHello");
	char tmpstr[128];

	delete msg;
	
	if(blClustered)
	{	
		return;
	}
	
	// Log("第二次，不管了  \");

	EndEvent = genEndMsg();
	scheduleAt(simTime()+IDLE_TIMEOUT*2, EndEvent);

}
/* 系统开始信息 */
cMessage* Application::genStartMsg()
{
 d("genCandMsg");

	 cMessage* msg_start = new cMessage("AppStart", MSG_START, CTRL_PKT_SIZE, P_CAND);
	 msg_start->addPar("source") = parentModule()->id();

 return msg_start;
}

/* 生成Cand消息 */

cMessage* Application::genCandMsg()
{
 d("genCandMsg");

 cMessage* msg_cand = new cMessage("Candiate", MSG_CAND, CTRL_PKT_SIZE, P_CAND);

 //cMessage * reply = new("Candiate", CAND_MSG);

 msg_cand->addPar("source") = parentModule()->id();
 
 return msg_cand;
}

/* 生成 Head 消息*/
cMessage* Application::genHeadMsg()
{
	d("genHeadMsg");

	cMessage * msg_head = new cMessage("Head", MSG_HEAD, CTRL_PKT_SIZE, P_HEAD);

	msg_head->addPar("source") = parentModule()->id();
	
	return msg_head;
}

/* 生成冲突消息 */
cMessage* Application::genConflictMsg()
{
	d("genConflictMsg");

	cMessage *msg_conflict = new cMessage("Conflict", MSG_CONFLICT, CTRL_PKT_SIZE, P_CONFLICT);

	msg_conflict->addPar("source") = parentModule()->id();

	return msg_conflict;
}
/* 生成 JOIN 消息 */

cMessage* Application::genJoinMsg()
{
	d("genJoinMsg");

	cMessage * msg_join = new cMessage("Join", MSG_JOIN, CTRL_PKT_SIZE, P_JOIN);

	msg_join->addPar("source") = parentModule()->id();

	return msg_join;
}

/* 生成 End询问 消息 */

cMessage* Application::genEndMsg()
{
	d("genEndMsg");

	cMessage * msg_end = new cMessage("End?", MSG_END, CTRL_PKT_SIZE, P_JOIN);

	msg_end->addPar("source") = parentModule()->id();

	return msg_end;
}
/* 生成数据信息　*/
cMessage* Application::genDataMsg()
{
 d("genCandMsg");

 cMessage* msg_data = new cMessage("DATA", MSG_DATA, CTRL_PKT_SIZE, P_CAND);

 //cMessage * reply = new("Candiate", CAND_MSG);

 msg_data->addPar("source") = parentModule()->id();
 msg_data->addPar("degree") = physic->nbList.items();
 
 return msg_data;
}
/* 打印 调试信息将邻接列表的信息打印出来 */
void Application::printNB()
{
	int i;
	cNeighbour* n;
	char tmpstr[128];

	sprintf(tmpstr,"****************节点[%d] 现在度为[%d]***************\n", parentModule()->id(), physic->nbList.items());
	Log(tmpstr);

	for(i=0;i<physic->nbList.items();i++)
	{
		n = (cNeighbour*)physic->nbList[i];
		sprintf(tmpstr,"****[%d] 该节点status[%d] degree[%d]\n", n->mobHost, n->status , n->degree );
		Log(tmpstr);
	}
	Log("********************end*******************************\n");

}

void Application::finish()
{
	int i;

	d("Applicarion says bye");
	parentModule()->setDisplayString(0,parentModule()->displayString(),true);

}