Subversion Repositories turbocodes

######################################################################
####                                                              ####
####  punct.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 myhdl import Signal, intbv, always_comb, always, posedge, negedge
 
def punct(clk, rst, y1, y2, y1Int, y2Int, y1Punct, y2Punct, y1IntPunct, y2IntPunct, rate = 13):
    """ Puncturing mechanism.
 
    rate                                        -- code rate (e.g. 13 for rate 1/3)
    clk, rst                                    -- in  : clock and negative reset
    y1, y2, y1Int, y2Int                        -- in  : original data
    y1Punct, y2Punct, y1IntPunct, y2IntPunct    -- out : punctured data
 
    """
    y1Sel = Signal(bool(0))
    y2Sel = Signal(bool(0))
    punctSel_i0 = punctSel(clk, rst, y1Sel, y2Sel, rate)
    punctMux_i0 = punctMux(y1Sel, y2Sel, y1, y2, y1Int, y2Int, y1Punct, y2Punct, y1IntPunct, y2IntPunct)
 
    return punctSel_i0, punctMux_i0
 
def punctSel(clk, rst, y1Sel, y2Sel, rate = 13):
    """ Puncturing selection (between original data (1) and 0 (0)).
 
    clk, rst        -- in  : clock and negative reset
    y1Sel, y2Sel    -- out : selection signals (1 -> original data, 0 -> 0)
 
    """
    if rate == 13:
        pattern = [[1], [1]]
    elif rate == 25:
        pattern = [[1, 1], [1, 0]]
    elif rate == 12:
        pattern = [[1], [0]]
    elif rate == 23:
        pattern = [[1, 0], [0, 0]]
    elif rate == 34:
        pattern = [[1, 0, 0], [0, 0, 0]]
    elif rate == 45:
        pattern = [[1, 0, 0, 0], [0, 0, 0, 0]]
    elif rate == 67:
        pattern = [[1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]
    else:
        print "ERROR: the code rate you specified is not valid!"
    cntMax = len(pattern[0])
    cnt = Signal(intbv(0, 0, cntMax))
    @always(clk.posedge, rst.negedge)
    def punctSelLogic():
        if rst.val == 0:
            y1Sel.next = 0
            y2Sel.next = 0
            cnt.next = 0
        else:
            if cnt.val < cntMax - 1:
                cnt.next = cnt.val + 1
            else:
                cnt.next = 0
            y1Sel.next = pattern[0][int(cnt.val)]
            y2Sel.next = pattern[1][int(cnt.val)]
    return punctSelLogic
 
def punctMux(y1Sel, y2Sel, y1, y2, y1Int, y2Int, y1Punct, y2Punct, y1IntPunct, y2IntPunct):
    """ Puncturing mux.
 
    y1Sel, y2Sel                                -- in  : selection signals (1 -> original data, 0 -> 0)
    y1, y2, y1Int, y2Int                        -- in  : original data
    y1Punct, y2Punct, y1IntPunct, y2IntPunct    -- out : punctured data
 
    """
    @always_comb
    def punctMuxLogic():
        if y1Sel.val == 1:
            y1Punct.next = y1.val
            y1IntPunct.next = y1Int.val
        else:
            y1Punct.next = 0
            y1IntPunct.next = 0
        if y2Sel.val == 1:
            y2Punct.next = y2.val
            y2IntPunct.next = y2Int.val
        else:
            y2Punct.next = 0
            y2IntPunct.next = 0
    return punctMuxLogic