channel.c

Go to the documentation of this file.

#include "standard.h"
#include "channel.h"
#include "clock.h"
#include "input.h"

#define MAX_RAND 2147483647

/*
 * Define "forward channel" through which data logically flows from the local 
 * side to the remote side.
 *
 * Define "reverse channel" through which data logically flows from the 
 * remote side to the local side.
 */

extern int debug;

#define BUFSIZE 65536


void apply_errors(byte *data, channel *chan)
{
  int i, j, count=0, num_bits;
  float r;
  float ber;
  byte b=*data;

  chan->bit_count += 8;

  if (chan->error==NoErrors)
    return;

  if (chan->error == Random) {
    if (chan->bit_error_rate == 0.0)
      return;

    if ((chan->bit_count/8) >= chan->error_offset) {
      for (j=0; j<8; j++) {
        r = (float) random() / MAX_RAND;
        if (r < chan->bit_error_rate) {
          b ^= (1 << j);
          count++;
          chan->error_count++;
          if (debug >= 2)
            printf("apply_errors() r=%e, bit %d flipped. \n", r, j);
        }
      }
    }
    else
      if (debug>=4) printf("apply_errors() - not applying errors yet\n");
  }

  else if (chan->error == File) { 
    if (chan->filename==NULL) {
      warn("apply_errors","channel's error file name is NULL");
      return;
    }
    if ((chan->bit_count/8) > chan->error_offset) {
      if (!chan->file_open) {
        chan->error_file = fopen(chan->filename,"r");
        if (chan->error_file == NULL) {
          error("apply_errors","Can't open error file");
        }
        chan->file_open = 1;
      }

      for (j=0; j<8; j++) {
        if (feof(chan->error_file))
          fseek(chan->error_file, 0, 0);
        if (fgetc(chan->error_file)=='1') {
          b ^= (1 << j);
          count++;
          chan->error_count++;
          if (debug >= 4)
            printf("apply_errors() bit %d flipped\n", j);
        }
      }
    }
    else
      if (debug>=4) printf("apply_errors() - not applying errors yet\n");
  } 
  if (debug >= 4) {
    printf("apply_errors() [%s] Applied %d errors to byte\n", 
           chan->label, count);
  }
  if (debug >= 1) {
    printf("apply_errors() [%s] Errors %d / %d bits (BER %e)\n",
           chan->label,
           chan->error_count, chan->bit_count, 
           (float) chan->error_count / chan->bit_count);
  }


  /* copy modified byte back to *data.  cheezy way of doing this. */

  *data = b;

  /*
   * Figure out the BER for this packet and log it.  
   */


  /* ber = (float) count / (float) num_bits;
  log_ber(ber, 0); */

  return;
}


int channel_write_indication(channel *one)
/*
 * Called by MUX to see if it can write to the channel
 * Returns 0 if not ready to write, nonzero if ready to write
 *
 * The idea is to compare the actual amount of data written to
 * the amount of data that we are "allowed" to have written at
 * this point, based on the elapsed time and the transmission 
 * speed.
 */
{
  /* int level = (one->transmission_speed * one->transmission_delay) / 8000; */
  long int allowed = (one->transmission_speed * get_clock()) / 8000; 
  
  return (one->write_count < allowed);
}


int channel_write(channel *one, byte m)
/*
 * Called by MUX to write bytes to the channel.
 * 
 * Returns 1 if successful, 0 if unsuccessful
 */
{
  bwrite(one->pdus, &m);
  one->write_count++;
}


int channel_read_indication(channel *one)
/*
 * Called by DEMUX to see if it can read a byte.
 * This is the complicated one.
 *
 * first, check to see if there is any data in the incoming buffer
 * second, check to see if the number of bytes that we have already read
 * is less than the amount we are "allowed" to have read at this point,
 * based on elapsed time, transmission delay, and transmission speed
 */
{
/*  long int pos = ((get_clock() * one->transmission_speed) / 8000) - one->transmission_delay; */
  long int allowed = ((get_clock() - one->transmission_delay) * one->transmission_speed) / 8000;

  if (blevel(one->pdus) > 0)
        return (one->read_count < allowed);
  else 
        return 0;
}


byte channel_read(channel *one)
/*
 * Called by DEMUX to read a byte from the channel.  
 */
{
  static byte b;

  bread(one->pdus, &b);

  apply_errors(&b, one);

  one->read_count++;

  return(b);
}


channel *new_channel(char *name)
{
  char s[256];
  int x;

  channel *one = malloc(sizeof(channel));
  if (one != NULL) {
    strcpy(one->label, name);
    one->transmission_speed = DEF_CHANNEL_SPEED;
    one->transmission_delay = DEF_CHANNEL_DELAY;
    one->error = DEF_CHANNEL_ERROR;
    one->bit_error_rate = DEF_CHANNEL_BER;
    strcpy(one->filename, DEF_CHANNEL_FILE);
    one->pdus = mkbuffer(BUFSIZE, sizeof(byte));
    one->error_count = 0;
    one->bit_count = 0;
    one->write_count=0;
    one->read_count=0;
    one->error_offset=0;
    one->file_open=0;
    one->error_file=NULL;
  }
  else
    error("new_channel","Can't malloc new channel");
  return (one);
}

void close_channel(channel *c)
{
  if (debug) {
    fprintf(stdout,"Channel %s:\n",c->label);
    fprintf(stdout,"Number of errors: %d\nNumber of bits:   %d\n",c->error_count,
            c->bit_count);
    fprintf(stdout,"BER:              %f\n", (float) c->error_count/c->bit_count);
  }
  if (c->error_file!=NULL)
    fclose(c->error_file);
  closebuffer(c->pdus);
  free(c);
}

---