gear.cc

基于Oment++的无线传感器网络仿真

		check =  atr.compareAttribute(x);
	x2=atr.getVal();
	atr= Attribute::find_key_from(Attribute::LATITUDE_L, &newVecAttr);
	if(check)	
		check =  atr.compareAttribute(y);
	y1=atr.getVal();
	atr= Attribute::find_key_from(Attribute::LATITUDE_R, &newVecAttr);
	if(check)
		check =  atr.compareAttribute(y);
	y2=atr.getVal();
	//printf("isInRegion returns %d MyNodeId==%d\n", check, MyNodeId);
    return check;
}

bool Gear::isAlreadyRecv(QueryPacket* Msg,int nodeid)
{	
	cPar param=Msg->par("VisitedNodeList");
    	cArray* VisitedNodes=(cArray*)param.objectValue();
	if (nodeid==-1)
	{
	 sprintf(s,"%d",MyNodeId);
	// printf("SUSPECT\n ");
	}
	else
	 sprintf(s,"%d",nodeid);
	 int i_index = VisitedNodes->find(s);
	//printf(" isAlreadyRecv nodeid %s index =%d  \n",s,i_index);
	 if(i_index==-1)
	 {
	 	return 0;
	 }
	 else
	 	return 1;

}

void Gear::UpdateLearnedCost(cMessage* MSg)
{
	
	QueryPacket* Msg;
	Msg=(QueryPacket*)MSg;
	Header *hdr=&Msg->getHdr();
	unsigned int nodeid=hdr->srcNodeId;
	int RegionX=Msg->getRegionX();
	int RegionY=Msg->getRegionY();
	int RegionRadius=Msg->getRadius();
	double cost=Msg->par("cost").doubleValue();
	sprintf(s,"%d,%d,%d",RegionX,RegionY,RegionRadius);
	Region* reg=(Region*)RegionList->get(s);
	cArray* myRegionCost=reg->getRegionCost();
	Cost* UpdatedCost=new Cost(nodeid,cost);
	sprintf(s,"%d",nodeid);		
	myRegionCost->takeOwnership(false);
	int index=myRegionCost->find(s);
	if(index!=-1)
	{
		myRegionCost->remove(index);
		myRegionCost->addAt(index,UpdatedCost);
	}
        int isLearned=Msg->par("isFromLearnedCost");
	if (((int)cost)==99999 && isLearned!=1)
	{
	 cPar param=Msg->par("VisitedNodeList");
	 cArray* VisitedNodes=(cArray*)param.objectValue();
	 sprintf(s,"%d",nodeid);
	 int pos=VisitedNodes->find(s);
	 sprintf(s,"%d",MyNodeId);
	 if(VisitedNodes->find(s)==pos-1)
	 {
 		//printf("ARE we RESENDING----YES at MyNodeId==%d\n", MyNodeId);
		ResendQuery(RegionX,RegionY,RegionRadius,Msg);
	 }
	}
}
void Gear::ResendQuery(int RegionX,int RegionY,int RegionRadius,QueryPacket* Msg)
{
	Msg->setKind(QUERY);
	 Header *hdr=&Msg->getHdr();
	 hdr->ttl=MAX_HOP;
	//printf("IN RESEND\n");	
	processQuery(RegionX,RegionY,RegionRadius,Msg,true);
}

void Gear::processQuery(int RegionX,int RegionY,int RegionRadius,QueryPacket* Msg,bool chkFlag)
{	
	cArray* RegionCost;	
	Header *hdr=&Msg->getHdr();
	unsigned int nodeid=hdr->srcNodeId;
	int x=hdr->srcLoc.x;
	int y=hdr->srcLoc.y;
	if(hdr->ttl<=0)
	{	
		delete Msg;
		return;
	}
	sprintf(s,"%d,%d,%d",RegionX,RegionY,RegionRadius);
	Location *loc=new Location(RegionX,RegionY);
	Region* reg;
	int index=RegionList->find(s);
	//printf(" simTime () %f REGIOn is %s index =%d \n",simTime(),s,index);
	if (index!=-1)
	{
		reg=(Region*)RegionList->get(index);
		if ((simTime()- reg->getLastUpdateTime())>region_threshold)
	  	PopulateCostsToNeighbhors(reg,Msg);
		int index1=RegionList->find(s);
		reg=(Region*)RegionList->get(index1);
		RegionCost= reg->getRegionCost();
        for(int i=0;i<RegionCost->items();i++)
		{
		   Cost * c=(Cost*)RegionCost->get(i);
		   //printf(" COST %d, %f \n",c->getNodeId(),c->getNodecost());	
		}
		if (!chkFlag)
		{
		 cArray* srcNodeList=reg->getSrcNodeList();
		 IdWrapper *idw=new IdWrapper(nodeid);
		 srcNodeList->takeOwnership(false);
		 srcNodeList->set(idw);
		}		
	}			
	else
	{
	    reg=new Region(loc,RegionRadius);
	    PopulateCostsToNeighbhors(reg,Msg);
	    cArray* srcNodeList=reg->getSrcNodeList();
	    IdWrapper *idw=new IdWrapper(nodeid);
	    srcNodeList->takeOwnership(false);
	    srcNodeList->set(idw);
	    RegionCost= reg->getRegionCost();
	    for(int i=0;i<RegionCost->items();i++)
	    {
	      Cost * c=(Cost*)RegionCost->get(i);
		  //printf(" The Cost of NodeId %d to region is %f\n",c->getNodeId(),c->getNodecost());
		
	    }
	}
	 	
	cArray* NodeCostForRegion2=(cArray*)reg->getRegionCost();
	//unsigned int nextHopId=88888888;
	unsigned int nextHopId;
	cArray* qList = reg->getQueryList();
	//if(Msg->getExp()||index==-1||(index!=-1&&!checkIfAnyQueryAlive(qList)))
	nextHopId=getNextHopNode(RegionCost,nodeid, Msg,chkFlag);
	cPar* qIdPar = &Msg->par("QueryId");
	char qId[50];
	strcpy(qId, qIdPar->stringValue());
	if(chkFlag)
	printf ( " GEAR Query nexthopId is %d for MynodeId %d \n",nextHopId,MyNodeId); 
	if(nextHopId!=99999)
	{
		if ((flag==0||flag==2)&&(!chkFlag))  /* flag==0  Message from bottom Layer  flag==2 isSelfMessage  */
		{
			//generateQueryAck(qId,nodeid,RegionX,RegionY,RegionRadius);
		}
		if(fileWrite)
		{
			char a[100];
			if(Msg->getExp())
			sprintf(a, "%f EXP- The Query Src = %d NextHopId = %d fileName %s \n", simTime(), Msg->getIQuerySrc(), nextHopId,fileName);
			else
			sprintf(a, "%.15f The Query Src = %d NextHopId = %d\n", simTime(), Msg->getIQuerySrc(), nextHopId);
			FILE * abc;
			abc = fopen(fileName, "ab");
			fputs(a, abc);
			fclose(abc);
		}
		//if((nextHopId!=88888888)||(Msg->getExp()&&(!checkIfAnyQueryAlive(qList))))
		generateContinuedQueryMessage(Msg,nextHopId);
		QueryObject* qryObject=new QueryObject(qId);
		qryObject->setSrcId(nodeid);
		qryObject->setFinalSrc(Msg->getIQuerySrc());
		if(Msg->getExp())
			qryObject->setIsAlive(true);
		reg->addToQueryList(qryObject);
	   // cArray* qList = reg->getQueryList();
		delete Msg;
	}
	else
	{
		cArray* srcNodeList=reg->getSrcNodeList();
	//	generateLearnedCostMessage(Msg, srcNodeList,99999,false);
		//printf("DROP THE QUERY packet GOOD MORNING by NodeId %d from sourceId  %d and previous %d \n",MyNodeId,Msg->getIQuerySrc(),nodeid);
		if(fileWrite)
		{
			char a[100];
			sprintf(a, "DROP QUERY PKT by NodeId  %d sourceId %d previous  = %d\n",MyNodeId, Msg->getIQuerySrc(), nextHopId);
			FILE * abc;
			abc = fopen(fileName, "ab");
			fputs(a, abc);
			fclose(abc);
		}
		delete Msg;
	}
}

void Gear::generateContinuedQueryMessage(QueryPacket* Msg,unsigned int nextHopId)
{
	 QueryPacket *msg=(QueryPacket*)Msg->dup();
	 unsigned int NodeId=((CoOrdinatorBase *) pCoOrdinator)->getNodeId();
	 Header *hdr=&msg->getHdr();
	 hdr->ttl-=1;
	 hdr->srcNodeId=NodeId;
	 hdr->NextHopDestId=nextHopId;
	 int delayTime= INTEREST_FORWARD_DELAY + (int) ((INTEREST_FORWARD_JITTER * (rand() * 1.0 / RAND_MAX) - (INTEREST_FORWARD_JITTER / 2)));
	 delay= delayTime / 1000.0;
	 sendDown(msg,delay);
}
void Gear::generateQueryAck(char* queryId,unsigned int nodeid,int RegionX,int RegionY,int radius)
{	
	
	if(nodeid!=MyNodeId)
	{
	//printf(" QUERYACK to nodeid %d from MyNodeId = %d",nodeid,MyNodeId);
	QueryPacket *msg=new QueryPacket("query_reply",QUERY_REPLY);
	Header *hdr=&msg->getHdr();
	hdr->ttl=1;
	hdr->srcNodeId=((CoOrdinatorBase *) pCoOrdinator)->getNodeId();			
	hdr->NextHopDestId=nodeid;
	hdr->OriginSrc=par("originsrc");
	msg->setRegionX(RegionX);
	msg->setRegionY(RegionY);
	msg->setRadius(radius);
	msg->addPar("QueryId");
	msg->par("QueryId")=queryId;
	sendDown(msg);	
	}
}


void Gear::PopulateCostsToNeighbhors(Region* reg, QueryPacket* Msg)
{
	Location* loc=reg->getRegionLocation();
	int RegionX = loc->x;
	int RegionY = loc->y;
	if((neigh_list->items()==0)||((simTime()-NeighUpdatedTime)>threshold))
	{
		cMessage *reply=generateBeaconMessage();
		sendDown(reply);
		scheduleAt(simTime()+WAIT_NEIGHBOR_UPDATE,Msg);
		//printf(" populateCostToNe %d \n",MyNodeId);
		return;
	}
	Heuristics*	h=new Heuristics();
	Cost *EstimatedCost;
	double maxEnergy = h->EnergyMaxValue(neigh_list);
	double minEnergy = h->EnergyMinValue(neigh_list);
	double maxDis = h->DisMaxValue(neigh_list, RegionX, RegionY);
	double minDis = h->DisMinValue(neigh_list, RegionX, RegionY);
	for(int i=0;i<neigh_list->items();i++)
	{
		NeighbhorInfo * neigh=(NeighbhorInfo*)neigh_list->get(i);
		EstimatedCost=h->EstimateCost(neigh, loc, maxEnergy, minEnergy, maxDis, minDis);
		h->LearnedCostEntry(reg,EstimatedCost);
		simtime_t now = simTime();
		reg->setLastUpdatedTime(now);
	}
	delete h;
	cArray* RegionCost= reg->getRegionCost();
	reg->setDataUpdateTime(0.0);
    reg->setExploratoryTime(0.0);
	RegionList->takeOwnership(false);
	RegionList->set(reg);
	
}

void Gear::getLearnedCost(QueryPacket* Msg)
{
 	Header *hdr=&Msg->getHdr();
	hdr->ttl=1;
	int SelectedNodeId=hdr->srcNodeId;
	int RegionX=Msg->getRegionX();
	int RegionY=Msg->getRegionY();
	int RegionRadius=Msg->getRadius();
	Location *loc=new Location(RegionX,RegionY);
	char s1[50];
	sprintf(s,"%d,%d,%d",RegionX,RegionY,RegionRadius);
	Region* reg;
	int	RegionObjectIndex=RegionList->find(s);
	if(RegionObjectIndex!=-1)
	{
		reg=(Region*)RegionList->get(RegionObjectIndex);
		cArray* SrcNodeList=reg->getSrcNodeList();
		cArray* NeighCostArray=reg->getRegionCost();
		char s[10];
		sprintf(s,"%d",SelectedNodeId);
		Cost* LearnedCostObject=(Cost*)NeighCostArray->get(s);
		double LearnedCost=LearnedCostObject->getNodecost();
		addDestToQueryObject(Msg,reg);	
		sprintf(s, "%i",MyNodeId);
		sprintf(s1, "%i",SelectedNodeId);
		int x =((CoOrdinatorBase*) pCoOrdinator)->getX();
		int y =((CoOrdinatorBase*) pCoOrdinator)->getY();
		Heuristics* h1 = new Heuristics();
		double gap = h1->Distance(x, y, ((Location*)(((NeighbhorInfo*)neigh_list->get(s1))->getLocation(SelectedNodeId)))->x, ((Location*)(((NeighbhorInfo*)neigh_list->get(s1))->getLocation(SelectedNodeId)))->y); 
		double LearnedCostForCurrentNode=LearnedCost+gap;
		delete h1;
	//	generateLearnedCostMessage( Msg,SrcNodeList,LearnedCostForCurrentNode,true);
	 }
	delete Msg;	
}

void Gear::addDestToQueryObject(QueryPacket* Msg,Region* reg)
{
	cPar* qIdPar = &Msg->par("QueryId");
	char qid[50];
	strcpy(qid, qIdPar->stringValue());
	Header *hdr=&Msg->getHdr();
	int destId=hdr->srcNodeId;
	cArray* qryList=reg->getQueryList();
	QueryObject* qryObject=(QueryObject*)qryList->get(qid);
	qryObject->setDestId(destId);
}


void Gear::generateLearnedCostMessage(QueryPacket* Msg, cArray* SrcNodeList,double LearnedCostForCurrentNode, bool fromLearned)
{
	
	QueryPacket* Msg1;
	Header *hdr=&Msg->getHdr();
	hdr->ttl=1;
	hdr->srcNodeId=((CoOrdinatorBase *) pCoOrdinator)->getNodeId();
	hdr->OriginSrc=par("originsrc");//-1;
	Msg->addPar("cost");
	Msg->par("cost")=LearnedCostForCurrentNode;
	Msg->setKind(UPDATE_LEARNED_COST);
	for(int i=0;i<SrcNodeList->items();i++)
	{	
		
		IdWrapper* id=(IdWrapper*)SrcNodeList->get(i);
		int nodeid=id->getNodeId();
		hdr->NextHopDestId=nodeid;
		if(nodeid==MyNodeId)
		continue;
		
		if(!fromLearned)
		{	
		  if(fileWrite)
		  {
		   FILE * abc;
		   sprintf(fileName, "500/%s%d.txt", filea, ((QueryPacket*)Msg)->getIQuerySrc());
		   abc = fopen(fileName, "ab");
		   char a[100];
		   sprintf(a, "SrcNode of NodeId === %d is = %d\n", MyNodeId,nodeid);
		   fputs(a, abc);
		   fclose(abc);
		  }					
		  Msg->addPar("isFromLearnedCost");
		  Msg->par("isFromLearnedCost")=0;
		}
		else
		  {
		  	Msg->addPar("isFromLearnedCost");
		  	Msg->par("isFromLearnedCost")=1;
		  }
		//printf(" LEARNEDCOST MSG from %d to %d \n", MyNodeId,nodeid);		 
		Msg1=(QueryPacket*)Msg->dup();
		sendDown(Msg1); //    NOT SURE WHETHER IT WILL WORK
	}
}


unsigned int Gear::getNextHopNode(cArray *regCost,unsigned int NodeId,QueryPacket* Msg,bool chkFlag)
{
	cArray* NodeCostForRegion=regCost;
	cPar param=Msg->par("VisitedNodeList");
	cArray* VisitedNodes=(cArray*)param.objectValue();
	if(NodeCostForRegion==NULL)
		Cost* NodeRegionCost;
	int CurrId;
	int minCostNodeId=99999;
	if((NodeCostForRegion->items()!=0))
	{
		double leastcost=99999;
		for(int i=0;i<NodeCostForRegion->items();i++)
		{
			Cost* NodeRegionCost=(Cost*)NodeCostForRegion->get(i);//Return the Cost object Cost(nodeId,nodeCost)
			double cost=NodeRegionCost->getNodecost();
			CurrId=NodeRegionCost->getNodeId();
			char s[10];
			int i_index=-1;
			sprintf(s,"%d",CurrId);
			i_index = VisitedNodes->find(s);
			int xx =((CoOrdinatorBase*)pCoOrdinator)->getX();
			int yy =((CoOrdinatorBase*)pCoOrdinator)->getY();
			Heuristics* h = new Heuristics();
			double myCost =h->Distance(xx, yy, Msg->getRegionX(), Msg->getRegionY());
			delete h;  	
			if((MyNodeId != CurrId)&&(i_index==-1))
			{
				if(cost<leastcost&&cost<myCost)
				{
					leastcost=cost;
					minCostNodeId=CurrId;
				}
			}
		}
		if((minCostNodeId!=99999)&&(!chkFlag))
		{
			IdWrapper* idw=new IdWrapper(MyNodeId);
			VisitedNodes->takeOwnership(false);
			VisitedNodes->add(idw);
		}
		//printf("For the query from %d, the cost is %f for node %d, mynodeid==%d", Msg->getIQuerySrc(), leastcost, minCostNodeId, MyNodeId);
		return minCostNodeId;
	}
	else
	{
		return 99999;
	}
}


void Gear::updateNeighborList(BeaconReplyPkt* Msg)
{
	Header *hdr=&Msg->getHdr();
	int nodeid=hdr->srcNodeId;
	int x=hdr->srcLoc.x;
	int y=hdr->srcLoc.y;
	Location* Loc=new Location(x,y);
	double eng=Msg->getEnergy();
	//printf("At MyNodeId==%d nodeid==%d added to NEIGHBORLIST \n", MyNodeId, nodeid);
	NeighbhorInfo* neighor =new NeighbhorInfo(nodeid,Loc,eng);
	neigh_list->set(neighor);
	NeighUpdatedTime=simTime();	 
	 			   
}


cMessage * Gear:: generateBeaconMessage()
{
	//printf("GENERATING BEACON MSG %d \n",MyNodeId);	
	unsigned int NodeId=((CoOrdinatorBase *) pCoOrdinator)->getNodeId();
	BeaconPkt *beaconPkt=new BeaconPkt("beacon",BEACON);
	Header *hdr=&beaconPkt->getHdr();
	hdr->ttl=1;
	hdr->srcNodeId=NodeId;
	hdr->NextHopDestId=999999;
	hdr->OriginSrc=par("originsrc");//-1;
	return beaconPkt;
}

cMessage * Gear::generateReplyBeaconMessage(int DestId)
{
	unsigned int NodeId=((CoOrdinatorBase *) pCoOrdinator)->getNodeId();
	double d_Energy = ((CoOrdinatorBase *) pCoOrdinator)->GetEnergySpent();
	BeaconReplyPkt *beaconReplyPkt=new BeaconReplyPkt("beaconReply",BEACON_REPLY);
    Header *hdr=&beaconReplyPkt->getHdr();
	hdr->ttl=1;
	hdr->srcNodeId=NodeId;
	hdr->srcLoc.x=((CoOrdinatorBase *) pCoOrdinator)->getX();
	hdr->srcLoc.y=((CoOrdinatorBase *) pCoOrdinator)->getY();
	hdr->NextHopDestId=DestId;
	hdr->OriginSrc=par("originsrc");//-1;
	beaconReplyPkt->setEnergy(d_Energy);
	return beaconReplyPkt;
}

void Gear::sendDown(cMessage *msg)
{	
	send(msg,"toBottomLayer");
}

void Gear::sendUp(cMessage *msg)
{
	
	send(msg,"toTopLayer");
}

void Gear::sendDown(cMessage *msg, double delay)
{
	//sendDelayed(msg,delay,"toBottomLayer");
	
	send(msg,"toBottomLayer");
}

void Gear::finish()
{		
	//printf("First SeqNo= %d MyNodeId %d \n",firstSeqNo,MyNodeId);
//	int RegionNo=(int)parentModule()->parentModule()->par("RegionNo");
//	int packetsNotGot=(firstSeqNo-1)*RegionNo;
//	printf("%d,%d,%d\n",MyNodeId,(seqNo*RegionNo)-(packetsNotGot),dataCount);
	//printf("seqNo %d Total packets generated =%d RegionNo = %d\n",seqNo,(seqNo*RegionNo)-(packetsNotGot),RegionNo);	
	//printf("Data Delivered to %d is %d\n",MyNodeId,dataCount);
	//printf(" %f Data generated total %d MyNodeID %d \n\n",simTime(),dataGeneratedTotal,MyNodeId);
	//printf("BeaconPkt made = %d deleted = %d \n", BeaconPkt::countBeaconPkt, BeaconPkt::countDestBecPkt);
	//printf("BeaconReplyPkt made = %d deleted = %d \n", BeaconReplyPkt::countBeaconReply, BeaconReplyPkt::countDestBecReply);
	//printf("QueryPacket made = %d deleted = %d \n", QueryPacket::countQueryPkt, QueryPacket::countDestQueryPkt);
	//printf("GearPacket made = %d deleted = %d \n", GearPacket::countGearPkt, GearPacket::countDestGearPkt);
	//printf("DataMsg made = %d deleted = %d \n", DataMsg::countDataPkt, DataMsg::countDestDataPkt);
	//printf("\n");
}