一个不伦不类的基于vc6.0的CSMA的系统

在原有的p坚持上加入了冲突检测功能，并且设置了40个站点，向总线上发送报文，并且显示了前两个站点的数据

正在想办法上传代码

还是直接复制粘贴吧

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<time.h>
#include<iostream>
using namespace std;






int counter_success=0;
int counter_all=0;


int numm=13;


#define dela 5


typedef struct zhan
{
double la;


int busy;


double data;


int bao_true;


int time_delay;
int time_flow;

double p_chance;


}zhan;




typedef struct route
{
    int busy;


struct zhan *running_zhan;






}route;








/************************/
///各个站的初始化/
/************************/




/*****************************************************************/
/***************这里是对站的各个值进行改变的地方***********//


zhan*  init_zhandian1(zhan *a)
{
a->la=0.25;
a->busy=NULL;
a->time_delay=1;
a->p_chance=1;
return a;
}
zhan*  init_zhandian2(zhan *b)
{
b->la=0.25;
b->busy=NULL;
b->time_delay=1;
b->p_chance=1;
return b;
}








/**************************/
/********碰撞处理****/
/***************/


void crash_deal(zhan *a)
{
if(a->busy==1)
{
if(a->time_flow<a->time_delay)
a->time_flow=a->time_delay;
else 
{
a->time_delay=a->time_delay+dela;
a->time_flow=a->time_delay;
}
a->busy=0;
a->data++;
}


}
/**/
/*碰撞检测


*/
void crash_alljudge(zhan *a,
zhan *b,  zhan *b1 ,zhan *b2, zhan *b3, zhan *b4,
zhan *b5, zhan *b6 ,zhan *b7, zhan *b8, zhan *b9,
zhan *b10,zhan *b11,zhan *b12,zhan *b13,zhan *b14,
zhan *b15,zhan *b16,zhan *b17,zhan *b18,zhan *b19,
zhan *b20,
               zhan *b21, zhan *b22, zhan *b23, zhan *b24,
zhan *b25, zhan *b26, zhan *b27, zhan *b28, 
zhan *b29, zhan *b30, zhan *b31, zhan *b32,
zhan *b33, zhan *b34, zhan *b35, zhan *b36,
zhan *b37, zhan *b38, route *rou)


{int route_num=0;
route_num=a->busy+b->busy+b1->busy+b2->busy+b3->busy+b4->busy
   +b5->busy+b6->busy+b7->busy+b8->busy+b9->busy
   +b10->busy+b11->busy+b12->busy+b13->busy+b14->busy
        +b15->busy+b16->busy+b17->busy+b18->busy+b19->busy
   +b20->busy+b21->busy+b22->busy+b23->busy+b24->busy
   +b25->busy+b26->busy+b27->busy+b28->busy+b29->busy
   +b30->busy+b31->busy+b32->busy+b33->busy+b34->busy
        +b35->busy+b36->busy+b37->busy+b38->busy;
if(route_num>1)
{
crash_deal(a);
crash_deal(b);
crash_deal(b1);
crash_deal(b2);
crash_deal(b3);
crash_deal(b4);
crash_deal(b5);
crash_deal(b6);
crash_deal(b7);
crash_deal(b8);
crash_deal(b9);
crash_deal(b10);
crash_deal(b11);
crash_deal(b12);
crash_deal(b13);
crash_deal(b14);
crash_deal(b15);
crash_deal(b16);
crash_deal(b17);
crash_deal(b18);
crash_deal(b19);
crash_deal(b20);
crash_deal(b21);
crash_deal(b22);
crash_deal(b23);
crash_deal(b24);
crash_deal(b25);
crash_deal(b26);
crash_deal(b27);
crash_deal(b28);
crash_deal(b29);
crash_deal(b30);
crash_deal(b31);
crash_deal(b32);
crash_deal(b33);
crash_deal(b34);
crash_deal(b35);
crash_deal(b36);
crash_deal(b37);
crash_deal(b38);


rou->busy=0;
}


}


//碰撞检测2个
/*void crash_judge(zhan *a,zhan *b,route *rou)//入口是所有的站
{
if(a->busy&&b->busy==1)
{


printf("\ncrash happen\n");
crash_deal(a);
crash_deal(b);


/*if(a->time_flow<a->time_delay)
a->time_flow=a->time_delay;
else 
{
a->time_delay=a->time_delay*2;
a->time_flow=a->time_delay;
}
a->busy=0;
a->data++;*/


//进行了碰撞//还需要加入碰撞检测，冲突规避
/* rou->busy=0;


}
}


*/










/*


站的开始


*/


zhan* start_zhan(zhan *a)
{  
int length=rand()%10+1;//
double bigla;



bigla=a->la*100;
srand(time(NULL)*numm*numm*numm*numm);
a->bao_true=(rand()%100)>bigla?0:1;
numm++;






if(a->bao_true==1)
{
a->data=length;
} 
else
{
//这里是还需要在变
a->data=-length;
}
return a;


}


/*********************/
/*信道初始化
*/
void init_zhan(zhan *a,route *rou)
{ if(a->bao_true==1)
{
if(a->p_chance*100>rand()%100)
{
rou->busy=1;
a->busy=1;
rou->running_zhan=a;
}
else
{
a->time_delay=a->time_delay+dela;
a->time_flow=a->time_delay;
}
}}


void init_route(zhan *a,
zhan  *b, zhan *b1 ,zhan *b2, zhan *b3, zhan *b4,
zhan *b5, zhan *b6 ,zhan *b7, zhan *b8, zhan *b9,
zhan *b10,zhan *b11,zhan *b12,zhan *b13,zhan *b14,
zhan *b15,zhan *b16,zhan *b17,zhan *b18,zhan *b19,
zhan *b20,
               zhan *b21, zhan *b22, zhan *b23, zhan *b24,
zhan *b25, zhan *b26, zhan *b27, zhan *b28, 
zhan *b29, zhan *b30, zhan *b31, zhan *b32,
zhan *b33, zhan *b34, zhan *b35, zhan *b36,
zhan *b37, zhan *b38, route *rou)
{


    init_zhan(a,rou);
    init_zhan(b,rou);
init_zhan(b1,rou);
init_zhan(b2,rou);
init_zhan(b3,rou);
init_zhan(b4,rou);
init_zhan(b5,rou);
init_zhan(b6,rou);
init_zhan(b7,rou);
init_zhan(b8,rou);
init_zhan(b9,rou);
init_zhan(b10,rou);
init_zhan(b11,rou);
init_zhan(b12,rou);
init_zhan(b13,rou);
init_zhan(b14,rou);
init_zhan(b15,rou);
init_zhan(b16,rou);
init_zhan(b17,rou);
init_zhan(b18,rou);
init_zhan(b19,rou);
init_zhan(b20,rou);
init_zhan(b21,rou);
init_zhan(b22,rou);
init_zhan(b23,rou);
init_zhan(b24,rou);
init_zhan(b25,rou);
init_zhan(b26,rou);
init_zhan(b27,rou);
init_zhan(b28,rou);
init_zhan(b29,rou);
init_zhan(b30,rou);
init_zhan(b31,rou);
init_zhan(b32,rou);
init_zhan(b33,rou);
init_zhan(b34,rou);
init_zhan(b35,rou);
init_zhan(b36,rou);
init_zhan(b37,rou);
init_zhan(b38,rou);


    
crash_alljudge(a,b,
b1,b2,b3,b4,b5,
b6,b7,b8,b9,b10,
b11,b12,b13,b14,b15,
b16,b17,b18,b19,b20,
b21,b22,b23,b24,b25,
b26,b27,b28,b29,b30,
b31,b32,b33,b34,b35,
b36,b37,b38,rou);
}




///*********/
//插入尝试
/********/
void insert_route_try(zhan *a,route *rou)
{ 
if(a->p_chance*100>rand()%100)///插入成功
{
rou->busy=1;
a->busy=1;
rou->running_zhan=a;
}
else //若低于p概率，插入失败
{
a->time_delay=a->time_delay+dela;
srand(time(NULL));
a->time_flow=(rand()%(a->time_delay));
}
}






/*********************/
/*分部使时间流动*/
/**********************/


void time_branch_shift(zhan *a,route *rou)
{
if(a->busy==0)
{
if(a->bao_true==1)
{
a->time_flow--;
if(a->time_flow<=0)
{
if(rou->busy==1)///如果信道忙
{
a->time_delay=a->time_delay+dela;
a->time_flow=a->time_delay;
}
else insert_route_try(a,rou);//如果信道是空闲状态，则进行插入尝试
}
}
else//如果这个包就是一个假的报文，即现在正处于间隔状态
{
a->data++;
if(a->data==0)
{
a=start_zhan(a);
a->time_delay=2;
a->time_flow=0;
}
}
}
}


/***************************/
/*********总线时间流动****/
/************************/
void time_center_shift(zhan *a,
zhan *b, zhan *b1 ,zhan *b2, zhan *b3, zhan *b4,
zhan *b5, zhan *b6 ,zhan *b7, zhan *b8, zhan *b9,
zhan *b10,zhan *b11,zhan *b12,zhan *b13,zhan *b14,
zhan *b15,zhan *b16,zhan *b17,zhan *b18,zhan *b19,
zhan *b20,
               zhan *b21, zhan *b22, zhan *b23, zhan *b24,
zhan *b25, zhan *b26, zhan *b27, zhan *b28, 
zhan *b29, zhan *b30, zhan *b31, zhan *b32,
zhan *b33, zhan *b34, zhan *b35, zhan *b36,
zhan *b37, zhan *b38, route *rou)
{
if(rou->busy==1)
{
if(rou->running_zhan->data!=0)
{
rou->running_zhan->data--;
counter_success++;


}
else //(rou->running_zhan->data==0)
{
rou->busy=0;
rou->running_zhan->busy=0;
   rou->running_zhan=start_zhan(rou->running_zhan);
rou->running_zhan->time_delay=2;
}
}




/*if(a.busy==1)
{
a.data--;
if()
}
else 
{*/


time_branch_shift(a,rou);
//}

time_branch_shift(b,rou);
time_branch_shift(b1,rou);
time_branch_shift(b2,rou);
time_branch_shift(b3,rou);
time_branch_shift(b4,rou);
time_branch_shift(b5,rou);
time_branch_shift(b6,rou);
time_branch_shift(b7,rou);
time_branch_shift(b8,rou);
time_branch_shift(b9,rou);
time_branch_shift(b10,rou);
time_branch_shift(b11,rou);
time_branch_shift(b12,rou);
time_branch_shift(b13,rou);
time_branch_shift(b14,rou);
time_branch_shift(b15,rou);
time_branch_shift(b16,rou);
time_branch_shift(b17,rou);
time_branch_shift(b18,rou);
time_branch_shift(b19,rou);
time_branch_shift(b20,rou);
time_branch_shift(b21,rou);
time_branch_shift(b22,rou);
time_branch_shift(b23,rou);
time_branch_shift(b24,rou);
time_branch_shift(b25,rou);
time_branch_shift(b26,rou);
time_branch_shift(b27,rou);
time_branch_shift(b28,rou);
time_branch_shift(b29,rou);
time_branch_shift(b30,rou);
time_branch_shift(b31,rou);
time_branch_shift(b32,rou);
time_branch_shift(b33,rou);
time_branch_shift(b34,rou);
time_branch_shift(b35,rou);
time_branch_shift(b36,rou);
time_branch_shift(b37,rou);
time_branch_shift(b38,rou);


crash_alljudge(a,b,
b1,b2,b3,b4,b5,
b6,b7,b8,b9,b10,
b11,b12,b13,b14,b15,
b16,b17,b18,b19,b20,
b21,b22,b23,b24,b25,
b26,b27,b28,b29,b30,
b31,b32,b33,b34,b35,
b36,b37,b38
,rou);


}




/**********************/
/***信道的可视化****/
/*****************/
void  route_watching()
{}




void show_zhan(zhan *a)
{
printf("%f\t%d\t%d\t%f\t",a->data,a->time_flow,a->time_delay,a->busy);
}












/***********************/
/******信道的数据统计***/
/***********************/
void route_count()
{}




















/*********/
/*信道运行*/
///


void run_route(zhan *a,
zhan  *b, zhan *b1 ,zhan *b2, zhan *b3, zhan *b4,
zhan *b5, zhan *b6 ,zhan *b7, zhan *b8, zhan *b9,
zhan *b10,zhan *b11,zhan *b12,zhan *b13,zhan *b14,
zhan *b15,zhan *b16,zhan *b17,zhan *b18,zhan *b19,
zhan *b20,
               zhan *b21, zhan *b22, zhan *b23, zhan *b24,
zhan *b25, zhan *b26, zhan *b27, zhan *b28, 
zhan *b29, zhan *b30, zhan *b31, zhan *b32,
zhan *b33, zhan *b34, zhan *b35, zhan *b36,
zhan *b37, zhan *b38, route *rou)
{
int i,j;

i=(time(NULL));
printf("a.data\ta.time_flow\ta.busy\ta.data\ta.time_flow\ta.busy\n");
while(1)
{j=50;
if(time(NULL)-i>0)
{
for(;j>0;j--)
{time_center_shift(a,b,
b1,b2,b3,b4,b5,
b6,b7,b8,b9,b10,
b11,b12,b13,b14,b15,
b16,b17,b18,b19,b20,
b21,b22,b23,b24,b25,
b26,b27,b28,b29,b30,
b31,b32,b33,b34,b35,
b36,b37,b38
,rou);




counter_all++;
       show_zhan(a);
show_zhan(b);






printf("\t%d\t%d\t",counter_success,counter_all);


printf("\n");
i=(time(NULL));
}

}
}




}








void main()
{


zhan *a,*b,
*b1,*b2,*b3,*b4,*b5,
*b6,*b7,*b8,*b9,*b10,
*b11,*b12,*b13,*b14,*b15,
*b16,*b17,*b18,*b19,*b20,
*b21,*b22,*b23,*b24,*b25,
*b26,*b27,*b28,*b29,*b30,
*b31,*b32,*b33,*b34,*b35,
*b36,*b37,*b38;
route *rou;
a=(zhan*)malloc(sizeof(zhan));
    b=(zhan*)malloc(sizeof(zhan));
b1=(zhan*)malloc(sizeof(zhan));
b2=(zhan*)malloc(sizeof(zhan));
b3=(zhan*)malloc(sizeof(zhan));
b4=(zhan*)malloc(sizeof(zhan));
b5=(zhan*)malloc(sizeof(zhan));
b6=(zhan*)malloc(sizeof(zhan));
b7=(zhan*)malloc(sizeof(zhan));
b8=(zhan*)malloc(sizeof(zhan));
b9=(zhan*)malloc(sizeof(zhan));
b10=(zhan*)malloc(sizeof(zhan));
b11=(zhan*)malloc(sizeof(zhan));
b12=(zhan*)malloc(sizeof(zhan));
b13=(zhan*)malloc(sizeof(zhan));
b14=(zhan*)malloc(sizeof(zhan));
b15=(zhan*)malloc(sizeof(zhan));
b16=(zhan*)malloc(sizeof(zhan));
b17=(zhan*)malloc(sizeof(zhan));
b18=(zhan*)malloc(sizeof(zhan));
b19=(zhan*)malloc(sizeof(zhan));
b20=(zhan*)malloc(sizeof(zhan));

b21=(zhan*)malloc(sizeof(zhan));
b22=(zhan*)malloc(sizeof(zhan));
b23=(zhan*)malloc(sizeof(zhan));
b24=(zhan*)malloc(sizeof(zhan));
b25=(zhan*)malloc(sizeof(zhan));
b26=(zhan*)malloc(sizeof(zhan));
b27=(zhan*)malloc(sizeof(zhan));
b28=(zhan*)malloc(sizeof(zhan));
b29=(zhan*)malloc(sizeof(zhan));
b30=(zhan*)malloc(sizeof(zhan));
b31=(zhan*)malloc(sizeof(zhan));
b32=(zhan*)malloc(sizeof(zhan));
b33=(zhan*)malloc(sizeof(zhan));
b34=(zhan*)malloc(sizeof(zhan));
b35=(zhan*)malloc(sizeof(zhan));
b36=(zhan*)malloc(sizeof(zhan));
b37=(zhan*)malloc(sizeof(zhan));
b38=(zhan*)malloc(sizeof(zhan));


rou=(route*)malloc(sizeof(route));










a=init_zhandian1(a);
    b=init_zhandian2(b);
    b1=init_zhandian2(b1);
b2=init_zhandian2(b2);
b3=init_zhandian2(b3);
b4=init_zhandian2(b4);
b5=init_zhandian2(b5);
b6=init_zhandian2(b6);
b7=init_zhandian2(b7);
b8=init_zhandian2(b8);
b9=init_zhandian2(b9);
b10=init_zhandian2(b10);
b11=init_zhandian2(b11);
b12=init_zhandian2(b12);
b13=init_zhandian2(b13);
b14=init_zhandian2(b14);
b15=init_zhandian2(b15);
b16=init_zhandian2(b16);
b17=init_zhandian2(b17);
b18=init_zhandian2(b18);
b19=init_zhandian2(b19);
b20=init_zhandian2(b20);
    b21=init_zhandian2(b21);
b22=init_zhandian2(b22);
b23=init_zhandian2(b23);
b24=init_zhandian2(b24);
b25=init_zhandian2(b25);
b26=init_zhandian2(b26);
b27=init_zhandian2(b27);
b28=init_zhandian2(b28);
b29=init_zhandian2(b29);
b30=init_zhandian2(b30);
b31=init_zhandian2(b31);
b32=init_zhandian2(b32);
b33=init_zhandian2(b33);
b34=init_zhandian2(b34);
b35=init_zhandian2(b35);
b36=init_zhandian2(b36);
b37=init_zhandian2(b37);
b38=init_zhandian2(b38);






a=start_zhan(a);
b=start_zhan(b);
b1=start_zhan(b1);
b2=start_zhan(b2);
b3=start_zhan(b3);
b4=start_zhan(b4);
b5=start_zhan(b5);
b6=start_zhan(b6);
b7=start_zhan(b7);
b8=start_zhan(b8);
b9=start_zhan(b9);
b10=start_zhan(b10);
b11=start_zhan(b11);
b12=start_zhan(b12);
b13=start_zhan(b13);
b14=start_zhan(b14);
b15=start_zhan(b15);
b16=start_zhan(b16);
b17=start_zhan(b17);
b18=start_zhan(b18);
b19=start_zhan(b19);
b20=start_zhan(b20);
b21=start_zhan(b21);
b22=start_zhan(b22);
b23=start_zhan(b23);
b24=start_zhan(b24);
b25=start_zhan(b25);
b26=start_zhan(b26);
b27=start_zhan(b27);
b28=start_zhan(b28);
b29=start_zhan(b29);
b30=start_zhan(b30);
b31=start_zhan(b31);
b32=start_zhan(b32);
b33=start_zhan(b33);
b34=start_zhan(b34);
b35=start_zhan(b35);
b36=start_zhan(b36);
b37=start_zhan(b37);
b38=start_zhan(b38);











init_route(a,b,
b1,b2,b3,b4,b5,b6,
b7,b8,b9,b10,b11,b12,
b13,b14,b15,b16,b17,b18,
b19,b20,b21,b22,b23,b24,
b25,b26,b27,b28,b29,b30,
b31,b32,b33,b34,b35,b36,
b37,b38,rou);

run_route(a,b,
b1,b2,b3,b4,b5,
b6,b7,b8,b9,b10,
b11,b12,b13,b14,b15,
b16,b17,b18,b19,b20,
b21,b22,b23,b24,b25,
b26,b27,b28,b29,b30,
b31,b32,b33,b34,b35,
b36,b37,b38,rou);








}