application.cpp

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

#include "h/application.h"

Define_Module(Application);

//applicaton sends data to a mobile host chosen
//randomly among the numHost device.
//the actual address of the chosen host is defined by
//the routing module,that can gain the number accessing
//the hosts arry in the physic module.

void Application::initialize()
{
	//store parameters for a faster access
	char tmpstr[512];
	FILE* fout = NULL;

	memset(tmpstr, 0x00, sizeof(tmpstr));


	rate = (int) par("rate");
	pktSize = (int) par("pktSize");
	numHost = (int) par("hostNum");
	active = (int) par("active");
	burstInterval = (simtime_t) par("burstInterval");
	ST1 = (simtime_t) par("burstInterval");	
	ST2 = ST1;
	ST3 = ST1;
	ST1 = 1;
	ST2 = 2;
	ST3 = 3;

	id = parentModule()->id()-2;

	cmCount = 1;
	nbCount = 0;
	cmList.setName("cmList");
	cmList.takeOwnership(false);

	chList.setName("chList");
	chList.takeOwnership(false);
	

	d("active = "<<active);
	physic = (Physic*)parentModule()->submodule("physic");	
	//physic->detectNeighbours();

	physic->getPos(posX, posY);

	//initialize the work variables
	pktNum = 0;
	dest = 0;
	
	status = IDLE;
	blClustered = false;
	blFoundNB = false;
	
	//let's go
	StartEvent = genStartMsg();
	HeadEvent = NULL;
	//DataEvent = genDataMsg();
	if (active)
	{
 	  //scheduleAt(simTime()+2+exponential(1),new cMessage("newAppBurst"));
	  scheduleAt(simTime(), StartEvent); //1秒中内启动
	//scheduleAt(simTime()+2+exponential(IDLE_TIMEOUT + id%10), DataEvent);
	}
}

void Application::handleMessage(cMessage* msg)
{
	int i,m;
	char displaystr[90], tmpstr[256];

	d("APPLication");

	sprintf(tmpstr,"Application HandleMsg Got Msg: %d", msg->kind());

	Log(tmpstr);

	if (msg->arrivedOn("in"))	/* 如果消息是从路由层过来的，则进行相应的接收处理*/
	{
		d("msg arrived from Route");
		Log("msg arrived from Route\n");

		switch(msg->kind())
		{
				case MSG_DATA:					
					handleData(msg);
					delete msg;
				break;
				
				case MSG_CAND:	/*如果已经准备发送Cand msg 则取消*/										
					handleCand(msg);
					delete msg;					
				break;

				case MSG_HEAD:
					if(!blClustered) 
					{
						handleHead(msg);					
					}
					delete msg;
				break;
				case MSG_CONFLICT:					
					sprintf(tmpstr,"节点 %d :收到的冲突消息暂没有处理\n", id); 
					Log(tmpstr);
				break;

				case MSG_JOIN:					
					handleJoin(msg);
					delete msg;					
				break;

				default:
					d("msgkindError");
					sprintf(tmpstr, "节点 %d :收到的未知消息%d暂处理\n", id, msg->kind());
					Log(tmpstr);

				break;
		}

	} //if ends
	else    /*如果消息是 APP自己发送的，则这是系统启动消息，则根据当前状态进行处理*/
	{
		Log("msg arrived from Self\n");
		switch(msg->kind())
			{
				case MSG_DATA:
					handleData(msg);//检查是否是孤立节点
					send(DataEvent, "out");
					//handleData(msg);
					break;
				case MSG_START: /* 这个处理比较特殊*/
					handleStart(msg);
					delete msg;
					break;				
				case MSG_HEAD:
					blClustered = true;
					status = HEAD;
					sprintf(displaystr, displayS, posX, posY, HEAD_COLOR);
					parentModule()->setDisplayString(0,displaystr,true);
					send(HeadEvent, "out");					
					break;

				case MSG_JOIN:
					blClustered = true;
					send(JoinEvent,"out");
					status = I_BAND;
					sprintf(displaystr, displayS, posX, posY, IBAND_COLOR);
					parentModule()->setDisplayString(0,displaystr, true);
					break;
				case MSG_END: /*节点自己询问是否结束了？*/
					handleEnd(msg);	//处理过程删除msg从新产生一个信息的msg				
					break;
				case MSG_CAND:
					send(CandEvent, "out");
					/*已经是候选节点改变系统的颜色 */
					status = CAND;
					sprintf(displaystr, displayS, posX, posY, CAND_COLOR);
					parentModule()->setDisplayString(0,displaystr,true);								
						/* 已经发出了候选消息，则生成HEAD 消息准备发送 */
					HeadEvent = genHeadMsg();
					scheduleAt(simTime()+2+exponential(CAND_TIMEOUT), HeadEvent);
					break;
				case MSG_CONFLICT:
					send(ConflictEvent,"out");
					status = I_BAND;
					sprintf(displaystr, displayS, posX, posY, IBAND_COLOR);
					parentModule()->setDisplayString(0,displaystr, true);
					break;

				default:
					sprintf(tmpstr, "收到自己发出的消息  %d\n", msg->kind());
					Log(tmpstr);
					break;
		} //end of switch		
	} //else end
}

/* 处理 候选消息 */
void Application::handleCand(cMessage* msg)
{
	d("process Cand msg");

}
/* 处理头 通知消息*/
void Application::handleHead(cMessage *msg)
{
	char displaystr[90], tmpstr[256];
	int i, sid, fmod, fph;
	
	cNeighbour *n = NULL;
		

	//fmod  = msg->frommod();
	
	if(blClustered) return;

	blClustered = true;
	
	sid = msg->par("source");

	for(i=0;i<physic->nbList.items();i++)
	{
		n = (cNeighbour*)physic->nbList[i];

		if(n->mobHost == sid)
		{
			n->blClustered = true;
			n->status = HEAD;

			sprintf(tmpstr, "[%d] handleHead 收到[%d]发出了要当簇头消息\n", parentModule()->id(), sid);
			Log(tmpstr);
			break;
		}
	}//更新NBLIST列表

	d("handleHello");
	switch(status)
	{
		case IDLE:
			status = I_BAND;

			sprintf(displaystr, displayS,posX, posY, IBAND_COLOR);			
			parentModule()->setDisplayString(0,displaystr,true);
			
			JoinEvent= genJoinMsg();
			JoinEvent->addPar("dest") = msg->par("source");
			scheduleAt(simTime(), JoinEvent);
			//scheduleAt(simTime()+2+exponential(TIMEOUT), JoinEvent);
			break;
		case CAND:
			/* 收到头节点信息， 取消发送头信息 ，变成成员节点 */
			status = I_BAND;
			
			if(HeadEvent != NULL)
			{
				if (HeadEvent->isScheduled())
				 cancelEvent(HeadEvent);
			}

			sprintf(displaystr, displayS,posX, posY, IBAND_COLOR);			
			parentModule()->setDisplayString(0,displaystr,true);

			JoinEvent= genJoinMsg();
			JoinEvent->addPar("dest") = msg->par("source");
			scheduleAt(simTime()+2+exponential(TIMEOUT), JoinEvent);

			break;
		case HEAD:			
			/*需要发送冲突消息*/		
			//ConflictEvent = genConflictMsg();
			
			sprintf(tmpstr, "节点%d 已是头节点 收到暂未处理头信息 %d , \n", id, msg->kind() );
			Log(tmpstr);
			break;
		case I_BAND:
			/*如果已经在某个节点IBAND，先不考虑加入该簇 在以后应该考虑比较两个簇头的ID大小在考虑加入哪一个 */
			status = I_BAND;
			
			break;
		case O_BAND:
			/*如果已经在某个节点IBAND */
			d("O_BAND");
			break;
		default:
			d("ErrorStatus");	
	}
}

/* 处理 冲突消息 */
void Application::handleConflict(cMessage *msg)
{
	d("HandleConflict");

}
/* 处理加入消息*/
void Application::handleJoin(cMessage *msg)
{
	d("HandleJoin");
	int i, destid, sid, ph;
	cNeighbour * n ;
	char tmpstr[256];
	bool bl= true;

	//pointer to the remote host object

	sid = msg->par("source");

	for(i=0;i<physic->nbList.items();i++)
	{
		n = (cNeighbour*)physic->nbList[i];
		
		if(n->mobHost == sid)
		{
			n->blClustered = true;
			n->status = MEM;
			sprintf(tmpstr, "[%d]handleJoin 收到[%d]发出的JOIN信息\n", parentModule()->id(), sid);
			Log(tmpstr);
			break;
		}
	}//更新NBLIST列表
	//如果我已经决定加入某个簇了(收到头信息了，或者自己为头了)，则返回吧，不用处理了 
	if((blClustered)||!blFoundNB) //或者没有检查邻接点
	{
		sprintf(tmpstr,"节点[%d] 已经加入某个簇或者还没有检查\n", parentModule()->id());
		Log(tmpstr);
		return; 
	}

	for(i=0;i<physic->nbList.items();i++)
	{
		n = (cNeighbour*)physic->nbList[i];
		if(n->degree < 0)
		{
			sprintf(tmpstr,"节点[%d] 的邻接点[%d]的度还不知道\n", parentModule()->id(), n->mobHost);
			Log(tmpstr);
			return; 
		}
	}
	
	/*普通节点收到其它节点的加入消息，如果我还没有加入其它节点,则检查头候选列表nbList，我是否可以成为簇头*/
	switch(status)
	{
		case IDLE:
			/*如果小ID 节点已经加入其它的簇，那边该节点记录下来，
				如果我已经是所有邻接点中最小的节点，则准备自己形成一个簇 */			
						
			/* 重新查找邻接点中为加入簇的新的最小ID */
			bl=true;
			MAXD = physic->nbList.items();
			for(i=0;i<physic->nbList.items();i++)
			{
				n=(cNeighbour*)physic->nbList[i];
				sprintf(tmpstr,"[%d]的邻接点[%d]\n", parentModule()->id(), n->mobHost);
				
				if((n->status == UNCLUSTERED)||(n->status == HEAD))
				{
					if(MAXD < n->degree)
					{
						MAXD = n->degree; 
						bl = false;
						return; //存在更大连通度的未分簇节点
					}
					else
					{
						if(MAXD == n->degree)
						{
							if(n->mobHost < parentModule()->id())
							{
								bl = false;
								return;
							}//虽然连通度相等，存在ID更小的节点
						}
					}
				}
			}

			if(bl&&(HeadEvent==NULL)) //如果我的连通度最大,且ID最小，而且IDLE，则发布head消息
			{
				blClustered = true;
				status = HEAD;
				HeadEvent = genHeadMsg();