wlan_mac_tmac_nav_rpm_31jan06_ver2.state variables

opnet无线网络编程

int	\packet_size;

/* The arrival time of the packet that is currently handled.	 	 */
double	\receive_time;

/* Sending ici to the bridge queue with final destination address.	 */
Ici*	\llc_iciptr;

/* Receiver power threshold for valid WLAN packets.					 */
double	\rx_power_threshold;

/* When BSS_ID attribute is being used , this variable identifies	  */
/* the BSS to which a node belongs. Otherwise, each subnet defines	 */
/* a BSS, and this state variable just retains its default value,	  */
/* which is -1.					                                                */
/* CHANGED: BSS now stores the subnet object ID as the BSS ID		     */
int	\bss_id;

/* Incremented each time when a PCF frame was unsuccessful in transmission */
int	\pcf_retry_count;

/* This variable counts the number of times a poll is sent, and */
/* receives no response.                                        */
int	\poll_fail_count;

/* The variable determines the maximum number of failed polls */
/* allowed before a station is skipped in sequence            */
int	\max_poll_fails;

/* Higher layer data arrival queue or list for CFP */
List*	\cfpd_list_ptr;

/* Used in storing fragmentation threshold attribute */
int	\pcf_queue_offset;

/* Beacon Interval in seconds */
double	\beacon_int;

/* PCF Fragmentation buffer used to store transmit packet fragments */
Sbhandle	\pcf_frag_buffer_ptr;

/* Make separate copy of pcf transmit frames before transmission */
Packet *	\wlan_pcf_transmit_frame_copy_ptr;

/* Number of data fragments that need to be transmitted */
/* for each pcf data frame received from higher layer   */
int	\pcf_num_fragments;

/* Size of the last PCF data fragment 		 */
OpT_Packet_Size	\pcf_remainder_size;

/* This structure is used to maintain the polling list for the PCF */
/*                                                                 */
int*	\polling_list;

/* This variable contains the size of the polling list */
int	\poll_list_size;

/* This is the index into the polling list indicating the STA */
/* currently being polled.                                    */
int	\poll_index;

/* PIFS interval is used by the stations during CFP 			 */
double	\pifs_time;

/* Event handle that keeps track of self interrupt for Beacon transmit time. */
Evhandle	\beacon_evh;

/* Event handle that keeps track of self interrupt for end of CFP. */
Evhandle	\cfp_end_evh;

/* Store packet id of the data packet in service. */
OpT_Packet_Id	\pcf_pkt_in_service;

/* Flag to read the attribute which indicates whether */
/* the station has PCF functional or not.	            */
int	\pcf_flag;

/* The variable indicates the presence of an active PC in the BSS */
Boolean	\active_pc;

/* This variable contain the number of beacon periods between */
/* Contention free periods                                    */
int	\cfp_prd;

/* This variable is used to track the "phase" of the cfp	   */
/* occurence relative to time =0.  It indicates the number	 */
/* of beacon periods the first cfp is offset from time=0.	  */
int	\cfp_offset;

/* This variable contains the default length in seconds of the */
/* CFP assuming the CFP starts at the TTBT.                    */
double	\cfp_length;

/* This variable determines if station to station traffic in 	 */
/* the presence of an AP is relayed through the AP, or sent  	 */
/* between stations directly 									                         */
Boolean	\ap_relay;

/* The full size of the DCF packet that is currently handled.	 */
OpT_Packet_Size	\packet_size_dcf;

/* The full size of the PCF packet that is currently handled.	 */
OpT_Packet_Size	\packet_size_pcf;

/* The arrival time of the packet that is currently handled by the DCF.	 */
double	\receive_time_dcf;

/* The arrival time of the packet that is currently handled by the PCF.	 */
double	\receive_time_pcf;

/* Indicates the CFP during which AP controls the medium.	 */
Boolean	\cfp_ap_medium_control;

/* Number of PCF enabled nodes in the network.				 */
int	\pcf_network;

/* Turn off beacons in non-PC APs */
int	\beacon_eff_mode;

/* The number of operating WLAN radio channels, which		    */
/* depends on the physical layer technology (i.e. 802.11a	 */
/* or 802.11/11b).											                              */
int	\channel_count;

/* The number of the channel that is currently being used.	 */
int	\channel_num;

/* The minimum frequency of the first one of the operating	 */
/* WLAN radio channels (in MHz).							                     */
double	\first_chan_min_freq;

/* The bandwidth of the operating WLAN radio channels in	 */
/* MHz.														                                     */
double	\channel_bandwidth;

/* The spacing between two operating WLAN radio channels in	 */
/* MHz.														                                        */
double	\channel_spacing;

/* BSS ID of the BSS under evaluation.						 */
int	\eval_bss_id;

/* Roaming related information.								 */
WlanT_Roam_State_Info*	\roam_state_ptr;

/* Receiver channel state information.						 */
WlanT_Rx_State_Info*	\rx_state_info_ptr;

/* Time interval for periodic check on the connectivity from AP */
double	\ap_connectivity_check_interval;

/* Time value indicating the next sim time to check the AP connectivity */
double	\ap_connectivity_check_time;

/* Event handle for the periodic AP connectivity check */
Evhandle	\ap_connectivity_check_evhndl;

/* Position information for the connected AP.					 */
WlanT_AP_Position_Info*	\conn_ap_pos_info_ptr;

/* Station information containing duplicate information.	 	 */
WlanT_Sta_Mapping_Info*	\my_sta_info_ptr;

/* Handle to the information record of the current BSS			 */
/* including the list of STAs that belong to that BSS.			 */
WlanT_Bss_Mapping_Info*	\my_bss_info_ptr;

/* Mutex used to serialize calling prg_mapping functions, which	 */
/* read/write global WLAN information, under multi-threaded		    */
/* execution with multiple CPUs.								                         */
PrgT_Mutex*	\mapping_info_mutex;

/* A flag that indicates if a station is asleep: 0->awake 1->asleep          */
/* this flag is used in evaluating the transitions from one state to another */
Boolean	\sleep;

/* Each FSM has a distinctive number that nodes use to determine what state to return to when they wake up */
WsnT_State	\state;

/* used in SMAC to indicate % of active portion of frame_period */
double	\duty_cycle;

/* the length of a frame period including the active and sleep parts */
double	\frame_period;

/* An event handler for SMAC's periodic sleep cycle */
Evhandle	\sleep_evh;

/* The time when a station wakes up, helps in offsetting nodes self interrupts */
double	\sleep_end;

/* The time when a backoff self interrupt will occur */
double	\intrpt_time_backoff;

/* Sleep statehandle used to graph nodes sleep cycle */
Stathandle	\sleep_stathandle;

/* Sleep statehandle used to graph nodes LPM 1 sleep cycle */
Stathandle	\LPM1_sleep_stathandle;

/* Sleep statehandle used to graph nodes LPM 2 sleep cycle */
Stathandle	\LPM2_sleep_stathandle;

/* Sleep statehandle used to graph nodes LPM 3 sleep cycle */
Stathandle	\LPM3_sleep_stathandle;

/* energy consumed during transmission unit (watts = AV) */
double	\energy_rate_transmit;

/* energy consumed during receive, idle, defer, etc unit (watts = AV) */
double	\energy_rate_receive;

/* energy consumed during LPM1 Sleep unit (watts = AV) */
double	\energy_rate_LPM1;

/* energy consumed during LPM1 Sleep unit (watts = AV) */
double	\energy_rate_LPM2;

/* energy consumed during LPM1 Sleep unit (watts = AV) */
double	\energy_rate_LPM3;

/* total energy consumed during LPM1 Sleep transition unit (watts* s = A* V * s */
double	\energy_total_LPM1_transition;

/* total energy consumed during LPM1 Sleep transition unit (watts* s = A* V * s */
double	\energy_total_LPM2_transition;

/* total energy consumed during LPM1 Sleep transition unit (watts* s = A* V * s */
double	\energy_total_LPM3_transition;

/* the time a node enters a particular state, this value helps in calculating a nodes */
/* energy consumption in a particular state                                           */
double	\state_start;

/* the total amount of current a node consumes during its lifetime */
double	\energy_consum_total_local;

// final WSN evaluation statistic calculated from global variables generated in WSN Sink process
double \wsn_average_packet_ETE_delay;

/* a statehandle used to graph a node's total energy consumption */
Stathandle	\energy_stathandle;

/* the time a deference interrupt is supposed to occur */
double	\deference_time;

/* this flag is used to determine whther a pending deference interrupt */
/* needs to be rescheduled when a station wakes up                     */
Boolean	\deference_pending;

/* this flag is used to determine whether a pending backoff needs to be */
/* rescheduled when a node wakes up                                     */
Boolean	\backoff_pending;

/* a nav duration that we are calculating */
double	\nav_duration_wsn;

/* the minimum duration for LPM1 */
double	\lpm1_duration;

/* the minimum duration for LPM2 */
double	\lpm2_duration;

/* the minimum duration for LPM3 */
double	\lpm3_duration;

/* writes messages to a log file for debugging purpooses */
Log_Handle	\wsn_log;

/* used for debugging purposes. the programmer can choose the address of a station */
/* to follow its traffic pattern                                                   */
int	\wsn_test_address;

/* used for debugging purposes, indicates the time printf should be outputted */
double	\wsn_test_time;

/* used for debugging purposes.  a programmer can indicate another node's address */
/* to output printf statements associated with                                    */
double	\wsn_test_address_2;

/* the duration of 1 slot */
double	\wsn_slot_time;

/* the data rate of a node in bps */
double	\wsn_data_rate;

/* the time required to transmit  1 byte */
double	\wsn_time_per_byte;

/* this mutex is used when nodes access the global variables "wsn_live_nodes", "wsn_throughput_global", and "wsn_energy_global" */
PrgT_Mutex*	\wsn_network_mutex;

/* a flag that indicates if a node is dead or alive: 1->dead, 0->alive */
Boolean	\node_dead;

/* the total number of bits a node has transmitted */
double	\wsn_throughput_local;

/* the total number of energy available to a single node */
double	\wsn_energy_per_node;

/* the energy consumed per bit, evluated by the last dying node is a network */
double	\wsn_energy_per_bit;

/* the amount of time a node spends in a FSM state */
double	\wsn_state_duration;

/* indicates a node has set its "wlan_flags>perform_cw flag" in the function block before deferring */
/* used to restore flag status when a node wakes up                                                 */
Boolean	\wsn_deference_cw;

/* indicates a node has set its "wlan_flags>perform_backoff flag" in the function block before deferring */
/* used to restore flag status when a node wakes up                                                      */
Boolean	\wsn_deference_backoff;

/* used to indicate a node has just scheduled a "perform CW" backoff interrupt in the */
/* backoff needed FSM, used when a node resheules a backoff interrupt upon waking up  */
Boolean	\wsn_interrupt_cw;

/* used to indicate a node has scheduled a "perform backoff" interrupt in the         */
/* backoff needed FSM.  This flag is used at the sleep FSM when backoff is reschedule */
Boolean	\wsn_interrupt_backoff;

Evhandle	\wake_evh;

double	\output_var;

/* statistic to maintain total time asleep */
double	\sleep_stat;

/* statistic to maintain total time in LPM1 */
double	\LPM1_sleep_stat;

/* statistic to maintain total time in LPM1 */
double	\LPM2_sleep_stat;

/* statistic to maintain total time in LPM1 */
double	\LPM3_sleep_stat;

double	\wsn_ta_time;

Evhandle	\wsn_ta_evh;

double	\wsn_period_end;

/* mutex to lock writes global variable wsn_channel */
PrgT_Mutex*	\wsn_channel_busy_mutex;

Evhandle	\wsn_nav_wakeup;

/* used to test multiple packet sends of same packet */
int	\packet_id;

/* Determines if sleep level LPM 1 is available with architecture */
Boolean	\LPM1_ALLOWED;

/* Determines if sleep level LPM 2 is available with architecture */
Boolean	\LPM2_ALLOWED;

/* Determines if sleep level LPM 3 is available with architecture */
Boolean	\LPM3_ALLOWED;

/* Determines if NAV Sleep allowed during message overhearing situations */
Boolean	\NAV_SLEEP_ALLOWED;

PrgT_Mutex*	\wsn_global_energy_pool_mutex;