dsr_waypoint_mobility.pr.c

afit的ad hoc路由协议源码

				op_ima_obj_attr_get(node_id,"y position",&y_pos);
				
				// Trace
				x_pos = (double) x_pos;
				y_pos = (double) y_pos;
				sprintf(msg,"Target  position  |X axis: %f   |Y axis: %f", x_target, y_target);
				sprintf(msg,"Current position  |X axis: %f   |Y axis: %f", x_pos, y_pos);
				
				// Compute the new x and y position according to the STEP_DIST and the current direction (angle)
				x= x_pos+ (double) step_range*cos(direction_angle);
				y= y_pos+ (double) step_range*sin(direction_angle);
				
				// Make sure the new position is inside the grid
				while(y<YMIN || YMAX<y || x<XMIN || XMAX<x)
					{
					// Compute a random new direction
					direction_angle= op_dist_outcome(one)*PI;
					// Compute the new x and y position according to the STEP_DIST and the current direction (angle)
					x= x_pos+ (double) step_range*cos(direction_angle);
					y= y_pos+ (double) step_range*sin(direction_angle);
					}
				
				// set the new position of the node
				op_ima_obj_attr_set(node_id, "x position",x);
				op_ima_obj_attr_set(node_id, "y position",y);
				
				// Decrease the value of the distance to cover
				distance_to_cover = distance_to_cover-step_range;
				
				// Check if target reached or not
				if(distance_to_cover < step_range)
					{
					// Set the pause flag to 1		
					PAUSE = 1;
					// Set avg speed to 0
					my_avg_speed = 0;
					
					// Schedule an interrupt for the end of the next pause state
					op_intrpt_schedule_self(op_sim_time()+PAUSE_TIME,END_PAUSE_CODE);
					sprintf(msg,"Target position reached: Enter Pause state\n\t\t- Distance to cover = %f\n\t\t- Pause time = %f",distance_to_cover,pause_time);
					}
				else
					{
					sprintf(msg,"Target position not reached yet: Keep on moving\n\t\t- Distance still to cover = %f",distance_to_cover);
					op_intrpt_schedule_self(op_sim_time()+MVT_STEP,MOVE_CODE);
					}
				}


			/** state (Move) exit executives **/
			FSM_STATE_EXIT_FORCED (2, "Move", "dsr_waypoint_mobility () [Move exit execs]")
				{
				}


			/** state (Move) transition processing **/
			FSM_TRANSIT_FORCE (3, state3_enter_exec, ;, "default", "", "Move", "idle")
				/*---------------------------------------------------------*/



			/** state (idle) enter executives **/
			FSM_STATE_ENTER_UNFORCED (3, state3_enter_exec, "idle", "dsr_waypoint_mobility () [idle enter execs]")
				{
				/* If there still a distance to cover (distance_to_cover > 0)
				/* then schedule an interrupt for the next movement after a
				/* MVT_STEP sec period of time.
				/* Else, schedule an interrupt to enter the Pause state now.
				*/
				
				
				}


			/** blocking after enter executives of unforced state. **/
			FSM_EXIT (7,dsr_waypoint_mobility)


			/** state (idle) exit executives **/
			FSM_STATE_EXIT_UNFORCED (3, "idle", "dsr_waypoint_mobility () [idle exit execs]")
				{
				}


			/** state (idle) transition processing **/
			FSM_INIT_COND (MOVE)
			FSM_TEST_COND (END_PAUSE)
			FSM_DFLT_COND
			FSM_TEST_LOGIC ("idle")

			FSM_TRANSIT_SWITCH
				{
				FSM_CASE_TRANSIT (0, 2, state2_enter_exec, ;, "MOVE", "", "idle", "Move")
				FSM_CASE_TRANSIT (1, 1, state1_enter_exec, ;, "END_PAUSE", "", "idle", "Init_Mvt")
				FSM_CASE_TRANSIT (2, 3, state3_enter_exec, ;, "default", "", "idle", "idle")
				}
				/*---------------------------------------------------------*/



			}


		FSM_EXIT (0,dsr_waypoint_mobility)
		}
	}

#if defined (__cplusplus)
	extern "C" { 
#endif
	extern VosT_Fun_Status Vos_Catmem_Register (const char * , int , VosT_Void_Null_Proc, VosT_Address *);
	extern VosT_Address Vos_Catmem_Alloc (VosT_Address, size_t);
	extern VosT_Fun_Status Vos_Catmem_Dealloc (VosT_Address);
#if defined (__cplusplus)
	}
#endif


Compcode
dsr_waypoint_mobility_init (void ** gen_state_pptr)
	{
	int _block_origin = 0;
	static VosT_Address	obtype = OPC_NIL;

	FIN (dsr_waypoint_mobility_init (gen_state_pptr))

	if (obtype == OPC_NIL)
		{
		/* Initialize memory management */
		if (Vos_Catmem_Register ("proc state vars (dsr_waypoint_mobility)",
			sizeof (dsr_waypoint_mobility_state), Vos_Vnop, &obtype) == VOSC_FAILURE)
			{
			FRET (OPC_COMPCODE_FAILURE)
			}
		}

	*gen_state_pptr = Vos_Catmem_Alloc (obtype, 1);
	if (*gen_state_pptr == OPC_NIL)
		{
		FRET (OPC_COMPCODE_FAILURE)
		}
	else
		{
		/* Initialize FSM handling */
		((dsr_waypoint_mobility_state *)(*gen_state_pptr))->current_block = 0;

		FRET (OPC_COMPCODE_SUCCESS)
		}
	}



void
dsr_waypoint_mobility_diag (void)
	{
	/* No Diagnostic Block */
	}




void
dsr_waypoint_mobility_terminate (void)
	{
	int _block_origin = __LINE__;

	FIN (dsr_waypoint_mobility_terminate (void))

	if (1)
		{
		Objid	       params_comp_attr_objid;
		Objid          params_attr_objid;
		double	       rand, prev_angle,x,y,z,x_pos,y_pos,z_pos;
		double         first_interval;
		char           msg[64];
		int            i;
		double         pause_time;

		/* No Termination Block */

		}
	Vos_Catmem_Dealloc (pr_state_ptr);

	FOUT;
	}


/* Undefine shortcuts to state variables to avoid */
/* syntax error in direct access to fields of */
/* local variable prs_ptr in dsr_waypoint_mobility_svar function. */
#undef one
#undef node_id
#undef process_id
#undef net_id
#undef MOBILE
#undef XMAX
#undef XMIN
#undef YMAX
#undef YMIN
#undef DEBUG
#undef node_addr
#undef TRANSMISSION_RANGE
#undef num_nodes
#undef my_avg_speed
#undef distance_to_cover
#undef PAUSE_TIME
#undef MVT_STEP
#undef SPEED_LIMIT
#undef direction_angle
#undef step_range
#undef DISTANCE_LIMIT
#undef uniform_double_x
#undef uniform_double_y
#undef PAUSE
#undef x_target
#undef y_target
#undef my_avg_speed_dist



void
dsr_waypoint_mobility_svar (void * gen_ptr, const char * var_name, char ** var_p_ptr)
	{
	dsr_waypoint_mobility_state		*prs_ptr;

	FIN (dsr_waypoint_mobility_svar (gen_ptr, var_name, var_p_ptr))

	if (var_name == OPC_NIL)
		{
		*var_p_ptr = (char *)OPC_NIL;
		FOUT;
		}
	prs_ptr = (dsr_waypoint_mobility_state *)gen_ptr;

	if (strcmp ("one" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->one);
		FOUT;
		}
	if (strcmp ("node_id" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->node_id);
		FOUT;
		}
	if (strcmp ("process_id" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->process_id);
		FOUT;
		}
	if (strcmp ("net_id" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->net_id);
		FOUT;
		}
	if (strcmp ("MOBILE" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->MOBILE);
		FOUT;
		}
	if (strcmp ("XMAX" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->XMAX);
		FOUT;
		}
	if (strcmp ("XMIN" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->XMIN);
		FOUT;
		}
	if (strcmp ("YMAX" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->YMAX);
		FOUT;
		}
	if (strcmp ("YMIN" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->YMIN);
		FOUT;
		}
	if (strcmp ("DEBUG" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->DEBUG);
		FOUT;
		}
	if (strcmp ("node_addr" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->node_addr);
		FOUT;
		}
	if (strcmp ("TRANSMISSION_RANGE" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->TRANSMISSION_RANGE);
		FOUT;
		}
	if (strcmp ("num_nodes" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->num_nodes);
		FOUT;
		}
	if (strcmp ("my_avg_speed" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->my_avg_speed);
		FOUT;
		}
	if (strcmp ("distance_to_cover" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->distance_to_cover);
		FOUT;
		}
	if (strcmp ("PAUSE_TIME" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->PAUSE_TIME);
		FOUT;
		}
	if (strcmp ("MVT_STEP" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->MVT_STEP);
		FOUT;
		}
	if (strcmp ("SPEED_LIMIT" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->SPEED_LIMIT);
		FOUT;
		}
	if (strcmp ("direction_angle" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->direction_angle);
		FOUT;
		}
	if (strcmp ("step_range" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->step_range);
		FOUT;
		}
	if (strcmp ("DISTANCE_LIMIT" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->DISTANCE_LIMIT);
		FOUT;
		}
	if (strcmp ("uniform_double_x" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->uniform_double_x);
		FOUT;
		}
	if (strcmp ("uniform_double_y" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->uniform_double_y);
		FOUT;
		}
	if (strcmp ("PAUSE" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->PAUSE);
		FOUT;
		}
	if (strcmp ("x_target" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->x_target);
		FOUT;
		}
	if (strcmp ("y_target" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->y_target);
		FOUT;
		}
	if (strcmp ("my_avg_speed_dist" , var_name) == 0)
		{
		*var_p_ptr = (char *) (&prs_ptr->my_avg_speed_dist);
		FOUT;
		}
	*var_p_ptr = (char *)OPC_NIL;

	FOUT;
	}