leachapp.cc

无线传感器网络中,基于ns2仿真平台,mannasim的源代码,研究ns2必不可少的

		tdmaSchedule_.assign(clusterNodes_.begin(), clusterNodes_.end());

		send(
			MAC_BROADCAST,
//			sensor_node_->nodeid(),
			LINK_BROADCAST,
			LEACH_ADV_SCH,
			(char *) msg,
			sizeof(int) * clusterNodes_.size(),
			dataSize,
			dist_,
			code_);

		listenJOINREQ_ = false;

//		delete [] msg;

		frameTime_   = (5 + clusterNodes_.size()) * config_.ssSlotTime_;
		lstRndDelay_ = Random::uniform(0, 0.01);
		xmitTime_    = config_.ssSlotTime_ * (clusterNodes_.size()) + lstRndDelay_;

		Scheduler::instance().schedule(
			eventHandler_,
			new LeachEvent(&LeachApp::sendDataToBS),
			xmitTime_);
	}
}

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

void LeachApp::recv(int type, double distance, int link_dst, int size, char * meta, int meta_size, int src_mac, int src_lnk)
{
#ifdef CHATO
	printf("Receiving packet at %lf => ", Scheduler::instance().clock());
#endif

//	if (link_dst < 0) // || link_dst == sensor_node_->nodeid())
		switch (type)
		{
			case LEACH_ADV_CH:
#ifdef CHATO
				printf("LEACH_ADV_CH\n");
#endif
//				if (isClusterHead())
					recvADV_CH(meta, meta_size, distance, src_mac, src_lnk);
				break;

			case LEACH_JOIN_REQ:
#ifdef CHATO
				printf("JOIN_REQ\n");
#endif

//				if (sensor_node_->nodeid() == link_dst)
					recvJOIN_REQ(meta, meta_size);
				break;

			case LEACH_ADV_SCH:
#ifdef CHATO
				printf("LEACH_ADV_SCH\n");
#endif
				recvADV_SCH(meta, meta_size, src_mac);
				break;

			case LEACH_DATA:
#ifdef CHATO
				printf("LEACH_DATA\n");
#endif
//				if (sensor_node_->nodeid() == link_dst)
					recvData(meta, meta_size);
				break;

			case LEACH_BS_HELLO:
#ifdef CHATO
				printf("LEACH_BS_HELLO\n");
#endif
				recvBSHello(meta, meta_size, distance);
				break;

			default:
				fprintf(stderr, "Unknown received data type on LeachApp!\n", type);
				exit(-1);
		}
//	else
//		fprintf(stderr, "Received a packet addressed to another node!\n");
}

void LeachApp::recvADV_CH(char * msg, int size, double distance, int src, int lnk_src)
{
	if (listenADV_)
	{
		chadv element;

		if (!isClusterHead())
			printf("%d received ADV_CH from %d (mac = %d, distance = %lf, code = %d) at %lf\n",
				sensor_node_->nodeid(),
				lnk_src,
				src,
				distance,
				*((int *) msg),
				Scheduler::instance().clock());

		element.nodeid   = lnk_src;
		element.distance = distance;
		element.mac      = src;
		element.code     = *((int *) msg);
		element.object   = NULL;

		clusterChoices_.push_back(element);
	}
}

void LeachApp::recvJOIN_REQ(char * msg, int size)
{
	if (!isClusterHead())
	{
		fprintf(stderr, "Node %d received a JOIN_REQ from %d but it's not a cluster head!\n",
			sensor_node_->nodeid(),
			*((int *) msg));
		exit(-1);
	}

	if (listenJOINREQ_)
	{
		printf("%d received JOIN_REQ from %d at %lf\n",
			sensor_node_->nodeid(),
			*((int *) msg),
			Scheduler::instance().clock());

		clusterNodes_.push_back(*((int *) msg));
	}
	else
		printf("%d received a late JOIN_REQ from %d at %lf\n",
			sensor_node_->nodeid(),
			*((int *) msg),
			Scheduler::instance().clock());
}

void LeachApp::recvADV_SCH(char * msg, int size, int src)
{
	int * vector = (int *) msg;
	int elements = size / sizeof(int);
	int nodeid   = sensor_node_->nodeid();
	double xmitat;

	if (src == currentCHMAC_)
	{
		printf("%d received ADV_SCH from %d at %lf\n",
			sensor_node_->nodeid(),
			src,
			Scheduler::instance().clock());

		for (int i = 0; i < elements; i++)
			if (vector[i] == nodeid)
			{
				/* Determine time for a single TDMA frame. Each node sends data once
				 * per frame in the specified slot.
				 */
				frameTime_  = (5 + elements) * config_.ssSlotTime_;
				xmitTime_   = config_.ssSlotTime_ * i;
				endFrmTime_ = frameTime_ - xmitTime_;
				xmitat      = Scheduler::instance().clock() + xmitTime_;
	
				printf("Node %d schedule to transmit at %lf (%lf) | It is now %lf\n",
					nodeid,
					xmitat,
					xmitTime_,
					Scheduler::instance().clock());
	
				if (xmitat + endFrmTime_ < nextChangeTime_ - 10 * config_.ssSlotTime_)
				{
					Scheduler::instance().schedule(
						eventHandler_,
						new LeachEvent(&LeachApp::sendData),
						xmitTime_);

					goToSleep();
				}
				else
					printf("teste!!!!!!!\n");
				return;
			}

		// There is no time slot available
		printf("Warning!!! %d doesn't have a transmit time for CH %d!\n", sensor_node_->nodeid(), currentCH_);
	
		sendMyDataToBS();
	}
}

void LeachApp::recvData(char * msg, int size)
{
	printf("CH %d received data from %d at %lf",
		sensor_node_->nodeid(),
		((SensedData *) msg)->node_id(),
		Scheduler::instance().clock());

	mergeSensedData((SensedData *) msg);

	printf(" - Now there is %d sensed data\n",
		sensedData_->getData().size());
}

/* Occurs when received a base station "hello".
 * This is usefull to determine the BS distance from
 * node, but it is not original from LEACH paper.
 * -- J鷏io C閟ar e Melo
 */
void LeachApp::recvBSHello(char * msg, int size, double distance)
{
	bsDist_ = distance;

	printf("Node %d received BS_Hello at distance %lf\n",
		sensor_node_->nodeid(),
		distance);
}

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

void LeachApp::sendData()
{
	int    dataSize;
	double xmitat;

	if (sensedData_->count() > 0 && !isClusterHead())
	{
		dataSize = config_.spreading_ * (BYTES_ID * sensedData_->msgSize() + config_.sigSize_);

		wakeUp();

		printf("Node %d sending %d data to CH %d at %lf | d = %lf\n",
			sensor_node_->nodeid(),
			sensedData_->count(),
			currentCH_,
			Scheduler::instance().clock() + frameTime_,
			dist_);

		sensedData_->node_id() = sensor_node_->nodeid();

		send(
	//		MAC_BROADCAST,
			currentCHMAC_,
			currentCH_,
			LEACH_DATA,
			sensedData_,
			dataSize,
			dist_,
			code_);

		// sensedData_ = new SensedData();
		clearSensedData();

		if (!isClusterHead())
			goToSleep();
	}

	xmitat = Scheduler::instance().clock() + frameTime_;

	if (xmitat + endFrmTime_ < nextChangeTime_ - 10 * config_.ssSlotTime_)
		Scheduler::instance().schedule(
			eventHandler_,
			new LeachEvent(&LeachApp::sendData),
			frameTime_);
}

void LeachApp::send(int mac_dst, int link_dst, int type, char * msg, int msg_size, int data_size, double dist, int code)
{
	if (dist <= 0)
	{
		printf("Distancia invalida! %lf\n", dist);
		exit(-1);
	}

	((RCAgent *) agent_)->sendmsg(
		data_size,
		msg,
		msg_size,
		mac_dst,
		link_dst,
		dist,
		code,
		type);
}

void LeachApp::send(int mac_dst, int link_dst, int type, void * msg, int msg_size, int data_size, double dist, int code)
{
	send(
		mac_dst,
		link_dst,
		type,
		(char *) msg,
		msg_size,
		data_size,
		dist,
		code);
}

void LeachApp::send(int mac_dst, int link_dst, int type, SensedData * msg, int data_size, double dist, int code)
{
	send(
		mac_dst,
		link_dst,
		type,
		(char *) msg,
		msg->msgSize(),
		data_size,
		dist,
		code);
}

void LeachApp::sendDataToBS()
{
	int    dataSize, compressedSize;
	double dist;
	double xmitat;
	double rndDelay;

	rndDelay     = Random::uniform(0, 0.01);
	xmitat       = rndDelay - lstRndDelay_ + frameTime_;
	lstRndDelay_ = rndDelay;

	if (sensedData_->count() > 0)
	{
		dataSize       = config_.spreading_ * (BYTES_ID * sensedData_->msgSize() + config_.sigSize_);

		if (!isClusterHead())
			wakeUp();

		printf("Node %d sending %d data to BS at time %lf\n",
			sensor_node_->nodeid(),
			sensedData_->count(),
			Scheduler::instance().clock());

		sensedData_->timeStamp() = Scheduler::instance().clock();
		sensedData_->node_id() = sensor_node_->nodeid();

		send(
			MAC_BROADCAST,
			destination_id_,
			LEACH_DATA,
			sensedData_,
			dataSize,
			bsDist_,
			config_.bsCode_);

		if (!isClusterHead())
			goToSleep();

		clearSensedData();
	}
	
	if (xmitat + endFrmTime_ < nextChangeTime_ - 10 * config_.ssSlotTime_)
		Scheduler::instance().schedule(
			eventHandler_,
			new LeachEvent(&LeachApp::sendDataToBS),
			xmitat);
}

void LeachApp::sendMyDataToBS()
{
	sendDataToBS();
}

void LeachApp::disseminateData(SensedData * data)
{                                                                                                                            
	if (data != NULL)
	{
		printf("Common Node %d - Disseminating data -  Time %.3lf\n",
                        sensor_node_->nodeid(),Scheduler::instance().clock());

//		printf("%d is aggregating sensed data -  Time %.3lf",
//			sensor_node_->nodeid(),Scheduler::instance().clock());

		mergeSensedData(data);

		printf(" - There is %d data aggregated.\n", sensedData_->count()); //sensedData_->getData().size());
	}
}

void LeachApp::mergeSensedData(SensedData * data)
{
	AppDataList list;

	list = data->getData();

	for (AppDataList::iterator it = list.begin(); it != list.end(); it++)
		sensedData_->insertNewData(*it);
}

void LeachApp::clearClusterChoices()
{
	for (CHs::iterator it = clusterChoices_.begin(); it != clusterChoices_.end(); it++)
	{
		chadv element = (chadv) *it;
		
		if (element.object != NULL)
			delete element.object;
	}
	
	clusterChoices_.clear();
}

void LeachApp::clearSensedData()
{
	sensedData_->clear();
}