channel.h

Go to the documentation of this file.

/* CHANNEL.H */

#ifndef _CHANNEL_H_
#define _CHANNEL_H_

#include "bytes.h"
#include "Buffer.h"


typedef enum { NoErrors, Random, File } errortype;


#define MAX_FILENAME_LENGTH 256
#define DEF_PACKET_SIZE 136
#define DEF_CHANNEL_SPEED 30000
#define DEF_CHANNEL_DELAY 100
#define DEF_CHANNEL_ERROR NoErrors
#define DEF_CHANNEL_BER 2.1e-2
#define DEF_CHANNEL_FILE "./dect1.asc"

typedef struct {
  char label[256];             /* something like "Forward" or "Backward" */
  errortype error;
  char filename[MAX_FILENAME_LENGTH];  /* only if errortype=FILE */
  FILE *error_file;                    /* only if errortype=FILE */
  int file_open;                       /* only if errortype=FILE 1 if efile open*/
  float bit_error_rate;                /* only if errortype=RANDOM */
  Buffer *pdus;               /* type=channel_pdu.
                               * A list of the PDU's in the channel. 
                               */
  
  int transmission_speed;     /* in bits per second */
  int transmission_delay;     /* in milliseconds */

  long int bit_count;              /* number of bits xmitted over channel */
  long int error_count;            /* number of errors applied over channel */

  long int write_count;

  long int read_count; 

  int error_offset;           /* bits delay before channel applies errors */
} channel;

void apply_errors(byte *data, channel *chan);
/*
 * This function will apply errors to the byte of data provided
 *   based on the channel error characteristics (none, random, file)
 */

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 channel_write(channel *one, byte m);
/*
 * Called by MUX to write bytes to the channel.
 *
 * Returns 1 if successful, 0 if unsuccessful
 */

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
 */

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

channel *new_channel(char *name);
/*
 * This function is called to make a new channel with label name
 */

void close_channel(channel *c);
/*
 * This function prints out the statistics for the channel
 *   when the program is finished
 */
#endif

---