滑动窗口协议(基于Opnet)

/* Process model C form file: Pro4_proc.pr.c */
/* Portions of this file copyright 1986-2008 by OPNET Technologies, Inc. */






/* This variable carries the header into the object file */
const char Pro4_proc_pr_c [] = "MIL_3_Tfile_Hdr_ 145A 30A modeler 7 4F7EE6BB 4F7EE6BB 1 microsof-d42869 Administrator 0 0 none none 0 0 none 0 0 0 0 0 0 0 0 1bcc 1                                                                                                                                                                                                                                                                                                                                                                                            ";
#include <string.h>






/* OPNET system definitions */
#include <opnet.h>






/* Header Block */


#include "protocol.h"
#define intrpt_from_networklayer (!op_strm_empty(0))
#define intrpt_from_physicallayer (op_intrpt_type() == OPC_INTRPT_STRM && op_intrpt_strm() == 1)
#define intrpt_pk_from_queue (op_intrpt_type() == OPC_INTRPT_SELF && op_intrpt_code() == 0)
#define intrpt_time_out (op_intrpt_type() == OPC_INTRPT_SELF && (op_intrpt_code() == 1 || op_intrpt_code() == 3))
#define intrpt_init (op_intrpt_type() == OPC_INTRPT_SELF && op_intrpt_code() == 2)
#define handle_packet (op_intrpt_type() == OPC_INTRPT_SELF && op_intrpt_code() == 4)
#define repeat (repeat_flag == 0)
#define not_repeat (repeat_flag == 1)
#define handle_over (op_intrpt_type() == OPC_INTRPT_SELF && op_intrpt_code() == 5)


/* End of Header Block */


#if !defined (VOSD_NO_FIN)
#undef BIN
#undef BOUT
#define BIN FIN_LOCAL_FIELD(_op_last_line_passed) = __LINE__ - _op_block_origin;
#define BOUT BIN
#define BINIT FIN_LOCAL_FIELD(_op_last_line_passed) = 0; _op_block_origin = __LINE__;
#else
#define BINIT
#endif /* #if !defined (VOSD_NO_FIN) */






/* State variable definitions */
typedef struct
{
/* Internal state tracking for FSM */
FSM_SYS_STATE
/* State Variables */
int                     next_frame_to_send                              ;
int                     frame_expected                                  ;
Packet*                 pk_copy0                                        ; /* 重传的时候使用 */
Evhandle               Timer1                                          ;
int                     send_flag                                       ;
Evhandle               Timer0                                          ;
Packet*                 pk_copy1                                        ;
int                     node_name                                       ;
int                     repeat_flag                                     ;
int                     next_flag                                       ;
int                     data_n                                          ;
Packet*                 pk_repeat                                       ;
} Pro4_proc_state;


#define next_frame_to_send       op_sv_ptr->next_frame_to_send
#define frame_expected           op_sv_ptr->frame_expected
#define pk_copy0                 op_sv_ptr->pk_copy0
#define Timer1                   op_sv_ptr->Timer1
#define send_flag               op_sv_ptr->send_flag
#define Timer0                   op_sv_ptr->Timer0
#define pk_copy1                 op_sv_ptr->pk_copy1
#define node_name               op_sv_ptr->node_name
#define repeat_flag             op_sv_ptr->repeat_flag
#define next_flag               op_sv_ptr->next_flag
#define data_n                   op_sv_ptr->data_n
#define pk_repeat               op_sv_ptr->pk_repeat


/* These macro definitions will define a local variable called */
/* "op_sv_ptr" in each function containing a FIN statement. */
/* This variable points to the state variable data structure, */
/* and can be used from a C debugger to display their values. */
#undef FIN_PREAMBLE_DEC
#undef FIN_PREAMBLE_CODE
#define FIN_PREAMBLE_DEC Pro4_proc_state *op_sv_ptr;
#define FIN_PREAMBLE_CODE \
op_sv_ptr = ((Pro4_proc_state *)(OP_SIM_CONTEXT_PTR->_op_mod_state_ptr));




/* Function Block */


#if !defined (VOSD_NO_FIN)
enum { _op_block_origin = __LINE__ + 2};
#endif


void start_timer(int seq)
{
FIN(start_timer);
if(seq == 0)
{
Timer0 = op_intrpt_schedule_self(op_sim_time() + 30,1);
//printf("Start Timer0 %d\n",node_name);
}
else if(seq == 1)
{
Timer1 = op_intrpt_schedule_self(op_sim_time() + 30,3);
//printf("Start Timer1 %d\n",node_name);
}
else{

}

FOUT;
}


void kill_timer(int seq)
{
FIN(kill_timer);
if(seq == 0)
{
if(op_ev_valid(Timer0) == OPC_TRUE)
{
op_ev_cancel(Timer0);
//printf("Kill Timer0 %d\n",node_name);
}
}
else if(seq == 1)
{
if(op_ev_valid(Timer1) == OPC_TRUE)
{
op_ev_cancel(Timer1);
//printf("Kill Timer1 %d\n",node_name);
}
}
else{

}
FOUT;
}


/* End of Function Block */


/* Undefine optional tracing in FIN/FOUT/FRET */
/* The FSM has its own tracing code and the other */
/* functions should not have any tracing.  */
#undef FIN_TRACING
#define FIN_TRACING


#undef FOUTRET_TRACING
#define FOUTRET_TRACING


#if defined (__cplusplus)
extern "C" {
#endif
void Pro4_proc (OP_SIM_CONTEXT_ARG_OPT);
VosT_Obtype _op_Pro4_proc_init (int * init_block_ptr);
void _op_Pro4_proc_diag (OP_SIM_CONTEXT_ARG_OPT);
void _op_Pro4_proc_terminate (OP_SIM_CONTEXT_ARG_OPT);
VosT_Address _op_Pro4_proc_alloc (VosT_Obtype, int);
void _op_Pro4_proc_svar (void *, const char *, void **);




#if defined (__cplusplus)
} /* end of 'extern "C"' */
#endif








/* Process model interrupt handling procedure */




void
Pro4_proc (OP_SIM_CONTEXT_ARG_OPT)
{
#if !defined (VOSD_NO_FIN)
int _op_block_origin = 0;
#endif
FIN_MT (Pro4_proc ());


{




FSM_ENTER ("Pro4_proc")


FSM_BLOCK_SWITCH
{
/*---------------------------------------------------------*/
/** state (init) enter executives **/
FSM_STATE_ENTER_UNFORCED_NOLABEL (0, "init", "Pro4_proc [init enter execs]")
FSM_PROFILE_SECTION_IN ("Pro4_proc [init enter execs]", state0_enter_exec)
{
//让流中有数据包可以获取
Objid my_id ;
next_frame_to_send = 0;
frame_expected = 0;
my_id = op_id_self();
op_ima_obj_attr_get_int32(my_id,"node_name",&node_name);
data_n = 0;
printf("<<<<<<<<<<<<<<<node_name = %d\n",node_name);

op_intrpt_schedule_self(op_sim_time() + 60,2);
}
FSM_PROFILE_SECTION_OUT (state0_enter_exec)


/** blocking after enter executives of unforced state. **/
FSM_EXIT (1,"Pro4_proc")




/** state (init) exit executives **/
FSM_STATE_EXIT_UNFORCED (0, "init", "Pro4_proc [init exit execs]")




/** state (init) transition processing **/
FSM_TRANSIT_FORCE (5, state5_enter_exec, ;, "default", "", "init", "send_first", "tr_16", "Pro4_proc [init -> send_first : default / ]")
/*---------------------------------------------------------*/






/** state (send) enter executives **/
FSM_STATE_ENTER_FORCED (1, "send", state1_enter_exec, "Pro4_proc [send enter execs]")
FSM_PROFILE_SECTION_IN ("Pro4_proc [send enter execs]", state1_enter_exec)
{
Packet* pkptr;

char name;
op_strm_access(0);
if(op_strm_empty(0) == OPC_FALSE)
{
pkptr = op_pk_get(0);
data_n++;
op_pk_nfd_set(pkptr,"seq",next_frame_to_send);
op_pk_nfd_set(pkptr,"ack",(1 - frame_expected));
op_pk_nfd_set(pkptr,"node_name",node_name);
op_pk_nfd_set(pkptr,"data",data_n);
if(next_frame_to_send == 0){
pk_copy0 = op_pk_copy(pkptr);
}
else
{
pk_copy1 = op_pk_copy(pkptr);
}
op_pk_send(pkptr,0);
start_timer(next_frame_to_send);
}

if(node_name == 0)
{
name = 'A';
}
else
{
name = 'B';
}
printf("%c发送(%d,%d,%c)\n",name,next_frame_to_send,(1-frame_expected),name);
printf("\n");

}
FSM_PROFILE_SECTION_OUT (state1_enter_exec)


/** state (send) exit executives **/
FSM_STATE_EXIT_FORCED (1, "send", "Pro4_proc [send exit execs]")




/** state (send) transition processing **/
FSM_TRANSIT_FORCE (2, state2_enter_exec, ;, "default", "", "send", "wait_for_ack", "tr_19", "Pro4_proc [send -> wait_for_ack : default / ]")
/*---------------------------------------------------------*/






/** state (wait_for_ack) enter executives **/
FSM_STATE_ENTER_UNFORCED (2, "wait_for_ack", state2_enter_exec, "Pro4_proc [wait_for_ack enter execs]")


/** blocking after enter executives of unforced state. **/
FSM_EXIT (5,"Pro4_proc")




/** state (wait_for_ack) exit executives **/
FSM_STATE_EXIT_UNFORCED (2, "wait_for_ack", "Pro4_proc [wait_for_ack exit execs]")




/** state (wait_for_ack) transition processing **/
FSM_PROFILE_SECTION_IN ("Pro4_proc [wait_for_ack trans conditions]", state2_trans_conds)
FSM_INIT_COND (intrpt_time_out)
FSM_TEST_COND (intrpt_from_physicallayer)
FSM_DFLT_COND
FSM_TEST_LOGIC ("wait_for_ack")
FSM_PROFILE_SECTION_OUT (state2_trans_conds)


FSM_TRANSIT_SWITCH
{
FSM_CASE_TRANSIT (0, 4, state4_enter_exec, ;, "intrpt_time_out", "", "wait_for_ack", "time_out", "tr_30", "Pro4_proc [wait_for_ack -> time_out : intrpt_time_out / ]")
FSM_CASE_TRANSIT (1, 3, state3_enter_exec, ;, "intrpt_from_physicallayer", "", "wait_for_ack", "ack_received", "tr_28", "Pro4_proc [wait_for_ack -> ack_received : intrpt_from_physicallayer / ]")
FSM_CASE_TRANSIT (2, 2, state2_enter_exec, ;, "default", "", "wait_for_ack", "wait_for_ack", "tr_40", "Pro4_proc [wait_for_ack -> wait_for_ack : default / ]")
}
/*---------------------------------------------------------*/






/** state (ack_received) enter executives **/
FSM_STATE_ENTER_FORCED (3, "ack_received", state3_enter_exec, "Pro4_proc [ack_received enter execs]")
FSM_PROFILE_SECTION_IN ("Pro4_proc [ack_received enter execs]", state3_enter_exec)
{
Packet* pkptr;
int seq;
int ack;
int flag;
char name;
char name_get;
int data_store;;
pkptr = op_pk_get(1);
pk_repeat = op_pk_copy(pkptr);
op_pk_nfd_get(pkptr,"seq",&seq);
op_pk_nfd_get(pkptr,"ack",&ack);
op_pk_nfd_get(pkptr,"node_name",&flag);
op_pk_nfd_get(pkptr,"data",&data_store);
repeat_flag = 0;

if(node_name == 0)
{
name = 'A';
}
else
{
name = 'B';
}

if(flag == 0)
{
name_get = 'A';
}
else
{
name_get = 'B';
}

if(seq == frame_expected)
{
frame_expected = (frame_expected+1)%2;

}
else
{
printf("sb111\n");
op_pk_send(pkptr,1);
}

if(ack  == next_frame_to_send)
{
kill_timer(ack);
repeat_flag = 1;
next_frame_to_send = (next_frame_to_send + 1)%2;
}

//printf("the data is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>%c,%d\n",name_get,data_store);
//printf("%c得到(%d,%d,%c)\n",name,seq,ack,name_get);
printf("data_store = %d\n",data_store);

}
FSM_PROFILE_SECTION_OUT (state3_enter_exec)


/** state (ack_received) exit executives **/
FSM_STATE_EXIT_FORCED (3, "ack_received", "Pro4_proc [ack_received exit execs]")




/** state (ack_received) transition processing **/
FSM_TRANSIT_FORCE (1, state1_enter_exec, ;, "default", "", "ack_received", "send", "tr_45", "Pro4_proc [ack_received -> send : default / ]")
/*---------------------------------------------------------*/






/** state (time_out) enter executives **/
FSM_STATE_ENTER_FORCED (4, "time_out", state4_enter_exec, "Pro4_proc [time_out enter execs]")
FSM_PROFILE_SECTION_IN ("Pro4_proc [time_out enter execs]", state4_enter_exec)
{
Packet* pkptr;
int seq;
int ack;
char name;
char name_get;
int flag;
if(op_intrpt_code() == 1)
{
printf("Timer0 out \n");
start_timer(0);
pkptr = op_pk_copy(pk_copy0);
}
else 
{
printf("Timer1 out \n");
start_timer(1);
pkptr = op_pk_copy(pk_copy1);
}

op_pk_nfd_get(pkptr,"seq",&seq);
op_pk_nfd_get(pkptr,"ack",&ack);
op_pk_nfd_get(pkptr,"node_name",&flag);
if(node_name == 0)
{
name = 'A';
}
else
{
name = 'B';
}

if(flag == 0)
{
name_get = 'A';
}
else
{
name_get = 'B';
}

printf("%c发送(%d,%d,%c)\n",name,seq,ack,name_get);

op_pk_send(pkptr,0);


}
FSM_PROFILE_SECTION_OUT (state4_enter_exec)


/** state (time_out) exit executives **/
FSM_STATE_EXIT_FORCED (4, "time_out", "Pro4_proc [time_out exit execs]")




/** state (time_out) transition processing **/
FSM_TRANSIT_FORCE (2, state2_enter_exec, ;, "default", "", "time_out", "wait_for_ack", "tr_11", "Pro4_proc [time_out -> wait_for_ack : default / ]")
/*---------------------------------------------------------*/






/** state (send_first) enter executives **/
FSM_STATE_ENTER_FORCED (5, "send_first", state5_enter_exec, "Pro4_proc [send_first enter execs]")
FSM_PROFILE_SECTION_IN ("Pro4_proc [send_first enter execs]", state5_enter_exec)
{
Packet* pkptr;
char name;

if(node_name == 0 )//|| node_name == 1)
{
op_strm_access(0);
if(op_strm_empty(0) == OPC_FALSE)
{

pkptr = op_pk_get(0);
op_pk_nfd_set(pkptr,"seq",next_frame_to_send);
op_pk_nfd_set(pkptr,"ack",(1 - frame_expected));
op_pk_nfd_set(pkptr,"node_name",node_name);
op_pk_nfd_set(pkptr,"data",data_n);
if(next_frame_to_send == 0){
pk_copy0 = op_pk_copy(pkptr);
}
else
{
pk_copy1 = op_pk_copy(pkptr);
}
if(node_name == 0){
op_pk_send(pkptr,0);
}
else{
op_pk_send_delayed(pkptr,0,1);
}
start_timer(next_frame_to_send);
}

if(node_name == 0)
{
name = 'A';
}
else
{
name = 'B';
}
printf("%c发送(%d,%d,%c)\n",name,next_frame_to_send,(1-frame_expected),name);
printf("\n");
}


}
FSM_PROFILE_SECTION_OUT (state5_enter_exec)


/** state (send_first) exit executives **/
FSM_STATE_EXIT_FORCED (5, "send_first", "Pro4_proc [send_first exit execs]")




/** state (send_first) transition processing **/
FSM_TRANSIT_FORCE (2, state2_enter_exec, ;, "default", "", "send_first", "wait_for_ack", "tr_20", "Pro4_proc [send_first -> wait_for_ack : default / ]")
/*---------------------------------------------------------*/






}




FSM_EXIT (0,"Pro4_proc")
}
}








void
_op_Pro4_proc_diag (OP_SIM_CONTEXT_ARG_OPT)
{
/* No Diagnostic Block */
}








void
_op_Pro4_proc_terminate (OP_SIM_CONTEXT_ARG_OPT)
{


FIN_MT (_op_Pro4_proc_terminate ())




/* No Termination Block */


Vos_Poolmem_Dealloc (op_sv_ptr);


FOUT
}




/* Undefine shortcuts to state variables to avoid */
/* syntax error in direct access to fields of */
/* local variable prs_ptr in _op_Pro4_proc_svar function. */
#undef next_frame_to_send
#undef frame_expected
#undef pk_copy0
#undef Timer1
#undef send_flag
#undef Timer0
#undef pk_copy1
#undef node_name
#undef repeat_flag
#undef next_flag
#undef data_n
#undef pk_repeat


#undef FIN_PREAMBLE_DEC
#undef FIN_PREAMBLE_CODE


#define FIN_PREAMBLE_DEC
#define FIN_PREAMBLE_CODE


VosT_Obtype
_op_Pro4_proc_init (int * init_block_ptr)
{
VosT_Obtype obtype = OPC_NIL;
FIN_MT (_op_Pro4_proc_init (init_block_ptr))


obtype = Vos_Define_Object_Prstate ("proc state vars (Pro4_proc)",
sizeof (Pro4_proc_state));
*init_block_ptr = 0;


FRET (obtype)
}


VosT_Address
_op_Pro4_proc_alloc (VosT_Obtype obtype, int init_block)
{
#if !defined (VOSD_NO_FIN)
int _op_block_origin = 0;
#endif
Pro4_proc_state * ptr;
FIN_MT (_op_Pro4_proc_alloc (obtype))


ptr = (Pro4_proc_state *)Vos_Alloc_Object (obtype);
if (ptr != OPC_NIL)
{
ptr->_op_current_block = init_block;
#if defined (OPD_ALLOW_ODB)
ptr->_op_current_state = "Pro4_proc [init enter execs]";
#endif
}
FRET ((VosT_Address)ptr)
}






void
_op_Pro4_proc_svar (void * gen_ptr, const char * var_name, void ** var_p_ptr)
{
Pro4_proc_state *prs_ptr;


FIN_MT (_op_Pro4_proc_svar (gen_ptr, var_name, var_p_ptr))


if (var_name == OPC_NIL)
{
*var_p_ptr = (void *)OPC_NIL;
FOUT
}
prs_ptr = (Pro4_proc_state *)gen_ptr;


if (strcmp ("next_frame_to_send" , var_name) == 0)
{
*var_p_ptr = (void *) (&prs_ptr->next_frame_to_send);
FOUT
}
if (strcmp ("frame_expected" , var_name) == 0)
{
*var_p_ptr = (void *) (&prs_ptr->frame_expected);
FOUT
}
if (strcmp ("pk_copy0" , var_name) == 0)
{
*var_p_ptr = (void *) (&prs_ptr->pk_copy0);
FOUT
}
if (strcmp ("Timer1" , var_name) == 0)
{
*var_p_ptr = (void *) (&prs_ptr->Timer1);
FOUT
}
if (strcmp ("send_flag" , var_name) == 0)
{
*var_p_ptr = (void *) (&prs_ptr->send_flag);
FOUT
}
if (strcmp ("Timer0" , var_name) == 0)
{
*var_p_ptr = (void *) (&prs_ptr->Timer0);
FOUT
}
if (strcmp ("pk_copy1" , var_name) == 0)
{
*var_p_ptr = (void *) (&prs_ptr->pk_copy1);
FOUT
}
if (strcmp ("node_name" , var_name) == 0)
{
*var_p_ptr = (void *) (&prs_ptr->node_name);
FOUT
}
if (strcmp ("repeat_flag" , var_name) == 0)
{
*var_p_ptr = (void *) (&prs_ptr->repeat_flag);
FOUT
}
if (strcmp ("next_flag" , var_name) == 0)
{
*var_p_ptr = (void *) (&prs_ptr->next_flag);
FOUT
}
if (strcmp ("data_n" , var_name) == 0)
{
*var_p_ptr = (void *) (&prs_ptr->data_n);
FOUT
}
if (strcmp ("pk_repeat" , var_name) == 0)
{
*var_p_ptr = (void *) (&prs_ptr->pk_repeat);
FOUT
}
*var_p_ptr = (void *)OPC_NIL;


FOUT
}