trellis.py

Turbo Decoder Release 0.3 * Double binary, DVB-RCS code * Soft Output Viterbi Algorithm * MyHDL c

    clk, rst    -- in  : clock and negative reset
    selState    -- in  : selected state at time (l - 1)
    state       -- in  : 4 possible states at time (l - 1)
    selTrans    -- in  : 8 selected transitions (1 per state) at time (l - 1)
    weight      -- in  : four weights sorted by transition code at time (l - 1)
    llr0        -- out : LLR for (a, b) = (0, 0) at time (l + m - 1)
    llr1        -- out : LLR for (a, b) = (0, 1) at time (l + m - 1)
    llr2        -- out : LLR for (a, b) = (1, 0) at time (l + m - 1)
    llr3        -- out : LLR for (a, b) = (1, 1) at time (l + m - 1)
    a, b        -- out : decoded values of (a, b) at time (l + m - 1)

    """
    reg = [[Signal(intbv(0, 0, 4)) for i in range(8)] for j in range(m)]
    free = intbv(255, 0, 256)
    freeBeg = [bool(1) for i in range(8)]
    pastState = [intbv(0, 0, 8) for i in range(8)]
    pathIdReg = [Signal(intbv(i, 0, 8)) for i in range(8)]
    pathId = [intbv(0, 0, 8) for i in range(8)]
    freePathId = intbv(0, 0, 8)
    revWeight = [[Signal(intbv(0, 0, 2**q)) for i in range(m)] for j in range(4)]
    revWeightTmp = [[intbv(0, 0, 2**q) for i in range(m)] for j in range(4)]
    revWeightFilt = [intbv(0, 0, 2**q) for j in range(3)]
    op = [intbv(0, 0, 2**q) for i in range(4)]
    tmp = [intbv(0, 0, 2**q) for i in range(4)]
    tmp4 = intbv(0, 0, 2**(q+1))
    notZero = [[intbv(0, 0, 4) for i in range(3)] for j in range(2)]
    ind = [[intbv(0, 0, 4) for i in range(3)] for j in range(2)]
    minTmp = [bool(0) for i in range(3)]
    while 1:
        if rst.val == 0:
            for i in range(4):
                for j in range(m):
                    revWeight[i][j].next = 0
            a.next = 0
            b.next = 0
            llr0.next = 0
            llr1.next = 0
            llr2.next = 0
            llr3.next = 0
            for i in range(8):
                pathIdReg[i].next = i
                for j in range(m):
                    reg[j][i].next = 0
        else:
            free = intbv(255)
            for i in range(8):
                pastState[i] = trans2state[i][int(selTrans[i].val)]
                pathId[i] = pathIdReg[pastState[i]].val
                free[int(pathId[i])] = 0
            freeBeg = [bool(1) for i in range(8)]
            for i in range(8):
                if freeBeg[int(pathId[i])] == 1:
                    reg[0][int(pathId[i])].next = selTrans[i].val
                    freeBeg[int(pathId[i])] = 0
                    pathIdReg[i].next = pathId[i]
                    for j in range(m - 1):
                        reg[j + 1][int(pathId[i])].next = reg[j][int(pathId[i])].val
                else:
                    if free[1:0] == 1:
                        freePathId = 0
                    if free[2:0] == 2:
                        freePathId = 1
                    if free[3:0] == 4:
                        freePathId = 2
                    if free[4:0] == 8:
                        freePathId = 3
                    if free[5:0] == 16:
                        freePathId = 4
                    if free[6:0] == 32:
                        freePathId = 5
                    if free[7:0] == 64:
                        freePathId = 6
                    if free[8:0] == 128:
                        freePathId = 7
                    reg[0][freePathId].next = selTrans[i].val
                    free[freePathId] = 0
                    pathIdReg[i].next = freePathId
                    for j in range(m - 1):
                        reg[j + 1][freePathId].next = reg[j][int(pathId[i])].val
            a.next = reg[m - 1][int(pathId[int(selState.val)])].val[1]
            b.next = reg[m - 1][int(pathId[int(selState.val)])].val[0]
            for i in range(4):
                for j in range(m - 1):
                    for k in range(4):
                        if reg[j][int(pathId[int(state[k].val)])].val == i and state[k].val != selState.val:
                            op[k] = weight[k].val
                        else:
                            op[k] = (2 ** q) - 1
                    if op[0] < op[1]:
                        tmp[0] = op[0]
                    else:
                        tmp[0] = op[1]
                    if op[2] < op[3]:
                        tmp[1] = op[2]
                    else:
                        tmp[1] = op[3]
                    if tmp[0] < tmp[1]:
                        tmp[2] = tmp[0]
                    else:
                        tmp[2] = tmp[1]
                    if tmp[2] < revWeight[i][j].val:
                        revWeightTmp[i][j + 1] = tmp[2]
                    else:
                        revWeightTmp[i][j + 1] = revWeight[i][j].val
                revWeightTmp[i][0] = weight[i].val
            for j in range(2):
                if revWeightTmp[0][j] == 0:
                    notZero[j] = [1, 2, 3]
                elif revWeightTmp[1][j] == 0:
                    notZero[j] = [0, 2, 3]
                elif revWeightTmp[2][j] == 0:
                    notZero[j] = [0, 1, 3]
                elif revWeightTmp[3][j] == 0:
                    notZero[j] = [0, 1, 2]
                if revWeightTmp[int(notZero[j][0])][j] <= revWeightTmp[int(notZero[j][1])][j]:
                    minTmp[0] = 0
                else:
                    minTmp[0] = 1
                if revWeightTmp[int(notZero[j][0])][j] <= revWeightTmp[int(notZero[j][2])][j]:
                    minTmp[1] = 0
                else:
                    minTmp[1] = 1
                if revWeightTmp[int(notZero[j][1])][j] <= revWeightTmp[int(notZero[j][2])][j]:
                    minTmp[2] = 0
                else:
                    minTmp[2] = 1
                if minTmp == [0, 0, 0]:
                    ind[j] = [0, 1, 2]
                elif minTmp == [0, 0, 1]:
                    ind[j] = [0, 2, 1]
                elif minTmp == [1, 0, 0]:
                    ind[j] = [1, 0, 2]
                elif minTmp == [0, 1, 1]:
                    ind[j] = [1, 2, 0]
                elif minTmp == [1, 1, 0]:
                    ind[j] = [2, 0, 1]
                elif minTmp == [1, 1, 1]:
                    ind[j] = [2, 1, 0]
                else:
                    print "ERROR: Configuration does not exist", minTmp
            for i in range(3):
                tmp[3]  = revWeightTmp[int(notZero[0][int(ind[0][i])])][0]
                tmp4    = revWeightTmp[int(notZero[1][int(ind[1][i])])][1] + (2 ** (q - 4))
                if tmp[3] < tmp4:
                    revWeightFilt[int(ind[0][i])] = tmp[3]
                else:
                    revWeightFilt[int(ind[0][i])] = intbv(tmp4)[q:0]
            for i in range(3):
                revWeightTmp[int(notZero[0][i])][0] = revWeightFilt[i]
            for i in range(4):
                for j in range(m):
                    revWeight[i][j].next = revWeightTmp[i][j]
            llr0.next = revWeight[0][m - 1]
            llr1.next = revWeight[1][m - 1]
            llr2.next = revWeight[2][m - 1]
            llr3.next = revWeight[3][m - 1]
        yield posedge(clk), negedge(rst)