Subversion Repositories dvb_s2_ldpc_decoder

//import "DPI-C" function
//int gaussian( input int  stddev );
//void gaussian( input int  length,
               //input int  stddev,
               //output int result[64800] );
 
 
`timescale 1ns/10ps
 
module tb_ldpc12();
 
localparam CLK_PERIOD = 5ns;
localparam HOLD       = 1ns;
 
localparam EBN0_MIN      = 0.6;
localparam EBN0_MAX      = 2.95;
localparam EBN0_STEP     = 0.1;
localparam CODE_TYPE     = "1_2";
 
localparam LLRWIDTH = 6;
 
//////////
// Clocks
//////////
logic clk;
logic rst;
 
initial
begin
  clk <= 1'b0;
  forever
    #(CLK_PERIOD /2) clk <= ~clk;
end
 
initial
begin
  rst <= 1'b1;
 
  repeat(3) @(posedge clk);
  rst <= #HOLD 1'b0;
end
 
// VCS was crashing with my old testbench, so I simplified dramatically and got rid of
// SystemVerilog classes
 
int debug_level; // -1=no output, 0=report error, 1=display some info, 2=display lots
string label = CODE_TYPE;
 
// Data
int n;
int k;
int q;
int word_width;
 
// Parity function
int h_defs_file;
int h_defs_height;
int h_defs_width;
int h_defs[];
 
// binary data
int orig_data[64800];
int coded_data[64800];
int decoded_data[64800];
 
// data after AWGN
real ebn0, N0;
real r[64800];
int  r_quantized[64800];
 
///////////////
// Functions
///////////////
function void encode();
  int parity_bits[];
 
  parity_bits = new[n-k];
 
  for( int rownum=0; rownum<h_defs_height; rownum++ )
    for( int colnum=0; colnum<h_defs_width; colnum++ )
    begin
      int base_position;
 
      base_position = h_defs[rownum*h_defs_width + colnum];
 
      if( base_position!=-1 )
        for( int local_offset=0; local_offset<360; local_offset++ )
        begin
          int parity_address;
          parity_address = (base_position + local_offset*q) % (n-k);
 
          parity_bits[parity_address] ^= orig_data[rownum*360 + local_offset];
        end
    end
 
  for( int parityloc=1; parityloc<n-k; parityloc++ )
    parity_bits[parityloc] ^= parity_bits[parityloc-1];
 
  // Copy input to output
  for( int j=0; j<n; j++ )
  begin
    if( j<k )
      coded_data[j] = -2*orig_data[j] +1;
    else
      coded_data[j] = -2*parity_bits[j-k] +1;
  end
 
  parity_bits.delete();
endfunction
 
// Add noise to coded data and store result in r
function void genNoiseVec( output real result[64800], input real ebn0db );
  string filename;
  real rand_noise_vec[10000];
  int noise_file;
  int check_eof;
 
  int db_int;
  int db_tenths;
  char db_int_char;
  char db_tenths_char;
  if( ebn0db>=2.0 )
    db_int = 2;
  else if( ebn0db>=1.0 )
    db_int = 1;
  else
    db_int = 0;
  db_tenths = int'(10*ebn0db) %10;
  db_int_char    = ( int'("0") + db_int );
  db_tenths_char = ( int'("0") + db_tenths );
 
$display("");
  filename  = { "noise_", CODE_TYPE, "_", db_int_char, "pt", db_tenths_char };
$display( "opening file %s", filename );
 
  noise_file = $fopen( filename, "r" );
 
  for( int i=0; i<10000; i++ )
    check_eof = $fscanf( noise_file, "%f", rand_noise_vec[i] );
 
  for( int i=0; i<n; i++ )
    result[i] = rand_noise_vec[ { $random() } % 10000  ];
 
for( int i=n-10; i<n; i++ )
  $display( "noise vec: %0d=%0f", i, result[i] );
 
  $fclose( noise_file );
endfunction
 
function void AddNoise( real ebn0db );
  real noisevec[64800];
  real rate;
 
  rate = (1.0*k)/ (1.0*n);
 
  N0 = 10.0**(-ebn0db/10.0) / rate / 2.0;
  $display( "RATE, N0 = %0f, %0f", rate, N0 );
 
  genNoiseVec( noisevec, ebn0db );
 
  // print noise vector
  for( int j=0; j<n; j++ )
    if( debug_level>1 ) $display( "noise %d = %f", j, noisevec[j] );
 
  // add noise vector
  for( int j=0; j<n; j++ )
    r[j] = 1.0*coded_data[j] + noisevec[j];
 
  // Convert to LLR
  // Based on IT++: LLR=received * 4 / N0   (I don't know why)
  for( int i=0; i<n; i++ )
    r[i] *= 4.0 / N0;
 
endfunction
 
// Quantize LLR to a few bits
function void QuantizeLlr( int llr_bits );
  real MAXVAL;
  int table_range;
  real quant_table[2048]; // only 2*table_range is used!
 
  MAXVAL      = 12.0 / N0;
  table_range = 1<<(llr_bits-1);
 
  // build table
  for( int i=0; i<2*table_range; i++ )
  begin
    quant_table[i] = 0.5*i * MAXVAL / (1.0*table_range-1.0);
    //if( this.debug_level>0 ) $display( "quant table[%0d] = %0f", i, quant_table[i] );
  end
 
  // find correct place in table for all values
  for( int i=0; i<n; i++ )
  begin
    int orig_sign;
    int j;
 
    orig_sign = r[i] < 0.0 ? -1 : 1;
    j=2*table_range-1;
 
    while( (r[i]*orig_sign) < quant_table[j] )
      j--;
 
    j = j>>1;
 
    r_quantized[i] = orig_sign * j;
  end
 
  if( debug_level>1 )
    for( int i=0; i<10; i++ )
      $display( "%0d --> %0d --> %0f --> %0d", orig_data[i], coded_data[i], r[i], r_quantized[i] );
endfunction
 
// Compare signs of r_quantized and coded_data to return number of errors
function int CountOrigErrs();
  CountOrigErrs = 0;
 
  for( int i=0; i<n; i++ )
    if( ((r_quantized[i]<0)  && (coded_data[i]>=0)) ||
        ((r_quantized[i]>=0) && (coded_data[i]<0)) )
      CountOrigErrs++;
endfunction
 
// Compare signs of r_quantized and coded_data to return number of errors after decode
function int CountDecodedErrs();
  CountDecodedErrs = 0;
 
  for( int i=0; i<n; i++ )
    if( ((decoded_data[i]<0)  && (coded_data[i]>=0)) ||
        ((decoded_data[i]>=0) && (coded_data[i]<0)) )
      CountDecodedErrs++;
endfunction
 
 
 
 
//////////////////////////
// Read matrix from file
//////////////////////////
// Variables for file input
int found_target;
string    oneline;
string    locallabel;
int       temp_i;
 
initial
begin
  if( debug_level>0 )
    $display( "Creating object" );
 
  // H is a sparse matrix. The location of each one is stored as an integer.
  // -1 is used to represent unused memory locations.
  h_defs_file = $fopen( "dvbs2_hdef.txt", "r" );
 
  if( !h_defs_file )
    $stop( "File dvbs2_hdef.txt not found\n" );
  h_defs_width  = 30;
 
  found_target = 0;
 
  while( !found_target )
  begin
    temp_i = $fgets( oneline, h_defs_file );
    temp_i = $sscanf( oneline, "label %s lines %d n %d q %d", locallabel, h_defs_height, n, q );
 
    if( label==locallabel )
      found_target = 1;
    else // discard this group
      for( int linenum=0; linenum<h_defs_height; linenum++ )
        temp_i = $fgets( oneline, h_defs_file );
 
    if( $feof(h_defs_file) )
    begin
      $fclose(h_defs_file);
      $stop( "Didn't find requested code type!" );
    end
  end
 
  // at this point, the label has been found and the file pointer is at the correct position
  h_defs = new[h_defs_height*h_defs_width];
 
  // fill array with -1
  for( int hdef_pos=0; hdef_pos<h_defs_height*h_defs_width; hdef_pos++ )
    h_defs[hdef_pos] = -1;
 
  // put correct values in array
  for( int linenum=0; linenum<h_defs_height; linenum++ )
  begin
    int eol;
    string c;
    string onechar;
    string oneword;
    int word_offset;
 
    eol         = 0;
    oneword     = "";
    word_offset = 0;
 
    while( !$feof(h_defs_file) && !eol )
    begin
      c       = $fgetc( h_defs_file );
      // onechar = (string)c;
      eol     = (c=="\n");
      oneword = { oneword, c };
 
      if( eol || (c==" ") )
      begin
        temp_i = $sscanf( oneword, "%d", h_defs[linenum*h_defs_width + word_offset] );
 
        word_offset = word_offset + 1;
        oneword     = "";
      end
    end
  end
 
  $fclose(h_defs_file);
 
  k = n - 360*q;
end
 
//////////////
// Transactors
//////////////
// Load data into LLR
// LLR I/O
logic      llr_access;
logic[7:0] llr_addr;
logic      llr_din_we;
logic[LLRWIDTH-1:0] llr_din;
bit signed[LLRWIDTH-1:0]  llr_dout;
 
// start command; completion indicator
logic      start;
logic[4:0] mode;
logic[5:0] iter_limit;
bit        done;
 
initial
begin
  debug_level = 0;
  label       = CODE_TYPE;
 
  llr_access  <= 0;
  llr_addr    <= 0;
  llr_din_we  <= 0;
  llr_din     <= 0;
  start       <= 0;
  mode        <= 0;
  iter_limit  <= 30;
 
  @( posedge rst );
  repeat( 5 ) @( posedge clk );
 
  for( real ebn0dB=EBN0_MIN; ebn0dB<EBN0_MAX; ebn0dB+=EBN0_STEP )
  begin
    int err_bits;
    int tested_bits;
    real ber_result;
 
    err_bits    = 0;
    tested_bits = 0;
 
    while( (err_bits<1000) && (tested_bits<1000000) )
    begin
      // create random data
      for( int i=0; i<k; i++ )
        orig_data[i] = {$random()} % 2;
 
      encode();
 
      AddNoise( ebn0dB );
      QuantizeLlr( LLRWIDTH );
 
      // begin testing DUT
      llr_access <= 1;
      @(posedge clk);
 
      // write normal data bits
      for( int i=0; i<k; i++ )
      begin
        int wr_val;
        int abs_wr_val;
 
        wr_val = r_quantized[i];
        abs_wr_val = wr_val < 0 ? -1*wr_val : wr_val;
 
        llr_addr   <= #HOLD i/360;
        llr_din_we <= #HOLD (i%360)==359;
        llr_din    <= #HOLD (wr_val<0) ? { 1'b1, abs_wr_val[LLRWIDTH-2:0] }
                                       : { 1'b0, abs_wr_val[LLRWIDTH-2:0] };
        @( posedge clk );
      end
 
      // write parity bits
      for( int i=0; i<(n-k); i++ )
      begin
        int rotate_pos;
        int wr_val;
        int abs_wr_val;
 
        rotate_pos = k + (i/360) + ((i%360)*q);
 
        llr_addr   <= #HOLD (k + i)/360;
        llr_din_we <= #HOLD (i%360)==359;
 
        wr_val = r_quantized[rotate_pos];
        abs_wr_val = wr_val < 0 ? -1*wr_val : wr_val;
 
        llr_din    <= #HOLD (wr_val<0) ? { 1'b1, abs_wr_val[LLRWIDTH-2:0] }
                                       : { 1'b0, abs_wr_val[LLRWIDTH-2:0] };
        @( posedge clk );
      end
 
      llr_din_we <= #HOLD 0;
      llr_access <= #HOLD 0;
      @( posedge clk );
 
      //controls
      start <= #HOLD 1;
 
      case( CODE_TYPE )
        "1_4":    mode <= #HOLD 0;
        "1_3":    mode <= #HOLD 1;
        "2_5":    mode <= #HOLD 2;
        "1_2":    mode <= #HOLD 3;
        "3_5":    mode <= #HOLD 4;
        "2_3":    mode <= #HOLD 5;
        "3_4":    mode <= #HOLD 6;
        "4_5":    mode <= #HOLD 7;
        "5_6":    mode <= #HOLD 8;
        "8_9":    mode <= #HOLD 9;
        "9_10":   mode <= #HOLD 10;
        "1_5s":   mode <= #HOLD 11;
        "1_3s":   mode <= #HOLD 12;
        "2_5s":   mode <= #HOLD 13;
        "4_9s":   mode <= #HOLD 14;
        "3_5s":   mode <= #HOLD 15;
        "2_3s":   mode <= #HOLD 16;
        "11_15s": mode <= #HOLD 17;
        "7_9s":   mode <= #HOLD 18;
        "37_45s": mode <= #HOLD 19;
        "8_9s":   mode <= #HOLD 20;
        default: $stop( "Illegal code type!" );
      endcase
      @( posedge clk );
      start <= #HOLD 0;
      @( posedge clk );
 
      // read data out
      @(posedge done);
      @(posedge clk);
 
      llr_addr   <= #HOLD 0;
      llr_access <= #HOLD 1;
      @(posedge clk);
 
      // read normal data bits
      for( int i=0; i<k; i++ )
      begin
        int result;
 
        if( (i%360)==0 )
        begin
          llr_addr   <= #HOLD i/360;
          repeat(2) @(posedge clk);
          llr_din_we <= #HOLD 1; //load up from RAM
          @( posedge clk );
          llr_din_we <= #HOLD 0;
          @( posedge clk );
        end
 
        llr_din <= #HOLD { LLRWIDTH{1'bX} };
 
        result = llr_dout[LLRWIDTH-1] ? -1 * llr_dout[LLRWIDTH-2:0]
                                      : llr_dout[LLRWIDTH-2:0];
        decoded_data[i] = result;
        //if( i<10 ) $display( "After decode: pos=%0d, result=%0d", i, result );
        @( posedge clk );
      end
 
      $display( "Begin read parity bits" );
      // read parity bits
      for( int i=0; i<(n-k); i++ )
      begin
        int result;
        int rotate_pos;
 
        if( ((k + i)%360)==0 )
        begin
          llr_addr <= #HOLD (k + i)/360;
          repeat(2) @(posedge clk);
          llr_din_we <= #HOLD 1; //load up from RAM
          @( posedge clk );
          llr_din_we <= #HOLD 0;
          @( posedge clk );
        end
 
        rotate_pos = k + (i/360) + ((i%360)*q);
 
        llr_din    <= #HOLD { LLRWIDTH{1'bX} };
 
        result = llr_dout[LLRWIDTH-1] ? -1 * llr_dout[LLRWIDTH-2:0]
                                      : llr_dout[LLRWIDTH-2:0];
        decoded_data[rotate_pos] = result;
        @( posedge clk );
      end
 
      llr_din_we <= #HOLD 0;
      llr_access <= #HOLD 0;
      @( posedge clk );
 
      tested_bits += 64800;
      err_bits    += CountDecodedErrs();
    end
 
    $write( "EbN0 = %0fdB: ", ebn0dB );
    ber_result = 1.0*err_bits / (1.0*tested_bits);
    $write( "%0d errs / %0d bits ==> BER = %0f\n", err_bits, tested_bits, ber_result );
  end
 
  h_defs.delete();
  $finish();
end
 
////////////
// Instance
////////////
ldp_top ldp_top_i(
  .clk(clk),
  .rst(rst),
 
  .llr_access (llr_access),
  .llr_addr   (llr_addr),
  .llr_din_we (llr_din_we),
  .llr_din    (llr_din),
  .llr_dout   (llr_dout),
 
  .start     (start),
  .mode      (mode),
  .iter_limit(iter_limit),
  .done      (done)
);
 
endmodule