dist_radio.h

博弈论自适应功率控制中的实现

#ifndef _dist_radio_h_
#define _dist_radio_h_

#include "jn_math.h"
#include "obj_funcs.h"
#include <stdlib.h>

double target_ber;
double max_power;

double exponent;

double channel(double p, double dist)
{
	double dist_div;

	dist_div = pow(dist,exponent);
	return p/dist_div;
};

double lin2dB(double d1)
{
	return 10*log10(d1);
};

double dB2lin(double d1)
{
	return pow(10.0,d1/10.0);
};

class generic_radio
{
protected:
	double transmit_power; //transmit power
	double rcv_power;
	double x,y; //distance from base station	
	double obj;
	double dist;

	int obj_index;
	int power_index;
	
	double *obj_store;
	double *power_store;

	int node_id;
	int desired_node_id;
	
public:

	double get_rcv(void)
	{
		return rcv_power;
	};

	void set_pos(double d1, double d2)
	{
		x = d1;
		y = d2;
	};
	
	double get_x(void)
	{
		return x;		
	};

	double get_y(void)
	{
		return y;		
	};

	double * get_power_store(void)
	{
		return power_store;
	};

	double * get_obj_store(void)
	{
		return obj_store;
	};

	virtual int allocate_space(int N)
	{
		obj_store = (double *) calloc(sizeof(double),N);
		power_store = (double *) calloc(sizeof(double),N);
		obj_index = 0;
		power_index = 0;
		return 0;
	};

	void set_power(double power)
	{
		transmit_power = power;
	};
	
	double get_power(void)
	{
		return transmit_power;
	};	

	double distance(generic_radio r)
	{
		double d;
		double dx,dy;
		dx = (*this).x - r.x;
		dy = (*this).y - r.y;
		d = sqrt(dx*dx + dy*dy);
		dist = d;
		return d;
	};

	double get_obj(void)
	{
		return obj;
	};

	//virtual functions, must be refined in children
	virtual double calc_rcv_power(generic_radio r)
	{		
		return transmit_power; // default no channel
	};

	virtual void update_decision(double rcv, double interference, double noise)
	{
	
	};	
};

class generic_radio_list : public generic_radio
{
	struct node
	{	
		generic_radio *current;
		struct node *next;
	};

private:
	node *front;
	node *rear;

public:
	generic_radio_list()
	{
		front = NULL;
		rear = NULL;
	};

	~generic_radio_list()
	{
		node *temp;
		while(front != NULL)
		{
			temp = front;
			front = (*front).next;
			delete temp;
		};		
	};

	generic_radio * get_radio(int N)
	{
		node *temp;
		int k;
		temp = front;
		k = 0;
		
		while((temp!=NULL)&(k<(N)))
		{
			temp = (*temp).next;
			k++;
		}

		return (*temp).current;
	};

	int allocate_space(int N)
	{
		node *temp;
		temp = front;
		// run process on clocked
		while(temp!=NULL)
		{
			(*(*temp).current).allocate_space(N);			
			temp = (*temp).next;
		}		
		return 1;
	};

	void add_radio(generic_radio *new_core)
	{
		node *add = new node;
		(*add).current = new_core;
		(*add).next = NULL;
		if(front == NULL)
		{
			front = add;
		}
		else
		{
			(*rear).next = add;
		}
		rear = add;	
	};

	double calc_rcv_power(generic_radio r)
	{		
		return transmit_power; // default no channel
	};

	void update_decision(double rcv, double interference, double noise)
	{
	
	};
};

class DSSS_radio : public generic_radio
{
protected:
	double spreading_gain;
	double max_power;

public:
	
	DSSS_radio()
	{
		max_power = 20;
	};

	void update_stats(void)
	{
		obj_store[obj_index] = obj;
		power_store[obj_index] = 10*log10(rcv_power); //10*log10(transmit_power);
		obj_index++;
	};

	void set_spreading_gain(double N)
	{
		spreading_gain = N;
	};
	
	double get_spreading_gain(void)
	{
		return spreading_gain;
	};

	double calc_rcv_power(generic_radio r)
	{
		double d;
		d = distance(r);
		rcv_power = channel(transmit_power,d);  
		return rcv_power;
	};

	void update_decision(double rcv, double interference, double noise)
	{
		double step_size = 0.1; // dBm
		double temp_receive_power;
		double temp_obj_plus;
		double temp_obj_minus;
		double temp_power_plus;
		double temp_power_minus;
		//obj = log_snr(rcv, interference, noise, target_ber);
		//obj = ber(rcv, interference, noise);
		obj = target_standard_ber(rcv, interference, noise, target_ber);
		//check to see if benefit from altering power

		//dither to see if change improves performance
		temp_power_plus = lin2dB(transmit_power) + step_size;
		temp_receive_power = channel(dB2lin(temp_power_plus),dist);
		//temp_obj_plus = ber(temp_receive_power, interference, noise);
		temp_obj_plus = target_standard_ber(temp_receive_power, interference, noise, target_ber);

		//temp_power_minus = lin2dB(transmit_power) - step_size;
		temp_receive_power = channel(dB2lin(temp_power_minus),dist);
		temp_obj_minus = target_standard_ber(temp_receive_power, interference, noise, target_ber);
		temp_obj_minus = ber(temp_receive_power, interference, noise);
				
		if(temp_obj_plus > obj)
			transmit_power = dB2lin(temp_power_plus);
		else if (temp_obj_minus > obj)
			transmit_power = dB2lin(temp_power_minus);

		// limit output power
		if(lin2dB(transmit_power) > max_power)
		{
			transmit_power = dB2lin(max_power);
		}
		if(transmit_power < 0)
		{
			transmit_power = 0;
		}
	};	
};

class DSSS_base_station : public generic_radio
{
protected:
	generic_radio_list mobile_list;
	int num_radios;
	double noise;
public:
	
	DSSS_base_station()
	{
		num_radios = 0;
	};

	void set_noise(double d)
	{
		noise = d;
	};

	void add_radio(generic_radio *radio)
	{
		mobile_list.add_radio(radio);
		num_radios++;
	};

	void set_total_iterations(int N)
	{
		mobile_list.allocate_space(N);		
	};

	//virtual functions, must be refined in children
	double calc_rcv_power(generic_radio r)
	{		
		return transmit_power; // default no channel
	};

	void iterate(void)
	{
		double total_power;
		double interference;
		double rcv;
		double spreading_gain;
		DSSS_radio *gr;
		int k;
		
		total_power = 0;
		// calculate total power
		for(k=0;k<num_radios;k++)
		{
			gr = (DSSS_radio *) mobile_list.get_radio(k);
			total_power += (*gr).calc_rcv_power(*this); 
		}

		for(k=0;k<num_radios;k++)
		{
			gr = (DSSS_radio *) mobile_list.get_radio(k);
			rcv = (*gr).calc_rcv_power(*this);
			spreading_gain = (*gr).get_spreading_gain();
			interference = (total_power -rcv)/spreading_gain; 
			(*gr).update_decision(rcv,interference,noise);
			(*gr).update_stats();
		}
	};

	void update_decision(double rcv, double interference, double noise)
	{
		double total_power;		
		//calc objective - capacity?
	};
};

class ad_hoc_radio : public generic_radio
{
protected:
	generic_radio_list mobile_list;
	int num_radios;
	double noise;
	generic_radio *node_of_interest;
	

public:
	DSSS_base_station()
	{
		num_radios = 0;
	};

	void set_noise(double d)
	{
		noise = d;
	};

	void add_radio(generic_radio *radio)
	{
		mobile_list.add_radio(radio);
		num_radios++;
	};

	void set_total_iterations(int N)
	{
		mobile_list.allocate_space(N);		
	};

	void iterate(void)
	{
		double total_power;
		double interference;
		double rcv;
		double spreading_gain;
		DSSS_radio *gr;
		int k;
		
		total_power = 0;
		// calculate total power
		for(k=0;k<num_radios;k++)
		{
			gr = (DSSS_radio *) mobile_list.get_radio(k);
			total_power += (*gr).calc_rcv_power(*this); 
		}

		for(k=0;k<num_radios;k++)
		{
			gr = (DSSS_radio *) mobile_list.get_radio(k);
			rcv = (*gr).calc_rcv_power(*this);
			spreading_gain = (*gr).get_spreading_gain();
			interference = (total_power -rcv)/spreading_gain; 
			(*gr).update_decision(rcv,interference,noise);
			(*gr).update_stats();
		}
	};
};

#endif