aloha.c

使用c语言实现aloha算法的简单模拟

#include "face.c"

#include "stdio.h"
#include "stdlib.h"
#include "time.h"

#define p 0.5


char* createData();
void pureAloha();
char** package(char *);

int packageNum = 0;    /* 总包数 */
int backNum = 0;    /* 所有包实际重发的次数 */


int main()
{

    char *stream=NULL;
    char **pack;
    int n=0;
    int i=0;
    srand(time(NULL));/*rand seed*/

    initgr();
    map();
    getch();
    stream=createData();
    printf("%s\n",stream);
    pack = package(stream);

/*     n=(int)pack[0][0]; */

/*     printf("%d\n",n); */
/*
    for(i=1;i<=n;i++)
    {
        printf("pack[%d] >: %s\n",i,pack[i]);
    }

*/
/*     getch(); */
    pureAloha(pack);
    getch();
    return 0;
}
/*  模拟等待操作 */
void wait()
{
    int i=10000;
    back();
    delay(90000);
/*    printf(">:wait.......\n");

*/  while(i)
    {
        i--;
    }
    
}


/* 模拟发送操作 */
void send(char *str)
{
    /*
    printf("sucess send:%s\n",str); */
    succesSend();
    show(str);

/*    delay(90000);
*/
}
/*随即生成字节流,并将流的头指针返回*/
char* createData()
{
    int n=0;
    int i=0;
    float k;
    char *head;


    n=(rand()/32767.0)*256;

    head=(char *)malloc(sizeof(char)*n);
    if(head==NULL)
        return head;

    for(i = 0;i < n-1; i ++)
    {
        k = rand()/32767.0;
        if(k>0.5)
            head[i]='0';
        else
            head[i]='1';

    }

    head[n-1]='\0';

    return head;
}

/*打包生成的数据
*返回数据包数组的指针，其中头结点中存放数据包节点的个数
*并不包括头结点
**/
char ** package(char * head)
{
    int length;
    int n,i,j;
    float temp;
    const int packSize = 8;
    char *pa=NULL;
    int pHead=0;/*record the head context*/
    char ** packHead;



    length=strlen(head);
    n = length/packSize;/*number of package*/
    if(length%packSize!=0)
        n++;

    n++;/*空出头结点作为备注空间*/
    packHead = (char **)malloc( n * sizeof(char *) );
    for(i=1 ; i < n; i++)
    {
        pa = (char*)malloc((packSize+1)*sizeof(char));
        if(pa==NULL)
            exit(0);

        for(j=0;j<packSize;j++)
        {
            pa[j]=head[pHead];
            pHead++;
        }

        pa[j] = '\0';
        packHead[i]=pa;
    }

    pa =(char*)malloc(sizeof(char)*2);

    if(pa==NULL)
        exit(0);

    pa[0]=(char)(n-1);
    packHead[0]=pa;
/*    printf("%d\n",length);

*/
    return packHead;
}

/**
 *查看当前的频段使用情况
 *通过一个随机数去模拟实现
 *线路忙返回1，否则返回0
 */
int testChanel()
{
    
    float ranNum ;
    go();
    ranNum=(float)rand()/32767;
    if(ranNum > 1-p)
    {
        return 0;
    }
    busy();
    return 1;
}

/**
* 模拟aloha 协议发送
*/
void pureAloha(char** pack)
{
    int collision = 1; /* 初始化冲突标志 */
    int n =(int) pack[0][0];    /* 记录当前的帧数 */
    int i=0,j=1,k=0;
    while(j <= n)/* 依次发送本地数据 */
    {
        /*
        **每一帧的发送过程是一个循环
        */
        sendOne(pack[j]);
        while(1)
        {    /* 不断测试直到发送 */
            collision = testChanel();
            if(collision == 1)
            {
                /* busy */
                backNum++;
                wait();

            }
            else
            {
                send(pack[j]);/* 成功发送 */
                collision = 1;
                break;
            }
        }
        j++;
    }

}