[Project 1] Viterbi Decoding Algorithm : 이동 통신 오류 정정

[Project 1] Viterbi Decoding Algorithm : 이동 통신 오류 정정

목 차 (1/2) Convolutional Codes Representation of Convolutional Codes
목 차 (1/2) Convolutional Codes Representation of Convolutional Codes Trellis Diagram Viterbi Decoder Viterbi Decoder의 구조 Viterbi Decoder – Example Convolutional Encoder 설계

목 차 (2/2) Viterbi Decoder 설계 Viterbi Decoder의 구조 Parameter
목 차 (2/2) Viterbi Decoder 설계 Viterbi Decoder의 구조 Parameter Input buffer Branch Metric Calculate(BMC) Add Compare Select(ACS) Normalization Path Metric Memory Traceback Viterbi Top module Viterbi Test bench

Convolutional Codes(1/6)
1955년 Elias의해 소개. Random error에 강한 특성. AWGN( Addtive White Gaussian Noise) 채널에서의 오류정정능력 우수. 인터리버(Interleaver/Deinterleaver)를 이용하여 Burst error에 대해서도 적용가능. 쉽게 Soft decision coding이 가능하다. 약 2 dB 추가적인 coding gain을 얻을 수 있다. Easy multirate codec Implementation. Convolutional codes의 응용 Satellite communications VSAT, INMARSAT, HDTV, MSAT,… Mobile communication, GSM, IMT-2000… Used for most radio communication systems

Convolutional codes(2/6)
일반적인 통신 시스템의 구성

( n, k, m) Convolutional encoder m : 메모리 소자의 개수 ( shift registers ) k : 입력 비트 수 n : 출력 비트 수 K : 구속장(constraint length) 한 개의 입력 비트가 영향을 끼치는 output sequence의 길이 K = m +1 Code rate : k/n Example : (2,1,3) convolutional code k =1, n = 2, shift registers = 3, code rate = 1/2 , K = 4

( 2, 1, 3) Convolutional encoder (a) Recursion formula

Generator sequences (impulse response) Recursion formula using generator sequences Information sequence : Generator sequence :

Output sequence:

Representation of Convolutional Codes(1/9)
Generation polynomials g(1)(D) = 1 + D2 + D3 g(2)(D) = 1 + D + D2 + D3 Gernerator matrix

Impulse response encoder Register contents Branch Word V1 V2 1000 1 0100 0010 0001 Input u Branch Word 1 Module Input seq : 1000 Output seq : 11, 01, 11, 11

Connection pictorial

Connection pictorial Input sequence : 1011 Output sequence : Input sequence가 각 시간(t)에 대하여 하나씩 입력 입력된 Input bit를 flush 하기 위하여 K-1개의 0을 넣어준다. Output sequence는 impulse sequence의 선형 중첩이 된다.

State representation of encoder K의 값이 커짐에 따라 상태의 수는 2K-1로 증가하게 된다. 큰 구속장을 가진 convolutional code에서는 표현이 어렵다. 시간의 변화에 대한 개념이 나타나지 않음

Tree representation of encoder 시간에 대한 개념 포함. 구속장이 길어질수록 대역폭이 지수적으로 증가하여 상태의 표현이 힘들다. 가지의 오른쪽은 Input: 0을 나타내며 왼쪽 가지는 Input: 1을 나타낸다. branch의 수가 2L 의 함수로 증가한다.( L input bit수 )

Tree representation of encoder Example Input sequence : 0, 1, 1, 0, … Output sequence : 00, 11, 10, 10, …

Trellis Diagram 대역폭의 증가없이 부호의 tree를 간단하게 표현 각 시간 단위에서 trellis는 2K-1 의 possible encoder state들을 나타내기 위하여 2K-1의 node 존재 Trellis Depth가 구속장 K만큼 진행후 고정된 주기적 구조 형성. Trellis diagram은 계속해서 반복적인 구조 사용 가능.

Trellis diagram : butterfly structure 각각의 state는 butterfly 구조를 가지고 있다.

Trellis Diagram(1/4) Example Generation polynomial G = ( 13, 17 )
Code rate R = ½ Constraint length K = 4 Input sequence

Trellis Diagram(2/4)

Trellis Diagram(3/4) 실선은 입력 bit가 0을 나타내며 점선은 입력 bit 1을 나타낸다

Trellis Diagram(4/4) Input sequence : 0, 1, 1, 0, 0, 1 …
Output sequence : 00, 11, 10, 10, 00, 00, …

Optimal Convolutional Code
R= 1/2 Generator polynomials D free R=1/3 m G1 G2 G3 2 5 7 8 3 13 17 6 15 10 4 23 35 25 33 37 12 65 57 47 53 75 133 171 145 175 345 237 225 331 367 16 753 561 557 663 711 18 9 1167 1545 1117 1365 1633 20

Free Distance(1/3) Convolution encoder에서의 모든 0의 입력에 대한 출력 data path는 모두 all zero path이여야 한다. 만약 error의 발생경우 all zero path는 존재하지 않는다. Error가 발생하였을때의 path는 0이상의 hamming distance를 가지게 되는데 이때의 최소가 되는 거리를 최소 자유거리 또는 유클리디안 자유거리라 하며 dfree라 한다. 유클리디안 자유거리는 에러정정능력과 다음의 관계에 있다.

Free Distance(2/3) 유클리디안 자유거리를 구하기 위한 가정 유클리디안 자유거리의 측정
All-zero 열이 입력될때 시작과 끝의 상태가 0이고 그 사이의 상태는 0가 아니여야 한다. 유클리디안 자유거리의 측정 00 상태로 시작해서 다시 00 state로 돌아오는 path중 hamming distance를 구하여 최소가 되는 hamming distance를 구한다. 1) trellis diagram을 그린다. 2) 00 state로 시작해서 00 state로 되돌아오는 path를 모두 찾는다. 3) 2)에서 찾아진 모든 path들 간에 hamming distance를 계산하여 trellis diagram에 출력 부호열 대신 표기한다. 4) 각 path의 hamming distance의 합을 구한다. 5) hamming distance의 합이 최소인 path를 찾는다. 이 path의 hamming distance가 유클리디안 자유거리 dfree이다.

Free Distance(3/3) Example Information sequence : 0110000…
Output sequence : …. Dfree = = 6

Hard decision / Soft decision
Q = 2 : Hard decision Q > 2 : Soft decision 이상적인 soft decision의 값은 무한대이다. 위에 그림은 Q = 8인 soft decision을 나타낸다.

Representation of soft decision data
Offset-binary representation Sign-magnitude representation signal Hard decision data Offset-binary representation Sign-magnitude representation Most negative Least negative 1 000 111 001 110 010 101 011 100 Least positive Most positive

Application of Convolution Codes(1/2)
Constraint length K = 5 (m = 4) (a) Generator polynomials : ( 23, 35 ) (b) dfree = 7 GSM system Constraint length K = 6 (m = 5) (a) Generator polynomials : ( 65, 57 ) (b) dfree = 8 (c) IS-54 american digital cellular system Constraint length K = 7 (m = 6) (a) Generator polynomials : ( 133, 171 ) (b) dfree = 10 Most satellite communication system

Application of Convolution Codes(1/2)
Constraint length K = 9 (m = 8) (a) Generator polynomials : ( 753, 561 ) (b) dfree = 12 IS-95 CDMA system( forward channel ) (a) Generator polynomials : ( 557, 663, 711 ) (b) dfree = 18 IS-95 CDMA system( reverse channel )

Viterbi Decoder(1/2) Convolutional codes의 복호화 방법 Sequential decoding
Code tree 에 서 정확한 경로를 찾아가는 시행 착오적인 방법 탐색상태의 수는 constraint length 와 무관 Sequential decoding, Fano algorithm, stack algorithm 탐색 되는 state metric수가 random 변수 잘못된 가정과 역방 탐색의 예상 수 채널 SNR 함수 계산량의 다양성을 때문에 도착되는 sequence 들을 저장하기 위해 buffer사용

Viterbi Decoder(2/2) Viterbi decoder Viterbi가 제안 높은 부호 이득 높은 하드웨어의 복잡도
하드웨어 복잡도는 state의 수 ( 2K-1 ))에 비례한다. Error 확률은 constraint length에 지수적으로 감소 최대 우호 복호( Maximum Likelihood decoding ) 사용 최근 convolutional decoder로 가장 많이 사용. Soft decision decoding 사용 시 hard decision에 비하여 약 2dB의 추가적인 부호이득을 얻을 수 있다. => 약간의 복잡도 증가

Viterbi Decoder의 구조(1/7)
Branch Metric Calculation(BMC) Path Metric Calculation Path Metric Memory Add-Compare-Select (ACS) Trace Back Memory Normalization

Branch Metric Calculation( BMC ) State의 수 : 2m Encoder 의 입력이 1이면 lower branch Encoder 의 입력이 0이면 upper branch Hard Decision Received sequence와 각각의 branch의 codeword 값과의 hamming distance를 구하여 branch metric 값을 계산한다. Soft Decision 신호로 받은 soft decision data는 BMC로 입력 된다. 3bit soft decision의 경우 다음과 같이 표현된다. J1 = x1 x2 x J2 = y2 y1 y0 Branch Metric Value BM0(t) BM1(t) BM2(t) BM3(t) Encoded (vi(1) , vi(2) ) 00 01 10 11

4개의 branch metric 값은 J1, J2값을 이용하여 다음과 같이 계산할 수 있다. 00 => BM0(t) = (2x – 1 – J2) + (2x –1 – J1) 01 => BM1(t) = (2x – 1 – J2) + J1 10 => BM2(t) = J2 + (2x –1 – J1) 11 => BM3(t) = J1 + J1 BM3(t) = 2x+1 – 2 - BM0(t), BM2(t) = 2x+1 – 2 - BM1(t) Example

ACS ( Add Compare Select ) 와 Path Metric Memory BMC(Branch Metric Calculate)에서 계산된 branch metric값과 현재상태의 Path metric 값을 이용하여 새로운 path metric 값을 계산한다. Path Metric의 개수 = state의 개수 = 2K-1 = 2m ( K : 구속장 ) K가 4인 convolutional encoder의 path metric 값은 다음과 같다. Path metric 개수 = 24-1 = 8 PM0(t), PM1(t), PM2(t), PM3(t), PM4(t), PM5(t), PM6(t), PM7(t)

PMi3(t) = Min{ PMi1(t-1) + BM1(t), PMi2(t-1) + BM2(t) } PMi4(t) = Min{ PMi1(t-1) + BM2(t), PMi2(t-1) + BM1(t) } PMi3(t) = Min{ PMi1(t-1) + BM0(t), PMi2(t-1) + BM3(t) } PMi4(t) = Min{ PMi1(t-1) + BM3(t), PMi2(t-1) + BM0(t) } 여기서 (i1, i2) , (j1, j2) => ( 2P, 2P+1 ) (i3, i4) , (j3, j4) => ( P, P+4 ) 단 ( K = 4 )

Normalization 현재 ACS의 출력으로 나온 Path Metric값은 계속해서 Branch Metric이 더해지므로 값이 증가하게 된다. 따라서 하드웨어적으로 Path Metric Memory의 크기의 증가를 가져오게 된다. 이를 방지하기 위하여 현재 상태의 전체 Path Metric값중 가장 작은 값을 찾아서 각각의 현재 상태의 Path Metric 값을 가장 작은 값으로 빼 줌으로서 가장 작은 metric 값이 0이 되게 한다.

TraceBack memory Trellis diagram에서 survivor path를 저장하고 Traceback 에 의하여 복호화된 비트를 찾아내는 역할을 하는 부분. Trellis diagram에서 현재 state값 중 가장 작은 값을 갖는 state를 초기값으로 하여 Traceback algorithm을 적용하여 원래 입력 정보와 확률이 가장 높은 값을 선택. ACS에서 이전 node 2p 가 생존하면 pointer 0을 저장, 2p + 1이 생존하면 pointer에 1을 저장한다. Traceback depth가 크면 BER의 성능이 좋아진다. 이상적인 traceback depth는 무한대 이지만 하드웨어 구현상 5~6배의 traceback depth 사용한다.

Viterbi Decoder - Example(1/16)
Generation polynomial G = ( 13, 17 ) Code rate R = ½ Constraint length K = 4 Input sequence ( )

각각의 branch에 branch metric을 구하고 각각의 node마다 path metric을 구한다 Branch metric : 수신된 값과 각 branch의 codeword와의 hamming distance를 구한다. Path metric : 전 단의 path metric + 각 branch에서의 branch metric을 구한다.

t0-t1의 branch metric, path metric Received seq : 00 branch : S0-S0 : => branch metric : 0 S0-S4 : => branch metric : 2 Path metric : S0 : = 0 S4 : = 2 t1-t2의 branch metric, path metric Received seq : 11 branch : S0-S0 : => branch metric : 2 S0-S4 : => branch metric : 0 S4-S2 : => branch metric : 1 S4-S6 : => branch metric : 1 Path metric : S0 : = 2 S2 : = 3 S4 : = 0 S6 : = 3

Received sequence를 이용하여 branch를 구한다. T3에서의 Path Metric 값과 t3과 t4사이의 Branch Metric값을 더하여 t4에서의 Path Metric 값을 구한다. 위의 그림에서는 Normalization 과정은 생략하였다.

State(t=3) Branch BM PM+BM Survivor path State(t=4) S0 4 S0-S0 2 6 1 3 S0-S4 S1-S0 S1 S2-S1 S1-S4 5 S3-S1 S2 S4-S2 S2-S5 S5-S2 S3 S6-S3 S3-S5 S7-S3 S4 S4-S6 S5 S5-S6 S6 S6-S7 S7 S6-S1 S7-S7

State(t=4) Branch BM PM+BM Survivor path State(t=5) S0 3 S0-S0 1 4 2 S0-S4 S1-S0 S1 S2-S1 S1-S4 S3-S1 S2 S4-S2 S2-S5 S5-S2 5 S3 S6-S3 S3-S5 S7-S3 S4 S4-S6 6 S5 S5-S6 S6 S6-S7 S7 S6-S1 S7-S7

State(t=5) Branch BM PM+BM Survivor path State(t=6) S0 2 S0-S0 S0-S4 4 S1-S0 5 S1 3 S2-S1 6 1 S1-S4 S3-S1 S2 S4-S2 S2-S5 S5-S2 S3 S6-S3 S3-S5 S7-S3 S4 S4-S6 S5 S5-S6 S6 S6-S7 S7 S6-S1 S7-S7

State(t=6) Branch BM PM+BM Survivor path State(t=7) S0 2 S0-S0 4 1 S0-S4 S1-S0 S1 S2-S1 3 S1-S4 S3-S1 6 S2 S4-S2 S2-S5 5 S5-S2 S3 S6-S3 S3-S5 S7-S3 S4 S4-S6 S5 S5-S6 S6 S6-S7 S7 S6-S1 S7-S7

State(t=7) Branch BM PM+BM Survivor path State(t=8) S0 2 S0-S0 S0-S4 4 S1-S0 5 S1 3 S2-S1 6 1 S1-S4 S3-S1 S2 S4-S2 S2-S5 S5-S2 S3 S6-S3 S3-S5 S7-S3 S4 S4-S6 S5 S5-S6 S6 S6-S7 S7 S6-S1 S7-S7

위의 그림에서 최종 stage에서 가장 작은 값을 찾아 초기state로 정하고 traceback 과정을 진행한다. 위의 그림에서 최종 stage에서의 가장 작은 metric값은 2이며 이때의 값에 대하여 Traceback 하여 복호 과정을 수행한다.

Input sequence Decoding data Traceback Memory안에 저장되어있는 값을 이용하여 최종 decoding data를 구할 수 있다. t8 t7 t6 t5 t4 t3 t2 t1 t0 1 S7 S5 S3 S1 S6 S4 S2 S0 Lowest state

Convolutional Encoder 설계
Example Generation polynomial G = ( 13, 17 ) Code rate R = ½ Constraint length K = 4 Input sequence ( )

Convolutional Encoder 설계 - parameter
/******************************************************************************************/ // MODULE : Parameter // // FILE NAME: parameter.v // VERSION: 1.0 // DATE: FAB 2, 2004 // AUTHOR: DONG KI CHOI // Description: This file defines a parameter. // defines simulation period `define FULL 20 `define HALF 10 `define PERIOD `FULL // defines delay `define DEL 1 // define parmeter `define CONS_K 4 `define DATA_WIDTH 4 `define BUS_WIDTH 16

Convolutional Encoder 설계 – D-F.F(1/2)
/******************************************************************************************/ // MODULE : D-type flip flop // // FILE NAME: dff_n.v // VERSION: 1.0 // DATE: JAN 14, 2004 // AUTHOR: DONG KI CHOI // Description: This module defines a D-type flip flop. // reset is active-low `include "parameter.v" module dff_n( clk, rst_n, d, q ); // parameter parameter CARDINALITY = 1;

Convolutional Encoder 설계 – D-F.F(2/2)
// input data input clk; input rst_n; input [CARDINALITY-1:0] d; // output data output [CARDINALITY-1:0] q; reg [CARDINALITY-1:0] q; wire [CARDINALITY-1:0] d; // main code clk or negedge rst_n) begin if ( ~rst_n ) q <= 0; else q <= d; end endmodule

Convolutional Encoder 설계 – Convolutional encoder(1/2)
/******************************************************************************************/ // MODULE : Convolution encoder // // FILE NAME: convol.v // VERSION: 1.0 // DATE: JAN 14, 2004 // AUTHOR: DONG KI CHOI // CODE TYPE: RTL Level // Description: This module defines a Convolution encoder. // K = 4, generation polynomial = (13,17), bit rate = 1/2 `include "parameter.v" module convol( clk, rst_n, data_in, data_out ); // input data input clk; input rst_n; input data_in;

Convolutional Encoder 설계 – Convolutional encoder(2/2)
// output data output [1:0] data_out; wire [`CONS_K-1:0] poly_a; // poly a = 13 wire [`CONS_K-1:0] poly_b; // poly b = 17 wire [`CONS_K-1:0] wa; wire [`CONS_K-1:0] wb; wire [0:`CONS_K-1] sh_reg; // main code assign poly_a = 4'b1011; assign poly_b = 4'b1111; dff_n df0( clk , rst_n, data_in, sh_reg[0] ); dff_n df1( clk , rst_n, sh_reg[0], sh_reg[1] ); dff_n df2( clk , rst_n, sh_reg[1], sh_reg[2] ); dff_n df3( clk , rst_n, sh_reg[2], sh_reg[3] ); assign wa = poly_a & sh_reg[0:`CONS_K-1]; assign wb = poly_b & sh_reg[0:`CONS_K-1]; assign data_out[0] = wa[3]^wa[2]^wa[1]^wa[0]; assign data_out[1] = wb[3]^wb[2]^wb[1]^wb[0]; endmodule

Convolutional Encoder 설계 – testbench(1/2)
/******************************************************************************************/ // MODULE : test bench-convolution encoder // // FILE NAME: test_conv.v // VERSION: 1.0 // DATE: JAN 14, 2004 // AUTHOR: DONG KI CHOI // CODE TYPE: Behavioral Level // Description: This module defines a test bench convolution encoder. `include "parameter.v" module test_conv(); reg rst_n; reg data_in; reg clk; wire [1:0] data_out; // main code convol conv ( .clk(clk), .rst_n(rst_n), .data_in(data_in), .data_out(data_out) ); always #(`PERIOD/2) clk <= ~clk; initial begin

Convolutional Encoder 설계 – testbench(2/2)
clk <= 0; rst_n <= 1; #10; rst_n <= 0; #10; rst_n <= 1; data_in <= 0; #`PERIOD; data_in <= 1; #`PERIOD; $stop; end endmodule

Viterbi Decoder 설계 Viterbi Decoder의 구조 Branch Metric Calculation(BMC)
Path metric Calculation Path Metric Memory Add-Compare-Select (ACS) Trace Back Memory

Parameter /******************************************************************************************/ // MODULE : Parameter // // FILE NAME: parameter.v // VERSION: 1.0 // DATE: FAB 2, 2004 // AUTHOR: DONG KI CHOI // Description: This file defines a parameter. // defines simulation period `define FULL 20 `define HALF 10 `define PERIOD `FULL // defines delay `define DEL 1 // define parmeter `define CONS_K 4 `define DATA_WIDTH 4 `define BUS_WIDTH 16

Input buffer /******************************************************************************************/ // MODULE : Input buffer // // FILE NAME: input_buf.v // VERSION: 1.0 // DATE: Feb 2, 2004 // AUTHOR: DONG KI CHOI // Description: This module defines a input buffer. `include "parameter.v" module input_buf( clk, rst_n, data_in, data_out ); // input data input clk; input rst_n; input [1:0] data_in; // output data output [1:0] data_out; // main code dff_n #(2) dff0( clk, rst_n, data_in, data_out ); endmodule

Branch Metric Calculate(1/5)
Input buffer 에서 들어오는 received sequence를 받아 Encoder_out에서 구한 branch codeword 를 이용하여 각각의 branch metric 값을 계산한다. 옆의 그림을 보면 received sequence와 각branch의 codeword 와의 hamming distance로 구한 branch metric값이 ()안의 값으로 표현 하였다. received sequence

/******************************************************************************************/ // MODULE : branch metric calculate // // FILE NAME: bmc.v // VERSION: 1.0 // DATE: JAN 14, 2004 // AUTHOR: DONG KI CHOI // Description: This module defines Branch metric calculate. `include "parameter.v" module bmc( data_in, bm_out ); // input data input [1:0] data_in; // output data output [31:0] bm_out; // calcualted hamming distance data wire [`CONS_K-1:0] polya; wire [`CONS_K-1:0] polyb; // generator polynomial wire [`CONS_K-1:0] b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15;

wire [1:0] br0, br1, br2, br3, br4, br5, br6, br7, br8, br9, br10, br11, br12, br13, br14, br15; wire [1:0] dout0, dout1, dout2, dout3, dout4, dout5, dout6, dout7, dout8, dout9, dout10, dout11, dout12, dout13, dout14, dout15; // main code assign polya = 4'b1011, polyb = 4'b1111; assign b0 = 4'b0000, b1 = 4'b0001, b2 = 4'b0010, b3 = 4'b0011, b4 = 4'b0100, b5 = 4'b0101, b6 = 4'b0110, b7 = 4'b0111, b8 = 4'b1000, b9 = 4'b1001, b10 = 4'b1010, b11 = 4'b1011, b12 = 4'b1100, b13 = 4'b1101, b14 = 4'b1110, b15 = 4'b1111; Generator polynomial Branch codeword를 만들기 위한 각 branch의 상태 표현 예를 들어 b8은 아래와 같은 상태를 만들기 위한 data

각 branch 의 codeword를 생성한다. en_out eo0 ( polya, polyb, b0, br0 ); assign br1 = ~br0; en_out eo1 ( polya, polyb, b2, br2 ); assign br3 = ~br2; en_out eo2 ( polya, polyb, b4, br4 ); assign br5 = ~br4; en_out eo3 ( polya, polyb, b6, br6 ); assign br7 = ~br6; en_out eo4 ( polya, polyb, b8, br8 ); assign br9 = ~br8; en_out eo5 ( polya, polyb, b10, br10 ); assign br11 = ~br10; en_out eo6 ( polya, polyb, b12, br12 ); assign br13 = ~br12; en_out eo7 ( polya, polyb, b14, br14 ); assign br15 = ~br14; hamming_dist ha0 ( data_in, br0, dout0 ); hamming_dist ha1 ( data_in, br1, dout1 ); hamming_dist ha2 ( data_in, br2, dout2 ); hamming_dist ha3 ( data_in, br3, dout3 ); hamming_dist ha4 ( data_in, br4, dout4 ); hamming_dist ha5 ( data_in, br5, dout5 ); hamming_dist ha6 ( data_in, br6, dout6 ); hamming_dist ha7 ( data_in, br7, dout7 ); hamming_dist ha8 ( data_in, br8, dout8 ); hamming_dist ha9 ( data_in, br9, dout9 ); hamming_dist ha10 ( data_in, br10, dout10 ); hamming_dist ha11 ( data_in, br11, dout11 ); hamming_dist ha12 ( data_in, br12, dout12 ); hamming_dist ha13 ( data_in, br13, dout13 ); hamming_dist ha14 ( data_in, br14, dout14 ); hamming_dist ha15 ( data_in, br15, dout15 ); data_in의 값과 en_out의 출력 값을 사용하여 hamming distance를 구한다 이 값이 각 branch metric 값이 된다. Ex) Branch metric

assign bm_out = { dout15, dout14, dout13, dout12, dout11, dout10, dout9, dout8, dout7, dout6, dout5, dout4, dout3, dout2, dout1, dout0 }; endmodule

Branch Metric Calculate-encoder_out(1/3)
옆의 그림과 같이 각 각의 가지에 대한 codeword를 생성한다. 여기에서 생성되는 codeword는 입력된 received sequence와 의 hamming distance를 구하여 branch metric값을 구할 수 있다.

/******************************************************************************************/ // MODULE : encoder out // // FILE NAME: bmc.v(sub module) // VERSION: 1.0 // DATE: JAN 14, 2004 // AUTHOR: DONG KI CHOI // Description: This module defines a encoder out. module en_out( polya, polyb, bran_state, br_out ); // input data input [`CONS_K-1:0] polya; input [`CONS_K-1:0] polyb; // generator polynomial input [`CONS_K-1:0] bran_state; // branch state // output data output [1:0] br_out; wire [`CONS_K-1:0] wa; wire [`CONS_K-1:0] wb; reg [1:0] br_out;

assign wa = bran_state & polya[`CONS_K-1:0]; assign wb = bran_state & polyb[`CONS_K-1:0]; or wb) begin br_out[1] = wa[0]^wa[1]^wa[2]^wa[3]; // encoding data, j[1] at branch state br_out[0] = wb[0]^wb[1]^wb[2]^wb[3]; // encoding data, j[0] at branch state end endmodule

Branch Metric Calculate-hamming dist(1/2)
Received sequence와 encoder out에서 생성된 codeword 의 hamming distance를 구하여 branch metric 값을 구한다. 아래의 그림에서 보면 각각의 입력에 대하여 Received sequence – data_in[1:0]와 encoder out에서 생성된 codeword br_out[1:0]각 bit단위로 exclusive-or 시키고 그 값을 더해주어 hamming distance를 구한다. 이때의 값이 branch metric 값이 된다. Received sequence Branch codeword Hamming distance

Branch Metric Calculate-hamming dist(2/2)
/******************************************************************************************/ // MODULE : hamming dist // // FILE NAME: bmc.v(sub module) // VERSION: 1.0 // DATE: JAN 14, 2004 // AUTHOR: DONG KI CHOI // Description: This module defines a hamming distance. module hamming_dist( data_in, br_out, hamout ); // input data input [1:0] data_in; input [1:0] br_out; // output data output [1:0] hamout; wire [1:0] hamout; // main code assign hamout = (data_in[1]^br_out[1]) + (data_in[0]^br_out[0]) ; endmodule

Branch Metric Calculate-testbench(1/3)
/******************************************************************************************/ // MODULE : Branch Metric Calculation Test-Bench // // FILE NAME: bmc_tb.v // VERSION: 1.0 // DATE: data_inAN 15, 2004 // AUTHOR: DONG KI CHOI // Description: This module defines a branch metric calculation testbench. `include "parameter.v" module bmc_tb(); reg [1:0] data_in; wire [31:0] dist; bmc bm1( data_in, dist ); initial begin #30; data_in = 2'b00; #`PERIOD; data_in = 2'b11; #`PERIOD; data_in = 2'b01; #`PERIOD;

data_in = 2'b00; #`PERIOD; data_in = 2'b11; #`PERIOD; $stop; end endmodule

Add_Compare_Select(1/6)
BMC(Branch Metric Calculate)에 서 계산된 branch metric값과 Path metric 값을 이용하여 새로운 path metric 값을 계산한다. Path metric의 개수 = state의 개수 = 2K-1 = 2m ( K : 구속장 ) K가 4인 convolutional encoder의 path metric 값은 다음과 같다. Path metric 개수 = 24-1 = 8 각 ACS의 전체적인 구조는 다음 page와 같이 표현된다. 이전 BMC에서의 branch metric 값과 metric memory가져온 path metric 값을 더한다. 2개의 PM + BM 값을 비교한다. 비교된 값 중 작은 값을 선택하여 normalize 모듈로 출력하고 큰 값은 버린다. 비교된 값 중 upper branch값이 선택되면 0, lower branch 값이 선택되면 1값을 traceback 모듈로 출력된다.

/******************************************************************************************/ // MODULE : Add-Compare-Select // // FILE NAME: acs.v // VERSION: 1.0 // DATE: JAN 15, 2004 // AUTHOR: DONG KI CHOI // Description: This module defines a add-compare-select(ACS) . `include "parameter.v" module acs( comp_en, bm_in, pm_in_h, pm_in_l, pm_out_h, pm_out_l, path_mem ); // input data input comp_en; // from bmc input [31:0] bm_in; // from metric_memory input [`BUS_WIDTH-1:0] pm_in_h; input [`BUS_WIDTH-1:0] pm_in_l;

// output data // to normalize output [`BUS_WIDTH-1:0] pm_out_h; output [`BUS_WIDTH-1:0] pm_out_l; // to path memory output [7:0] path_mem; wire [`BUS_WIDTH-1:0] pm_in_h; wire [`BUS_WIDTH-1:0] pm_in_l; wire [`BUS_WIDTH-1:0] pm_out_h; wire [`BUS_WIDTH-1:0] pm_out_l; wire [`DATA_WIDTH-1:0] pm_in0, pm_in1, pm_in2, pm_in3, pm_in4, pm_in5, pm_in6, pm_in7; wire [`DATA_WIDTH-1:0] pm_out0, pm_out1, pm_out2, pm_out3, pm_out4, pm_out5, pm_out6, pm_out7; wire [1:0] bm00_0, bm01_0, bm02_1, bm03_1, bm04_2, bm05_2, bm06_3, bm07_3, bm10_4, bm11_4, bm12_5, bm13_5, bm14_6, bm15_6, bm16_7, bm17_7; wire [`DATA_WIDTH-1:0] sum00_0, sum01_0, sum02_1, sum03_1, sum04_2, sum05_2, sum06_3, sum07_3, sum10_4, sum11_4, sum12_5, sum13_5, sum14_6, sum15_6, sum16_7, sum17_7; wire [7:0] path_mem; // main code assign { bm17_7, bm16_7, bm15_6, bm14_6, bm13_5, bm12_5, bm11_4, bm10_4, bm07_3, bm06_3, bm05_2, bm04_2, bm03_1, bm02_1, bm01_0, bm00_0 } = bm_in; assign { pm_in7, pm_in6, pm_in5, pm_in4, pm_in3, pm_in2, pm_in1, pm_in0 } = { pm_in_h, pm_in_l }; assign { pm_out_h, pm_out_l } = { pm_out7, pm_out6, pm_out5, pm_out4, pm_out3, pm_out2, pm_out1, pm_out0 };

branch metric 값과 path metric 값을 더한다. // input information bit :0 assign sum00_0 = pm_in0 + bm00_0, sum01_0 = pm_in1 + bm01_0, sum02_1 = pm_in2 + bm02_1, sum03_1 = pm_in3 + bm03_1, sum04_2 = pm_in4 + bm04_2, sum05_2 = pm_in5 + bm05_2, sum06_3 = pm_in6 + bm06_3, sum07_3 = pm_in7 + bm07_3, sum10_4 = pm_in0 + bm10_4, sum11_4 = pm_in1 + bm11_4, sum12_5 = pm_in2 + bm12_5, sum13_5 = pm_in3 + bm13_5, sum14_6 = pm_in4 + bm14_6, sum15_6 = pm_in5 + bm15_6, sum16_7 = pm_in6 + bm16_7, sum17_7 = pm_in7 + bm17_7; // compare branch metrices compare comp0 ( comp_en, sum00_0, sum01_0, pm_out0, path_mem[0] ); compare comp1 ( comp_en, sum02_1, sum03_1, pm_out1, path_mem[1] ); compare comp2 ( comp_en, sum04_2, sum05_2, pm_out2, path_mem[2] ); compare comp3 ( comp_en, sum06_3, sum07_3, pm_out3, path_mem[3] ); compare comp4 ( comp_en, sum10_4, sum11_4, pm_out4, path_mem[4] ); compare comp5 ( comp_en, sum12_5, sum13_5, pm_out5, path_mem[5] ); compare comp6 ( comp_en, sum14_6, sum15_6, pm_out6, path_mem[6] ); compare comp7 ( comp_en, sum16_7, sum17_7, pm_out7, path_mem[7] ); endmodule 두개의 pm + bm 값 중 작은 branch 값을 선택한다.

Add_Compare_Select-Compare(1/2)
/******************************************************************************************/ // MODULE : Compare // // FILE NAME: acs.v(acs submodule) // VERSION: 1.0 // DATE: JAN 15, 2004 // AUTHOR: DONG KI CHOI // Description: This module defines a Compare module . module compare( comp_en, sum_in_a, sum_in_b, min_metric, sel ); // input data input comp_en; input [`DATA_WIDTH-1:0] sum_in_a; input [`DATA_WIDTH-1:0] sum_in_b; // output data output [`DATA_WIDTH-1:0] min_metric; output sel; reg [`DATA_WIDTH-1:0] min_metric; reg sel;

Add_Compare_Select-Compare(2/2)
// main code sum_in_a or sum_in_b or comp_en) begin if (~comp_en) min_metric <= sum_in_a; sel <= 0; end else if( sum_in_a <= sum_in_b ) end // else if else min_metric <= sum_in_b; sel <= 1; end // else end // always endmodule Comp_en comp_en 은 K(constraint length)-1 이후 stage부터 동작하게 된다. 이것은 K-1 이전 stage에서는 비교의 과정이 필요가 없으며 처음에 사용하지 않는 branch의 값과 비교하여 traceback memory에 잘못된 값이 저장될 수 있다.

ACS Enable K stage 부터 ACS 모듈에서compare 과정을 수행하도록 신호를 발생시킨다.
/******************************************************************************************/ // MODULE : ACS enable // // FILE NAME: acs_en.v // VERSION: 1.0 // DATE: Feb 2, 2004 // AUTHOR: DONG KI CHOI // Description: This module defines acs enable. module acs_en( clk, rst_n, comp_en ); input clk; input rst_n; output comp_en; wire comp_en0, comp_en1, comp_en2; dff_n en0( clk, rst_n, rst_n, comp_en0 ); dff_n en1( clk, rst_n, comp_en0, comp_en1 ); dff_n en2( clk, rst_n, comp_en1, comp_en2 ); dff_n en3( clk, rst_n, comp_en2, comp_en ); endmodule K stage 부터 ACS 모듈에서compare 과정을 수행하도록 신호를 발생시킨다.

Normalization(1/3) /******************************************************************************************/ // MODULE : Normalize path metric // // FILE NAME: normalize.v // VERSION: 1.0 // DATE: JAN 14, 2004 // AUTHOR: DONG KI CHOI // Description: This module defines a Normalize path metric. `include "parameter.v" module normalize( pm_in_h, pm_in_l, norm_out_h, norm_out_l, small_state ); // input data input [`BUS_WIDTH-1:0] pm_in_h; input [`BUS_WIDTH-1:0] pm_in_l; // output data output [`BUS_WIDTH-1:0] norm_out_h; output [`BUS_WIDTH-1:0] norm_out_l; output [2:0] small_state;

Normalization(2/3) 전체 state중에서 가장 작은 state를 찾는다
wire [`DATA_WIDTH-1:0] pm_dat0, pm_dat1, pm_dat2, pm_dat3, pm_dat4, pm_dat5, pm_dat6, pm_dat7; wire [`DATA_WIDTH-1:0] comp_re0, comp_re1, comp_re2, comp_re3, comp_re4, comp_re5; wire [`DATA_WIDTH-1:0] smallest; wire [`DATA_WIDTH-1:0] norm0, norm1, norm2, norm3, norm4, norm5, norm6, norm7; reg [2:0] small_state; // main code assign { pm_dat7, pm_dat6, pm_dat5, pm_dat4, pm_dat3, pm_dat2, pm_dat1, pm_dat0 } = { pm_in_h, pm_in_l }; // compare and find smallest value & state assign comp_re0 = ( pm_dat0 <= pm_dat1 )? pm_dat0 : pm_dat1, comp_re1 = ( pm_dat2 <= pm_dat3 )? pm_dat2 : pm_dat3, comp_re2 = ( pm_dat4 <= pm_dat5 )? pm_dat4 : pm_dat5, comp_re3 = ( pm_dat6 <= pm_dat7 )? pm_dat6 : pm_dat7; assign comp_re4 = ( comp_re0 <= comp_re1 )? comp_re0 : comp_re1, comp_re5 = ( comp_re2 <= comp_re3 )? comp_re2 : comp_re3; assign smallest = ( comp_re4 <= comp_re5 )? comp_re4 : comp_re5; assign norm0 = pm_dat0 - smallest, norm1 = pm_dat1 - smallest, norm2 = pm_dat2 - smallest, norm3 = pm_dat3 - smallest, norm4 = pm_dat4 - smallest, norm5 = pm_dat5 - smallest, norm6 = pm_dat6 - smallest, norm7 = pm_dat7 - smallest; 전체 state중에서 가장 작은 state를 찾는다 가장 작은 state의 metric 값으로 전체 state값을 빼준다.

Normalization(3/3) assign { norm_out_h, norm_out_l } = { norm7, norm6, norm5, norm4, norm3, norm2, norm1, norm0 }; begin case (smallest) pm_dat0 : small_state = 3'b000; pm_dat1 : small_state = 3'b001; pm_dat2 : small_state = 3'b010; pm_dat3 : small_state = 3'b011; pm_dat4 : small_state = 3'b100; pm_dat5 : small_state = 3'b101; pm_dat6 : small_state = 3'b110; pm_dat7 : small_state = 3'b111; endcase // case end // always endmodule Trace back과정 수행시 초기 state를 찾기 위하여 전체 state중 가장 작은 state를 traceback 모듈로 출력한다.

Path Metric Memory(1/2) /******************************************************************************************/ // MODULE : Path Metric Memory // // FILE NAME: Metric_mem.v // VERSION: 1.0 // DATE: JAN 14, 2004 // AUTHOR: DONG KI CHOI // Description: This module defines a Path metric Memory. `include "parameter.v" module metric_mem( clk, rst, path_mem_in_h, path_mem_in_l, path_mem_out_h, path_mem_out_l ); // input data input clk; input rst; input [`BUS_WIDTH-1:0] path_mem_in_h; input [`BUS_WIDTH-1:0] path_mem_in_l; // output data output [`BUS_WIDTH-1:0] path_mem_out_h; output [`BUS_WIDTH-1:0] path_mem_out_l;

Path Metric Memory(2/2) path metric값을 저장한다. wire clk; wire rst;
wire [`BUS_WIDTH-1:0] path_mem_in_h; wire [`BUS_WIDTH-1:0] path_mem_in_l; wire [`BUS_WIDTH-1:0] path_mem_out_h; wire [`BUS_WIDTH-1:0] path_mem_out_l; // main code dff_n #(16) mm_h ( clk, rst, path_mem_in_h, path_mem_out_h ); dff_n #(16) mm_l ( clk, rst, path_mem_in_l, path_mem_out_l ); endmodule path metric값을 저장한다.

Traceback(1/7) Trellis diagram에서 survival path를 저장하고 traceback 에 의하여 복호화된 비트를 찾아내는 역할을 하는 부분. Trellis diagram에서 현재 state값중 가장 작은 값을 갖는 state를 초기값으로 하여 Traceback algorithm을 적용하여 원래 입력 정보와 확률이 가장 높은 값을 선택하여 Traceback과정을 진행하고 최종 정보를 decoding 한다. Input sequence Decoding data t8 t7 t6 t5 t4 t3 t2 t1 t0 1 S7 S5 S3 S1 S6 S4 S2 S0 Lowest state

Traceback(2/7) 그림 2 그림 3 그림 1

Traceback(3/7) Traceback unit는 convolutional encoding 의 역과정을 진행한다. 그림 1의 경우를 보면 굵은선으로 나타난 방향으로 branch metric 값이 이동하였다. 이과정에 대한 traceback 과정은 그림 3과 같이 나와있다. 그림 3에서 보면 현재 상태의 값과 survivor path값을 이용하여이전의 상태를 찾을수 있고 그때의 decoding out를 찾을수 있다. 이 과정을 전체 state 에 반복하여 진행하여 최종 decoding out을 찾는다.

Traceback(4/7) /******************************************************************************************/ // MODULE : Traceback // // FILE NAME: traceback.v // VERSION: 1.0 // DATE: JAN 15, 2004 // AUTHOR: DONG KI CHOI // Description: This module defines a Traceback. //`include "parameter.v" module traceback( clk, rst_n, acs_out, small_state, decode_out ); input clk; input rst_n; input [7:0] acs_out; input [2:0] small_state; output decode_out; wire [7:0] acs_out; wire [7:0] pa_mem0, pa_mem1, pa_mem2, pa_mem3, pa_mem4, pa_mem5, pa_mem6, pa_mem7, pa_mem8, pa_mem9, pa_mem10, pa_mem11, pa_mem12, pa_mem13, pa_mem14, pa_mem15, pa_mem16, pa_mem17, pa_mem18, pa_mem19;

Traceback(5/7) ACS모듈에서의 survivor path값을 저장한다.
wire [2:0] next_state0, next_state1, next_state2, next_state3, next_state4, next_state5, next_state6, next_state7, next_state8, next_state9, next_state10, next_state11, next_state12, next_state13, next_state14, next_state15, next_state16, next_state17, next_state18, next_state19; wire out0, out1, out2, out3, out4, out5, out6, out7, out8, out9, out10, out11, out12, out13, out14, out15, out16, out17, out18, out19; wire [2:0] small_state; wire decode_out; // main code tb_mem tbm0( clk, rst_n, acs_out, pa_mem0); tb_mem tbm1( clk, rst_n, pa_mem0, pa_mem1); tb_mem tbm2( clk, rst_n, pa_mem1, pa_mem2); tb_mem tbm3( clk, rst_n, pa_mem2, pa_mem3); tb_mem tbm4( clk, rst_n, pa_mem3, pa_mem4); tb_mem tbm5( clk, rst_n, pa_mem4, pa_mem5); tb_mem tbm6( clk, rst_n, pa_mem5, pa_mem6); tb_mem tbm7( clk, rst_n, pa_mem6, pa_mem7); tb_mem tbm8( clk, rst_n, pa_mem7, pa_mem8); tb_mem tbm9( clk, rst_n, pa_mem8, pa_mem9); tb_mem tbm10( clk, rst_n, pa_mem9, pa_mem10); tb_mem tbm11( clk, rst_n, pa_mem10, pa_mem11); ACS모듈에서의 survivor path값을 저장한다. Traceback depth는 하드웨어 구현시 약 K값의 5~6배의 값을 사용한다. Traceback depth는 K = 4이기 때문에 20에서 24정도의 Traceback depth값을 가질수 있도록 설계

Traceback(6/7) 저장된 survivor path 값을 이용하여 traceback 과정을 진행한다.
tb_mem tbm12( clk, rst_n, pa_mem11, pa_mem12); tb_mem tbm13( clk, rst_n, pa_mem12, pa_mem13); tb_mem tbm14( clk, rst_n, pa_mem13, pa_mem14); tb_mem tbm15( clk, rst_n, pa_mem14, pa_mem15); tb_mem tbm16( clk, rst_n, pa_mem15, pa_mem16); tb_mem tbm17( clk, rst_n, pa_mem16, pa_mem17); tb_mem tbm18( clk, rst_n, pa_mem17, pa_mem18); tb_mem tbm19( clk, rst_n, pa_mem18, pa_mem19); tb_unit tbu0(small_state, pa_mem0, next_state0, out0 ); tb_unit tbu1(next_state0, pa_mem1, next_state1, out1 ); tb_unit tbu2(next_state1, pa_mem2, next_state2, out2 ); tb_unit tbu3(next_state2, pa_mem3, next_state3, out3 ); tb_unit tbu4(next_state3, pa_mem4, next_state4, out4 ); tb_unit tbu5(next_state4, pa_mem5, next_state5, out5 ); tb_unit tbu6(next_state5, pa_mem6, next_state6, out6 ); tb_unit tbu7(next_state6, pa_mem7, next_state7, out7 ); tb_unit tbu8(next_state7, pa_mem8, next_state8, out8 ); tb_unit tbu9(next_state8, pa_mem9, next_state9, out9 ); tb_unit tbu10(next_state9, pa_mem10, next_state10, out10 ); tb_unit tbu11(next_state10, pa_mem11, next_state11, out11 ); tb_unit tbu12(next_state11, pa_mem12, next_state12, out12 ); tb_unit tbu13(next_state12, pa_mem13, next_state13, out13 ); tb_unit tbu14(next_state13, pa_mem14, next_state14, out14 ); tb_unit tbu15(next_state14, pa_mem15, next_state15, out15 ); 저장된 survivor path 값을 이용하여 traceback 과정을 진행한다.

Traceback(7/7) 최종 출력을 decoding 출력으로 사용한다.
tb_unit tbu16(next_state15, pa_mem16, next_state16, out16 ); tb_unit tbu17(next_state16, pa_mem17, next_state17, out17 ); tb_unit tbu18(next_state17, pa_mem18, next_state18, out18 ); tb_unit tbu19(next_state18, pa_mem19, next_state19, out19 ); dff_n buff1 ( clk, rst_n, out19, decode_out ); endmodule 최종 출력을 decoding 출력으로 사용한다.

Traceback Unit(1/2) /******************************************************************************************/ // MODULE : Traceaback unit // // FILE NAME: tb_unit.v // VERSION: 1.0 // DATE: JAN 15, 2004 // AUTHOR: DONG KI CHOI // Description: This module defines a Traceaback unit. `include "parameter.v" module tb_unit( state, surv_data, next_state, out ); // input data input [2:0] state; // from lowest state or previous state input [7:0] surv_data; // from traceback memory // output data output [2:0] next_state; // to next state output out; // present state decode out data

Traceback Unit(2/2) // main code assign out = state[2];
assign next_state = { state[1:0], surv_data[state[2:0]] }; endmodule

Traceback Memory(1/2) /******************************************************************************************/ // MODULE : Traceback Memory // // FILE NAME: traceback.v // VERSION: 1.0 // DATE: JAN 15, 2004 // AUTHOR: DONG KI CHOI // Description: This module defines a Traceback memory. `include "parameter.v" module tb_mem( clk, rst_n, tb_in, tb_out, ); // input data input clk; input rst_n; input [7:0] tb_in; // output data output [7:0] tb_out; wire clk; wire rst_n; wire [7:0] tb_in; wire [7:0] tb_out;

Traceback Memory(2/2) // main code
dff_n #(8) tbm0( clk, rst_n, tb_in, tb_out ); endmodule

Viterbi Decoder- Top(1/3)
/******************************************************************************************/ // MODULE : Viterbi decoder // // FILE NAME: viterbi.v ( top module ) // VERSION: 1.0 // DATE: Feb 2, 2004 // AUTHOR: DONG KI CHOI // Description: This module defines Viterbi decoder. `include "parameter.v" module viterbi( clk, rst_n, data_in, decode_out ); // input data input clk; input rst_n; input [1:0] data_in; // output data output decode_out;

wire clk; wire rst_n; wire [1:0] data_in; wire [1:0] data_out; wire [31:0] bm_data; wire [`BUS_WIDTH-1:0] acs_mem_h; wire [`BUS_WIDTH-1:0] acs_mem_l; wire [`BUS_WIDTH-1:0] acs_norm_h; wire [`BUS_WIDTH-1:0] acs_norm_l; wire [`BUS_WIDTH-1:0] norm_mem_h; wire [`BUS_WIDTH-1:0] norm_mem_l; wire [2:0] small_state; wire [7:0] acs_out; wire decode_out; wire comp_en; input_buf buf0( clk, rst_n, data_in, data_out ); bmc bm1( data_out, bm_data ); acs_en acsen0( clk, rst_n, comp_en); acs acs1( comp_en, bm_data, acs_mem_h, acs_mem_l, acs_norm_h, acs_norm_l, acs_out ); normalize norm1( acs_norm_h, acs_norm_l, norm_mem_h, norm_mem_l, small_state ); metric_mem mm1( clk, rst_n, norm_mem_h, norm_mem_l, acs_mem_h, acs_mem_l); traceback tb1( clk, rst_n, acs_out, small_state, decode_out ); endmodule

Viterbi Decoder-Testbench(1/3)
/******************************************************************************************/ // MODULE : viterbi testbench // // FILE NAME: viterbi_test.v(testbench) // VERSION: 1.0 // DATE: JAN 14, 2004 // AUTHOR: DONG KI CHOI // Description: This module defines a viterbi testbench. `include "parameter.v" module viterbi_tb(); wire decode_out; reg clk; reg rst_n; reg [1:0] data_out; viterbi vi1( clk, rst_n, data_out, decode_out); always #`HALF clk = ~clk; initial begin clk= 1;rst_n = 1;#5; rst_n = 0;#5; rst_n = 1;

data_out = 2'b00; #`PERIOD; // data_out = 2'b11; #`PERIOD; // data_out = 2'b11; #`PERIOD; // 10 1 error! data_out = 2'b11; #`PERIOD; // 01 1 error! data_out = 2'b01; #`PERIOD; // 01 0 data_out = 2'b00; #`PERIOD; // 00 0 data_out = 2'b11; #`PERIOD; // 11 0 data_out = 2'b11; #`PERIOD; // 11 1 // 10 data_out = 2'b11; #`PERIOD; // 11 0 // 20 2개의 error 삽입

data_out = 2'b00; #`PERIOD; // 00 0 // 30 // 40 $stop; // initial end endmodule

Testbench - Input buffer
Transmitted sequence : …

Testbench – BMC

Testbench – ACS

Testbench – Normalize

Testbench – Path Metric Memory

Testbench – Trace Back

Testbench – Decoding out

[Project 1] Viterbi Decoding Algorithm : 이동 통신 오류 정정

Similar presentations

Presentation on theme: "[Project 1] Viterbi Decoding Algorithm : 이동 통신 오류 정정"— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

[Project 1] Viterbi Decoding Algorithm : 이동 통신 오류 정정

Similar presentations

Presentation on theme: "[Project 1] Viterbi Decoding Algorithm : 이동 통신 오류 정정"— Presentation transcript:

Similar presentations

About project

Feedback