Subversion Repositories turbocodes

######################################################################
####                                                              ####
####  noiser.py                                                   ####
####                                                              ####
####  This file is part of the turbo decoder IP core project      ####
####  http://www.opencores.org/projects/turbocodes/               ####
####                                                              ####
####  Author(s):                                                  ####
####      - David Brochart(dbrochart@opencores.org)               ####
####                                                              ####
####  All additional information is available in the README.txt   ####
####  file.                                                       ####
####                                                              ####
######################################################################
####                                                              ####
#### Copyright (C) 2005 Authors                                   ####
####                                                              ####
#### This source file may be used and distributed without         ####
#### restriction provided that this copyright statement is not    ####
#### removed from the file and that any derivative work contains  ####
#### the original copyright notice and the associated disclaimer. ####
####                                                              ####
#### This source file is free software; you can redistribute it   ####
#### and/or modify it under the terms of the GNU Lesser General   ####
#### Public License as published by the Free Software Foundation; ####
#### either version 2.1 of the License, or (at your option) any   ####
#### later version.                                               ####
####                                                              ####
#### This source is distributed in the hope that it will be       ####
#### useful, but WITHOUT ANY WARRANTY; without even the implied   ####
#### warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      ####
#### PURPOSE. See the GNU Lesser General Public License for more  ####
#### details.                                                     ####
####                                                              ####
#### You should have received a copy of the GNU Lesser General    ####
#### Public License along with this source; if not, download it   ####
#### from http://www.opencores.org/lgpl.shtml                     ####
####                                                              ####
######################################################################
 
 
 
from random import gauss
from myhdl import Signal, posedge, negedge, always
 
def noiser(clk, rst, a, b, y1, y2, y1Int, y2Int, aNoisy, bNoisy, y1Noisy, y2Noisy, y1IntNoisy, y2IntNoisy, n = 4 , mu = 2**(4 - 1), sigma = 2**(4 - 2) + 2**(4 - 3)):
    """ Signal noiser (Gauss distribution).
 
    n           -- number of bits for the coding of the noisy signals (= for the sampling of the received data)
    mu          -- mean value for the distribution
    sigma       -- standard deviation for the distribution (0 means no noise)
    clk, rst    -- in  : clock and negative reset
    a, b, y1, y2, y1Int, y2Int  -- in  : original coder signals, coded with 1 bit
    aNoisy, bNoisy, y1Noisy, y2Noisy, y1IntNoisy, y2IntNoisy    -- out : noisy signals, coded with n bits and delayed by 1 clock cycle
 
    """
    #mu = 2**(n - 1) #8
    #sigma = 2**(n - 2) + 2**(n - 3) #6
#    cnt = Signal(int(0))
    @always(clk.posedge, rst.negedge)
    def noiserLogic():
        if rst.val == 0:
            aNoisy.next  = 0
            bNoisy.next  = 0
            y1Noisy.next = 0
            y2Noisy.next = 0
#            cnt.next = 0
        else:
#            if cnt.val < 10:
#                cnt.next = cnt.next + 1
#                aNoisy.next = ((a.val * 2) - 1) * 7
#                bNoisy.next = ((b.val * 2) - 1) * 7
#                y1Noisy.next = ((y1.val * 2) - 1) * 7
#                y2Noisy.next = ((y2.val * 2) - 1) * 7
#                y1IntNoisy.next = ((y1Int.val * 2) - 1) * 7
#                y2IntNoisy.next = ((y2Int.val * 2) - 1) * 7
#            else:
#                cnt.next = 0
#                aNoisy.next = 7
#                bNoisy.next = 7
#                y1Noisy.next = 7
#                y2Noisy.next = 7
#                y1IntNoisy.next = 7
#                y2IntNoisy.next = 7
            if a.val == 0:
                aNoisy.next  = int(round(gauss(-mu + 1, sigma)))
            else:
                aNoisy.next  = int(round(gauss(mu - 1, sigma)))
            if b.val == 0:
                bNoisy.next  = int(round(gauss(-mu + 1, sigma)))
            else:
                bNoisy.next  = int(round(gauss(mu - 1, sigma)))
            if y1.val == 0:
                y1Noisy.next = int(round(gauss(-mu + 1, sigma)))
            else:
                y1Noisy.next = int(round(gauss(mu - 1, sigma)))
            if y2.val == 0:
                y2Noisy.next = int(round(gauss(-mu + 1, sigma)))
            else:
                y2Noisy.next = int(round(gauss(mu - 1, sigma)))
            if y1Int.val == 0:
                y1IntNoisy.next = int(round(gauss(-mu + 1, sigma)))
            else:
                y1IntNoisy.next = int(round(gauss(mu - 1, sigma)))
            if y2Int.val == 0:
                y2IntNoisy.next = int(round(gauss(-mu + 1, sigma)))
            else:
                y2IntNoisy.next = int(round(gauss(mu - 1, sigma)))
    return noiserLogic