tcc_binary_unix.c

This CD-ROM is distributed by Kluwer Academic Publishers with ABSOLUTELY NO SUPPORT and NO WARRANTY

/* Turbo code Test Driver: log_map, random interleaver */
/* Creation date : Jan.3 2001     */
/* Program written by: Gao yingzi */


/* This program simulates the classical turbo encoding-decoding system */

/* It uses parallel concatenated convolutional codes described in Figure 2.9 in Chapter 2. */
/* Two component RSC (Recursive Systematic Convolutional) encoders are used.               */
/* First encoder is terminated with tails bits. (Info + tail) bits are scrambled and       */
/* passed to the second encoder, while second encoder is left open without tail bits.      */

/* Random information bits are modulated into +1/-1, and transmitted through an AWGN channel. */
/* Interleavers are randomly generated for each frame. */

/* Log-MAP algorithm without quantization or approximation is used. */
/* By making use of ln(e^x+e^y) = max (x,y) + ln(1+e^(-abs(x-y))),  */
/* the Log-MAP is simplified with a look-up table for the correction term. */
/* When the approximation ln(e^x+e^y) = max (x,y) is, we have MAX-Log-MAP. */

/* To set the number of iterations, change the globle variable "DECITER". To set the frame length,   */
/* the globle variable "FRAMESIZE" should be changed. To simulate a different range of Eb/N0, change */
/* the globle variable LOEBNO and HIEBNO, as well as the step size of Eb/No increment. */



#include <malloc.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>


#define K 3              /* constraint length */
#define NUMSTATES 4      /* 2^(K - 1) -- change as required */

#define PUNCTURE 1       /* rate increase from 1/3 to 1/2 if puncture=0 */

#define INF 1000000      /* set infinity to an arbitrarily large value */
 
#define PI 3.141592654   /* circumference of circle divided by diameter */

#define FRAMESIZE 900    /* how many bits in each test message */
#define DECITER 6        /* decoding iteration numbers */ 

#define LOEBN0 0.0       /* minimum Eb/No at which to test */
#define HIEBN0 3.0       /* maximum Eb/No at which to test */
#define EBN0STEP 0.5     /* Eb/No increment for test driver */


//#define DEBUG            /* test the outputs of the trellis function */

void gen01dat(int data_len, int *out_array);
void turbo_encd(int g[2][K], int alpha[FRAMESIZE], int *in_array, int puncture, int *turbo_en_out);
void addnoise(float eb_ovr_n0, int data_len, int *in_array, float *out_array);
void de_multiplex(int alpha[FRAMESIZE], int puncture, float *in_array,
			 float *decd1_in_array, float *decd2_in_array);
void logmap(int g[2][K], int len_total, int num_decd, float *rec_s, float *L_a, float *L_u);

main() 
{
  int i, j, a, iter, t, start;                /* loop variables */
  int len_total, msg_length, channel_length;  /* length of I/O files */
  int puncture, num_decd;
  int alpha[FRAMESIZE] = {0};      /* random interleaver matric */

  int *onezer;
  int *encoded;                    /* original, encoded array */
  float *splusn;                   /* noisy data array */
  float *rec_s1;
  float *rec_s2;
  float *L_a;
  float *L_e_1;
  float *L_e_2;
  float *L_u;
  float *L_all;
  int *turbout;

  FILE *fp;

  int m, dec_iter;                 /* m = K - 1,turbo decoding iteration */
  float eb_ovr_n0,rate,L_c,bit_errors,temp_bit_errors,frame_errors,e_threshold,e_ber,f_ber; /* various statistics */

  int g[2][K] = {{1, 1, 1},     /* 7 */
                   {1, 0, 1}};    /* 5 */

  fp = fopen("TCC_Binary_UNIX_data","wa+");
  if ((fp = fopen("TCC_Binary_UNIX_data","wa+"))==NULL){
    printf("cannot open file\n");
    exit (0);
  }

  printf("\ng1 = %d%d%d", g[0][0], g[0][1], g[0][2] );
  printf("\ng2 = %d%d%d\n", g[1][0], g[1][1], g[1][2] );
  fprintf(fp,"\ng1 = %d%d%d", g[0][0], g[0][1], g[0][2] );
  fprintf(fp,"\ng2 = %d%d%d\n", g[1][0], g[1][1], g[1][2] );

  puncture = PUNCTURE;
  rate = (float) 1.0/(2.0 + PUNCTURE);
  a = 1;
  m = K - 1;
  msg_length = FRAMESIZE - m;
  len_total = FRAMESIZE;

  for (i=0; i<len_total; i++){
    alpha[i] = rand() % len_total;
    if (i>0) {
      for (j=0; j<i; j++)
	if(alpha[i] == alpha[j]) i = i-1;
    }
  }

  printf("\nK = %d  puncture = %d  message length = %d\n", K, puncture, msg_length);
  fprintf(fp,"\nK = %d  puncture = %d  message length = %d\n", K, puncture, msg_length);

  if (puncture > 0) channel_length = ( msg_length + m ) * 3;
  else channel_length = ( msg_length + m ) * 2;

  onezer = malloc( msg_length * sizeof( int ) );
  if (onezer == NULL) {
     printf("\n TCC_Binary_UNIX.c:  error allocating onezer array, aborting!");
        exit(1);
  }

  encoded = malloc( channel_length * sizeof(int) );
  if (encoded == NULL) {
     printf("\n TCC_Binary_UNIX.c:  error allocating encoded array, aborting!");
     exit(1);
  }

  splusn = malloc( channel_length * sizeof(float) );
  if (splusn == NULL) {
      printf("\n TCC_Binary_UNIX.c:  error allocating splusn array, aborting!");
      exit(1);
  }

  rec_s1 = malloc( channel_length * sizeof( float ) );
  if (rec_s1 == NULL) {
      printf("\n TCC_Binary_UNIX.c:  error allocating received symbol 1 array, aborting!");
      exit(1);
  }
  rec_s2 = malloc( channel_length * sizeof( float ) );
  if (rec_s2 == NULL) {
      printf("\n TCC_Binary_UNIX.c:  error allocating received symbol 2 array, aborting!");
      exit(1);
  }

  L_a = malloc( len_total * sizeof( float ) );
  if (L_a == NULL) {
      printf("\n TCC_Binary_UNIX.c:  error allocating L_a array, aborting!");
      exit(1);
  }

  L_e_1 = malloc( len_total * sizeof( float ) );
  if (L_e_1 == NULL) {
      printf("\n TCC_Binary_UNIX.c:  error allocating L_e_1 array, aborting!");
      exit(1);
  }

  L_e_2 = malloc( len_total * sizeof( float ) );
  if (L_e_2 == NULL) {
      printf("\n TCC_Binary_UNIX.c:  error allocating L_e_2 array, aborting!");
      exit(1);
  }

  L_u = malloc( len_total * sizeof( float ) );
  if (L_u == NULL) {
      printf("\n TCC_Binary_UNIX.c:  error allocating L_u array, aborting!");
      exit(1);
  }

  L_all = malloc( len_total * sizeof( float ) );
  if (L_all == NULL) {
      printf("\n TCC_Binary_UNIX.c:  error allocating L_all array, aborting!");
      exit(1);
  }

  turbout = malloc( msg_length * sizeof( int ) );
  if (turbout == NULL) {
      printf("\n TCC_Binary_UNIX.c:  error allocating turbo decoding out array, aborting!");
      exit(1);
  }

  for (eb_ovr_n0 = LOEBN0; eb_ovr_n0 <= HIEBN0; eb_ovr_n0 += EBN0STEP) {

    start = time(NULL);

    L_c = 4 * a * rate * pow(10,eb_ovr_n0/10); 
 
    printf("\nreliability = %f",L_c);
    fprintf(fp,"\nStart:Reliability = %f",L_c);

    printf("   channel length = %d", channel_length);
    fprintf(fp,"   channel length = %d", channel_length);

    bit_errors = 0.0;
    frame_errors = 0.0;
    e_ber = 0.0;
    f_ber = 0.0;
    iter = 0;

    if (eb_ovr_n0 <= 3.5) e_threshold = 100; /* +/- 20% */
    else e_threshold = 20;                   /* +/- 100 % */

    while (bit_errors < e_threshold) {
       iter += 1;

       gen01dat(msg_length, onezer);

       turbo_encd(g, alpha, onezer, puncture, encoded);

       addnoise(eb_ovr_n0, channel_length, encoded, splusn);

       de_multiplex(alpha, puncture, splusn, rec_s1, rec_s2);

       for (i=0; i<2*len_total; i++){
 	 *(rec_s1+i) = 0.5*L_c**(rec_s1+i);
	 *(rec_s2+i) = 0.5*L_c**(rec_s2+i);
       }   

       for (i=0; i<len_total; i++){
         *(L_a+i) = 0;
         *(L_e_1+i) = 0;
         *(L_e_2+i) = 0;
         *(L_u+i) = 0;
       }

       for (dec_iter = 0; dec_iter < DECITER; dec_iter++){
	 for (i=0; i<len_total; i++)
	   *(L_a + alpha[i]) = *(L_e_1 + i);
	
	 num_decd = 1;              /* Decoder one */ 
	 logmap(g, len_total, num_decd, rec_s1, L_a, L_u); 

	 num_decd = 2;              /* Decoder two */ 
         for (i=0; i<len_total; i++) 
           *(L_e_2+i) = *(L_u+i) - 2**(rec_s1+2*i) - *(L_a+i);

	 for (i=0; i<len_total; i++)
	   *(L_a + i) = *(L_e_2 + alpha[i]);

	 logmap(g, len_total, num_decd, rec_s2, L_a, L_u); 
         
         for (i=0; i<len_total; i++){ 
           *(L_e_1+i) = *(L_u+i) - 2**(rec_s2+2*i) - *(L_a+i);
	 }
       }

       for (i=0; i<len_total; i++)
	 *(L_all + alpha[i]) = *(L_u + i);

       for (j=0; j<msg_length; j++){
	 if (*(L_all+j)>0.0) *(turbout+j) = 1;
	 else *(turbout+j) = 0;
       }

       temp_bit_errors = bit_errors;   
       for (t = 0; t < msg_length; t++) {
          if ( *(onezer + t) != *(turbout + t) ) {
             bit_errors = bit_errors + 1;
          } /* end if */
       } /* end t for-loop */
       if ((bit_errors - temp_bit_errors) > 0) frame_errors = frame_errors + 1;
    }

    e_ber = bit_errors / (msg_length * iter);
    f_ber = frame_errors / iter;
    printf("\nframe errors=%f",frame_errors);

    printf("\nThe elapsed time was %d seconds for %d frames:  dec_iter=%d",
                   time(NULL) - start, iter, dec_iter);
    fprintf(fp,"\nThe elapsed time was %d seconds for %d frames:  dec_iter%d",
                   time(NULL) - start, iter, dec_iter);

    printf("\nAt %1.1fdB Eb/No, ", eb_ovr_n0);
    fprintf(fp,"\nAt %1.1fdB Eb/No, ", eb_ovr_n0);

    printf("the e_ber was %1.1e the f_ber was %1.1e \n ", e_ber, f_ber);
    fprintf(fp,"the e_ber was %1.1e the f_ber was %1.1e\n ", e_ber, f_ber);
  } /* end of eb_ovr_n0 loop */

  fclose (fp);

  free(onezer);
  free(encoded);
  free(splusn);
  free(rec_s1);
  free(rec_s2);
  free(L_a);
  free(L_e_1);
  free(L_e_2);
  free(L_u);
  free(L_all);
  free(turbout);

  exit(0);
}

/*******************/
/* 0/1 Generation  */
/*******************/
void gen01dat( int data_len, int *out_array ) 
{
  int t;                          /* time */

  rand();                         /* re-seed the random number generator */

  for (t = 0; t < data_len; t++)  /* generate random data, write to output array */
    *( out_array + t ) = (int)( rand() / (RAND_MAX / 2) > 0.5 );
}

/***************************/
/* PCCC Turbo code encoder */
/***************************/
void rsc_encd(int g[2][K], int input_len, int R, int *in_array, int *out_array_0, int *out_array);

void turbo_encd( int g[2][K], int alpha[FRAMESIZE], int *in_array, int puncture, int *turbo_en_out)
{
  int i,j,t,tt;                         /* loop variables */
  int R;                                /* RSC encoder number */
  int yy[3][FRAMESIZE],y[3*FRAMESIZE];  /* make a matrix to store the output */
  int *output0,*output1,*output2;
  int *rsc2_in_array,*info_array,*unuse;
  int m,input_len,len_total;

  m = K-1;
  len_total = FRAMESIZE;
  input_len = len_total-m;

  info_array = malloc((input_len)*sizeof(int));
  if (info_array == NULL) {
     printf("\n turbo_encd:  error allocating info array, aborting!");
     exit(1);
    }
  output0 = malloc((len_total)*sizeof(int));
  if (output0 == NULL) {
     printf("\n turbo_encd:  error allocating tail_RSC1 output array, aborting!");
     exit(1);
  }
  output1 = malloc((len_total)*sizeof(int));
  if (output1 == NULL) {
     printf("\n turbo_encd:  error allocating RSC1 output array, aborting!");
     exit(1);
  }
  rsc2_in_array = malloc((len_total)*sizeof(int));
  if (rsc2_in_array == NULL) {
     printf("\n turbo_encd:  error allocating RSC2 input array, aborting!");
     exit(1);
  }
  unuse = malloc((len_total+m)*sizeof(int));
  if (unuse == NULL) {
     printf("\n turbo_encd:  error allocating RSC2 useless output array, aborting!");
     exit(1);
  }
  output2 = malloc((len_total+m)*sizeof(int));
  if (output2 == NULL) {
     printf("\n turbo_encd:  error allocating RSC2 output array, aborting!");
     exit(1);
  }

  for (i=0; i<input_len; i++)
    *(info_array + i) = *(in_array + i);
  R = 1;
  rsc_encd(g, input_len, R, info_array, output0, output1);

  /* make a matrix with first row corresponding to info sequence */
  /* second row corresponding to RSC #1 s check/parity bits */
  /* third row corresponding to RSC #2 s check/parity bits */

  for (i=0; i<len_total; i++){
    yy[0][i] = *(output0 + i);
    yy[1][i] = *(output1 + i);
  }

  for (i=0; i<len_total; i++)
    *(rsc2_in_array + i) = *(output0 + alpha[i]);

  R != 1;
  rsc_encd(g, len_total, R, rsc2_in_array, unuse, output2);
 
  for (i=0; i<len_total; i++){
    yy[2][i] = *(output2 + i);
  }

	 /* Paralell to serial multiplex to get output vector */
  if (puncture > 0){                   /* puncture = 1: unpunctured, rate = 1/3 */
    for (i=0; i<len_total; i++){
      for (j=0; j<3; j++)
	y[3*i+j] = yy[j][i];
    }
    for (t=0; t<3*len_total; t++)
      *(turbo_en_out + t) = y[t];
  }

  else {                               /* puncture = 0: rate increase from 1/3 to 1/2 */
    for (i=0; i<len_total; i++){
      y[2*i] = yy[0][i];
      if (i%2==0) y[2*i+1] = yy[1][i]; /* even check bits from rsc1 */
      else y[2*i+1] = yy[2][i];        /* odd check bits from rsc2 */
    }
    for (tt=0; tt<2*len_total; tt++)
      *(turbo_en_out + tt) = y[tt];
  }

  free(info_array);
  free(output0);