DO AN TN_DUY_KHA

5/11/2018 DO AN TN_DUY_KHA - slidepdf.com

http://slidepdf.com/reader/full/do-an-tnduykha 1/131

<<

BỘ GIÁO DỤC VÀ ĐÀO TẠO

TRƯỜNG ĐẠI HỌC SƯ PHẠM KỸ THUẬT TP.HCMKHOA ĐIỆN – ĐIỆN TỬ

BỘ MÔN ĐIỆN TỬ - VIỄN THÔNG

----------

ĐỒ ÁN TỐT NGHIỆP

NGÀNH: CÔNG NGHỆ ĐIỆN TỬ VIỄN THÔNG

Đề tài:

THỰC HIỆN BỘ GIẢI MÃ VITERBI

TRÊN FPGA

GVHD: ThS. Lê Minh ThànhKS. Đặng Phước Hải Trang

SVTH: Huỳnh Minh Khả

MSSV: 06117029SVTH: Lê DuyMSSV: 06117010

Thành phố Hồ Chí Minh, tháng 1 năm 2011



Thực hiện bộ giải mã Viterbi trên FPGA Trang i

LỜI CẢM ƠN

Phần A: Giới thiệu

Cuốnđồán

tốtn

ghiệp

đãhoànth

ànhđúngthờigianq

uyđịnhvà

đạtđượck

ếtquảnhưmongđợi.

Đểđạtđượ

ckếtqu

ảđó,trướchế

tnhóm

thựch

iệnmu

ốngửilờibiếtơnđế

ncácbậcc

hamẹđãk

hổ

côngsinh

thànhdư

ỡn

gdụcđểtạonênnh

ững

thành

viêncủan

hóm

ngày

hôm

nay.Bêncạnhđ

ó,

khôngthểk

hôngkểđếnsựtậntì

nhgiúpđỡ

củacácth

ầycôtrongbộmônĐ

iệntử-Viễ

nthôngcũ

ng

nhưcácthầ

ycôtrong

khoaĐiện-Điệntử,c

áct

hầycô

đãhếtmực

giúpđỡn

hómtrongsuốtquátrì n

h

họctậptại

trường,

khôngchỉgiá

odụcnhó

mv

ềkiến

thứcmàcònchỉbảo

nhữngkỹn

ăngsốngc

ần

thiếtđểnhó

mcóthểđ

ứngvữngtrongcuộcs ống

tựlập

saukhirat rư

ờng.Đặ

cbiệt,nhómthựchiện

đề

tàixinchân

thànhcảmơnthầyL

êMinhTh

ành

vàthầ

yĐặngPhướcHảiT

r anglànhữ

nggiảngv

iên

đãtrựctiếp

hướngdẫn

nhómtrongquátrình

thự

chiệnđ

ềtài.Các

thầyđãtậntìnhgiúpđ

ỡnhómtro

ng

quátrìnhhọ

ctậptạ

itrườngvàth

ểhiệnsựq

uan

tâmvớ

iviệcđảmnhậnhướn

gdẫnnhóm

thựchiện

đề

tàitốtnghiệ

p.

Mộtlầnnữanhómthự

chiệnxin

chânthành

biếtơncácbậccham

ẹvàchânt h

ànhcảmơ

nquýthầy

côđãtậntì

nhgiúpđỡnhómtrong

quátrình

học

tậptại

trường.

TPHCM

.N

gày1thán

g1năm20

11

Nhómthực

hiệnđềtài



Thực hiện bộ giải mã Viterbi trên FPGA Trang ii

QUYẾT ĐỊNH GIAO ĐỀ TÀI

Họ và tên sinh viên: Huỳnh Minh Khả MSSV: 06117029Lê Duy MSSV: 06117010

Ngành: Công Nghệ Điện tử - Viễn thôngTên đề tài: Thực hiện bộ giải mã Viterbi trên FPGA

1) Cơ sở ban đầu:Từ thực tiễn của việc thông tin di động và viễn thông ngày càng bùng nổ, cùng

với sự đam mê trong lĩnh vực điện tử và viễn thông, nhóm thực hiện đề tài đã quyếtđịnh chọn nội dung đồ án tốt nghiệp là mô tả một thuật giải mã kênh truyền phổ

biến là thuật giải Viterbi cho mã xoắn. Đây có thể xem là một sự kết hợp tốt giữakiến thức viễn thông và chuyên ngành điện tử.

2) Nội dung các phần thuyết minh và tính toán:

o Tổng quan về hệ thống thông tin số.

o Mã hóa chập và thuật toán giải mã Viterbi.

o Mô phỏng thuật toán giải mã Viterbi trên Matlab.

o Xây dựng thuật toán giải mã Viterbi trên KIT DE2.

3) Các bản vẽ:

..........................................................................................................................

..........................................................................................................................

4) Giáo viên hướng dẫn: ThS. Lê Minh Thành

KS. Đặng Phước Hải Trang

5) Ngày giao nhiệm vụ: ....../....../2010

6) Ngày hoàn thành nhiệm vụ: ....../....../2011


Giáo viên hướng dẫn Ngày........tháng....năm 20….

Chủ nhiệm bộ môn

BỘ GIÁO DỤC VÀ ĐÀO TẠOTRƯỜNG ĐẠI HỌC SƯ PHẠM KỸ THUẬT

THÀNH PHỐ HỒ CHÍ MINH

CỘNG HÒA XÃ HỘI CHỦ NGHĨA VIỆT NAM

Độc lập - Tự do - Hạnh phúc



Thực hiện bộ giải mã Viterbi trên FPGA Trang iii

NHẬN XÉT CỦA GIÁO VIÊN HƯỚNG DẪN

…………………………………………………………

………………………………………………………………………………………………………………………………

………………………………………………………………

………………………………………………………………

………………………………………………………………

………………………………………………………………

………………………………………………………………

………………………………………………………………

………………………………………………………………

………………………………………………………………

………………………………………………………………

………………………………………………………………

……………………………………………

TP Hồ Chí Minh, ngày......tháng......năm 2011

Giáo viên hướng dẫn




Thực hiện bộ giải mã Viterbi trên FPGA Trang iv

NHẬN XÉT CỦA GIÁO VIÊN PHẢN BIỆN

…………………………………………………………

………………………………………………………………………………………………………………………………

………………………………………………………………

………………………………………………………………

………………………………………………………………

………………………………………………………………

………………………………………………………………

………………………………………………………………

………………………………………………………………

………………………………………………………………

………………………………………………………………

………………………………………………………………

……………………………………………

TP Hồ Chí Minh, ngày......tháng......năm 2011

Giáo viên phản biện




Thực hiện bộ giải mã Viterbi trên FPGA Trang v

LỜI NÓI ĐẦU

Cùng với sự phát triển của khoa học và công nghệ phục vụ cho cuộc sống của

con người, công nghệ viễn thông trong những năm qua đã có những bước phát triểnmạnh mẽ cung cấp ngày càng nhiều tiện ích cho con người.

Thế kỷ 21 chứng kiến sự bùng nổ thông tin, trong đó thông tin di động đóngmột vai trò rất quan trọng. Nhu cầu trao đổi thông tin ngày càng tăng cả về sốlượng, chất lượng và các loại hình dịch vụ kèm theo, điều này đòi hỏi phải tìm ra

phương thức trao đổi thông tin mới ngày càng ưu việt và mang lại hiệu quả cao hơn.Các công nghệ di động và viễn thông ngày một phát triển nhanh chóng để hướng tớimục đích tăng tốc độ cũng như chất lượng của các dịch vụ nhằm đáp ứng nhu cầu

ngày càng cao của con người về các thiết bị không dây bỏ túi.Một trong những khâu quan trọng nhất của việc thông tin không dây đó là việc

truyền và nhận tín hiệu. Điều này cần thiết phải có một loại mã hóa dành riêng chokênh truyền có khả năng sửa chữa sai sót của tín hiệu truyền đi do các tác động củamôi trường. Các hình thức được sử dụng để mã hóa kênh truyền trước đó đều cónhững khuyết điểm nhất định trong việc khôi phục dữ liệu bị sai sót trên đườngtruyền, thường chỉ có khả năng phát hiện lỗi và báo về bên phát để thực hiện truyềnlại tin tức bị sai đó. Điều này làm chậm quá trình truyền tin tức. Bộ mã hóa dùng mã

chập và thuật giải mã Viterbi là một chuẩn đang được ứng dụng rất rộng rãi trêntoàn thế giới với nhiều ưu điểm vượt trội so với các hình thức trước đó, ngoài khảnăng phát hiện lỗi tốt nhờ sự kiểm soát chặt chẽ tin tức truyền đi, nó còn có khảnăng tự khôi phục các tin tức bị sai trong quá trình truyền trên kênh truyền. Điềunày giúp giảm thiểu tối đa thời gian truyền nhận tin tức, do đó tốc độ dữ liệu ngàymột được nâng cao. Tuy vẫn còn một số hạn chế nhất định trong việc khôi phục cácđoạn tin tức sai hàng loạt, nhưng thuật toán Viterbi vẫn là sự lựa chọn ưu tiên và lànền tảng cho việc phát triển các hình thức mã hóa và giải mã tốt hơn nữa hiện tại vàsau này.

Vì những ưu điểm nổi bật và tính ứng dụng cao của thuật toán này trong hiệntại và tương lai của ngành viễn thông, nhóm thực hiện quyết định chọn đề tài là“Thực hiện bộ giải mã Viterbi trên FPGA”. Trong phạm vi của cuốn đồ án này,nhóm thực hiện đề tài sẽ giới thiệu khái quát về hai hình thức mã hóa và giải mãnày và tiến hành mô phỏng thuật toán mã hóa và giải mã đó trên Matlab cũng nhưmô tả phần cứng trên kit DE2 của Altera.

Nội dung của đồ án sẽ bao gồm các vấn đề sau:

• Chương 1: Tổng quan về hệ thống thông tin số




Thực hiện bộ giải mã Viterbi trên FPGA Trang vi

Giới thiệu về vị trí vai trò của mã hóa kênh truyền trong hệ thống thông tinsố, so sánh hai hình thức mã hóa là mã khối và mã trellis.

• Chương 2: Thuật toán Viterbi

Khái niệm và phân tích mã chập, cách thức mã hóa sử dụng mã chập, cũngnhư cấu trúc của bộ mã hóa chập. Giới thiêu thuật toán giải mã Viterbi,nguyên lý thực hiện giải mã và phân loại một số phương pháp giải mã.

• Chương 3: Xây dựng thuật giải Viterbi dùng Matlab

Tiến hành đi mô phỏng thuật toán mã hóa mã chập và thuật toán giải mãViterbi. Phân tích thuật toán

• Chương 4: Xây dựng thuật giải Viterbi trên kit DE2

Mô phỏng thuật toán thực tế hơn trên kit DE2 với các led hiển thị dữ liệu từđó thấy được hiệu quả của thuật toán Viterbi, ứng dụng ngôn ngữ thiết kế phần cứng VHDL

• Chương 5: Kết luận

Đánh giá kết quả thực hiện của đồ án và đưa ra phương hướng phát triểncủa đề tài trong tương lai.

TP HCM. Ngày … tháng … năm 2011

Nhóm thực hiện đề tài




Thực hiện bộ giải mã Viterbi trên FPGA Trang vii

MỤC LỤCTrang

TRƯỜNG ĐẠI HỌC SƯ PHẠM KỸ THUẬT TP.HCM .................................1

LỜI CẢM ƠN .......................................................................................................i

QUYẾT ĐỊNH GIAO ĐỀ TÀI ...........................................................................ii

NHẬN XÉT CỦA GIÁO VIÊN HƯỚNG DẪN ...............................................iii

LỜI NÓI ĐẦU .....................................................................................................v

MỤC LỤC .........................................................................................................vii

LIỆT KÊ HÌNH ...................................................................................................xLIỆT KÊ BẢNG ................................................................................................xii

PHẦN B ..................................................................................................................13

CHƯƠNG 1 .......................................................................................................14

1.1 Vị trí của mã hóa kênh trong hệ thống thông tin số .................................14

1.2 Khái niệm mã hóa kênh và phân loại ......................................................15

1.2.1 Khái niệm .........................................................................................15

1.2.2 Phân loại mã hóa kênh .....................................................................16

1.3 Khái quát về mã khối và mã trellis ..........................................................16

1.3.1 Mã khối ............................................................................................16

1.3.2 Mã trellis ..........................................................................................17

CHƯƠNG 2 .......................................................................................................19

2.1 Khái niệm mã chập ..................................................................................19

2.2 Phân tích mã hóa dùng mã chập ..............................................................19

2.3 Cấu trúc mã chập .....................................................................................23

2.4 Biểu diễn mã chập ..................................................................................27

2.5 Ưu nhược điểm của mã chập ..................................................................30

2.5.1 Ưu điểm ...........................................................................................30

2.5.2 Nhược điểm .....................................................................................30

2.6 Định nghĩa thuât toán Viterbi ..................................................................30

2.7 Phân tích thuật giải Viterbi ......................................................................312.8 Giải mã quyết định cứng và giải mã quyết định mềm .............................43




Thực hiện bộ giải mã Viterbi trên FPGA Trang viii

2.8.1 Thuật toán Viterbi quyết định cứng .................................................43

2.8.2 Thuật toán Viterbi quyết định mềm .................................................49

2.8.2.1 Thuật toán Viterbi quyết định mềm (phương pháp 1) ...............49

2.8.2.2 Thuật toán Viterbi quyết định mềm (phương pháp 2) ...............502.8.3 Ưu điểm của giải mã quyết định mềm so với giải mã quyết định cứng .................................................................................................................... 52

2.9 Xác suất lỗi ............................................................................................55

2.10 Ưu nhược điểm của thuật toán giải mã Viterbi .....................................56

2.10.1 Ưu điểm .........................................................................................56

2.10.2 Nhược điểm ...................................................................................56

CHƯƠNG 3 .......................................................................................................573.1 Giới thiệu ...............................................................................................57

3.2 Sơ đồ khối hệ thống ................................................................................57

3.3 Lưu đồ mô phỏng ...................................................................................58

3.3.1 Khối tạo bit ngõ vào .........................................................................58

3.3.2 Khối mã hóa .....................................................................................59

3.3.3 Khối cộng nhiễu Gausse trắng .........................................................59

3.3.4 Khối giải mã ....................................................................................59

3.3.5 Tính toán và vẽ BER ........................................................................60

3.4 Hình ảnh về chương trình mô phỏng ........................................................60

CHƯƠNG 4 .......................................................................................................66

4.1 Giới thiệu sơ lược KIT DE2 và phần mềm Quartus ................................66

4.1.1 KIT DE2 của Altera ..........................................................................66

4.1.1.1 Tổng quan kit DE2 .....................................................................66

4.1.1.2 Sử dụng nút nhấn và Switch .....................................................68

4.1.1.3 Sử dụng LCD ............................................................................69

4.1.2 Phần mềm lập trình Quatus II .........................................................69

4.2 Giải quyết vấn đề ....................................................................................70

4.2.1 Giải mã viterbi quyết định cứng ........................................................70

4.2.2 Giải mã viterbi quyết định mềm ........................................................74

4.3 Lưu dồ thuật toán lập trình .......................................................................764.4 Kết quả ...................................................................................................83




Thực hiện bộ giải mã Viterbi trên FPGA Trang ix

CHƯƠNG 5: KẾT LUẬN .................................................................................89

5.1 Tổng kết nhận xét .....................................................................................89

5.2 Tồn tại và hướng phát triển của đề tài ......................................................89

PHẦN C ..................................................................................................................91I. Phụ lục .......................................................................................................92

1. Hướng dẫn sử dụng kit DE2 để mô phỏng .............................................92

2. Tài nguyên sử dụng trên Kit DE2 ..........................................................92

3. Mã nguồn Matlab .................................................................................95

4. Mã nguồn VHDL ................................................................................106

II. Tài liệu tham khảo ..................................................................................130




Thực hiện bộ giải mã Viterbi trên FPGA Trang x

LIỆT KÊ HÌNH

Hình 1.1: Vị trí của mã hóa kênh truyền trong hệ thống thông tin số

Hình 1.2: Sự phân chia mã hóa kênh thành hai nhánh riêng biệtHình 2.1: Bộ mã hóa cho mã chập tốc độ 1 / 2 R =Hình 2.2: Bộ mã hóa hệ thống với 1 / 2 R =Hình 2.3: Bộ mã hóa hệ thốngHình 2.4: Sơ đồ bộ mã hóa hệ thống 2 / 3 R = có phần cứng đơn giảnHình 2.5: Sơ đồ tổng quát bộ mã chậpHình 2.6: Bộ mã chập (3,2,2)Hình 2.7: Sơ đồ bộ mã chập với N=3, k=1, n=3Hình 2.8: Sơ đồ hình cây bộ mã (2,1,3)Hình 2.9: Sơ đồ hình lưới bộ mã chập (2,1,3).Hình 2.10: Sơ đồ trạng thái của bộ mã chập (2,1,3).Hình 2.11: Bộ mã chập tốc độ ½Hình 2.12: Đồ hình trạng thái của mã chập ½Hình 2.13: Các nhánh trong bộ mã hóaHình 2.14: Đường đi hoàn chỉnh khôi phục chính xác tín hiệu tại ngõ raHình 2.15: Tín hiệu nhận có 2 bit sai tại t =2 và t = 11Hình 2.16: Tại thời điểm t = 1

Hình 2.17: Tại thời điểm t = 2Hình 2.18: Tại thời điểm t = 3Hình 2.19: Tại thời điểm t = 4Hình 2.20: Tại thời điểm t = 5Hình 2.21: Tất cả dữ liệu đã được giải mã và sửa sai chính xácHình 2.22: Bộ mã tốc độ 1/3 và K= (7,7,5)Hình 2.23: Giải mã quyết định cứng và mềmHình 2.24: Hệ thống mã tích chậpHình 2.25: Kiểu kênh hệ thống nhị phân, trong đó p là xác suất chéo

Hình 2.26: Biểu diễn Viterbi theo ví dụHình 2.27: Mô tả giải mã quyết định cứng với bộ mã parityHình 2.28: Mô tả giải mã quyết định mềm với bộ mã parityHình 3.1: Sơ đồ khối hệ thốngHình 3.2: Lưu đồ mô phỏngHình 3.3: Giao diện khởi đầu chương trình mô phỏngHình 3.4: Giao diện chương trình mô phỏng 1Hình 3.5: Giao diện chương trình mô phỏng 2

Hình 3.6: Nhập bit ngẫu nhiên – Quyết định mềmHình 3.7: BER của quyết định mềm




Thực hiện bộ giải mã Viterbi trên FPGA Trang xi

Hình 3.8: Nhập bit ngẫu nhiên – Quyết định cứngHình 3.9: BER của quyết định cứngHình 3.10: So sánh BER của cả quyết định cứng và mềmHình 3.11: Tự nhập bit vào – Quyết định mềm

Hình 4.1: KIT DE2 của AlteraHình 4.2: Sơ đồ khối KIT DE2Hình 4.3: Chống dội phím nhấnHình 4.4: Tính toán metric nhánh và metric đường cho bộ giải mã ViterbiHình 4.5: Lưu đồ giải thuật chính của chương trìnhHình 4.6: Lưu đồ giải thuật bộ giải mãHình 4.7: Lưu đồ chi tiết giải thuật giải mã viterbi tren Kit DE2Hình 4.8: Lưu đồ tính khoảng cách HammingHình 4.9: Lưu đồ giải thuật tính khoảng cách Euclidean

Hình 4.10: Lưu đồ khối tính khoảng cách nhánhHình 4.11: Lưu đồ khối ACSHình 4.12: Lưu đồ khối truy hồiHình 4.13: Lưu đồ khối giải mãHình 4.14: Kết quả mô phỏng 1Hình 4.15: Kết quả mô phỏng 2Hình 4.16: Kết quả mô phỏng 3Hình 4.17: Kết quả mô phỏng 4

Hình 4.18: Kết quả mô phỏng 5Hình 4.19: Kết quả mô phỏng 6Hình 4.20: Mô phỏng trên MatlabHình 4.21: Hình thực tế bộ kit 1Hình 4.22: Hình thực tế bộ kit 2Hình 4.23: Hình thực tế bộ kit 3




Thực hiện bộ giải mã Viterbi trên FPGA Trang xii

LIỆT KÊ BẢNG

Bảng 2.1: Trạng thái ngõ vào và ngõ ra của bộ mã hóa tốc độ ½

Bảng 2.2: Bảng ma trận tích lũy của cả 8 bit của bản tin

Bảng 2.3: Bảng lịch sử trạng thái (state history table)

Bảng 2.4: Bảng các trạng thái được lựa chọn khi truy hồi

Bảng 2.5: Bảng trạng thái kế tiếp (next state table)

Bảng 2.6: Bảng chứa các dữ liệu của bản tin gốc đã được khôi phục

Bảng 2.7: Ví dụ về punctured code

Bảng 2.8: Các giá trị metric bit thông thường

Bảng 2.9: Các giá trị metric bit cách 2

Bảng 2.10: Ví dụ với bộ mã parity

Bảng 2.11: Tính toán khoảng cách Hamming cho quyết định cứng

Bảng 2.12: Tính toán khoảng cách Euclidean cho quyết định mềm

Bảng 4.1: Thứ tự kết nối phím nhấn với các chân của FPGA

Bảng 4.2: Gán chân FPGA cho màn hình LCDBảng 4.3: Trạng thái hiện tại và trạng thái trước của nó

Bảng 4.4: Bảng trạng thái tiếp theo




PHẦN B

NỘI DUNG



Thực hiện bộ giải mã Viterbi trên FPGA Trang 14

CHƯƠNG 1

TỔNG QUAN VỀ HỆ THỐNG THÔNG TIN SỐ1.1 Vị trí của mã hóa kênh trong hệ thống thông tin số

Mã hóa kênh là một khâu rất quan trọng trong hệ thống thông tin số không dâycùng với mã hóa nguồn, ghép kênh, điều chế,… để tạo ra một tín hiệu phù hợp choviệc truyền dẫn vô tuyến và tín hiệu đó có khả năng điều khiển được sự sai bit và

sửa các lỗi xảy ra nếu có để có thể khôi phục lại gần như nguyên dạng tín hiệu tintức mà mình truyền đi.

Hình 1.1: Vị trí của mã hóa kênh truyền trong hệ thống thông tin số

Mã hoá kênh: mục đích là làm giảm xác suất sai thông tin khi truyền qua kênhtruyền.

Việc giảm thiểu xác suất sai dựa việc phát hiện sai và sửa sai có thể dẫn đến việcgiảm tỉ số tín hiệu trên nhiễu (SNR) cần thiết nhờ đó giảm được công suất, tiết kiệmnăng lượng. Việc sửa sai hữu hiệu cho tín hiệu SNR nhỏ sẽ thuận lợi cho việc bảomật, trải phổ và tăng độ chính xác của thông tin nhận- mục đích quan trọng nhất của

truyền thông.

Chương 1: Tổng quan về hệ thống thông tin số




1.2 Khái niệm mã hóa kênh và phân loại

1.2.1 Khái niệm

Mã hóa kênh là việc đưa thêm các bit dư vào tín hiệu số theo một quy luật nào

đấy, nhằm giúp cho bên thu có thể phát hiện và thậm chí sửa được cả lỗi xảy ra trênkênh truyền.

Một số hệ thống có thể khắc phục lỗi bằng cách gởi một yêu cầu cho bên phátgửi lại tín hiệu nếu phát hiện lỗi, đó là chế độ ARQ. Nhưng việc này chỉ thích hợpcho các hệ thống truyền dẫn hữu tuyến và một số hệ thống vô tuyến không yêu cầuvể thời gian trễ. Thay vào đó, với các hệ thống thông tin không dây ngày nay, ngườita hay sử dụng một loại mã có thể phát hiện và khắc phục lỗi một cách tự động.Việc này giảm thiểu thời gian trể so với các hệ thống yêu cầu truyền lại. Bộ mã này

thường được gọi là mã điều khiển lỗi (ECC), hay chính xác hơn là FEC.Mục đích của lý thuyết Mã hóa trên kênh truyền là tìm những mã có thể truyền

thông nhanh chóng, chứa đựng nhiều từ mã tự hợp lệ và có thể sửa lỗi hoặc ít nhất phát hiện các lỗi xảy ra. Các mục đích trên không phụ thuộc vào nhau, và mỗi loạimã có công dụng tối ưu cho một ứng dụng riêng biệt. Những đặc tính mà mỗi loạimã này cần còn tuỳ thuộc nhiều vào xác suất lỗi xảy ra trong quá trình truyền thông.

Đối với một đĩa CD thông thường, lỗi trong âm thanh xảy ra chủ yếu là do bụivà những vết xước trên mặt đĩa. Vì thế, các mã được lồng vào với nhau. Dữ liệu

được phân bổ trên toàn bộ mặt đĩa. Tuy không được tốt cho lắm, song một mã táidiễn đơn giản có thể được dùng làm một ví dụ dễ hiểu. Chẳng hạn, chúng ta lấy mộtkhối số liệu bit (đại diện cho âm thanh) và truyền gửi chúng ba lần liền. Bên máythu, chúng ta kiểm tra cả ba phần lặp lại ở trên, từng bit từng bit một, rồi lấy cái nàocó số bầu cao nhất. Điểm khác biệt ở đây là, chúng ta không chỉ truyền gửi các bittheo thứ tự. Chúng ta lồng nó vào với nhau. Khối dữ liệu này, trước tiên, được chiara làm 4 khối nhỏ. Sau đó chúng ta gửi một bit ở khối đầu tiên, tiếp theo một bit ở khối thứ hai v.v tuần tự qua các khối. Việc này được lặp đi lặp lại ba lần để phân bổsố liệu ra trên bề mặt đĩa. Trong ngữ cảnh của mã tái diễn đơn giản ở trên, việc làm

này hình như không được hiệu quả cho lắm. Song hiện nay có những mã có hiệuứng cao, rất phù hợp với việc sửa lỗi xảy ra đột ngột do một vết xước hay một vết

bụi, khi dùng kỹ thuật lồng số liệu nói trên.

Mỗi mã thường chỉ thích hợp cho một ứng dụng nhất định. Viễn thông trong vũtrụ bị giới hạn bởi nhiễu nhiệt trong thiết bị thu. Hiện trạng này không xảy ra mộtcách đột phát bất thường, song xảy ra theo một chu trình tiếp diễn. Tương tự nhưvậy, modem với dải tần hẹp bị hạn chế vì nhiễu âm tồn tại trong mạng lưới điệnthoại. Những nhiễu âm này có thể được biểu hiện rõ hơn bằng một mô hình tạp âm

tiếp diễn. Điện thoại di động hay có vấn đề do sự suy sóng nhanh chóng xảy ra. Tầnsố cao được dùng có thể gây ra sự suy sóng tín hiệu một cách nhanh chóng, ngay cả





khi máy nhận chỉ dời chỗ vài phân Anh. Một lần nữa, người ta hiện đã có một loạimã hóa trên kênh truyền được thiết kế để đối đầu với tình trạng suy sóng.

1.2.2 Phân loại mã hóa kênh

Lý thuyết mã hóa đại số được chia ra làm 2 loại mã chính1. Mã khối.

2. Mã trellis.

Chúng phân tích ba đặc tính sau của mã (nói chung) là:

• Chiều dài của mã.

• Tổng số các từ mã hợp lệ.

• Khoảng cách Hamming tối thiểu giữa hai từ mã hợp lệ.

Hình 1.2: Sự phân chia mã hóa kênh thành hai nhánh riêng biệt

Trong mỗi loại mã lại được phân tách thành 2 nhánh nữa đó là mã tuyến tính và

mã không tuyến tính.

Thường thì các mã không tuyến tính không được ứng dụng trong thực tế vì cácnhược điểm của nó, nên ở đây chúng ta chỉ đề cập đến các mã tuyến tính.

Trong phần tiếp theo chúng ta sẽ khái quát sơ lược về mã khối và mã trellis.

1.3 Khái quát về mã khối và mã trellis

1.3.1 Mã khối

Mã khối tuyến tính mang tính năng tuyến tính, chẳng hạn tổng của hai từ mã nào

đấy lại chính là một từ mã; và chúng được ứng dụng vào các bit của nguồn trêntừng khối một; cái tên mã khối tuyến tính là vì vậy. Có những khối mã bất tuyến





tính, song khó mà chứng minh được rằng một mã nào đó là một mã tốt nếu mã ấykhông có đặc tính này.

Bất cứ mã khối tuyến tính nào cũng được đại diện là (n,m,d min), trong đó

1. n, là chiều dài của từ mã, trong ký hiệu,2. m, là số ký hiệu nguồn được dùng để mã hóa tức thời,

3. d min, là khoảng cách hamming tối thiểu của mã.

Có nhiều loại mã khối tuyến tính, như

1. Mã vòng (Mã Hamming là một bộ phận nhỏ của mã tuần hoàn).

2. Mã chẵn lẻ.

3. Mã Reed-Solomon.

4. Mã BCH.

5. Mã Reed-Muller.

6. Mã hoàn hảo.

Mã khối được gắn liền với bài toán “đóng gói đồng xu” là bài toán gây một sốchú ý trong nhiều năm qua. Trên bề diện hai chiều, chúng ta có thể hình dung đượcvấn đề một cách dễ dàng. Lấy một nắm đồng xu, để nằm trên mặt bàn, rồi dồnchúng lại gần với nhau. Kết quả cho chúng ta một mẫu hình lục giác tương tự như

hình tổ ong. Các mã khối còn dựa vào nhiều chiều khác nữa, không dễ gì mà hìnhdung được. Mã Golay có hiệu ứng cao, dùng trong truyền thông qua khoảng khôngvũ trụ, sử dụng những 24 chiều. Nếu được dùng là mã nhị phân (thường thấy), cácchiều ám chỉ đến chiều dài của từ mã như đã định nghĩa ở trên.

1.3.2 Mã trellis

Mã trellis hay còn gọi là mã chập (kết hợp) được sử dụng trong các modem dảitần âm (V.32, V.17, V.34) và trong các điện thoại di động GSM, cũng như trong cácthiết bị truyền thông của quân đội vũ trang và trong các thiết bị truyền thông với vệtinh.

Mục đích của việc tạo ra mã chập là nhằm làm cho tất cả các ký hiệu từ mã trở thành tổng trọng số của nhiều loại ký hiệu thông điệp trong nhập liệu. Nó tương tựnhư toán kết hợp được dùng trong các hệ tuyến tính bất biến để dùng tìm xuất liệucủa một hệ thống, khi chúng ta biết nhập liệu và các đáp ứng xung.

Nói chung chúng ta tìm xuất liệu của bộ mã chập hệ thống, tức sự kết hợp củanhập liệu bit, đối chiếu với trạng thái của bộ mã hóa kết hợp, hoặc trạng thái của cácthanh ghi.





Về cơ bản mà nói, mã chập không giúp thêm gì trong việc chống nhiễu hơn mộtmã khối tương ứng. Trong nhiều trường hợp, chúng nói chung cho chúng ta một

phương pháp thực thi đơn giản hơn, hơn hẳn một mã khối có hiệu quả tương ứng.Bộ mã hóa thường là một mạch điện đơn giản, có một bộ nhớ, một vài biện pháp

truyền thông tin phản hồi báo tình hình, thường là các cổng loại trừ XOR. Bộ mãhóa có thể được thực thi trong phần mềm hay phần sụn.

Thuật toán Viterbi là một thuật toán tối ưu nhất được dùng để giải mã các mãchập. Hiện có những phương pháp giảm ước giúp vào việc giảm khối lượng tínhtoán phải làm. Những phương pháp này phần lớn dựa vào việc tìm tuyến đường cókhả năng xảy ra cao nhất. Tuy không ngắn gọn, song trong môi trường nhiễu thấphơn, người ta thường thấy chúng cho những kết quả khả quan. Các bộ điều hành vixử lý hiện đại có khả năng thực hiện những thuật toán tìm giảm ước nói trên với tỷ

lệ trên 4000 từ mã trong một giây.Đề tài chủ yếu nghiên cứu về thuật toán giải mã Viterbi để thấy được ưu điểm

của thuật toán trong việc giảm tối thiểu sai số khi mã hóa và giải mã tín hiệu. Dođó, trong các phần tiếp theo của đồ án, chúng ta chỉ tìm hiểu việc mã hóa tin tứcdùng mã chập và giải mã dựa trên thuật toán Viterbi cũng như những ưu khuyếtđiểm của chúng. Đồng thời ta tiến hành mô phỏng thuật toán trên Matlab và trênKit FPGA để kiểm chứng thực tế hơn. Còn đối với các mã trellis còn lại thì ta sẽkhông phân tích trong phạm vi cuốn đồ án này.





CHƯƠNG 2

THUẬT GIẢI MÃ VITERBI2.1 Khái niệm mã chập

Mã chập là một kỹ thuật mã hóa sửa sai. Mã chập thuộc họ mã lưới (mã hóatheo Trellis) và được xây dựng dựa trên một đa thức sinh hoặc một sơ đồ chuyểntrạng thái (trellis mã) đặc trưng. Quá trình giải mã của mã chập phải dựa vào trellismã thông qua các giải thuật khác nhau, trong đó nổi tiếng nhất là giải thuật Viterbi.

Tại sao gọi là mã chập vì cấu trúc mã hóa có thể biểu diễn dưới dạng phép tínhchập giữa đa thức sinh mã và chuỗi tín hiệu được mã hóa.

Mã hóa chập và thuật toán giải mã Viterbi được sử dụng trong khoảng hơn mộttỉ điện thoại, có thể là lớn nhất trong các loại thuật toán được ứng dụng. Tuy nhiên,hiện tại thì thuật toán xử lý viterbi được ứng dụng nhiều nhất trong các thiết bị âmthanh và hình ảnh kỹ thuật số. Ngày nay, chúng còn được sử dụng trong các thiết bị

bluetooth.

Mục đích của mã hóa kênh truyền là nhằm tăng dung lượng kênh truyền, bằngcách cộng thêm vào tín hiệu những dữ liệu dư thừa được thiết kế một cách cẩn thậntrước khi truyền lên kênh truyền. Mã hóa chập và mã hóa khối là 2 dạng chính củamã hóa kênh truyền. Mã hóa chập thì dựa trên dữ liệu nối tiếp, 2 hoặc một vài bitđược truyền một lúc, còn mã hóa khối thì dựa trên một khối dữ liệu lớn tương quan(đặc trưng là khoảng vài trăm bytes). Ví dụ, mã Redsolomon là một mã hóa khối.

Sự khác nhau cơ bản giữa mã hóa khối và mã hóa chập là mã hóa khối là mãhóa không nhớ. Cho một chuỗi dữ liệu K bit, thì ngõ ra của bộ mã hóa khối là mộtkhối dữ liệu n bit duy nhất. Mã hóa chập không kết nối các khối bit riêng vào trongmột khối từ mã, thay vào đó nó sẽ chấp nhận một chuỗi bit liên tục và taọ thành mộtchuỗi ngõ ra. Hiệu quả hay tốc độ dữ liệu của mã hóa chập được đánh giá bằng tỉ lệcủa số bit ngõ vào k, và số bit ngõ ra n. Trong mã hóa chập là có một vài bộ nhớ

dùng để ghi nhớ dòng bit vào. Thông tin này được sử dụng để mã hóa các bit tiếptheo.

2.2 Phân tích mã hóa dùng mã chập

Mã chập là mã tuyến tính có ma trận sinh có cấu trúc sao cho phép mã hóa cóthể xem như một phép lọc (hoặc lấy tổng chập). Mã chập được sử dụng rộng rãitrong thực tế. Bởi mã hóa được xem như một tập hợp các bộ lọc số tuyến tính vớidãy mã là các đầu ra của bộ lọc được ghép xen kẽ. Các mã chập là các mã đầu tiênđược xây dựng các thuật toán giải mã quyết định mềm hiệu quả.

Mã khối từ các khối k dấu (hay ký hiêu) tạo ra các khối n dấu. Với các mãchập (thường được xem là các mã dòng), bộ mã hóa hoạt động trên dòng liên tục

Chương 2: Thuật giải mã Viterbi




các bit vào không được phân thành các khối tin rời rạc. Tuy nhiên tốc độ mã

[ ]n

F X ∈ k

nđược hiểu là cứ có k ngõ vào ở mỗi bước thời gian sẽ tạo ra n ngõ ra.

Các phép tính số học sử dụng trong hình thức mã hóa này có thể được thực hiện

trên một trường tùy ý nhưng thông thường vẫn là trên GF(2).Ta biểu thị các dãy và các hàm truyền đạt như các chuỗi lũy thừa của biến x

(đôi khi còn dùng ký hiệu D thay cho x). Dãy {…,m -2, m-1, m0, m1, m2, …} (vớicác phần tử mi thuộc trường F) được xem như một chuỗi Laurent:

( ) e

ee

m X m x∞

=−∞

= ∑

Tập tất cả các chuỗi Laurent trên F là một trường, ta ký hiệu trường này là

[ ] F X . Như vậy [ ]( )m X F X ∈

Đối với dòng nhiều bit vào ta dùng ký hiệu m (1)(x) biểu thị dòng đầuvào đầu tiên, m(2)(x) biểu thị dòng đầu vào thứ hai. Tập các dòng vào xem như mộtvectơ:

m(x) = [m(1)(x) m(2)(x)] [ ]2

F X ∈

Bộ mã hóa cho mã chập thường được coi là một tập các bộ lọc số. Hình 2.1 chỉ ramột ví dụ về một bộ mã hóa

Hình 2.1: Bộ mã hóa cho mã chập tốc độ 12

R =

(các ô D biểu thị các ô nhớ một bít – các trigger D)

Dòng vào mk đi qua hai bộ lọc dùng chung các phần tử nhớ tạo ra hai dòngra.

C(1)k = mk + mk-1 + mk-2

và C(2)k = mk + mk-2 .

Hai dòng ra này được đưa ra xen kẽ để tạo ra dòng được mã hóa Ck . Nhưvậy cứ mỗi bít vào lại có hai bít mã hóa được đưa ra, kết quả là ta có một mã có tốc





độ R = 1/2.

Thông thường ta coi trạng thái ban đầu của các phần tử nhớ là 0. Như vậy,với dòng vào m = {1, 1, 0, 0, 1, 0, 1} các đầu ra sẽ là:

C

(1)

= {1, 0, 0, 1, 1, 1, 0, 1, 1}và C(2)= {1, 1, 1, 1, 1, 0, 0, 0, 1}

Dòng ra: C = {11, 01, 01, 11, 11, 10, 00, 10, 11}

Ở đây dấu phẩy phân cách các cặp bít ra ứng với mỗi bít vào.

Ta có thể biểu thị hàm truyền từ đầu vào m(x) từ đầu ra C(1)(x) như sau:

g1(x) = 1 + x +x2.

Tương tự ta có g2(x)= 1 + x 2.

Dòng vào m = {1, 1, 0, 0, 1, 0, 1} có thể biểu thị như sau:

m (x) = 1+ x+ x4+ x6 .

Các đầu ra sẽ là:

C(1)(x) = m(x)g1(x) = (1+ x +x4 + x6 )(1+ x + x2) = 1 +x3 +x4 +x5 +x7 + x8

C(2)(x) = m(x)g2(x) = (1+ x +x4 + x6 )(1+ x2) = 1+x + x2 +x3 +x4 +x8

Với mỗi mã chập tốc độ có một hàm truyền ma trận k × n ∈(x) (còn

được gọi là ma trận truyền). Với mã tốc độ ở ví dụ trên ta có:

Ga (x) = [1+ x+ x 2 1 + x 2]

Ma trận truyền này không chỉ có dạng các đa thức, ta có thể thấy thông quaví dụ sau:

Ví dụ 2.2.1: Xét ma trận truyền của mã chập sau:

Vì có “1” ở cột đầu tiên nên dòng vào sẽ xuất hiện trực tiếp ở đầu ra đan xen, bởivậy đây là một mã chập hệ thống. Bộ mã hóa cho mã này được mô tả ở hình 2.2:

Hình 2.2: Bộ mã hóa hệ thống với12

R =





Với dòng vào: m (x) = 1+ x + x 2 + x3+ x 4 + x8 các đầu ra C(1)k và C(2)

k códạng:

C(1)k = m(x) =1 + x +x2 + x3 + x 4 + x8

( )2 3 4 8 2

(2)2(1 x x x x x )(11k x xC x

x+ + + + + + += +

Một bộ mã hóa chỉ có các hàng đa thức trong ma trận truyền được gọi là bộmã hóa có đáp ứng xung hữu hạn. Một bộ mã hóa có các hàm hữu tỷ trong ma trậntruyền gọi là bộ mã hóa có đáp ứng xung vô hạn.

Với mã có tốc độ k/n với k > 1 dãy tin tức đầu vào (ta coi như được tách ratừ một dãy tin tức thành k dòng), ta có:

m(x) = [m(1)( x), m(2)(x),…,m(k)(x)]

và

Dãy ra được biểu thị như sau:C(X) = [C(1)(x), C(2)(x),…,C(n)(x)] = m(x)G(x)

Ma trận truyền G(x) được gọi là hệ thống nếu có thể xác định được một matrận đơn vị trong các phần tử của G(x) (chẳng hạn nếu bằng các phép hoán vị hàngvà/hoặc cột của G(x) có thể thu được một ma trận đơn vị).

Ví dụ 2.2.2: Cho mã hệ thống tốc độ23

R = có ma trận truyền sau:

Sơ đồ thể hiện của mã này cho trên hình 2.3:





Hình 2.3: Bộ mã hóa hệ thống

Một sơ đồ mã hóa khác có hiệu quả hơn được mô tả ở hình 2.4:

Hình 2.4: Sơ đồ bộ mã hóa hệ thống23

R = có phần cứng đơn giản

Giả sử: m(x) = [1+ x2 + x4+ x5+ x7+…,x2 + x5 + x6 + x7 + …]Khi đó đầu ra C(x) có dạng:

C(x) = [1+ x 2+ x 4+ x5+ x7+ …, x 2+ x5+ x6+ x7+ …, x+ x3+ x5+ …]

Khi đưa ra xen kẽ dòng ra sẽ là:

{100, 001, 110, 001, 100, 111, 010, 110}

Từ các ví dụ trên ta có định nghĩa sau cho mã chập

Định nghĩa: Mã chập tốc độ R = k/n trên trường các chuỗi Laurent hữu tỷ

[ ] F X trường F là ảnh của một ánh xạ tuyến tính đơn ánh của các

chuỗi Laurent k chiều m (x) [ ]k

F X ∈ vào các chuỗi Laurent C(x) [ ]n

F X ∈

2.3 Cấu trúc mã chập

Mã chập được tạo ra bằng cách cho chuỗi thông tin truyền qua hệ thống cácthanh ghi dịch tuyến tính có số trạng thái hữu hạn. Cho số lượng thanh ghi dịch làm (cũng ký hiệu là N), bộ mã có k bit ngõ vào và đầu ra bộ mã chập có n bit ngõ ra

(n hàm đại số tuyến tính hoặc n ngõ ra công modulo). Tốc độ mã là R = k/n, số ônhớ của bộ ghi dịch là m×k và tham số L gọi là chiều dài ràng buộc (Constraintlength) của mã chập (với L=k(m-1)).




Chuỗi mã n bit


Các thông số k,n có phạm vi giới hạn trong khoảng giá trị từ 1 đến 8, thông số mtrong khoảng từ 2 đến 10, và tốc độ mã R từ 1/8 đến 7/8 ngoại trừ các bộ mã hóađược sử dụng trong viễn thông vũ trụ có thể có tốc độ 1/100 hoặc thậm chí cao hơn.

Trong một số tài liệu, khi nói đến mã chập, người ta còn đặc trưng cho bộ mã

hóa chập bằng chiều dài ràng buộc K và tốc độ mã R. Tốc độ mã, R=k/n, được hiểulà tỉ số giữa số bit ngõ vào và số ký hiệu ngõ ra của bộ mã hóa. Thông số chiều dàiràng buộc, K, cho biết “chiều dài” của bộ mã hóa mã chập, ví dụ, có bao nhiêu trạngthái k-bit có thể đưa đến mạch logic tổ hợp để tạo ra ký hiệu ngõ ra. Trong nội dungđề tài này, chúng tôi sử dụng bộ mã với bộ dữ liệu bao gồm chiều dài ràng buộc K và tốc độ bộ mã R như đã đề cập ở trên.

Khi thực hiện với mã chập trong các ứng dụng thông thường, người ta thườngchỉ chọn số thanh ghi giới hạn, mỗi thanh ghi chỉ có 1 ô nhớ để đơn giản cho việc

thiết kế mà vẫn đảm bảo tính năng mã hóa tốt. Tương ứng với mỗi tốc độ mã hóa(các bộ mã đơn giản), người ta cũng đã thử nghiệm và chọn ra chỉ một số đa thứcsinh cho hiệu quả mã hóa cao để sử dụng.

Giả thiết, bộ mã chập làm việc với các chữ số nhị phân, thì tại mỗi lần dịch sẽcó k bit thông tin đầu vào được dịch vào thanh ghi dịch thứ nhất và tương ứng có k

bit thông tin trong thanh ghi dịch cuối cùng được đẩy ra ngoài mà không tham giavào quá trình tạo chuỗi bit đầu ra. Đầu ra nhận được chuỗi n bit mã từ n bộ cộngmôđun-2 (xem hình 2.5). Như vậy, giá trị chuỗi đầu ra kênh không chỉ phụ thuộc

vào k bit thông tin đầu vào hiện tại mà còn phụ thuộc vào (m-1)k bit trướcđó, và được gọi là mã chập (n,k,m).

Hình 2.5: Sơ đồ tổng quát bộ mã chập.

Giả sử u là véctơ đầu vào, x là véctơ tương ứng được mã hoá, bây giờ chúng tamô tả cách tạo ra x từ u. Để mô tả bộ mã hoá chúng ta phải biết sự kết nối giữathanh ghi đầu vào vào đầu ra hình 2.5. Cách tiếp cận này có thể giúp chúng ta chỉ rasự tương tự và khác nhau cũng như là với mã khối. Điều này có thể dẫn tới những

ký hiệu phức tạp và nhằm nhấn mạnh cấu trúc đại số của mã chập. Điều đó làmgiảm đi tính quan tâm cho mục đích giải mã của chúng ta. Do vậy, chúng ta chỉ


Chuỗi thông tin

đầu vào k bit 12...k

12... k 12... k

1

2

3

n




phác hoạ tiếp cận này một cách sơ lược. Sau đó, mô tả mã hoá sẽ được đưa ra vớinhững quan điểm khác.

Để mô tả bộ mã hoá hình 2.5 chúng ta sử dụng N ma trận bổ sung G1,G2…,G N

bao gồm k hàng và n cột. Ma trận Gi mô tả sự kết nối giữa đoạn thứ i của k ô nhớ trong thanh ghi ngõ vào với n ô của thanh ghi ngõ ra. N ngõ vào của hàng đầu tiêncủa Gi mô tả kết nối của ô đầu tiên của đoạn thanh ghi đầu vào thứ i với n ô củathanh ghi ngõ ra. Kết quả là “1” trong Gi nghĩa là có kết nối, là “0” nghĩa là khôngkết nối. Do đó chúng ta có thể định nghĩa ma trận sinh của mã chập:

Và tất cả các các ngõ vào khác trong ma trận bằng 0. Do đó nếu ngõ vào là

véctơ u, tương ứng véctơ mã hoá là: . x u G∞=

Bộ mã chập là hệ thống nếu trong mỗi đoạn của n chữ số đuợc tạo, k số đầu làmẫu của các chữ số đầu vào tương ứng. Nó có thể xác định rằng điều kiện nàytương đương có các ma trận k×n theo sau

vài = 2,3,….,N

Chúng ta xét một vài ví dụ minh hoạ sau đây:

Ví dụ 2.3.1: Xét mã (3,2,2). Bộ mã hoá được chỉ trong hình 2.6. Bây giờ mã được

định nghĩa thông qua 2 ma trận:

Bộ mã hoá là hệ thống, ma trận sinh được tạo ra:





Chuỗi thông tin u = ( 11011011…) được mã hóa thành chuỗi mãx = (111010100110…)

Hình 2.6: Bộ mã chập (3,2,2).

Một cách tương tự ta cũng có thể biểu diễn ma trận sinh G = (G1,G2,…,G N), Như vậy ý nghĩa của ma trận sinh là nó chỉ ra phải sử dụng các hàm tương ứng nào

để tạo ra véc tơ dài n mỗi phần tử có một bộ cộng môđun-2, trên mỗi véc tơ có N×k tham số biểu diễn có hay không các kết nối từ các trạng thái của bộ ghi dịch tới bộcộng môđun-2 đó. Xét véc tơ thứ i (gi, n ≥ i ≥ 1), nếu tham số thứ j của gi (L×k ≥ j≥1) có giá trị “1” thì đầu ra thứ j tương ứng trong bộ ghi dịch được kết nối tới bộcộng môđun-2 thứ i và nếu có giá trị “0” thì đầu ra thứ j tương ứng trong bộ ghidịch không được kết nối tới bộ cộng môđun-2 thứ i.

Ví dụ 2.3.2: Cho bộ mã chập có số thanh ghi N = 3, số ô nhớ trong mỗi thanh ghidịch k = 1, chiều dài chuỗi đầu ra n = 3 tức là mã (3,1,3) và ma trận sinh của mã

chập có dạng sau:

1

2

100

101 (4,5,7)

111n

g

g G G G

g

= ⇔ =

M

Có thể biểu diễn dưới dạng đa thức sinh là:

G(D) = [1 1+D2 1+D+D2]

Do đó sơ đồ mã chập được biểu diễn như sau:





Hình 2.7: Sơ đồ bộ mã chập với N=3, k=1, n=3

2.4 Biểu diễn mã chập

Có ba phương pháp để biểu diễn mã chập đó là: sơ đồ lưới, sơ đồ trạng thái, vàsơ đồ hình cây. Để làm rõ phương pháp này ta tập trung phân tích dựa trên ví dụhình 2.1 với bộ mã (2,1,3), đa thức sinh (7,5).

* Sơ đồ hình cây:

Từ ví dụ hình 2.1, giả thiết trạng thái ban đầu của các thanh ghi dịch trong bộmã đều là trạng thái “toàn 0”. Nếu bit vào đầu tiên là bit “0” thì đầu ra ta nhận đượcchuỗi “00”, còn nếu bit vào đầu tiên là bit “1” thì đầu ra ta nhận được chuỗi “11”.

Nếu bit vào đầu tiên là bit “1” và bit vào tiếp theo là bit “0” thì chuỗi thứ nhất là“11” và chuỗi thứ hai là chuỗi “10”. Với cách mã hoá như vậy, ta có thể biểu diễnmã chập theo sơ đồ có dạng hình cây (xem hình 2.8).Với hướng lên là hướng của

bit 0 đi vào bộ mã, nhánh đi xuống biểu hiện cho bit 1 được dịch vào. Từ sơ đồhình cây ta có thể thực hiện mã hoá bằng cách dựa vào các bit đầu vào và thực hiệnlần theo các nhánh của cây, ta sẽ nhận được tuyến mã, từ đó ta nhận được dãy cácchuỗi đầu ra.





00

10

0

1

00

10

01

11

00

10

01

11

00

10

01

11

00

00

11

00

11

00

10

01

10

01

11

11

00

01

10

Hình 2.8: Sơ đồ hình cây của bộ mã (2,1,3)

*Sơ đồ hình lưới:

Do đặc tính của bộ mã chập, cấu trúc vòng lặp được thực hiện như sau: chuỗi n bit đầu ra phụ thuộc vào chuỗi k bit đầu vào hiện hành và (N-1) chuỗi đầu vào trướcđó hay (N-1) × k bit đầu vào trước đó. Từ ví dụ hình 2.1 ta có chuỗi 2 bit đầu ra phụthuộc vào 1 bit đầu vào là “1” hoặc “0” và 4 trạng thái có thể có của hai thanh ghidịch, là “00”; “01”; “10”; “11”. Từ sơ đồ hình cây trên, ta thấy rằng tại tầng thứ 3,cứ mỗi trạng thái 00, 01, 10, 11 đều có 2 nhánh đến từ các trạng thái trước đó tùythuộc vào bit được dịch vào bộ mã là bit 0 hay bit 1. Với tính chất đó ta có thể biểudiễn mã chập bằng sơ đồ có dạng hình lưới gọn hơn, trong đó các đường liền nét

được ký hiệu cho bit đầu vào là bit “1” và đường đứt nét được ký hiệu cho các bitđầu vào là bit “0” (xem hình 2.9). Ta thấy rằng từ sau tầng thứ hai hoạt động củalưới ổn định, tại mỗi nút có hai đường vào nút và hai đường ra khỏi nút. Trong haiđường đi ra thì một ứng với bit đầu vào là bit “0” và đường còn lại ứng với bit đầuvào là bit “1”.





T=1 T=0

State

00

State

01

State

10

State

11

00

11

T=2

11

00

10

01

T=3

11

00

10

11

00

01

10

01

T=4

11

00

10

11

00

01

10

01

T=5

11

00

10

11

00

01

10

01

Hình 2.9: Sơ đồ hình lưới bộ mã chập (2,1,3) và bộ phát mã (7,5).

Trạng thái ban đầu toàn bằng “0”

*Sơ đồ trạng thái:

Sơ đồ trạng thái được thực hiện bằng cách đơn giản sơ đồ 4 trạng thái có thể

có của bộ mã (00, 01, 10 và 11) và trạng thái chuyển tiếp có thể được tạo ra từ trạngthái này chuyển sang trạng thái khác, quá trình chuyển tiếp có thể là:

Next State/output symbol, if

Current State Input = 0: Input = 1:

00 00/00 10/11

01 00/11 10/00

10 01/10 11/01

11 01/01 11/10

Kết quả ta thu được sơ đồ trạng thái trong hình 2.10 như sau:

Hình 2.10: Sơ đồ trạng thái của bộ mã chập (2,1,3)





Từ sơ đồ trạng thái hình 2.10, các đường liền nét được ký hiệu cho bit đầu vàolà bit “0” và đường đứt nét được ký hiệu cho các bit đầu vào là bit “1”. So với sơ đồhình lưới và sơ đồ hình cây thì sơ đồ trạng thái là sơ đồ đơn giản nhất.

2.5 Ưu nhược điểm của mã chập

2.5.1 Ưu điểm

Cũng như các mã sửa sai khác, mã chập cho phép chúng ta có thể sửa lại dữ liệuđã bị sai lệch khi truyền qua kênh truyền để khôi phục chính xác tín hiệu gốc.

Việc thực hiện mã hóa dùng mã chập tương đối đơn giản hơn các loại mã sửa saikhác mà chất lượng mã hóa lại tốt.

Việc thực hiện mã hóa dùng mã chập có thể được thực hiện bằng phần cứng và phần mềm.

Dựa trên hình thức mã hóa mã chập cùng thuật giải Viterbi cho nó, các bộ mãhóa sau này đều kế thừa những đặc tính ưu việt của nó.

2.5.2 Nhược điểm

Việc mã hóa và giải mã liên quan đến mã chập chỉ giải quyết được các lỗi một bit còn đối với các kênh truyền xuất hiện nhiều bit liên tiếp thì thuật toán mã hóa vàgiải mã này sẽ không còn hoàn hảo nữa.

Kênh truyền ở đây phải là kênh truyền ít nhiễu, vì nếu kênh truyền nhiễu quá

lớn, mã hóa chập sẽ không còn tốt nữa. Khi đó ta phải cần tới trải phổ tín hiệu đểđưa tín hiệu xuống dưới mức nhiễu để giảm thiểu ảnh hưởng.

2.6 Định nghia thuât toán Viterbi

Thuât toán Viterbi là môt giải phá p được sử dụng phổ biến để giải mã chuỗi bit được mã hóa bởi bô mã hóa tích châ p. Chi tiết của môt bô giải mã riêng phụthuôc vào môt bô mã hóa tích châ p tương ứng. Thuât toán Viterbi không phải là môt thuât toán đơn lẻ có thể dùng để giải mã những chuỗi bit mà được mã hóa bởi

bất cứ môt bô mã hóa châ p nào.

Thuât toán Viterbi được khởi xướng bởi Andrew Viterbi năm 1967 như là môtthuât toán giải mã cho mã châ p qua các tuyến thông tin số có nhiễu. Nó được sửdụng trong cả hai hê thống CDMA và GSM, các modem số, vê tinh, thông tin vũ trụ, và các hê thống mạng cục bô không dây. Hiên nay còn được sử dụng phổ biếntrong kỹ thuât nhân dạng giọng nói, nhân dạng từ mã, ngôn ngữ học máy tính.

Thuật toán giải mã Viterbi là một trong hai loại thuật toán giải mã được sửdụng với bộ mã hóa mã chập- một loại khác đó là giải mã tuần tự. Ưu điểm của giải

mã tuần tự so với Viterbi là nó có thể hoạt động tốt với các mã chập có chiều dàiràng buộc lớn, nhưng nó lại có thời gian giải mã biến đổi.





Còn ưu điểm của thuật toán giải mã Viterbi là nó có thời gian giải mã ổn định.Điều đó rất tốt cho việc thực thi bộ giải mã bằng phần cứng. Nhưng mà yêu cầu vềsự tính toán của nó tăng theo hàm mũ như là một hàm của chiều dài ràng buộc, vìvậy, trong thực tế, người ta thường giới hạn chiều dài ràng buộc của nó K = 9 hoặc

nhỏ hơn. Stanford Telecom tạo ra một bộ giải mã Viterbi K = 9 hoạt động ở tốc độđến 96 kbps, và một bộ giải mã với K = 7 hoạt động với tốc độ lên đến 45 Mbps.Các kỹ thuật không dây nâng cao có thể tạo ra một bộ giải mã Viterbi với K = 9hoạt động ở tốc độ lên đến 2 Mbps. NTT tuyên bố rằng họ đã tạo được bộ giãi mãViterbi hoạt động ở tốc độ 60 Mbps, nhưng tính khả thi của nó vẫn chưa được kiểmchứng.

2.7 Phân tích thuật giải Viterbi

Chúng ta sẽ lấy ví dụ về mã chập có tốc độ mã là k/n = ½

Hình 2.11: Bộ mã chập tốc độ ½

FF: thanh ghi dịch. Tại mỗi xung clock, nội dung của thanh ghi dịch được dịch qua phải 1 bit. Bit đầu tiên sẽ là ngõ vào, và bit cuối cùng sẽ là ngõ ra. Một thanh ghidịch có thể sẽ xem xét việc cộng trễ vào ngõ vào. Các thanh ghi dịch có thể đượchiểu như là bộ nhớ của bộ mã hóa. Nó ghi nhớ những bit đầu của chuỗi.

Thanh ghi dịch được khởi đầu với tất cả giá trị là 0.

Thuật toán XOR: 1 1= 0; 1 0=1; 0 1=1; 0 0=0 Nếu chúng ta làm việc trên một chuỗi ngõ vào là 01011101, ngõ ra là 00 11

10 00 01 10 01 002. Bộ mã hóa này cũng có thể được mô hình bởi một bảng trạngthái hữu hạn. Mỗi một trạng thái được quy định bởi 2 bit nhị phân- trạng thái của 2thanh ghi dịch. Mỗi một sự chuyển trạng thái được quy định bởi w/v1v2 với w đạidiện cho bit ngõ vào, và v1v2 là đại diện cho 2 bit ngõ ra, trong trường hợp nàychúng ta luôn luôn có w = v1.





Bảng 2.1: Trạng thái ngõ vào và ngõ ra của bộ mã hóa tốc độ ½

Next State/output symbol, if

Current State Input = 0: Input = 1:

00 00/00 10/11

01 00/11 10/00

10 01/10 11/01

11 01/01 11/10

Hình 2.12: Đồ hình trạng thái của mã chập ½

Bậy giờ chúng ta có thể mô tả thuật toán giải mã, phần chính là thuật toánViterbi. Có lẽ, khái niệm quan trọng nhất để hỗ trợ cho việc hiểu được thuật toánViterbi đó là sơ đồ Trellis. Hình bên dưới cho chúng ta thấy sơ đồ trellis cho ví dụcủa chúng ta ở tốc độ ½, mã hóa chập với chiều dài ràng buộc K = 3 với bản tin 8

bit.

T=5 T=6 T=7 T=8 T=9 T=10 T=4 T=3 T=2 T=1 T=0

State 00

State 01

State 10

State 11

Hình 2.13: Các nhánh trong bộ mã hóa





Bốn trạng thái có thể của bộ mã hóa được mô tả như 4 hàng của những dấuchấm theo chiều ngang. Có một cột của 4 chấm cho trạng thái khởi đầu của bộ mãhóa và một ở mỗi thời điểm của bản tin. Các đường in đậm kết nối các điểm trongsơ đồ biểu diễn cho sự chuyển trạng thái khi ngõ vào là một bit 1. Đường chấm

chấm là biểu diễn cho sự chuyển trạng thái khi ngõ vào là bit 0. Ta có thể thấy rõ sự phù hợp giữa sơ đồ trellis và đồ hình trạng thái đã nói ở trên.

Hình vẽ bên dưới cho ta thấy trạng thái trellis cho toàn bộ 8 bit ngõ vào. Các bitngõ vào bộ mã hóa và ký hiệu ngõ ra được thể hiện ở bên dưới của hình.

T=5 T=6 T=7 T=8 T=9 T=10 T=4 T=3 T=2 T=1 T=0

State 00

State 01

State 10

State 11

ENC IN =

ENC OUT =

0 1 0 1 1 1 0 1 0 0

00 11 10 00 01 10 01 00 10 11

Hình 2.14: Đường đi hoàn chỉnh khôi phục chính xác tín hiệu tại ngõ ra.

Các bit ngõ vào và các ký hiệu ngõ ra của bộ mã thì có thể xem ở dưới cùng củahình trên. Chú ý sự phù hợp giữa các ký hiệu ngõ ra và bảng ngõ ra chúng ta đã đềcập ở trên. Hãy xem xét một cách chi tiết hơn, sử dụng phiên bản mở rộng của sựchuyển đổi từ một trạng thái tức thời đến một trạng thái kế tiếp như hình bên dưới:

State

00

State

01

State

10

State

11

00

11

10

01

11

00

01

10

Giờ chúng ta sẽ xem xét cách thức giải mã của thuật toán Viterbi. Bây giờ chúng ta giả sử là chúng ta có một mẫu tin đã mã hóa (có thể có vài lỗi) và chúng ta

muốn khôi phục lại tín hiệu gốc.Giả sử chúng ta nhận được mẫu tin đã mã hóa ở trên với 1 bit lỗi.





T=5 T=6 T=7 T=8 T=9 T=10 T=4 T=3 T=2 T=1 T=0

State 00

State 01

State 10

State 11

ENC IN =

ENC OUT =

0 1 0 1 1 1 0 1 0 0

00 11 10 00 01 10 01 00 10 11

RECEIVED = 00 11 11 00 01 10 01 00 10 11

ERRORS = X

Hình 2.15: Tín hiệu nhận có 1 bit sai tại t =2

Ở mỗi thời điểm chúng ta nhận được 2 bit trong ký hiệu. Chúng ta sẽ tính toánthông số metric để đo “khoảng cách” giữa những gì mà chúng ta nhận được với tấtcả các cặp bit ký hiệu kênh truyền có thể mà chúng ta có thể nhận được. Đi từ thờiđiểm t=0 đến t=1, chỉ có 2 trạng thái mà chúng ta có thể nhận được là 00 và 11. Đólà bởi vì chúng ta biết được bộ mã hóa tích chập bắt đầu với trạng thái tất cả đều là0 và cho 1 bit vào là 0 hay 1 thì chỉ có 2 trạng thái mà chúng ta có thể đi đến và 2

ngõ ra của bộ mã hóa. Những ngõ ra này có trạng thái là 00 và 11.

Thông số metric mà chúng ta sẽ sử dụng là khoảng cách Hamming giữa cặp bitcủa ký hiệu nhận được và cặp bit có thể của kênh truyền. Khoảng cách Hammingđược tính một cách đơn giản bằng cách đếm có bao nhiêu bit khác giữa cặp bit nhậnđược từ kênh truyền và cặp bit so sánh. Kết quả chỉ có thể là 0, 1, 2. Giá trị củakhoảng cách Hamming (hay thông số metric) mà chúng ta tính toán ở mỗi khoảngthời gian cho đường dẫn của trạng thái tại thời điểm trước và trạng thái hiện tạiđược gọi là metric nhánh (branch metric). Ở thời điểm đầu tiên, chúng ta sẽ lưu

những kết quả này như là “thông số metric tích lũy”, được liên kết đến các trạngthái. Ở thời điểm thứ 2, thông số metric tích lũy sẽ được tính toán bằng cách cộngthêm thông số metric tích lũy trước đó vào metric nhánh hiện tại.

Ở thời điểm t=1, ta nhận được 2 bit “00”. Chỉ có một cặp ký hiệu kênh truyềnmà chúng ta có khả năng nhận được là “00” và “11”. Khoảng cách Hamming giữa“00” và “00” là bằng 0. Khoảng cách Hamming giữa “00” và “11” là 2. Do đó, giátrị thông số metric nhánh cho nhánh ứng với sự chuyển trạng thái từ “00” đến “00”là 0 và cho nhánh từ “00” đến “10” là 2. Khi mà thông số metric tích lũy trước đó là

0 thì thông số metric tổng sẽ chính bằng thông số metric của nhánh vừa xét. Tươngtự ta tính được thông số metric cho 2 trạng thái kia. Hình bên dưới minh họa kết quảtại thời điểm t= 1





T=1 T=0

State

00

State

01

State

10

State

11

ENCIN =

ENCOUT =

0

00

RECEIVED = 00

Accumulated

Error Metric =

0

2

00

11

Hình 2.16: Tại thời điểm t = 1

Điều gì sẽ xảy ra ở thời điểm t=2, chúng ta nhận được một cặp kí hiệu kênh

truyền là “11”, trong khi đó cặp ký hiệu kênh truyền mà chúng ta có thể nhận đượclà “00” nếu chuyển từ trạng thái “00” sang trạng thái “00” và “11” khi chuyển từtrạng thái “00” đến trạng thái “10”, “10” khi chuyển từ trạng thái “10” đến trạngthái “01”, “01” khi chuyển từ trạng thái “10” đến trạng thái “11”. Khoảng cáchHamming giữa 00 và 11 là 2, giữa 11 và 11 là 0, giữa 01 hoặc 10 với 11 là 1.Chúng ta cộng các thông số metric ở mỗi nhánh lại với nhau. ở thời điểm t=1 thìtrạng thái chỉ có thể là 00 hoặc 10, thông số metric tích lũy sẽ được cộng vào là 0hoặc là 2 một cách tương ứng. Hình bên dưới thể hiện sự tính toán thông số metrictích lũy ở thời điểm t=2.

T=1 T=0

State

00

State

01

State

10

State

11

ENCIN =

ENCOUT =

0

00

RECEIVED = 00

Accumulated

Error Metric =

0+2=200

11

T=2

1

11

11

11

00

10

01

2+1=3

0+0=0

2+1=3


Đó là tất cả sự tính toán cho thời điểm t=2. Đường nét đậm là metric nhánhđược lựa chọn vì theo các nhánh đó, thông số metric là nhỏ nhất. Giờ chúng ta sẽtính thông số metric tích lũy cho mỗi trạng thái tại thời điểm t=3.

Giờ chúng ta hãy nhìn vào hình minh họa cho thời điểm t=3. Chúng ta sẽ gặp phải một ít phức tạp hơn ở đây, tại mỗi trạng thái trong 4 trạng thái tại t=3 sẽ có 2





đường đến từ 4 trạng thái của thời điểm t=2. Chúng ta sẽ xoay sở thế nào? Câu trảlời là, chúng ta sẽ tính toán thông số metric tích lũy liên quan của mỗi nhánh, vàchúng ta sẽ bỏ đi giá trị metric lớn hơn, tức là sẽ loại bỏ nhánh đó đi. Nếu cặp thôngsố metric ở mỗi trạng thái là bằng nhau thì chúng ta sẽ giữ lại cả 2 trạng thái. Chúng

ta sẽ kế thừa những tính toán đã thực hiện ở thời điểm t=2. Thuật toán cộng thôngsố metric tích lũy trước đó vào nhánh mới, so sánh kết quả và chọn thông số metricnhỏ hơn (nhỏ nhất) để tiếp tục dùng cho thời điểm kế tiếp, được gọi là thuật toáncộng-so sánh-chọn. Hình bên dưới cho thấy kết quả của việc xử lý tại thời điểm t=3.

T=1 T=0

State

00

State

01

State

10

State

11

ENCIN =

ENCOUT =

0

00

RECEIVED = 00

Accumulated

Error Metric =00

11

T=2

1

11

11

11

00

10

01

0+1, 3+1 : 1

T=3

0

10

11

11

00

10

11

00

01

10

01

2+0, 3+2 : 2

0+1, 3+1 : 1

2+2, 3+0 : 3


Chú ý là cặp ký hiệu kênh truyền thứ 3 mà chúng ta nhận được sẽ có một lỗi.Thông số metric nhỏ nhất hiện tại là 1.

Chúng ta hãy xem điều gì xảy ra ở thời điểm t=4. Tiến trình xử lý cũng giốngnhư ở thời điểm t=3. Kết quả xem ở hình bên dưới

T=1 T=0

State

00

State

01

State

10

State

11

ENC IN =

ENC OUT =

0

00

RECEIVED = 00

Accumulated

Error Metric =00

11

T=2

1

11

11

11

00

10

01

2+1 , 1+1 : 2

T=3

0

10

11

11

00

10

11

00

01

10

01

3+2 , 1+0 : 1

2+1 , 1+1 : 2

3+0 , 1+2 : 3

T=4

1

00

00

11

00

10

11

00

01

10

01






Chú ý là ở thời điểm t=4, đường trellis của tin tức thực sự truyền đi được xácđịnh bằng đường in đậm, với thông số metric tích lũy là nhỏ nhất. Hãy xem xét ở thời điểm t=5:

T=1 T=0

State

00

State

01

State

10

State

11

ENC IN =

ENC OUT =

0

00

RECEIVED = 00

00

11

T=2

1

11

11

11

00

10

01

T=3

0

10

11

11

00

10

11

00

01

10

01

T=4

1

00

00

11

00

10

11

00

01

10

01

Accumulated

Error Metric =

1+0 , 2+2 : 1

3+1 , 2+1 : 3

1+2 , 2+0 : 2

3+1 , 2+1 : 3

T=5

1

01

01

11

00

10

11

00

01

10

01


Ở thời điểm t=10, sơ đồ trellis sẽ như thế này, các nhánh ko được chọn đã được bỏ đi:

T=5 T=6 T=7 T=8 T=9 T=10 T=4 T=3 T=2 T=1 T=0

State 00

State 01

State 10

State 11

ENC IN =

ENC OUT =

0 1 0 1 1 1 0 1 0 0

00 11 10 00 01 10 01 00 10 11

RECEIVED = 00 11 11 00 01 10 01 00 10 11

ERRORS = X

Hình 2.21: Tất cả dữ liệu đã được giải mã và sửa sai chính xác

Kết quả ở đây cho thấy chúng ta đã giải mã đúng chuỗi dữ liệu gốc. Nếu chúngta nhìn lại con đường để chúng ta tìm ra dữ liệu gốc là bằng cách so sánh dữ liệu

nhận được với dữ liệu so sánh của bộ giải mã có được từ bảng trạng thái. Điều nàycho thấy chúng ta đang sử dụng thuật toán giải mã dựa trên sự giống nhau lớn nhất.





Việc xử lý giải mã bắt đầu với xây dựng một thông số metric tích lũy cho một sốcặp ký hiệu kênh truyền nhận được, và lưu giữ trạng thái ở mỗi thời điểm t màthông số metric là nhỏ nhất. Một khi thông tin này được dựng lên thì bộ giải mãviterbi sẵn sàng để khôi phục lại chuỗi bit đã đưa vào bộ mã hóa chập, khi mẫu tin

được mã hóa để truyền đi. Điều này đạt được bằng những bước sau:o Đầu tiên, chọn một trạng thái có thông số metric nhỏ nhất và lưu lại

số trạng thái của trạng thái đó.

o Sử dụng lặp lại cho những bước kế tiếp mãi cho đến khi bắt đầu của

trellis đạt được: dựa vào bảng ghi nhớ trạng thái cho trạng thái đượcchọn, chọn một trạng thái mới được liệt kê trong bảng ghi nhớ trạngthái khi chuyển từ trạng thái trước đến trạng thái đó. Lưu số trạng tháicủa mỗi trạng thái được chọn. Bước này được gọi là truy hồi

(traceback).

o Chúng ta làm việc tiếp với danh sách những trạng thái được chọn đã được

lưu trong bước xử lý trước đó. Chúng ta tra xem bit ngõ vào nào phù hợp vớisự truyền dẫn từ mỗi trạng thái trước đến trạng thái kế tiếp. Đây là bit mà

phải được mã hóa bằng mã tích chập.

Bảng sau cho chúng ta thấy ma trận tích lũy của đầy đủ 8 bit (cộng với 2 bit phụthêm) của bản tin ở mỗi thời điểm t:

Bảng 4.2: Bảng ma trận tích lũy của cả 8 bit của bản tin

Chú ý rằng ở ví dụ về bộ giải mã Viterbi ngõ vào quyết định cứng này, thôngsố metric tích lũy nhỏ nhất ở trạng thái cuối chỉ ra được có bao nhiêu lỗi ký hiệukênh truyền xảy ra.

Bảng lịch sử trạng thái bên dưới cho thấy trạng thái tồn tại trước đó cho mỗi trạngthái tại thời điểm t:





Bảng 2.3: Bảng lịch sử trạng thái

Tương ứng 0,1,2,3 là các vị trí 00,01,10,112.Bảng sau cho thấy trạng thái được lựa chọn khi truy hồi đường dẫn từ bảng trạngthái tồn tại ở trên:

Bảng 2.4: Bảng các trạng thái được lựa chọn khi truy hồi

Sử dụng bảng ta thấy được sự chuyển đổi trạng thái đến các ngõ vào gây ra chúng,giờ chúng ta đã có thể tạo lại bản tin gốc. Bảng này rất giống với ví dụ của chúng taở bộ mã hóa chập tốc độ ½ và K= 3.

Bảng 2.5: Bảng trạng thái kế tiếp





Ghi chú: trong bảng ở trên, “x” chỉ ra là một sự chuyển trạng thái không thể xảy ratừ một trạng thái đến một trạng thái khác.

Bây giờ chúng ta đã có tất cả các công cụ cần thiết để tái tạo lại bản tin gốc từ bảntin mà chúng ta nhận được.

Bảng 2.6: Bảng chứa các dữ liệu của bản tin gốc đã được khôi phục

Hai bit phụ đã được bỏ qua.

Làm thế nào mà thuật toán truy hồi cuối cùng cũng tìm ra con đường đi đúng

nhất của nó thậm chí nếu nó chọn trạng thái ban đầu là sai. Điều này có thể xảy ranếu có hơn một trạng thái có thông số metric tích lũy là nhỏ nhất. Chúng ta sẽ dùnglại hình 2.18 để làm sáng tỏ điều này:

T=1 T=0

State

00

State

01

State

10

State

11

ENCIN =

ENCOUT =

0

00

RECEIVED = 00

Accumulated

Error Metric =00

11

T=2

1

11

11

11

00

10

01

0+1 , 3+1 : 1

T=3

0

10

11

11

00

10

11

00

01

10

01

2+0 , 3+2 : 2

0+1 , 3+1 : 1

2+2 , 3+0 : 3

Ở thời điểm t=3, cả 2 trạng thái “01” và “11” đều có thông số metric là 1.

Đường đi đúng đi đến trạng thái “01”, chú ý là đường in đậm là đường đi thực sựcủa bản tin để đến trạng thái này. Nhưng giả sử chúng ta chọn trạng thái “11” để bắtđầu quá trình truy hồi của chúng ta. Trạng thái trước đó của trạng thái “11” là trạngthái “10”, cũng là trạng thái trước đó của trạng thái “01”. Điều này là bởi vì ở thờiđiểm t=2, trạng thái “10” có thông số metric tích lũy là nhỏ nhất. Vì vậy, sau trạngthái bắt đầu sai, chúng ta có thể ngay lập tức trở lại với tuyến đường đúng.

Với ví dụ về bản tin 8 bit, chúng ta tiến hành xây dựng một sơ đồ trellis chotoàn bộ bản tin trước khi bắt đầu quá trình truy hồi. Với các bản tin dài hơn hoặccác chuỗi dữ liệu liên tục, điều này là không thực tế, bởi vì bộ nhớ chiều dài ràng

buộc và sự trì hoãn trong giải mã. Nghiên cứu cho thấy là độ sâu truy hồi của Kx5chỉ đủ cho việc giải mã viterbi với loại bộ mã mà chúng ta đang thảo luận. Bất cứ





một sự truy hồi sâu hơn sẽ làm tăng thời gian delay giải mã và bộ nhớ yêu cầu choviệc giãi mã và cũng ko làm tăng hiệu quả việc giải mã, ngoại trừ bộ mã hóa thủng(punctured code) mà chúng ta sẽ nói sau.

Để thực thi một bộ giải mã Viterbi bằng phần mềm, bước đầu tiên là phải xây

dựng một vài cấu trúc dữ liệu xoay quanh thuật giải mã sẽ được thực thi. Nhữngcấu trúc dữ liệu này được thực thi tốt nhất khi là các mảng. Sáu mảng chính màchúng ta cần cho bộ giải mã viterbi là:

- Một bản sao của “Bảng trại thái kế tiếp” của bộ mã hóamã chập, bảng chuyển trạng thái của bộ mã hóa. Kíchcỡ của bảng này (hàng x cột) là 2(K-1) x 2K . Mảng này

phải được khởi đầu trước khi bắt đầu tiến trình giải mã.

- Một bản sao của “bảng ngõ ra” của bộ mã hóa mã chập.Kích cỡ của bảng này là 2(K-1) x 2K . Mảng này cũng cần

phải được khởi đầu trước khi bắt đầu tiến trình giải mã.

- Một mảng để lưu trữ trạng thái hiện tại và trạng thái kếcủa bộ mã hóa mã chập, với giá trị ngõ vào (0 hoặc 1) sẽcho ra trạng thái kế tiếp và trạng thái hiện tại. Chúng tasẽ gọi bảng này là “bảng ngõ vào”. Kích thước của bảnglà 2(K-1) x 2(K-1). Mảng này cũng cần phải được khởi đầutrước khi bắt đầu tiến trình giải mã.

- Một mảng để lưu trữ lịch sử các trạng thái trước chomỗi trạng thái của bộ mã hóa cho Kx5 + 1 cặp kí hiệukênh truyền nhận được. Chúng ta sẽ gọi bảng này là“bảng lịch sử trạng thái”. Kích thước của mảng này là2(K-1) x (Kx5 +1). Mảng này không cần khởi động trướckhi bắt đầu tiến trình giải mã.

- Một mảng để lưu trữ thông số metric tích lũy cho mỗitrạng thái được tính toán sử dụng nguyên tắc cộng- sosánh- lựa chọn. Mảng này sẽ được gọi là “mảng thôngsố metric tích lũy”. Kích thước của mảng này là 2 (K-1) x2. Mảng này không cần khởi động trước khi bắt đầu tiếntrình giải mã.

- Một mảng dùng để lưu trữ danh sách các trạng thái đãđược quyết định trong suốt quá trình truy hồi. Nó đượcgọi là “mảng chuỗi trạng thái”. Kích thước của mảngnày là (Kx5 + 1). Mảng này không cần khởi động trước

khi bắt đầu tiến trình giải mã.





Giờ chúng ta hãy nói về tốc độ của những bộ mã hóa chập mà có thể được giảimã bởi các bộ giải mã Viterbi. Ở trên chúng ta đã đề cập đến bộ mã hóa thủng, làmột hướng chung của bộ mã hóa tốc độ cao, tốc độ lớn hơn từ k đến n. Puncturedcode được tạo ra bởi dữ liệu mã hóa đầu tiên sử dụng một bộ mã hóa tốc độ 1/n

như là bộ mã hóa thí dụ được mô tả trước đây và sau đó xóa bỏ một vài ký hiệukênh truyền ở ngõ ra của bộ mã hóa. Quá trình này được gọi là “puncturing”. Ví dụ,để tạo ra mã tốc độ ¾ từ mã tốc độ ½, thì đơn giản là sẽ xóa ký hiệu kênh truyềntheo mẫu punctured sau đây:

Bảng 2.7: Ví dụ về punctured code

Trong đó, bit “1” chỉ ra rằng một ký hiệu kênh truyền sẽ được truyền, và bit“0” để chỉ ra rằng một kí hiệu kênh truyền sẽ được xóa. Để xem làm thế nào màviệc này có thể tạo ra bộ mã tốc độ ¾. Hãy nghĩ là mỗi cột của bảng trên tương ứngvới một bit ngõ vào đến bộ mã hóa và mỗi một bit “1” trong bảng tương ứng vớimột ký hiệu kênh ở ngõ ra. Có 3 cột trong bảng và 4 bit “1”. Thậm chí bạn có thể

tạo ra bộ mã tốc độ 2/3 sử dụng một bộ mã hóa ½ với mẫu puncturing sau:

với 2 cột và 3 bit “1”.

Để giải mã một punctured code, bit “1” phải thay thế những kí hiệu rỗng cho

những kí hiệu đã bị xóa ở ngõ vào của bộ giải mã Viterbi. Kí hiệu rỗng có thể là kíhiệu được lượng tử đến mức “1” yếu và mức “0” yếu hoặc hơn nữa có thể là một kíhiệu cờ đặc biệt, mà khi được xử lí bằng mạch ACS trong bộ giải mã, kết quả làkhông thay đổi thông số metric tích lũy từ trạng thái trước.

Dĩ nhiên, n không phải bằng 2. Ví dụ, một mã tốc độ 1/3 và K=3 (7,7,5) cóthể được mã hóa sử dụng bộ mã hóa như bên dưới:





Hình 2.22: Bộ mã tốc độ 1/3 và K= (7,7,5)

Bộ mã hóa này có 3 bộ cộng modulo, vì vậy với mỗi một bit ngõ vào, có thể tạo ra3 ngõ ra kí hiệu kênh truyền. Dĩ nhiên, với mẫu puncturing phù hợp, bạn có thể tạora những mã tốc độ cao hơn sử dụng bộ mã hóa này.

2.8 Giải mã quyết định cứng và giải mã quyết định mềm

Giải mã quyết định mềm và quyết định cứng dựa vào loại lượng tử hóa được sửdụng ở các bit nhận được. Giải mã quyết định cứng sử dụng loại lượng tử hóa 1 bittrên các giá trị kênh nhận được. Giải mã quyết định mềm sử dụng loại lượng tử hóanhiều bit trên các giá trị kênh nhận được. Đối với giải mã quyết định mềm lý tưởng

(lượng tử hóa không xác định), các giá trị kênh nhận được được sử dụng trực tiếptrong bộ giải mã hóa kênh. Hình 2.23 biểu diễn giải mã quyết định cứng và quyếtđịnh mềm.

Hình 2.23: Giải mã quyết định cứng và mềm

2.8.1 Thuật toán Viterbi quyết định cứng

Đối với mã tích chập, chuỗi ngõ vào được xoắn thành chuỗi mã hóa c. Chuỗi c

được phát xuyên qua kênh nhiễu và chuỗi nhận được là chuỗi r . Thuật toán Viterbilà thuật ước đoán khả năng xảy ra lớn nhất (Maximum Likelihood-ML) cho rachuỗi mã hóa được ước đoán y từ chuỗi nhận được r để cho chuỗi này đạt được xác





xuất p(r/y) lớn nhất. Chuỗi y phải là một trong những chuỗi mã hóa cho phép vàkhông thể là bất kì chuỗi tùy ý nào.

Hình 2.24 trình bày cấu trúc hệ thống

Hình 2.24: Hệ thống mã tích chập

Đối với một mã tích chập có tốc độ r , các ngõ vào của bộ mã hóa k bit songsong và các ngõ ra n bit song song tại mỗi bước. Chuỗi ngõ ra là

0 0 0 1 1 1 1(1), (2), ..., ( ), (1), (2), ..., ( ), (1), ...,l m l m x x x x k x x x k x+ − += (2.8.1)

Và chuỗi được mã hóa là

0 0 0 1 1 1 1(1), (2), ..., ( ), (1), (2), ..., ( ), (1), ...,l m l mc c c c n c c c n c c+ − + −= (2.8.2)

Trong đó L là chiều dài của chuỗi tin ngõ vào và m là chiều dài lớn nhất của cácthanh ghi dịch. Yêu cầu phải thêm vào đuôi của chuỗi mã hóa với m bit zero để cho

bộ mã hóa tích chập trở về trạng thái tất cả zero. Yêu cầu bộ mã hóa phải bắt đầu vàkết thúc tại trạng thái tất cả zero. Các chỉ số bên dưới là chỉ số thời gian và các chỉsố bên trên là bit chỉ ra khối k bit ngõ vào hay n bit ngõ ra riêng lẻ. Các chuỗi đượcước đoán y và chuỗi nhận được r có thể được mô tả tương tự.

1 1

(1) ( 2 ) ( ) (1) ( 2 ) ( ) (1)

1 1 1, , ..., , , , ..., , , ...l m l m

n n

o o or r r r r r r r + − +

= (2.8.3)

Và

1 1

(1) ( 2 ) ( ) (1) ( 2 ) ( ) (1)

1 1 1

, , ..., , , , ..., , , ...l m l m

n n

o o o

y y y y y y y y+ − +

=

(2.8.4)

Đối với giải mã ML, thuật toán Viterbi chọn y để P(r/y) lớn nhất. Giả thiết kênhlà không nhớ, và vì vậy quá trình nhiễu ảnh hưởng lên bit nhận được độc lập vớiquá trình nhiễu ảnh hưởng lên tất cả các bit khác. Từ lý thuyết xác suất (xác suấtliên kết), xác suất của tập hợp các sự kiện độc lập tương đương với tính xác suất củacác sự kiện riêng lẻ. Vì vậy,

( ) ( ) ( ) ( )1

(1) (1) ( 2 ) ( 2 ) ( )

0

| | | .... L m

n n

i i i i i

i

p r y p r y p r y p r + −

=

= ∏ (2.8.5)





( ) ( )1

( ) ( )

0 1

| | L m n

j j

i i

i j

p r y p r y+ −

= =

=

∏ ∏ (2.8.6)

Biểu thức này được gọi là hàm có khả năng xảy ra của y với r nhận được. Việc

ước đoán P(r/y) lớn nhất cũng là logP(r/y) lớn nhất bởi vì các hàm logarit là cáchàm tăng đều. Vì vậy, một hàm log của khả năng xảy ra có thể được định nghĩa log log(/),

( )1

( ) ( )

0 1

log ( | ) log |l m n

j j

i i

i j

p r y p r y+ −

= =

=

∑ ∑ (2.8.7)

Vì thao tác trên các tổng dễ dàng hơn thao tác trên các hàm log nên một metricbit được định nghĩa như sau:

( ) ( )( ) ( ) ( ) ( )| log | j j j j

i i i iM r y a p r y= (2.8.8)

Trong đó a và b được chọn trước để cho metric bit là một số nguyên dương nhỏnhất. Các giá trị a và b được định nghĩa cho kênh hệ thống nhị phân (BSC) hay giảimã quyết định cứng. Hình 2.25 trình bày một BSC

Hình 2.25: Kiểu kênh hệ thống nhị phân, trong đó p là xác suất chéo

Đối với BSC a và b có thể được chọn theo 2 cách phân biệt. Theo cách thôngthường a và b được chọn như sau:

(2.8.9)

Và

(2.8.10)

Kết quả metric bit là

(2.8.11)





Từ kiểu BSC, rõ ràng chỉ lấy giá trị p và 1-p. Bảng 2.8 trình bày kết quả metric bit

Bảng 2.8: Các giá trị metric bit thông thường

Bit nhận Bit nhận

Bit được giải mã

0 1


1 0

Metric bit này biểu diễn ước lượng của các bit giải mã và các bit nhận. Ví dụnếu bit được giải mã yi

(j) = 0 và bit nhận được r i(j) = 0 thì ước lượng M(yi(j) | r i(j)) = 0.

Tuy nhiên, nếu bit được giải mã yi(j) = 0 và bit nhận được r i(j) = 1 thì ước lượng

M(yi(j) | r i(j)) = 1. Như vậy điều này liên quan đến khoảng cách Hamming và được

biết như là metric của khoảng cách Hamming . Vì vậy, thuật toán Viterbi chọn chuỗimã y qua trellis có ước lượng/khoảng cách Hamming nhỏ nhất liên quan đến chuỗinhận được r.

Cách khác a và b có thể được chọn như sau:

(2.8.12)

Và

(2.8.13)

Kết quả metric bit cách 2 là

(2.8.14)

Bảng 2.9: Các giá trị metric bit cách 2

Bit nhận Bit nhận






1 0


0 1

Đối với trường hợp này thuật toán Viterbi chọn chuỗi mã hóa y qua trellis cóước lượng/khoảng cách Hamming lớn nhất đối với chuỗi nhận được r. Hơn nữa,

đối với một kênh tùy ý(không nhất thiết là BSC), các giá trị a và b được tìm theonguyên tắc thử- và – sai để lấy metric bit có thể chấp nhận được.

Từ metric bit, metric đường được định nghĩa là:

(2.8.15)

Và chỉ ra tổng ước lượng của việc ước đoán chuỗi bit nhận được r với chuỗi bit

được mã hóa y trong sơ dồ trellis. Hơn nữa metric nhánh thứ K được định nghĩanhư sau:

(2.8.16)

Và metric đường thành phần được định nghĩa như sau:

(2.8.17)

Do đó:(2.8.18)

Metric nhánh thứ k chỉ ra việc ước lượng chọn một nhánh từ biểu đồ trellis.Metric đường thứ k chỉ ra việc ước lượng chọn một chuỗi bit được mã hóa từng

phần y tới chỉ số thời gian k.

Thuật toán Viterbi sử dụng biểu đồ trellis để tính các metric đường. Mỗi trạng

thái (nút) trong biểu đồ trellis được gán một giá trị gọi là metric đường thành phần.Metric đường từng phần được xác định từ trạng thái s = 0 tại thời điểm t = 0 đến





một trạng thái đặc biệt s = k tại thời điểm t >= 0. Tại mỗi trạng thái metric đườngtừng phần tốt nhất được chọn từ các đường kết thúc tại trạng thái đó. Metric đườngtừng phần tốt nhất, có thể là metric lớn nhất hay nhỏ nhất phụ thuộc vào a và b đượcchọn theo cách thông thường hay chọn lựa khác. Metric được chọn diễn tả bằng

đường tồn tại (survivor) và các metric còn lại được diễn tả bằng đường không phùhợp (nonsurvivor). Các đường tồn tại được lưu lại trong khi các đường không phùhợp bị loại bỏ trong sơ đồ trellis. Thuật toán Viterbi chọn đường tồn tại đơn giản đitừ cuối của tiến trình giống như đường ML. Sau đó truy ngược theo đường MLtrong biểu đồ trellis sẽ tìm được chuỗi giải mã ML.

Thuật toán Viterbi quyết định cứng có thể được thực hiện như sau:

Sk,t là trạng thái trong biểu đồ trellis tương ứng với trạng thái Sk tại thời điểm t.Mỗi trạng thái trong Trellis được gán một giá trị là V(Sk,t).

1. (a) khởi tạo t = 0

(b) khởi tạo V(S0,0) = 0 và tất cả các V khác V(Sk,t) = +oo

2. (a) lấy t = t+1

(b) Tính các metric đường từng phần cho tất cả đường đi đến trạng thái S k

tại thời điểm t.

Đầu tiên, tìm metric nhánh thứ t

(2.8.19)

Metric này được tính từ khoảng cách Hamming

(2.8.20)

Thứ hai, tính metric đường thành phần thứ t

(2.8.21)

Metric này được tính từ

3. a) Lấy V(Sk,t) đến metric đường từng phần tốt nhất là trạng thái Sk tạithời điểm t. Thông thường, metric đường từng phần tốt nhất là metricđường từng phần có giá trị nhỏ nhất

(b) Nếu có một nút TIE nằm trên metric đường từng phần tốt nhất, sauđó bất kì một metric đường từng phần có thể được chọn.

4. Lưu trữ metric đường từng phần và các và các đường trạng thái cùng

với bit tồn tại liên kết của nó.5. Nếu t < L+m-1, trở về bước 2.





Kết quả của thuật toán Viterbi là một đường Trellis duy nhất tương ứngvới từ mã ML.

Ví dụ: Biểu đồ chuyển tiếp trạng thái trình bày các bit tin và các bit mã hóađược ước đoán theo các nhánh (cần thiết cho quá trình giải mã ). Việc giải mã chọn

đường ML thông qua trellis như được trình bày trong hình 2.26. Metric đường từng phần (được lưu trữ) được chọn cho ví dụ này là khoảng cách Hamming lớn nhất vàđược trình bày trong hình cho mỗi nút. Các metric đường từng phần đậm tương ứngvới ML. Các đường tồn tại được biểu diễn bởi các đường liền nét đậm và các đườngcạnh tranh được biểu diễn bởi các đường nét đứt.

Hình 2.26: Biểu diễn Viterbi theo ví dụ

2.8.2 Thuật toán Viterbi quyết định mềm

Có 2 phương pháp tổng quát thực hiện thuật toán Viterbi quyết định mềm.Phương pháp thứ nhất (phương pháp 1) sử dụng metric khoảng cách Euclidean thaycho metric khoảng cách Hamming. Các bit nhận sử dụng trong metric khoảng cáchEuclidean được xử lí bằng lượng tử hóa nhiều mức. Phương pháp thứ hai (phương

pháp 2) sử dụng một metric tương quan trong đó các bit nhận được của nó dùng

trong metric này cũng được xử lí bằng lượng tử hóa nhiều mức.2.8.2.1 Thuật toán Viterbi quyết định mềm (phương pháp 1)

Trong giải mã quyết định mềm, bộ thu không gán 0 hay 1 (lượng tử hóa bitđơn) cho mỗi bit nhận được mà sử dụng các giá trị lượng tử hóa nhiều bit hay bitkhông xác định. Lý tưởng, chuỗi thu r được lượng tử hóa bit không xác định vàđược sử dụng trực tiếp trong bộ giải mã quyết định mềm. Thuật toán Viterbi quyếtđịnh mềm tương tự với thuật toán quyết định cứng ngoại trừ khoảng cách Euclidean

bình phương được sử dụng trong metric thay cho khoảng cách Hamming.

Thuật toán Viterbi quyết định mềm có thể được thực hiện như sau





Sk, t là trạng thái trong biểu đồ trellis tương ứng với trạng thái S k tại thời điểm t.Mỗi trạng thái trong trellis được gán một giá trị là V(Sk, t).

1. (a) khởi tạo t = 0

(b) Khởi tạo V(S0, 0) = 0 và tất cả các V khác V(Sk, t) = +00

2. (a) Lấy t = t + 1

(b) Tính các metric đường thành phần cho tất cả các đường đi đến trạng tháiSk tại thơi điểm t.

Đầu tiên tìm metric nhánh thứ t

(2.8.22)

Metric này được tính từ khoảng cách Euclidean

(2.8.23)

Thứ 2, tính metric đường từng phần thứ t

(2.8.24)


(2.8.25)

3. (a) Gán V(Sk, t ) cho metric đường từng phần tốt nhất là trạng thái Sk, tại thờiđiểm t. Thông thường metric đường từng phần tốt nhất là metric đường từng

phần có giá trị nhỏ nhất.

(b) Nếu có một TIE cho một metric đường từng phần tốt nhất, thì sau đó bấtkỳ một trong những metric đường từng phần có thể được chọn.

4. Lưu trữ metric đường từng phần và các đường trạng thái và các bit tồn tạiliên kết của nó.

5. Nếu t <= L+m -1, trở về bước 2.

2.8.2.2 Thuật toán Viterbi quyết định mềm (phương pháp 2)

Thuật toán viterbi quyết định mềm thứ 2 được trình bày bên dưới. Hàm khảnăng xảy ra được biểu diễn bằng hàm mật độ xác suất Gaussian

(2.8.26)

Trong đó E b là năng lượng nhận được /bit của từ mã và N0 là mật độ phổ nhiễu

một phía. Bit nhận được là biến ngẫu nhiên Gaussian có trung bình là và phương sai là N/2. Hàm log của khả năng xảy ra có thể được định nghĩa là:





Trong đó

Trong đó C1 và C2 là hằng số, không phải là hàm của y

(2.8.28)

Từ đây metric bit được định nghĩa là

(2.8.29)

Thuật toán Viterbi quyết định mềm có thể được thực hiện như sau:

Sk, t là trạng thái trong biểu đồ trellis tương ứng với trạng thái Sk tại thời điểm t.Mỗi trạng thái trong trellis được gán một giá trị là V(Sk, t ).

1. (a) Khởi tạo t = 0

(b) Khởi tạo V(S0, 0) = 0 và tất cả các V khác V(Sk, t) = +00

2. (a) Lấy t = t + 1

(b) Tính các metric đường thành phần cho tất cả các đường đi đến trạng tháiSk tại thơi điểm t.

Đầu tiên tìm metric nhánh thứ t

(2.8.30)

Metric này được tính từ sự tương quan của và , .





Thứ 2, tính metric đường từng phần thứ t

(2.8.31)


(2.8.32)

3. (a) Lấy V(Sk,t ) đến metric đường từng phần tốt nhất là trạng thái Sk tại thờiđiểm t. Metric đường từng phần tốt nhất là metric đường từng phần có giá trịlớn nhất.

(b) Nếu có một thay đổi cho metric đường thành phần tốt nhất, thì sau đó bấtkỳ một trong những metric đường từng phần có thể được chọn.

4. Lưu trữ metric đường từng phần và các đường trạng thái và các bit tồn tại

liên kết của nó.5. Nếu t < L + m – 1, trở về bước 2.

Thông thường đối với giải mã quyết định mềm, trong kênh nhiễu Gaussian thì độlợi mã hóa khoảng 2dB so với giải mã quyết định cứng.

2.8.3 Ưu điểm của giải mã quyết định mềm so với giải mã quyết định cứng

Với việc thuật toán giải mã quyết định mềm chia ra nhiều mức để nhận dạngtín hiệu thu được thì độ tin cậy giải mã sẽ đảm bảo hơn so với giải mã quyết định

cứng chỉ có 2 mức duy nhất cho tín hiệu nhận được.Để thấy rõ ưu điểm của thuật toán quyết định mềm so với quyết định cứng,

chúng ta xét một ví dụ đơn giản sử dụng bộ mã parity sau:

Bảng 2.10: Ví dụ với bộ mã parity

Bit vào 1 Bit vào 2Bit parity được tạo

bởi bộ mã hóaTừ mã

0 0 0 0

0 1 1 011

1 0 1 101

1 1 0 110

Tất cả các trạng thái có thể được tạo bởi bộ mã hóa là 000, 011, 101, 110.Bây giờ chúng ta sẽ tiến hành truyền bản tin “01” xuyên qua kênh truyền.





Đối với giải mã quyết định cứng:

Giả sử hệ thống thông tin của chúng ta bao gồm một bộ mã hóa tạo kiểm parity, kênh truyền, và một bộ thu giải mã quyết định cứng

Với bản tin “01” đưa đến bộ mã hóa parity, từ mã ngõ ra ta nhận được sẽ là “011”,

Hình 2.27 Mô tả giải mã quyết định cứng với bộ mã parity

Từ mã này giả sử sẽ được truyền qua kênh truyền như sau: “0” được truyềndưới dạng điện áp “0 volt”, “1” được truyền với điện áp “1 volt”. Kênh truyền cónhiễu sẽ làm suy giảm tín hiệu và tín hiệu thu được tại bộ nhận sẽ bị suy giảm (dạngsóng màu đỏ). Bộ giải mã quyết định cứng thực hiện quyết định dựa trên một mứcđiện áp ngưỡng. Với trường hợp này, điện áp ngưỡng của chúng ta sẽ là 0,5 volt(nằm giữa các mức 0V và 1V). Ở mỗi thời điểm lấy mẫu của bộ thu (như hình trên),

bộ tách sóng quyết định cứng sẽ quyết định trạng thái đó là mức “0” nếu mức áp thuđược là nhỏ hơn 0,5V và sẽ chọn là mức “1” nếu áp thu được lớn hơn 0,5V. Dođó, ngõ ra của khối quyết định cứng trên sẽ là “001”. Có lẽ ngõ ra “001” này là vôlý khi so sánh với các từ mã có thể như bảng ở trên, do đó, các bit của từ mã trên cóthể đã sai do tác động trên kênh truyền. Bộ giải mã quyết định cứng so sánh ngõ racủa khối giải mã quyết định cứng trên với tất cả các trạng thái có thể của từ mã và

tính toán khoảng cách Hamming bé nhất cho mỗi trường hợp. Mô tả như bảng bêndưới:

Bảng 2.11: Tính toán khoảng cách Hamming cho quyết định cứng

Tất cả từ mã có thể Ngõ ra quyết định Khoảng cách

000 001 1

011 001 1

101 001 1


http://3.bp.blogspot.com/_4Q2hMGW5AXs/SznR1yrkziI/AAAAAAAAD2E/qXv5UaQ2PkE/s1600-h/Hard_decision_decoding.JPG




110 001 3

Công việc của bộ giải mã là chọn ta từ mã đã phát đi dựa trên khoảng cách

Hamming bé nhất. Tuy nhiên, ở đây có tới 3 trường hợp cho ra khoảng cáchHamming đều là 1. Do đó, bộ giải mã có thể sẽ chọn ngẫu nhiên một trong 3 trườnghợp trên làm quyết định cuối cùng. Vì vậy, xác xuất đúng chỉ là 1/3.

Đối với bộ giải mã quyết định mềm:

Sự khác biệt chủ yếu của thuật toán quyết định cứng và quyết định mềm nhưta đã biết chính là thuật toán giải mã quyết định mềm sử dụng khoảng cáchEuclidean thay vì khoảng cách Hamming.

Với cùng một bộ mã hóa và kênh truyền, giờ ta sẽ xem hiệu quả của quyếtđịnh mềm so với quyết định cứng.

Hình 2.28 Mô tả giải mã quyết định mềm với bộ mã parity

Mức điện áp của tín hiệu nhận được tại mỗi thời điểm lấy mẫu như hình trên.Khối quyết định cứng tính toán khoảng cách Euclidean của tất cả các từ mã có thểvới tín hiệu nhận được.

Bảng 2.12: Tính toán khoảng cách Euclidean cho quyết định mềm

Từ mã có thểMức điện áp tại mỗi

thời điểm lấy mẫu củadạng sóng nhận được

Tính toán khoảngcách Euclidean

Khoảng cáchEuclidean

0 0 0

( 0V 0V 0V )0.2V 0.4V 0.7V

(0-0.2)2+ (0-0.4)2+(0-0.7)2 0.69

0 1 1( 0V 1V 1V )

0.2V 0.4V 0.7V (0-0.2)2+ (1-0.4)2+(1-0.7)2 0.49


http://2.bp.blogspot.com/_4Q2hMGW5AXs/SzrdsLcdVOI/AAAAAAAAD2Q/vsZNraE1_vA/s1600-h/Soft_decision_decoding.JPG




1 0 1

( 1V 0V 1V )0.2V 0.4V 0.7V

(1-0.2)2+ (0-0.4)2+(1-0.7)2 0.89

1 1 0

( 1V 1V 0V )0.2V 0.4V 0.7V

(1-0.2)2+ (1-0.4)2+

(0-0.7)2

1.49

Khoảng cách Euclidean bé nhất là 0,49 tương ứng với từ mã “011”, chính làtừ mã mà chúng ta đã truyền đi. Bộ giải mã quyết định mềm sẽ chọn nó làm từ mãgiải được ở ngõ ra, nếu bộ tạo kiểm parity không thể sửa lỗi thì lưu đồ giải mãquyết định mềm này sẽ giúp khôi phục tin tức trong trường hợp này.

Qua ví dụ trên ta có thể thấy được ưu điểm của giải mã quyết định mềm sovới giải mã quyết định cứng. Tuy nhiên, với trường hợp trên, người ta cũng có thểnhanh chóng tìm ra lỗi của phương pháp xử lí này nếu các mức điện áp tương ứng

là 0,2V, 0,4V và 0,6V. Đó là bởi vì bộ tạo kiểm parity không có khả năng sửa lỗimà chỉ có thể phát hiện lỗi 1 bit. Khi đó, sử dụng bộ giải mã quyết định mềm sẽnâng cao hiệu quả của bộ nhận chừng 2 dB so với bộ giải mã quyết định cứng.

2.9 Xác suất lỗi

Có 2 xác suất lỗi liên quan đến mã tích chập, là xác suất lỗi sự kiện đầu tiên vàxác suất lỗi bit. Xác suất lỗi sự kiện đầu tiên, Pe, là xác suất lỗi mà một lỗi bắt đầutại thời điểm đặc biệt. Xác suất lỗi bit, P b, là số các lỗi bit ở chuỗi được mã hóa.

Đối với giải mã quyết định cứng, xác suất lỗi bit và xác suất lỗi sự kiện đầu tiênđược định nghĩa như sau:

(2.9.1)

Và

(2.9.2)

Trong đó,

(2.9.3)

Và

(2.9.4)

Đối với giải mã quyết định mềm, xác suất lỗi sự kiện đầu tiên và xác suất lỗi bitđược định nghĩa như sau:

(2.9.5)

Và





(2.9.6)

2.10 Ưu nhược điểm của thuật toán giải mã Viterbi

2.10.1 Ưu điểm

• Thuật toán Viterbi là thuật giải mã có nhớ nên việc giải mã có độ chính xáccao.

• Tốc độ xử lí của mộ giải mã Viterbi cao hơn nhiều so với bộ giải mã tuần tựvì ở cùng một thời điểm, bộ giải mã Viterbi giải quyết hết tất cả các nhánhcòn bộ giải mã tuần tự chỉ chọn ngẫu nhiên một nhánh nên nó sẽ mất thờigian nếu sự lựa chọn trước đó là không đúng.

2.10.2 Nhược điểm

• Thuật toán giải mã Viterbi dựa trên thuật giải mã giống nhau lớn nhất (ML-Maximum likelihood), thuật toán này lại phải dựa trên các nguyên lý sau đểviệc giải mã được chính xác:

Lỗi xảy ra phải không thường xuyên, xác suất lỗi phải nhỏ

Xác suất lỗi kép phải thấp hơn nhiều so với lỗi 1 bit, do đó lỗi phảiđược phân bố một cách ngẫu nhiên.

Do vậy, với kênh truyền có xác suất lỗi lớn và thường xuyên, lỗi nhiều bit

liên tiếp thì hiệu quả của việc giải mã sẽ không như mong muốn.• Một nhược điểm nữa là thuật toán giải mã Viterbi sử dụng bộ nhớ để ghi lại

các trạng thái và thông số metric nên cần có bộ nhớ cho giải mã, bộ giải mãcàng phức tạp thì dung lượng bộ nhớ càng lớn.

• Không thích hợp với các mã có chiều dài ràng buộc dài và tỉ số S/N lớn (chỉthích hợp với bộ giải mã tuần tự).





CHƯƠNG 3

MÔ PHỎNG THUẬT GIẢI MÃ VITERBI

BẰNG MATLAB3.1 Giới thiệu

Matlab là một phần mềm được ứng dụng rộng rãi trong nhiều lĩnh vực như viễnthông, cơ điện, hệ thống điều khiển tự động …, trong đó ứng dụng mô phỏng xử lýtín hiệu trong viễn thông là một ứng dụng mạnh nhất của Matlab. Matlab tích hợpkhoảng hơn 400 hàm cho phép người lập trình sử dụng cho công việc một cách hiệuquả và nhanh chóng.

Với đề tài này, để mô phỏng quá trình mã hóa dùng mã chập, truyền tín hiệu trênkênh truyền có nhiễu và sử dụng thuật toán Viterbi để giải mã hóa, người thực hiệnđề tài đã sử dụng các hàm có sẵn trong Matlab để thực hiện. Để dễ dàng hơn choviệc quan sát và trình bày, tác giả đã sử dụng giao diện đồ họa GUI để mô phỏngthuật giải viterbi. Quá trình mô phỏng sẽ được trình bày rõ ràng trong phần sau.

3.2 Sơ đồ khối hệ thống

Hình 3.1: Sơ đồ khối hệ thống

Tín hiệu sau khi được số hóa thành các bit, các bit này được đưa đến bộ mã hóamã chập. Sau khi được mã hóa, tín hiệu (các bit) được truyền trên kênh truyền cónhiễu, ở đây tác giả chỉ xét nhiễu Gauss trắng. Tín hiệu đã bị thay đổi bởi nhiễuđược thu và giải mã nhờ bộ giải mã Viterbi. Nhờ thuật toán Viterbi, tín hiệu đượcgiải mã sẽ gần giống nhất với tín hiệu ban đầu.

Chương 3: Mô phỏng thuật toán Viterbi dùng Matlab

Khối mã hóamã chập

Khối giải mãViterbi

Ngõ ra bit Ngõ vào bit

Bitmãhóa

Bitnhậnđược

AWGN

Kênh truyền




3.3 Lưu đồ mô phỏng

Hình 3.2: Lưu đồ mô phỏng3.3.1 Khối tạo bit ngõ vào

Tác giả đưa ra hai lựa chọn cho việc tạo bit tín hiệu ngõ vào. Thứ nhất là tạo bitngẫu nhiên theo số lượng bit nhập từ người dùng, và thứ hai là nhập trực tiếp chuỗi

bit vào.

Để tạo bit vào ngẫu nhiên, trong Matlab tác giả sử dụng hàm randint.

inbits = randint(1, numbit ) ;

với inbits là chuỗi bit ngõ vào, numbit là số lượng bit ngõ vào được nhập bởingười dùng trên giao diện GUI. Hàm randint với 2 thông số sẽ mặc định tạo một


Mã hóa mãchập

Cộng nhiễuGauss trắng

Lượng tử bitnhận được

Giải mãViterbi

Tính và vẽBER

Xây dựng sơ đồ trellis

Xác định đa thức sinh

và chiều dài ràng buộc

Tạo bit

Khối tạo bit ngõ vào Khối

mãhóa

Khốigiảimã




ma trận số nhị phân với chiều của ma trận tương ứng với 2 thông số đó. Kíchthước tối đa có thể tạo ra phụ thuộc vào bộ nhớ dành cho chương trình. Với câulệnh như trên thì numbit tối đa chỉ là 106.

3.3.2 Khối mã hóa

Đối với bộ mã hóa mã chập, như đã giới thiệu, có rất nhiều cách để người ta quyước cho một bộ mã hóa mã chập dựa trên số thanh ghi, ngõ vào, ngõ ra, đa thứcsinh, tốc độ bộ mã..v.v. và tương ướng với mỗi bộ mã có một phương pháp tínhtoán riêng.

Ở đây tác giả mô tả việc tính toán mã chập dựa trên bộ mã được quy ước bởi cácnhà sản xuất chip thực hiện mã chập bao gồm các thông số: chiều dài ràng buộc K và tốc độ của bộ mã R.

Và G1 và G2 là các đa thức sinh, được nhập bởi người sử dụng.Để tạo sơ đồ trellis, trong Matlab tác giả sử dụng hàm poly2trellis:

trellis = poly2trellis (len, [g1 g2]);

Dùng hàm convenc để mã hóa mã chập tín hiệu:

encbits = convenc(inpbits,trellis);

3.3.3 Khối cộng nhiễu Gausse trắng

Khối này mô phỏng cho việc tín hiệu bị can nhiễu khi truyền trên kênh truyền.

Tín hiệu bị cộng nhiễu Gauss với thông số SNR đã xác định trước.

Sử dụng hàm awgn để cộng nhiễu vào tín hiệu:

awgnbits = awgn(encbits,snr,measured);

3.3.4 Khối giải mã

Tín hiệu sau khi được cộng nhiễu được đưa đến bộ thu, tại đây tín hiệu đượclượng tử trước khi sử dụng thuật toán viterbi để giải mã. Tùy vào kiểu quyết địnhgiải mã mà sử dụng các lượng tử khác nhau.

Với quyết định cứng

Tín hiệu thu được lượng tử về 2 mức 0 và 1 tương ứng với tín hiệu có mức điệnáp nhỏ hơn và lớn hơn 0. Sử dụng hàm quantiz để lượng tử tín hiệu.

partition = [0];

codebook = [0 1];

quanbits = quantiz(awgnbits,partition,codebook);

Sử dụng hàm vitdec với quyết định cứng để giải mã Viterbi

decbits = vitdec(quanbits,trellis,numbit-1,’term’,’hard’);





Với quyết định mềm

Tín hiệu thu được lượng tử về 8 mức và việc sử dụng hàm quantiz như sau

partition = [-.8571 -.5714 -.2857 0 .2857 .5714 .8571];

codebook = [-.99 -.8571 -.5714 -.2857 0 .2857 .5714 .8571];quanbits = quantiz(awgnbits,partition,codebook);

Sử dụng hàm vitdec với quyết định mềm

decbits = vitdec(quanbits,trellis,numbit -1,’term’,’soft’,3);

3.3.5 Tính toán và vẽ BER

Tỉ số bit lỗi là số tỉ số bit lỗi sau khi giải mã so với tổng số bit ngõ vào. Trongmatlab tác giả sử dụng hàm semilogy để vẽ BER

semilogy(Eb_N0_dB,ratioerr_comp,’mp-‘,’LineWidth’,2);

3.4 Hình ảnh về chương trình mô phỏng

Hình 3.3: Giao diện khởi đầu chương trình mô phỏng





Hình 3.4: Giao diện chương trình mô phỏng 1

Hình 3.5: Giao diện chương trình mô phỏng 2





Hình 3.6: Nhập bit ngẫu nhiên – Quyết định mềm

Hình 3.7: BER của quyết định mềm





Hình 3.8: Nhập bit ngẫu nhiên – Quyết định cứng

Hình 3.9: BER của quyết định cứng





Hình 3.10: So sánh BER của cả quyết định cứng và mềm

Hình 3.11: Tự nhập bit vào – Quyết định mềm





Nhận xét :

- Từ các hình 3.6 và 3.8 ta có thể thấy rằng, với cùng một số lượng bitvào như nhau thì giải mã quyết định cứng sẽ giải mã với số bit sai nhiềuhơn so với giải mã quyết định mềm. Bởi vì như chúng ta đã đề cập trước

đó, giải mã quyết định mềm sử dụng lượng tử hóa nhiều bit, do đó nó tạođộ tin cậy khi giải mã cao hơn so với giải mã quyết định mềm chỉ sử dụnglượng tử 1 bit.

- Tỷ số tín hiệu/nhiễu SNR càng cao thì điều đó có nghĩa kênh truyềncàng ít nhiễu, khi đó, giải mã quyết định cứng và mềm sẽ cho kết quả giảimã là gần như nhau.

- Hình 3.10 cho ta thấy được giản đồ BER của cả hai loại quyết định.Đường BER của giải mã quyết định mềm luôn nằm thấp hơn đường BER của giải mã quyết định cứng. Điều đó có nghĩa là với cùng một tỷ số E b/N0

thì giải mã quyết định mềm luôn có BER nhỏ hơn so với giải mã quyết địnhcứng. Do đó, xác suất sai bit sẽ nhỏ hơn.

- Vì giải mã quyết định mềm sử dụng lượng tử nhiều bit nên bộ nhớ cầnđể lưu trữ cho việc giải mã quyết định mềm sẽ lớn hơn nhiều so với khi giảimã quyết định cứng.





CHƯƠNG 4

XÂY DỰNG THUẬT GIẢI MÃ VITERBI TRÊN

KIT DE24.1 Giới thiệu sơ lược KIT DE2 và phần mềm Quartus

4.1.1 KIT DE2 của Altera

4.1.1.1 Tổng quan kit DE2

KIT DE2 có rất nhiều tài nguyên cho phép người sử dụng thực thi rất nhiều mạchứng dụng từ các mạch đơn giản cho tới các dự án lớn có độ phức tạp cao.

Hình 4.1 KIT DE2 của Altera

Một số tài nguyên trên Kit DE2:

• Chip FPGA Cyclone II 2C35.

• Thiết bị cấu hình nối tiếp EPCS16.

• Cổng USB cho lập trình và điều khiển, hỗ trợ cả 2 chế độ JTAG và

nối tiếp (AS).

• 512 Kbyte SRAM.

Chương 4: Xây dựng thuật toán giải mã Viterbi trên Kit DE2




• 8 Mbyte SDRAM.

• 4 Mbyte bộ nhớ Flash.

• 4 nút nhấn và 18 Switch.

• 18 Led đỏ và 9 led xanh.

• 2 bộ tạo dao động 50Mhz và 27 Mhz.

• Chip codec Audio 24 bit và chip DAC video 10 bit, cổng ethernet10/100

Cổng RS232 9 chân và cổng PS/2 cho kết nối chuột và bàn phím.

• Bộ nhận tín hiệu hồng ngoại.

• Và một số chức năng khác... Sơ đồ khối

Hình 4.2 Sơ đồ khối KIT DE2

Chip Cyclone EPCS16:

•

33,216 Logic Elements• 105 M4K RAM blocks





• Tổng cộng 483,840 RAM bits

• 4 PLLs

• 475 chân I/O

4.1.1.2 Sử dụng nút nhấn và Switch

KIT DE2 có 4 nút nhấn, mỗi nút nhấn được chống dội bằng mạch Smithtrigger như hình 4.3. Các ngõ ra của mạch Smith Trigger được gọi làKEY0,...,KEY3 được kết nối trực tiếp đến Cyclone II FPGA. Các nút nhấn cungcấp mức logic cao (3.3V) khi không nhấn và cung cấp logic thấp (0V) khi đượcnhấn.

Hình 4.3: Chống dội phím nhấn

Có tổng cộng 18 Switch gạt trên kit DE2, mỗi switch được kết nối trực tiếpđến chân của Cyclone II FPGA. Khi switch ở vị trí DOWN (gần cạnh của board),nó cung cấp mức logic thấp (0V) đến FPGA, và khi nó được gạt đến vị trí UP thìcho ra mức logic cao (3.3 V).

Có 27 led đơn trên board, 18 led đỏ và 9 led xanh, mỗi led cũng được kết nốitrực tiếp đến 1 chân của FPGA. Led sáng khi nhận được mức logic cao từ FPGA,ngược lại led tắt.

Có 8 Led 7 đoạn trên Kit chia làm 2 cặp và một nhóm 4 led, led sáng mức

thấp. Mỗi đoạn của led được kết nối trực tiếp đến 1 chân của FPGA.

Bảng 4.1: Thứ tự kết nối phím nhấn với các chân của FPGA





4.1.1.3 Sử dụng LCD

LCD có phông chữ cài sẵn có thể dùng để hiển thị các văn bản bằng cách gởi cáclệnh đến bộ điều khiển hiển thị (HD44780).

Bảng 4.2: Gán chân FPGA cho màn hình LCD

4.1.2 Phần mềm lập trình Quatus II

Quartus II là công cụ phần mềm phát triển của hãng Altera, cung cấp môi trườngthiết kế toàn diện cho các thiết kế SOPC (hệ thống trên 1 chip khả trình - system ona programmable chip).

Đây là phần mềm đóng gói tích hợp đầy đủ phục vụ cho thiết kế logic với các linhkiện logic khả trình PLD của Altera, gồm các dòng APEX, Cyclone, FLEX, MAX,Stratix... Quartus cung cấp các khả năng thiết kế logic sau:

• Môi trường thiết kế gồm các bản vẽ, sơ đồ khối, công cụ soạn thảo các ngônngữ: AHDL, VHDL, và Verilog HDL.





• Thiết kế LogicLock.

• Là công cụ mạnh để tổng hợp logic.

• Khả năng mô phỏng chức năng và thời gian.

• Phân tích thời gian.

• Phân tích logic nhúng với công cụ phân tích SignalTap@ II.

• Cho phép xuất, tạo và kết nối các file nguồn để tạo ra các file chương trình.

• Tự động định vị lỗi.

• Khả năng lập trình và nhận diện linh kiện.

• Phần mềm Quartus II sử dụng bộ tích hợp NativeLink@ với các công cụ

thiết kế cung cấp việc truyền thông tin liền mạch giữa Quartus với các côngcụ thiết kế phần cứng EDA khác.

• Quartus II cũng có thể đọc các file mạch (netlist) EDIF chuẩn, VHDL vàVerilog HDL cũng như tạo ra các file netlist này.

• Quartus II có môi trường thiết kế đồ họa giúp nhà thiết kế dễ dàng viết mã, biên dịch, soát lỗi, mô phỏng...

Với Quartus có thể kết hợp nhiều kiểu file trong 1 dự án thiết kế phân cấp. Cóthể dùng bộ công cụ tạo sơ đồ khối (Quartus Block Editor) để tạo ra sơ đồ khối môtả thiết kế ở mức cao, sau đó dùng các sơ đồ khối khác, các bản vẽ như: AHDL TextDesign Files (.tdf), EDIF Input Files (.edf), VHDL Design Files (.vhd), và VerilogHDL Design Files (.v) để tạo ra thành phần thiết kế mức thấp.

Quartus II cho phép làm việc với nhiều file ở cùng thời điểm, soạn thảo file thiếtkế trong khi vẫn có thể biên dịch hay chạy mô phỏng các dự án khác. Công cụ biêndịch Quartus II nằm ở trung tâm hệ thống, cung cấp quy trình thiết kế mạnh cho

phép tùy biến để đạt được thiết kế tối ưu trong dự án. Công cụ định vị lỗi tự độngvà các bản tin cảnh báo khiến việc phát hiện và sửa lỗi trở nên đơn giản hơn.

4.2 Giải quyết vấn đề

4.2.1 Giải mã viterbi quyết định cứng

Giờ ta sẽ đi giải quyết thuật toán việc giải mã Viterbi (quyết định cứng) cho bộ mãtốc độ ½ với K= 3 và bộ phát mã (hay đa thức sinh) là (5,7)8 đã nhắc đến trongchương 4 về thuật toán Viterbi.

Ta đã biết rằng, với trường hợp bộ mã này thì nếu có N bit mã hóa ngõ vào thì sẽ

phải tìm từ 2 N sự kết hợp có thể (tương ứng một bit vào sẽ có 2 bit ra). Điều này trở nên vô cùng phức tạp nếu N càng lớn. Tuy nhiên, ông Andrew J Viterbi trong một





ghi chép về “ Error bounds for convolutional codes and an asymptotically optimumdecoding algorithm”, IEEE Transactions on Information Theory 13(2):260–269,tháng 4 năm 1967 đã mô tả một sơ đồ để kéo giảm tính phức tạp đó đến mức có thểđiều khiển được. Một vài giả thuyết quan trọng được đưa ra như sau:

- Như chúng ta thấy trong bảng 4.1 và hình 4.2 thì bất kì một trạng thái nàocũng đều đến từ chỉ 2 trạng thái có thể trước đó.

- Trong 2 trạng thái đó thì chỉ có một trạng thái đúng là trạng thái trước đó.Chúng ta có thể tìm ra trạng thái đó dựa trên bit mã hóa nhận được và bỏ quatrạng thái còn lại.

- Lỗi xuất hiện trong chuỗi bit mã hóa nhận được là một phân bố ngẫu nhiênvà xác xuất của lỗi là nhỏ.

Dựa theo các giả thuyết như trên, Lưu đồ giải mã được tiến hành như sau: Giả sửlà có N bit được mã hóa, lấy 2 bit mã hóa ở cùng một thời điểm để xử lí và tínhtoán khoảng cách Hamming , metric nhánh , metric đường , và thông số đường tồntại cho N/2 +K-1 lần, lấy i là biến chạy từ 1 đến N/2 + K -1.

Tính toán khoảng cách Hamming

Để giải mã, ta hãy xem xét 2 bit mã hóa nhận được ở thời điểm y i và tính toánkhoảng cách hamming giữa tất cả những sự kết hợp có thể của 2 bit này. Số bit khácnhau có thể được tính toán bằng thuật toán XOR giữa yi với 00, 01, 10, 11 và

sau đó tính toán số bit 1.

là số bit 1 thu được sau phép tính




Tính toán metric nhánh và metric đường

Như đã đề cập trước đó, mỗi trạng thái chỉ có thể đến từ 2 trạng thái có thểtrước đó (thể hiện bằng 2 đường màu đỏ và xanh tương ứng trong hình 4.4). Thôngsố metric nhánh chính là tổng của metric đường của trạng thái trước đó và khoảngcách hamming trong sự chuyển đổi giữa 2 trạng thái. Trong 2 metric nhánh cóđược, thông số metric nhánh nhỏ hơn sẽ được chọn để giữ lại. Đây chính là nhiệmvụ chính của bộ ACS (Add Compare and Select).

Ghi chú:





1. Theo quy ước thì mã hóa chập luôn bắt đầu từ trạng thái 00, và bộ giải mãViterbi cũng tương tự.

2. Khi i = 1, metric nhánh cho trạng thái 00 (từ trạng thái 00_dịch bit 0 vào) vàtrạng thái 10 (từ trạng thái 00_ dịch bit 1 vào) có thể được tính toán. Trong

trường hợp này, metric đường cho mỗi trạng thái là chính bằng với metricnhánh khi các nhánh còn lại là không hợp lệ (không tồn tại).

3. Khi i = 2, metric nhánh cho trạng thái 00 (từ trạng thái 00), trạng thái 01 (từtrạng thái 10), trạng thái 10 (từ trạng thái 00), và trạng thái 11 (từ trạng thái10) có thể được tính toán. Trong trường hợp này cũng vậy, metric đường chomỗi trạng thái chính bằng metric nhánh khi các nhánh khác là không hợp lệ.

4. Bắt đầu từ thời điểm i = 3, mỗi trạng thái có 2 nhánh và chúng ta cần tiến hànhthuật toán ACS đã nói ở trên.

5. Trong trường hợp 2 metric nhánh có cùng giá trị, chúng ta chọn ngẫu nhiên 1trạng thái để tiến hành xử lí tiếp

Hình 4.4 Tính toán metric nhánh và metric đường cho bộ giải mã Viterbi

Trạng thái 00 có thể đến từ 2 nhánh

(a) Trạng thái 00 với ngõ ra 00. Metric nhánh cho sự chuyển đổi này,

(4.1)

(b) Trạng thái 01 với ngõ ra 11. Metric nhánh cho sự chuyển đổi này,

(4.2)





Metric đường cho trạng thái 00 được chọn dựa trên giá trị nhỏ hơn trong 2 metricnhánh ở trên.

(4.3)

Đường tồn tại cho trạng thái 00 được lưu trữ trong biến “metric đường tồn tại ”Trạng thái 01 có thể đến từ 2 nhánh

(c) Trạng thái 10 với ngõ ra 10. Metric nhánh cho sự chuyển đổi này,

(4.4)

(d) Trạng thái 11 với ngõ ra 01. Metric nhánh cho sự chuyển đổi này,

(4.5)


(4.6)

Đường tồn tại cho trạng thái 01 được lưu trữ trong biến “metric đường tồn tại ”


(e) Trạng thái 00 với ngõ ra 11. Metric nhánh cho sự chuyển đổi này,

(4.7)

(f) Trạng thái 01 với ngõ ra 00. Metric nhánh cho sự chuyển đổi này,

(4.8)


. (4.9)



(g) Trạng thái 10 với ngõ ra 01. Metric nhánh cho sự chuyển đổi này,

(4.10)

(h) Trạng thái 11 với ngõ ra 10. Metric nhánh cho sự chuyển đổi này,

(4.11)

Metric đường cho trạng thái 11 được chọn dựa trên giá trị nhỏ hơn trong 2 metric

nhánh ở trên.

. (4.12)






Khối truy hồi

Khi đường tồn tại được tính toán N/2 + K – 1 lần, thuật toán giải mã có thể

bắt đầu ước lượng chuỗi ngõ vào. Nhờ vào sự có mặt của các bit tận cùng (K-1 bit 0thêm vào), thì trạng thái cuối cùng của chuỗi bit theo bộ mã hóa chập là trạng thái00.

Vì vậy, bắt đầu từ metric đường cuối cùng được tính toán ở thời điểm N/2 +K -1 cho trạng thái 00, từ đường tồn tại, ta tìm ra trạng thái trước đó tương ứng vớitrạng thái hiện tại. Từ kiến thức về trạng thái hiện tại và trạng thái trước, chuỗi ngõvào có thể được quyết định (xem bảng 4.3 về trạng thái ngõ vào và trạng thái ngõra). Tiếp tục truy hồi dựa theo đường tồn tại và ước lượng chuỗi ngõ vào cho đếnthời điểm i = 1.

Bảng 4.3: Trạng thái hiện tại và trạng thái trước của nó

Input,

if previous state

Current state 00 01 10 11

00 0 0 x x

01 x x 0 0

10 1 1 x x

11 x x 1 1

4.2.2 Giải mã viterbi quyết định mềm

Ở trên chúng ta đã bàn về thuật toán lập trình giải mã Viterbi quyết định

cứng, giờ chúng ta tiến hành phân tích thuật toán giải mã viterbi quyết định mềm.Điều chế được sử dụng là BPSK và kênh truyền được giả sử là kênh AWGN.

Mô hình hệ thống

Chuỗi mã nhận được là

, trong đó c là chuỗi mã hóa đã được điều chế sẽ có giá trị nếu

bit được mã hóa là bit 1 và nếu bit được mã hóa là bit 0, n là nhiễu Gauss

trắng cộng tính với hàm phân phối xác xuất là,

với giá trị trung bình và phương sai .





Hàm phân bố xác xuất (PDF) có điều kiện của y nếu bit được mã hóa là bit 0 là,

(4.13)

Hàm phân bố xác xuất (PDF) có điều kiện của y nếu bit được mã hóa là bit 1 là,

(4.14)

Khoảng cách Euclidean

Trong giải mã Viterbi quyết định mềm, dựa trên vị trí của ký hiệu đã được mã hóanhận được, bit đã mã hóa được ước lượng; nếu ký hiệu nhận được là lớn hơn 0, bitđã mã hóa nhận được sẽ là 1; nếu ký hiệu nhận được là bé hơn hoặc bằng 0, bit đã

mã hóa nhận được sẽ là bit 0.Trong giải mã quyết định mềm, thay vì ước lượng bit đã được mã hóa và tìmkhoảng cách Hamming, ta sẽ tìm khoảng cách giữa ký hiệu nhận được và ký hiệu cóthể đã được phát đi.

Khoảng cách Euclidean nếu bit đã mã hóa được truyền đi là bit 0 là,

(4.15)

Khoảng cách Euclidean nếu bit đã mã hóa được truyền đi là bit 1 là,

(4.16)

Các thành phần , y2, và là chung cho cả 2 biểu thức nên chúng có thể được

bỏ đi. Khoảng cách Euclidean sau khi đơn giản biểu thức là,

và (4.17)

Khi thuật toán Viterbi nhận được 2 bit mã hóa ở cùng một thời điểm để xử lí, chúng

ta cần phải tìm ra khoảng cách Euclidean từ cả 2 bit.

(4.18)





4.3 Lưu dồ thuật toán lập trình

Lưu đồ giải thuật chính của chương trình

Bắt đầu

Cài đặt ban đầuDữ liệu vào

Tính 4 khoảng cách nhánh

Liên kết với các khoảngcách nhánh trước đó

Cộng-So sánh-Lựa chọn

Lưu trữ thông tin đường

Trellis cuối ?

Truy hồi

Dữ liệu ra

Kết thúc

Đ

S

Hình 4.5: Lưu đồ giải thuật chính của chương trình





Khối cài đặt ban đầu thiết lập những thông số cho bộ mã giống như bên phầnmã chập, đồng thời nhận các bit ngõ vào từ kênh truyền. Bảng trạng thái tiếp theocũng được tính toán trước và lưu vào bộ nhớ ở khối này.

Sau đó, với mỗi xung bộ giải mã sẽ tính toán 4 khoảng cách nhánh Hamming

hoặc Euclidean (gọi chung là khoảng cách), phụ thuộc vào chế độ quyết định cứnghay mềm đã lựa chọn ban đầu. Với mỗi trạng thái, khối Cộng-So sánh-Lựa chọn(ACS) tính toán hai khoảng cách đường, so sánh và lựa chọn ra đường có khoảngcách bé nhất. Tại thời điểm này, bộ giải mã cũng lưu lại các thông số tích lũy chotrạng thái.

Giống như mã chập, sơ đồ trellis được xây dựng, trên sơ đồ này, các điểmtruyền được đánh dấu với các thông số tương tứng như thông số đường và trạng tháitrước đó. Khi tất cả các bit vào đã được nhận, sơ đồ trellis đã xây dựng xong, tính

toán tất cả các thông số tích lũy, dựa vào bẳng tích lũy bộ giữa mã tìm đường tồntại, kết hợp giữa đường tồn tại và bảng trạng thái tiếp theo bộ giải mã sẽ tìm rachuỗi bit ban đầu.

TínhThông số

nhánhDữ liệu vào

CộngSo sánh

Lựa chọn

Lưu trữthông sốđường

Truy hồi- Tìm đường tốiưu nhất

Dữ liệu ra

Hình 4.6: Lưu đồ giải thuật bộ giải mã

Sau đây là lưu đồ chi tiết hơn cho bộ giải mã Viterbi





Vào 3 bit

Quyết định cứng / mềm

Tính khoảng cáchEuclidean

3 bit 3 bit

Chọn chế độ

Mềm Cứng

Vào 1 bit

Tính khoảng cáchHamming

1 bit 1 bitinput0 input1 input0 input1


Chọn chế độ

Các khoảng cách

Dist_00 Dist_01 Dist_10 Dist_11

So Sánh

+ +

Lưu trữ thông số tích lũy

Trellits Cuối ?

Bộ nhớ lưu trữ trạng tháitiếp theo và ngõ ra

Dữ liệu ra

Dữ liệu ra

Truy hồi tìm đường tồn tại

S

Đ

S

Hình 4.7: Lưu đồ chi tiết giải thuật giải mã Viterbi trên Kit DE2





Trước khi thực hiện giải mã, bộ giải mã phải được cài đặt chế độ quyết địnhcho giải mã từ bên ngoài. Với mỗi chế độ, sẽ có cách tính khoảng cách nhánh khácnhau, Hamming (tương ứng với quyết định cứng) hay Euclidean (tương ứng vớiquyết định mềm).

Khối tính khoảng cách Hamming

Lượng tử 1bit

1 bit vào

Lượng tử 1bit

1 bit vào

1 b i t

Bit chuẩnGiống nhau ? Giống nhau ?

Khoảng cách = 0

Đ

Khoảng cách = 1

S

Khoảng cá ch = 0

Khoảng cá ch = 1

Đ

S

+

Khoảng cách Hamming

1 b i t

Hình 4.8: Lưu đồ tính khoảng cách Hamming

Như đã trình bày trong phần trước, các bit nhận được ở bộ thu sẽ được lượng tửvới 1 bit, khoảng cách Hamming được tính dựa trên sự khác nhau giữa bit thu đượcvà bit chuẩn tương ứng 00, 01, 10, 11. Sau khi qua khối tính khoảng cáchHamming, kết quả được đưa đến khối ACS để tìm ra đường tồn tại.

Theo sơ đồ trên, mặc dù khối cộng có 4 ngõ vào, tuy nhiên tại 1 thời điểm, chỉcó 2 ngõ vào tương ứng với giá trị khi so sánh sự giống nhau của bit thu được và bitchuẩn.

Khối tính khoảng cách Euclidean





Lượng tử 3 bit (Y)

1 bit vào

Lượng tử 3 bit (Y)

1 bit vào

3 b i t

3

b i t

Bit chuẩn (X)

+

Khoảng cách Euclidean

(X – Y )(X – Y ) (X – Y )(X – Y )

Hình 4.9: Lưu đồ giải thuật tính khoảng cách Euclidean

Khi chế độ lựa chọn là quyết định mềm thì bộ giải mã sẽ tính toán khoảng cáchEuclidean thay cho khoảng cách Hamming. Lý thuyết về việc tính toán khoảng cáchEuclidean đã được trình bày ở phần trước.

Kết quả tính toán khoảng cách Hamming hay Euclidean đều được lưu vào 1 biến duy nhất tương ứng với bit chuẩn (00, 01, 10, 11). Các giá trị này được so sánhvới nhau để tìm ra khoảng cách có giá trị nhỏ nhất. Các thông số liên quan đến giátrị nhỏ nhất này được lưu trữ bào bộ nhớ để phục vụ cho quá trình truy hồi sau này.

Khối trạng thái tiếp theo

Khi vừa cấp nguồn, bộ giải mã sẽ thực hiện tính toán và lưu trữ một bảng baogồm các giá trị của ngõ ra và giá trị tiếp theo tương ứng với tất cả các giá trị ngõvào. Bảng này gọi là bảng trạng thái tiếp theo. Bảng trạng thái tiếp theo được sửdụng kết hợp với giá trị của đường tối ưu để tìm ra chuỗi bit ban đầu.

Việc tạo ra các giá trị tiếp theo giống như tạo mã chập cho các giá trị ngõ vàođược cho trước. Các giá trị này nằm ở các vị trí đã được xác định, để bộ giải mã cóthể truy cập đến một cách chính xác để tìm ra bit ngõ vào chính xác.

Bảng trạng thái tiếp theo của bộ mã được sử dụng trong bài báo cáo này đượcxác định như sau:





Bảng 4.4: Bảng trạng thái tiếp theo

PreviousState

INPUT 0 INPUT 1

Next State Output Bit Next State Output Bit

00 00 00 10 11

01 00 11 10 00

10 01 01 11 10

11 01 10 11 01

Khối tính khoảng cách nhánh

Vào 3 bit

Tính khoảng cáchEuclidean

3 bit 3 bit

Vào 1 bit

Tính khoảng cáchHamming

1 bit 1 bitinput0 input1 input0 input1


Chọn chế độ

Các khoảng cách

Dist_00 Dist_01 Dist_10 Dist_11

Hình 4.10: Lưu đồ khối tính khoảng cách nhánh

Tương ứng với mỗi cặp bit vào, bộ giải mã tính ra 4 khoảng cách nhánh tương ứngvới các cặp bit chuẩn 00, 01, 10, 11.

Khối cộng so sánh lựa chọn





+

Dist _00

Bảng thông số tích lũy

+

Dist _11

<

0 1

Hình 4.11: Lưu đồ khối ACS

Khoảng cách nhánh tại trrạng thái hiện tại được cộng dồn với giá trị đã tích lũytrước đó trên cùng đường đi của sơ đồ trellis. Sau khi cộng, bộ giải mã sẽ so sánh 2kết quả cộng trên, giả sử tại thời điểm này, hai kết quả này bằng nhau, bộ so sánh sẽtiếp tục dịch lên một trạng thái và tiến hành so sánh lần thứ hai, lúc này bộ giải mãsẽ tìm ra giá trị nhỏ nhất, từ đó bộ so sánh truy ngược lại và xác định giá trị lựachọn ở trạng thái trước. Giá trị sau khi được lựa chọn sẽ được lưu vào bảng tích lũy,

bảng này sẽ phục vụ cho việc tìm đường tồn tại sau này.Khối truy hồi

Tăng trạng thái lên 1

So sánh các khoảng cáchnhánh tích lũy trong trạng

thái

Trạng thái 0

Trạng thái cuối ?

Lưu lại khoảng cách nhỏnhất

S

Đ

Đường tối ưu nhất

Hình 4.12: Lưu đồ khối truy hồi





Từ trạng thái đầu tiên, khối truy hồi sẽ so sánh các giá trị trong bảng tích lũy đểtìm ra đường tồn tại tối ưu nhất.

Khối giải mã

Bảng trạng thái tiếp theo

Đường tối ưu nhất

Giống nhau ?

Dữ liệu ra

Bộ đếm

Bit 0 vào Bit 1 vàoTrạng thái tiếp theo

Hình 4.13: Lưu đồ khối giải mã

Sau khi qua khối truy hồi, bộ giải mã đã tìm được đường tồn tại. Bộ giải mã sẽtiến hành so sánh giá trị tiếp theo của đường tồn tại tại thời điểm hiện tại với giá trịcủa đường tồn tại tại thời điểm sau một trạng thái. Với mỗi lần so sánh, bộ giải mãsẽ thử với một trong hai bit vào là 0 hay 1, so sánh sự giống nhau tương ứng với giátrị vào là 0 hay 1, bộ giải mã sẽ xác định được bit được mã hóa ban đầu ở khối phátlà 0 hay 1.

Sau khi hoàn thành so sánh tất cả các trạng thái, bộ giải mã đã xác định đượcchuỗi bit ban đầu.

4.4 Kết quả

Quá trình thực hiện được chia làm hai quá trình, thứ nhất là lập trình giải thuậtmã hóa mã chập và thuật giải Viterbi chạy mô phỏng sử dụng phần mềm mô phỏngcó sẵn trong Quartus II; thứ hai là tiến hành biên dịch tổng hợp và đổ chương trìnhlên Kit DE2 có kèm theo chương trình hiển thị trên LCD cà các Led đơn, trongchương trình đổ lên Kit DE2 thì người lập trình đã loại bỏ khối mã hóa mã chập.

Giả sử cho chuỗi bit ban đầu trước khi mã hóa mã chập là: 11100101.

Sau khi mã hóa mã chập cho ra chuỗi bit sau: 1110011011110100





Cho ngược chuỗi 16 bit trên vào ngõ vào của bộ giải mã Viterbi. Kết quả ngõ ralà: 11100101

Vì không có nhiễu tác động nên kết quả của hai quyết định cứng và mềm là nhưnhau.

Kết quả mô phỏng trên phần mềm Quartus II như sau:

Hình 4.14: Kết quả mô phỏng 1

Giả sử ngõ vào bộ giải mã Viterbi bị sai 2 bit: 1010011010110100

Kết quả ra vẫn chính xác: 11100101






Giả sử ngõ vào bộ giải mã Viterbi bị sai 3 bit : 1010011010110101

Kết quả 1 bit cuối bị giải mã sai: 11100100


Giả sử ngõ vào bộ giải mã Viterbi bị sai 4 bit : 1010001010110101

Kết quả 1 bit cuối bị giải mã sai: 11100100


Kết quả trên chứng minh bộ giải mã Viterbi có khả năng sửa sai bit đơn rất tốt.

Giả sử ngõ vào bộ giải mã Viterbi bị sai 1 cặp bit : 1101011011110100

Kết quả 2 bit bị giải mã sai: 10110101






Giả sử ngõ vào bộ giải mã Viterbi bị sai 1 bit đơn và 1cặp bit :1101011011111100

Kết quả 5 bit bị giải mã sai: 10110010


Kết quả trên cho thấy, thuật giải mã Viterbi không có khả năng sửa lỗi sai trong

trường hợp lỗi đa bit.So sánh với kết quả đã mô phỏng trên Matlab

Vẫn chuỗi bit vào như trên: 11100101. Với mô phỏng trên Matlab, hệ thống cótác động của nhiễu trắng Gaussian. Kết quả giải mã bị sai 1 bit với quyết địnhmềm.





Hình 4.20: Mô phỏng trên Matlab

Vì mô phỏng trên Kit DE2 là môi trường lý tưởng, dữ liệu bit nhận được nhậpvào bởi người sử dụng, không bị tác động của kênh truyền, do đó kết quả giải mãcho chính xác hơn so với giải mã trên Matlab.

Hình ảnh thực tế trên Kit DE2 như sau:

Hình 4.21: Hình thực tế bộ kit 1


Khởi động chương trình mô phỏng, LCD hiển thị DHSPKT TPHCM và dòng chữ

DO AN TOT NGHIEP




Hình 4.22: Hình thực tế bộ kit 2

Hình 4.23: hình thực tế bộ kit 3


Tiếp theo, LCD hiển thịnhóm thực hiện đề tài

4. LCD hiểnthị chuỗi dữliệu cần giải

mã và chuỗi dữliệu sau giảimã.

5. 8 LED biễu diễnchuỗi dữ liệu sau giải

mã.

2. 16 SW để gán dữliệu cần giải mã.

3. Mức 1để bắt

đầu giảimã.

1. Mức 0để chọngiải mãquyết địnhmềm

Key 0 để

reset mạch




CHƯƠNG 5: KẾT LUẬN5.1 Tổng kết nhận xét

Tổng kết lại, trong cuốn đồ án này nhóm đã thực hiện được những nội dung

sau:

• Giới thiệu về vị trí vai trò của mã hóa kênh truyền trong hệ thống thông tinsố, so sánh hai hình thức mã hóa là mã khối và mã trellis.

• Khái niệm và phân tích mã chập, cách thức mã hóa sử dụng mã chập, cũngnhư cấu trúc của bộ mã hóa chập.

• Khái niệm và phân tích thuật toán giải mã Viterbi, cách mà thuật toán Viterbigiải mã một tín hiệu và sửa sai các lỗi xảy ra trên kênh truyền, phân biệt hai

phương pháp giải mã là giải mã quyết định cứng và quyết định mềm.• Thực hiện mô phỏng Matlab để xem hiệu quả của thuật toán Viterbi.

• Thực hiện mô tả trên Kit DE2 bằng ngôn ngữ VHDL để kiểm chứng kết quảmô phỏng.

Qua kết quả mô phỏng bằng Matlab và kết quả mô tả trên kit DE2, nhóm đã rútra được những nhận xét sau:

• Mã hóa kênh truyền giúp giảm thiểu tác động của nhiễu và cải thiện

tin tức tốt.• Thuật toán giải mã viterbi đạt hiệu quả cao, xác suất lỗi thấp

• Trên kênh truyền có lỗi Gauss trắng, tín hiệu có thể được phục hồi tốt.

• Thuật toán viterbi với quyết định mềm cho kết quả tốt hơn quyết địnhcứng. Vì với quyết định mềm tín hiệu sau khi được nhận ở bộ thu đượclượng tử với nhiều mức, do đó dẫn đến xác suất sai sẽ thấp hơn so với quyếtđịnh cứng.

• Đối với các lỗi nhiều bit liên tiếp, thuật toán Viterbi không mang lạihiệu quả.

• Trong kênh truyền có tỉ số SNR cao, thuật toán viterbi với cả 2 quyếtđịnh cứng và mềm đều cho kết quả tốt gần như nhau.

5.2 Tồn tại và hướng phát triển của đề tài

Những mặt còn tồn tại:

- Việc mô phỏng trên matlab cũng như mô tả trên kit DE2 đều chỉ mới tiến

hành với bộ mã đơn giản tốc độ ½ với chiều dài ràng buộc thấp. Vì thế,kết quả mô phỏng có thể sẽ không bao quát và nói hết được ưu nhượcđiểm của thuật toán.





- Việc mô tả trên kit DE2 chỉ là khâu giải mã với chuỗi bit nhận được nhập bởi người sử dụng. Do đó, ta không thể đánh giá được hết tác động củanhiễu chỉ với vài lần thử nghiệm với các bit nhận được là sai.

- Việc giải mã Viterbi quyết dịnh mềm chỉ mới thực hiện với phương pháp

dùng khoảng cách Euclidean.

Hướng phát triển đề tài:

- Với giới hạn thời gian cũng như khả năng có hạn nên nhóm tác giả vẫncòn chưa tìm hiểu hoàn chỉnh về mã chập cũng như thuật giải Viterbi. Vìvậy, có thể phương pháp thực hiện cũng như lập trình sẽ không là giải

pháp tối ưu. Nếu có cơ hội để nghiên cứu tiếp thì đề tài có thể nâng lên đểthực hiện tối ưu hóa cho bộ thu Viterbi, thử nghiệm với các bộ mã khácnhau để từ đó tìm ra bộ mã tối ưu nhất cho kênh truyền AWGN.

- Cải thiện việc mô tả trên kit DE2 bằng cách thêm phần tạo bit nhận ngẫunhiên chứ không nhập trực tiếp bằng tay, từ đó tổng hợp đánh giá tác độngcủa nhiễu lên tín hiệu một cách tổng quát hơn.

- Từ kết quả của đề tài, chúng ta có thể thiết kế các IC thực hiện các chứcnăng khác nhau trong hệ thống thông tin số.

- Nghiên cứu tiến hành xây dựng bộ mã hóa nguồn.




PHẦN C

PHỤ LỤC VÀ TÀILIỆU THAM KHẢO



I. Phụ lục

1. Hướng dẫn sử dụng kit DE2 để mô phỏng

Chức năng các một số thiết bị trên Kit DE2 như sau:

- Switch 0: Chức năng start, để bắt đầu quá trình giải mã. Mức 1 tươngứng với lệnh thực hiện bắt đầu.

- Switch 1: Chức năng lựa chọn chế độ quyết định cứng hay mềm.

1. Mức 0: Quyết định cứng

2. Mức 1: Quyết định mềm

- Switch 2 đến 17: Tương ứng với 16 bit ngõ vào.

- Nút nhấn Key 0: Chức năng reset mạch.

- LCD: Chức năng hiển thị thông tin về đồ án và dữ liệu vào ra của bộgiải mã.

- Led 0 đến 7: Chức năng hiển thị giá trị của 8 bit ngõ ra.

1. Led sáng: Mức 1

2. Led tắt: Mức 0

Quá trình mô phỏng trên Kit DE2 như sau:

Sau khi đã nạp chương trình từ máy tính xuống Kit DE2, màn hình LCD sẽhiển thị một số thông tin về đồ án. Khi gạt các Switch từ 2 đến 17 để cấp dữ liệungõ vào cho bộ giải mã, LCD sẽ hiển thị giá trị 16 bit này. Khi gạt Switch 0, quátrình giải mã bắt đầu, LCD hiển thị thêm 8 bit ra ở dòng thứ 2, đồng thời các Led sẽsáng.

Nếu nhấn nút Key 0 (Reset), LCD sẽ hiển thị lại các thông tin ban đầu, nếu lúc này,Switch Start đang bật thì các Led vẫn sáng, nếu Switch Start gạt xuống mức 0 thìcác Led tắt hết.

2. Tài nguyên sử dụng trên Kit DE2Bảng: Thông báo về tài nguyên sử dụng trên kit DE2

Phần C: Phụ lục và tài liệu tham khảo



Bảng: Danh sách các chân sử dụng trên Kit DE2

Signal Name PIN Discription

Clock_50 PIN_N2 50 mHz clock input

SW[0] PIN_N25 Toggle Switch[0]


SW[2] PIN_P25 Toggle Switch[2]

SW[3] PIN_AE14 Toggle Switch[3]

SW[4] PIN_AF14 Toggle Switch[4]

SW[5] PIN_AD13 Toggle Switch[5]

SW[6] PIN_AC13 Toggle Switch[6]

SW[7] PIN_C13 Toggle Switch[7]

SW[8] PIN_B13 Toggle Switch[8]

SW[9] PIN_A13 Toggle Switch[9]




SW[13] PIN_T7 Toggle Switch[13]SW[14] PIN_U3 Toggle Switch[14]




SW[15] PIN_U4 Toggle Switch[15]

SW[16] PIN_V1 Toggle Switch[16]

SW[17] PIN_V2 Toggle Switch[17]

LEDR[0] PIN_AE23 LED Red[]

LEDR[1] PIN_AF23 LED Red[]

LEDR[2] PIN_AB21 LED Red[]

LEDR[3] PIN_AC22 LED Red[]

LEDR[4] PIN_AD22 LED Red[]



LEDR[7] PIN_AC21 LED Red[]

KEY[0] PIN_G26 Pushbutton[0]

LCD_DATA[0] PIN_J1 LCD DATA []

LCD_DATA[1] PIN_J2 LCD DATA []LCD_DATA[2] PIN_H1 LCD DATA []

LCD_DATA[3] PIN_H2 LCD DATA []





LCD_RW PIN_K4 LCD Read/Write Select, 0 = Write, 1 =Read

LCD_EN PIN_K3 LCD Enable

LCD_RS PIN_K1 LCD Command/Data Select, 0 =Command, 1 = Data

LCD_ON PIN_L4 LCD Power ON/OFF




LCD_BLON PIN_L2 LCD Back Light ON/OFF

3. Mã nguồn Matlab

function varargout = viterbi2(varargin)gui_Singleton = 1;gui_State = struct('gui_Name', mfilename, ...

'gui_Singleton', gui_Singleton, ...'gui_OpeningFcn', @viterbi2_OpeningFcn, ...'gui_OutputFcn', @viterbi2_OutputFcn, ...'gui_LayoutFcn', [] , ...'gui_Callback', []);

if nargin && ischar(varargin{1})gui_State.gui_Callback = str2func(varargin{1});

end if nargout

[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});else

gui_mainfcn(gui_State, varargin{:});end

function viterbi2_OpeningFcn(hObject, eventdata, handles, varargin)handles.output = hObject;guidata(hObject, handles);h1 = getappdata(0,'GUI1_handle');close(h1)

h2 = gcf;

setappdata(0,'GUI2_handle',h2);

axes(handles.logo);imshow('KHOADIENTU.png');viterbi3;set(handles.bitin,'Enable','inactive');global inbit numin ;inbit =0;

function varargout = viterbi2_OutputFcn(hObject, eventdata, handles)varargout{1} = handles.output;




function button_back_Callback(hObject, eventdata, handles)viterbi1;

function button_exit_Callback(hObject, eventdata, handles)exit = questdlg('Ready to quit?',...

'Exit Dialog','Yes','No','No');switch exit

case 'Yes',disp('Exiting MATLAB');savequit

case 'No'

quit cancel;end

function numin_Callback(hObject, eventdata, handles)user_entry = str2double(get(hObject,'String'));if isnan(user_entry)

errordlg('Type the integer, maximum value is 10^6! ','Input Error !','modal')set(hObject,'String','');

returnend function numin_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'),get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');end

function numin_ButtonDownFcn(hObject, eventdata, handles) function g2_Callback(hObject, eventdata, handles)user_entry = str2double(get(hObject,'string'));if isnan(user_entry)

errordlg('Type the integer ! ','Input Error !','modal')set(hObject,'String','');return

end function g2_CreateFcn(hObject, eventdata, handles)




if ispc && isequal(get(hObject,'BackgroundColor'),get(0,'defaultUicontrolBackgroundColor'))


function g1_Callback(hObject, eventdata, handles)user_entry = str2double(get(hObject,'string'));if isnan(user_entry)


end

function g1_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'),get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');end function length_Callback(hObject, eventdata, handles)user_entry = str2double(get(hObject,'string'));

if isnan(user_entry)errordlg('Type the integer ! ','Input Error !','modal')set(hObject,'String','');return

end function length_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'),get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');end function numout_Callback(hObject, eventdata, handles)user_entry = str2double(get(hObject,'string'));if isnan(user_entry)


end




if (user_entry > 2)||(user_entry < 1)errordlg('The Viterbi decoder is just for maximum 2 outputs !','Input

Error !','modal')set(hObject,'String','');

returnendif user_entry == 1

set(handles.g2,'Enable','inactive');set(handles.textber,'ForegroundColor','black')

elseif user_entry == 2set(handles.g2,'Enable','on');set(handles.textber,'ForegroundColor','blue')

end

function numout_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'),get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');end function auto_Callback(hObject, eventdata, handles)if (get(hObject,'Value') == get(hObject,'Max'))

a = 1;set(handles.numin,'Enable','inactive');set(handles.numin,'String','');set(handles.bitin,'Enable','on');set(handles.bitin,'String','');set(handles.text7,'ForegroundColor','black');

elsea = 0;set(handles.numin,'Enable','on');

set(handles.bitin,'Enable','inactive');set(handles.text7,'ForegroundColor','blue');

end

function bitin_Callback(hObject, eventdata, handles)

function bitin_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'),get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');




end function bitencoded_Callback(hObject, eventdata, handles)

function bitencoded_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'),get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');end function bitout_Callback(hObject, eventdata, handles)

function bitout_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'),get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');end function ber_Callback(hObject, eventdata, handles)clc;if (get(handles.auto,'Value') == get(handles.auto,'Max'))

a = 1;elsea = 0;

end

if a == 1inbit = get(handles.bitin,'String');inbit = str2num(inbit);numin = length(inbit);

elsenumin = get(handles.numin,'String');numin = str2num(numin);inbit = randint(1,numin);

endnumout = get(handles.numout,'String');numout = str2num(numout);len = get(handles.length,'String');len = str2num(len);g1 = get(handles.g1,'String');g1 = str2num(g1);




g2 = get(handles.g2,'String'g2 = str2num(g2); Eb_N0_dB = [1:1:10];

for i = 1:length(Eb_N0_dB)snr_db = Eb_N0_dB(i)if numout == 1

trellis = poly2trellis(len,g1);elseif numout == 2trellis = poly2trellis(len,[g1 g2]);

end

encbits = convenc(inbit,trellis);encbits = 2*encbits - 1;

awgnbits = awgn(encbits,snr_db,'measured');

str = get(handles.typeofdec,'String');val = get(handles.typeofdec,'Value');switch str{val}

case 'Soft Decision'select = 0;case 'Hard Decision'

select = 1;case 'Both'

select = 2;end

if select == 0

partition = [-.8571 -.5714 -.2857 0 .2857 .5714 .8571];codebook = [-.99 -.8571 -.5714 -.2857 0 .2857 .5714 .8571];quanbits = quantiz(awgnbits,partition,codebook);tblen = numin -1 ;opmode = 'term';dectype = 'soft';nsdec = 3;decbits = vitdec(quanbits,trellis,tblen,'term','soft',nsdec);

endif select == 1

partition = [0];




codebook = [0 1];quanbits = quantiz(awgnbits,partition,codebook);tblen = numin-1;opmode = 'term' ;

dectype = 'hard';decbits = vitdec(quanbits,trellis,tblen,'term','hard');

end

if select == 0 || select == 1[numerr ratioerr] = biterr(inbit, decbits);ratioerr_comp(i) = ratioerr

end

if select == 2partition_h = [0];codebook_h = [0 1];quanbits_h = quantiz(awgnbits,partition_h,codebook_h);tblen_h = numin-1;opmode_h = 'term' ;dectype_h = 'hard';decbits_h = vitdec(quanbits_h,trellis,tblen_h,'term','hard');

partition_s = [-.8571 -.5714 -.2857 0 .2857 .5714 .8571];codebook_s = [-.99 -.8571 -.5714 -.2857 0 .2857 .5714 .8571];quanbits_s = quantiz(awgnbits,partition_s,codebook_s);tblen_s = numin -1 ;opmode_s = 'term';dectype_s = 'soft';nsdec = 3;decbits_s = vitdec(quanbits_s,trellis,tblen_s,'term','soft',nsdec);

[numerr_s ratioerr_s] = biterr(inbit, decbits_s);ratioerr_comp_s(i) = ratioerr_s[numerr_h ratioerr_h] = biterr(inbit, decbits_h);ratioerr_comp_h(i) = ratioerr_h

endendif select == 0

figuresemilogy(Eb_N0_dB,ratioerr_comp,'mp-','LineWidth',2);axis([0 10 10^-8 0.5])grid on




legend('Viterbi-Soft decision(rate-1/2, [5,7]_8)');xlabel('Eb/No, dB');ylabel('Bit Error Rate');title('BER for Viterbi-Soft decision decoding in AWGN');

end

if select == 1figuresemilogy(Eb_N0_dB,ratioerr_comp,'bd-','LineWidth',2);axis([0 10 10^-8 0.5])grid onlegend('Viterbi-Hard decision(rate-1/2, [5,7]_8)');xlabel('Eb/No, dB');

ylabel('Bit Error Rate');title('BER for Viterbi-Hard decision decoding in AWGN');

end

if select == 2figuresemilogy(Eb_N0_dB,ratioerr_comp_s,'mp-','LineWidth',2);hold on;

semilogy(Eb_N0_dB,ratioerr_comp_h,'bd-','LineWidth',2);axis([0 10 10^-8 0.5])grid onlegend('Viterbi-Soft decision(rate-1/2, [5,7]_8)','Viterbi-Hard decision(rate-1/2,

[5,7]_8)');xlabel('Eb/No, dB');ylabel('Bit Error Rate');title('BER for both types of decision of Viterbi decoding in AWGN');

end

function reset_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'),get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');end function start_Callback(hObject, eventdata, handles)clc;

global inbit numin ratioerr inbit = get(handles.bitin,'String');




inbit = str2num(inbit);numin = length(inbit);numout = get(handles.numout,'String');numout = str2num(numout);

len = get(handles.length,'String');len = str2num(len);g1 = get(handles.g1,'String');g1 = str2num(g1);g2 = get(handles.g2,'String');g2 = str2num(g2); if numout == 1

trellis = poly2trellis(len,g1);

elseif numout == 2trellis = poly2trellis(len,[g1 g2]);

end encbits = convenc(inbit,trellis);encbits = num2str(encbits);set(handles.bitencoded,'String',encbits)encbits = str2num(encbits);

encbits = 2*encbits - 1;snr = get(handles.snr,'String');snr = str2num(snr);awgnbits = awgn(encbits, snr, 'measured'); str = get(handles.typeofdec,'String');

val = get(handles.typeofdec,'Value');switch str{val}

case 'Soft Decision'.

select = 0;case 'Hard Decision'

select = 1;case 'Both'

select = 2;end

if select == 0

partition = [-.8571 -.5714 -.2857 0 .2857 .5714 .8571];codebook = [-.99 -.8571 -.5714 -.2857 0 .2857 .5714 .8571];quanbits = quantiz(awgnbits,partition,codebook);




tblen = numin -1 ;opmode = 'term';dectype = 'soft';nsdec = 3;

decbits = vitdec(quanbits,trellis,tblen,'term','soft',nsdec);endif select == 1

partition = [0];codebook = [0 1];quanbits = quantiz(awgnbits,partition,codebook);tblen = numin-1;opmode = 'term' ;dectype = 'hard';

decbits = vitdec(quanbits,trellis,tblen,'term','hard');end decbits = num2str(decbits);set(handles.bitout,'String',decbits)decbits = str2num(decbits); [numerr ratioerr] = biterr(inbit, decbits);

numerr = num2str(numerr);set(handles.numerr,'String',numerr);numerr = str2num(numerr);ratioerr = num2str(ratioerr);set(handles.ratioerr,'String',ratioerr);ratioerr = str2num(ratioerr); function reset_Callback(hObject, eventdata, handles)clc;

set(handles.typeofdec,'Value',1);set(handles.auto,'Value',0);set(handles.bitin,'Enable','inactive');set(handles.numin,'String','');set(handles.numout,'String','2');set(handles.length,'String','3');set(handles.g1,'String','5');set(handles.g2,'String','7');set(handles.snr,'String','5');set(handles.bitin,'String','');set(handles.bitencoded,'String','');




set(handles.bitout,'String','');set(handles.numerr,'String','');set(handles.ratioerr,'String','');set(handles.g2,'Enable','on');

set(handles.textber,'ForegroundColor','blue')

function togglebutton1_Callback(hObject, eventdata, handles) function edit17_Callback(hObject, eventdata, handles)

function edit17_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'),get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');end function snr_Callback(hObject, eventdata, handles)user_entry = str2double(get(hObject,'string'));if isnan(user_entry)

errordlg('Type the integer ! ','Input Error !','modal')set(hObject,'String','');

returnend

function snr_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'),get(0,'defaultUicontrolBackgroundColor'))


function pushbutton5_Callback(hObject, eventdata, handles)

function start_KeyPressFcn(hObject, eventdata, handles)

function taoinbit_Callback(hObject, eventdata, handles)clc;

global inbit numin ;if (get(handles.auto,'Value') == get(handles.auto,'Max'))

a = 1;else




a = 0;end

if a == 1

inbit = get(handles.bitin,'String');inbit = str2num(inbit);

elsenumin = get(handles.numin,'String');numin = str2num(numin);inbit = randint(1,numin);

end

inbit = num2str(inbit);

set(handles.bitin,'Enable','on');set(handles.bitin,'String',inbit);inbit = str2num(inbit);

function viwebit_Callback(hObject, eventdata, handles)close 'Gui_3' ; function typeofdec_Callback(hObject, eventdata, handles)

function typeofdec_CreateFcn(hObject, eventdata, handles)if ispc && isequal(get(hObject,'BackgroundColor'),get(0,'defaultUicontrolBackgroundColor'))


4. Mã nguồn VHDL

Viterbi.vhdLIBRARY ieee;

USE ieee.std_logic_1164.all;

USE ieee.std_logic_arith.all;

USE ieee.std_logic_unsigned.all;

USE work.distance.all;

USE work.converter.all;

ENTITY viterbi is




GENERIC(

CONSTANT K: natural: = 1;

CONSTANT N: natural: = 2;

CONSTANT L: natural: = 3;CONSTANT Ga: natural: = 5;

CONSTANT Gb: natural: = 7;

CONSTANT V: natural: = 8

);

PORT(

clk : in std_logic;

reset : in std_logic;

start : in std_logic;

dec_in: in std_logic;

sel_dec: in std_logic;

data : in std_logic_vector (V*N-1 downto 0);

data_out: out std_logic_vector (V-1 downto 0);

conv_in: in std_logic_vector(V-1 downto 0);

conv_out: out std_logic_vector(V*N-1 downto 0)

);

END viterbi;

ARCHITECTURE rtl OF viterbi IS

TYPE matrix_1 is array (0 to 3, 0 to 1) of std_logic_vector(3 downto 0);

TYPE matrix_2 is array (0 to 3, 0 to 10) of integer ;TYPE matrix_3 is array (0 to 3, 0 to 1) of integer;

TYPE matrix_4 is array (0 to 8) of integer;

TYPE matrix_7 is array (0 to 7) of std_logic_vector (1 downto 0);

TYPE matrix_8 is array (0 to 3, 0 to 10) of integer;

TYPE matrix_9 is array (0 to 10) of integer;

SIGNAL data_in : matrix_7;

SIGNAL ne_st_reg: matrix_1;




BEGIN

---------------------------------------------------------------------------------

-- the firt part is get data input

---------------------------------------------------------------------------------get_data_in: PROCESS(dec_in,reset,sel_dec)

VARIABLE v2: integer;

BEGIN

IF reset = '0' THEN v2: = 0;

ELSIF dec_in = '1' THEN

FOR v2 in 0 to 7 LOOP

data_in(7-v2) <= data(v2*2+1 downto v2*2);

END LOOP;

END IF;

END PROCESS;

-------------------------------------------------------------------------------

-- The second part is to initialize the next state

--------------------------------------------------------------------------------

next_state_out_reg: PROCESS(reset)

VARIABLE lp1: std_logic_vector(1 downto 0);

VARIABLE lp2: std_logic;

VARIABLE l1,l2,l3: integer;

BEGIN

IF reset = '0' THENlp1: = "00";

lp2: = '0';

ELSE

FOR l1 in 0 to 3 LOOP


lp1: = conv_std_logic_vector(l1,2);

IF l2=0 THEN




lp2: = '0';

ELSE

lp2: = '1';

END IF;-- next state and output bits

ne_st_reg(l1,l2) <= lp2&lp1(1)&(lp2 xor lp1(0))&(lp2 xor lp1(1) xor lp1(0));

END LOOP;

END LOOP;

END IF;

END PROCESS;

-------------------------------------------------------------------------------

-- The third part is calculate Hamming distance

--------------------------------------------------------------------------------

Hd_calculation: PROCESS(clk,start)

VARIABLE pre_state_reg: matrix_2; -- previous states for trace back

VARIABLE aem_reg : matrix_3; -- aem

VARIABLE ssa_reg : matrix_4; -- trace back

VARIABLE result : std_logic_vector(V-1 downto 0);VARIABLE ac_reg : matrix_8; -- accumalated metric table

VARIABLE sv_reg : matrix_9; -- survier path register

VARIABLE cnt : integer: =0; -- internal cuonter

VARIABLE flag : std_logic: = '0';

VARIABLE dist_00, dist_01, dist_10, dist_11: integer;

VARIABLE v3: integer: =0;

VARIABLE t1: std_logic_vector (1 downto 0);

VARIABLE t3,t4: integer range 0 to 3;

VARIABLE l1,l2,l3: integer;

VARIABLE dec_en: std_logic: = '0';

BEGIN

IF reset = '0' THEN v3: = 0; cnt: = 0;

ELSIF start = '1' THEN




IF Rising_edge(clk) THEN

-- cnt is a counter to count terllics diagrame to tell us which step now

cnt: = cnt + 1;

IF cnt = 10 THENcnt: = 0;

END IF;

-- This part is to calculate Hamming distance or Euclidean distance

IF sel_dec = '1' THEN -- Euclidean

dist_00: = euclid(data_in(cnt-1),"00");




ELSE -- Hamming

dist_00: = hamming(data_in(cnt-1),"00");




END IF;

------------------------------------------------

-- This is ACS block

-------------------------------------------------

-- This is Branch Metric Unit

CASE cnt isWHEN 0 =>


aem_reg(l1,0): = 0;

aem_reg(l1,1): = 0;


ac_reg(l1,l2): = 0;

END LOOP;




END LOOP;

WHEN 1 =>

ac_reg(0,1): = dist_00 ;

ac_reg(2,1): = dist_11 ; pre_state_reg(0,1): = 0;

pre_state_reg(2,1): = 0;

WHEN 2 =>

ac_reg(0,2): = dist_00 + ac_reg(0,1);

ac_reg(1,2): = dist_01 + ac_reg(2,1);

ac_reg(2,2): = dist_11 + ac_reg(0,1);

ac_reg(3,2): = dist_10 + ac_reg(2,1);





WHEN others =>

aem_reg(0,0): = dist_00 + ac_reg(0,cnt-1);






aem_reg(1,1): = dist_10 + ac_reg(3,cnt-1);aem_reg(3,1): = dist_01 + ac_reg(3,cnt-1);

END CASE;

--The following part compare each 2 possible path and select

-- a small one and write the survival path to the survival path register.

IF (cnt >= 3) and (cnt <= 8) THEN


t1: = conv_std_logic_vector(l1,2);




IF aem_reg(l1, 0) <= aem_reg(l1, 1) THEN

ac_reg(l1,cnt): = aem_reg(l1, 0);

pre_state_reg(l1,cnt): = conv_int(t1(0) & '0');

ELSEac_reg(l1,cnt): = aem_reg(l1, 1);

pre_state_reg(l1,cnt): = conv_int(t1(0) & '1');

END IF;

END LOOP;

END IF;

-- This is the trace back part which finds the Most Likelihood Path

IF cnt = 9 THEN

sv_reg(0): = 0; -- 0 is allway the first step

IF ac_reg(0,1) < ac_reg(2,1) THEN -- the second step

sv_reg(1): = 0;

ELSIF ac_reg(0,1) > ac_reg(2,1) THEN

sv_reg(1): = 2;

ELSE -- compare the third step

IF ac_reg(0,2) <= ac_reg(2,2) THEN

l2: = ac_reg(0,2);

ELSE

l2: = ac_reg(2,2);

END IF;

IF ac_reg(1,2) <= ac_reg(3,2) THENl3: = ac_reg(1,2);

ELSE

l3: = ac_reg(3,2);

END IF;

IF l2 <= l3 THEN

sv_reg(1): = 0;

ELSE




sv_reg(1): = 2;

END IF;

END IF;

FOR l1 in 2 to 8 LOOPIF ac_reg(0,l1) <= ac_reg(1,l1) THEN

l2: = ac_reg(0,l1);

ELSE

l2: = ac_reg(1,l1);

END IF;

IF ac_reg(2,l1) <= ac_reg(3,l1) THEN

l3: = ac_reg(2,l1);

ELSE

l3: = ac_reg(3,l1);

END IF;

IF l2 < l3 THEN

IF ac_reg(0,l1) <= ac_reg(1,l1) THEN

sv_reg(l1): = 0;

ELSE

SV_reg(l1): = 1;

END IF;

ELSIF l2 > l3 THEN

ac_reg(2,l1) <= ac_reg(3,l1) THEN

sv_reg(l1): = 2;ELSE

sv_reg(l1): = 3;

END IF;

ELSE

IF ac_reg(0,l1+1) <= ac_reg(1,l1+1) THEN

l2: = ac_reg(0,l1+1);

ELSE




l2: = ac_reg(1,l1+1);

END IF;

IF ac_reg(2,l1+1) <= ac_reg(3,l1+1) THEN

l3: = ac_reg(2,l1+1);ELSE

l3: = ac_reg(3,l1+1);

END IF;

IF l2 <= l3 THEN

IF ac_reg(0,l1+1) <= ac_reg(1,l1+1) THENsv_reg(l1): = pre_state_reg(0,l1+1);

ELSESV_reg(l1): = pre_state_reg(1,l1+1);

END IF;

ELSIF l2 > l3 THEN

IF ac_reg(2,l1+1) <= ac_reg(3,l1+1) THENsv_reg(l1): = pre_state_reg(2,l1+1);

ELSE

sv_reg(l1): = pre_state_reg(3,l1+1);

END IF;

END IF;

END IF;IF l1 = 8 THEN flag: = '1';

ELSE flag: = '0';

END IF;

END LOOP;

END IF;

-----------------------------------------------------------------------

-- when the flag is one, it means the TB part is done.

-- Then the decoder begins to decode the data

IF flag = '1' THEN


t3: = sv_reg(l1);




t4: = sv_reg(l1+1);

IF t4 = conv_int(ne_st_reg(t3, 0)(3 downto 2)) THEN

result(l1): = '0';

ELSIF t4 = conv_int(ne_st_reg(t3, 1)(3 downto 2)) THENresult(l1): = '1';

END IF;

END LOOP;

END IF;

END IF;


data_out(l1) <= result(7-l1);

END LOOP;

IF l1 = 7 THEN dec_en: = '1';

END IF;

END IF;

END PROCESS;

-------------------------------------------------------------------------

-- This part is show convolution processor.

Convolution: PROCESS(clk,reset)

VARIABLE conv_out_v: std_logic_vector(15 downto 0);

VARIABLE ff: std_logic_vector(2 downto 0):="000";

VARIABLE i: integer: = 8;

VARIABLE j: integer: = 15;BEGIN

IF reset = '0' THEN i:= 8; j: = 15;

ELSIF Rising_edge(clk) THEN

IF i > 0 THEN

ff: = ff(1 downto 0) & conv_in(i-1) ;

conv_out_v(j): = ff(0) xor ff(2);

conv_out_v(j-1): = ff(0) xor ff(1) xor ff(2);




END IF;

j: = j-2;

i: = i-1 ;

END IF;IF i = 0 THEN

conv_out <= conv_out_v(15 downto 0) ;

END IF;

END PROCESS;

END ARCHITECTURE rtl;

CONVERTER.VHD

LIBRARY IEEE;




PACKAGE converter IS

FUNCTION conv_std_logic(gt_v: in INTEGER; sl_v: in INTEGER)RETURN std_logic_vector;

FUNCTION conv_int(gt_i: in std_logic_vector(1 downto 0)) RETURNinteger;

END converter;

PACKAGE BODY converter IS

FUNCTION conv_std_logic(gt_v,sl_v: integer) RETURN std_logic_vector IS

VARIABLE i_v: integer range 0 to (gt_v - 1): = 0;

VARIABLE u_v: std_logic_vector(sl_v downto 0);

BEGIN

IF gt_v /= 0 THEN

FOR i in 0 to (gt_v - 1) LOOP

u_v: = u_v + 1;




END LOOP;

END IF;

RETURN u_v;

END conv_std_logic;FUNCTION conv_int(gt_i: in std_logic_vector(1 downto 0)) RETURN

integer IS

VARIABLE i_i, u_i: integer;

BEGIN

CASE gt_i IS

WHEN "00" => i_i: = 0;

WHEN "01" => i_i: = 1;

WHEN "10" => i_i: = 2;

WHEN others => i_i: = 3;

END CASE;

RETURN i_i;

END conv_int;

END converter;

DISTANCE.VHD

LIBRARY IEEE;




USE work.converter.all;

PACKAGE distance IS

FUNCTION hamming(i1,i2: in std_logic_vector(1 downto 0)) RETURNinteger;

FUNCTION euclid(e1,e2: in std_logic_vector(1 downto 0)) RETURNinteger;

END distance;




PACKAGE BODY distance IS

FUNCTION hamming(i1,i2: in std_logic_vector(1 downto 0)) RETURNinteger IS

VARIABLE result: integer: = 0;VARIABLE u: std_logic_vector(1 downto 0);

BEGIN

IF i1(0) > '0' THEN

u(0): = '1';

ELSE

u(0): = '0';

END IF;

IF i1(1) > '0' THEN

u(1): = '1';

ELSE

u(1): = '0';

END IF;

IF u(0) = i2(0) THENresult: = 0;

ELSE

result: = result + 1;

END IF;

IF u(1) = i2(1) THEN

result: = result;

ELSE

result: = result + 1;

END IF;

RETURN result;

END hamming;

END distance;




DISPLAY.VHD

LIBRARY ieee;


package display_types istype display_mode is ( name, information,author, inoutbit, bits);

end package display_types;

LIBRARY ieee;


USE work.display_types.all;

USE work.lcd_types.all;

package display_components is

component display is

PORT (

reset, clock: IN STD_LOGIC;

SW : IN std_logic_vector(17 downto 0);

DATA_OUT: IN std_logic_vector(7 downto 0);

mode: IN display_mode;

lcd_dd: OUT CHAR_VECTOR(0 to 31)

);

end component;

end package;

LIBRARY ieee;

USE ieee.std_logic_1164.all;USE ieee.std_logic_unsigned.all;

use ieee.numeric_std.all;

USE work.display_types.all;


USE work.lcd_conv.all;

ENTITY display IS




PORT (


SW : IN std_logic_vector(17 downto 0);

DATA_OUT: IN std_logic_vector(7 downto 0);mode: IN display_mode;

lcd_dd: OUT CHAR_VECTOR(0 to 31)

);

END ENTITY display;

ARCHITECTURE display OF display IS

SIGNAL A: char: = x"41";SIGNAL B: char: = x"42";

SIGNAL C: char: = x"43";SIGNAL D: char: = x"44";

SIGNAL E: char: = x"45";SIGNAL F: char: = x"46";

SIGNAL G: char: = x"47";SIGNAL H: char: = x"48";

SIGNAL I: char: = x"49";SIGNAL J: char: = x"4A";

SIGNAL K: char: = x"4B";SIGNAL L: char: = x"4C";

SIGNAL M: char: = x"4D";SIGNAL N: char: = x"4E";

SIGNAL O: char: = x"4F";SIGNAL P: char: = x"50";

SIGNAL Q: char: = x"51";SIGNAL R: char: = x"52";

SIGNAL S: char: = x"53";SIGNAL T: char: = x"54";

SIGNAL U: char: = x"55";SIGNAL V: char: = x"56";

SIGNAL W: char: = x"57";SIGNAL X: char: = x"58";

SIGNAL Y: char: = x"59";SIGNAL Z: char: = x"5A";

SIGNAL s1: char: = x"31";SIGNAL s6: char: = x"36";SIGNAL s2: char: = x"32";SIGNAL s7: char: = x"37";

SIGNAL s3: char: = x"33";SIGNAL s8: char: = x"38";



SIGNAL KT: char: = x"20"; -- KHOANG TRONG

BEGIN

-- the first row




with mode select lcd_dd(0 to 15) <=

-- DH SPKT TP HCM

(KT,D,H,KT,S,P,K,T,KT,T,P,KT,H,C,M,KT) when information,

-- GIAI THUAT(KT,KT,G,I,A,I,KT,KT,T,H,U,A,T,KT,KT,KT) when name,

--SVTH LE DUY

(S,V,T,H,KT,KT,L,E,KT,D,U,Y,KT,KT,KT,KT) when author,

--16 BITS VAO

(s1,s6,KT,B,I,T,S,KT,V,A,O,KT,KT,KT,KT,KT) when inoutbit,

-- hien thi 16 bitS vao

(b162slv(SW(15 downto 0))) when bits;

-- the second row

with mode select lcd_dd(16 to 31) <=

--DO AN TOT NGHIEP

(D,O,KT,A,N,KT,T,O,T,KT,N,G,H,I,E,P) when information,

-- VITERBI

(KT,KT,KT,KT,V,I,T,E,R,B,I,KT,KT,KT,KT,KT) when name,

-- HUYNH MINH KHA

(KT,H,U,Y,N,H,KT,M,I,N,H,KT,K,H,A,KT) when author,

--8 BIT RA

(s8,KT,B,I,T,S,KT,R,A,KT,KT,KT,KT,KT,KT,KT) when inoutbit,

-- hien thi 8 bits ra

(b82slv(DATA_OUT(7 downto 0))) when bits;END ARCHITECTURE display;

LCD.VHD

library ieee;

use ieee.std_logic_1164.all;

package lcd_types is

subtype char is std_logic_vector(7 downto 0);




type char_vector is array(natural range <>) of char;

end package lcd_types;

library ieee;

use ieee.std_logic_1164.all;use work.lcd_types.all;

package lcd_components is

component lcd is

port(


dd: IN CHAR_VECTOR(0 to 31);

LCD_ON: OUT STD_LOGIC;

LCD_BLON: OUT STD_LOGIC;

LCD_RW: OUT STD_LOGIC;

LCD_EN: OUT STD_LOGIC;

LCD_RS: OUT STD_LOGIC;

LCD_DATA: INOUT STD_LOGIC_VECTOR(7 DOWNTO 0)

);

end component lcd;

end package lcd_components;

library ieee;

use ieee.std_logic_1164.all;

use ieee.std_logic_unsigned.all;

use ieee.numeric_std.all;use work.lcd_types.all;

ENTITY lcd IS

PORT(


dd: IN CHAR_VECTOR(0 to 31);

LCD_ON: OUT STD_LOGIC;

LCD_BLON: OUT STD_LOGIC;




LCD_RW: OUT STD_LOGIC;

LCD_EN: OUT STD_LOGIC;

LCD_RS: OUT STD_LOGIC;

LCD_DATA: INOUT STD_LOGIC_VECTOR(7 DOWNTO 0));

END ENTITY lcd;

ARCHITECTURE lcd of lcd is

SIGNAL wait_counter: INTEGER: = 0;

SIGNAL timing_counter: INTEGER: = 0;

TYPE timing_states IS (idle, setup, hold);

SIGNAL timing_state: timing_states: = idle;

TYPE timing_modes IS (idle, read_cmd, read_data, write_cmd, write_data);

SIGNAL timing_mode: timing_modes: = idle;

SIGNAL timing_done: STD_LOGIC: = '1';

CONSTANT init_cmds_count: INTEGER: = 4;

CONSTANT init_cmds: CHAR_VECTOR(0 to init_cmds_count - 1): = (

x"38", -- set up interface

x"0C",-- set up display

x"01", -- clear screen

x"06" -- set up entry mode

);

CONSTANT init_cmds_wait: INTEGER: = 100000; -- wait 2 ms for eachinit command

TYPE states IS (

init,

init_cmd,

init_cmd_complete,

update_dd,

update_dd_addr,

update_dd_addr_complete,

update_dd_data,




update_dd_data_complete

);

SIGNAL state: states: = init;

SIGNAL i, j: INTEGER: = 0;BEGIN

LCD_ON <= '1';

LCD_BLON <= '1';

timing: PROCESS(clock, reset) IS

BEGIN

IF (reset = '1') THEN

timing_state <= idle;

timing_counter <= 0;

timing_done <= '1';

ELSIF (clock = '1' AND clock'event) THEN

IF (timing_counter > 0) THEN

timing_counter <= timing_counter - 1;

ELSE

CASE timing_state IS

WHEN idle =>

CASE timing_mode IS

WHEN idle =>

LCD_RS <= '0';

LCD_RW <= '1';timing_done <= '1';


WHEN read_cmd =>

LCD_RS <= '0';

LCD_RW <= '1';

timing_done <= '0';





timing_state <= setup;

WHEN read_data =>

LCD_RS <= '1';

LCD_RW <= '1';timing_done <= '0';



WHEN write_cmd =>

LCD_RS <= '0';

LCD_RW <= '0';

timing_done <= '0';



WHEN write_data =>

LCD_RS <= '1';

LCD_RW <= '0';

timing_done <= '0';



END CASE;

WHEN setup =>

LCD_EN <= '1';

timing_counter <= 30;timing_state <= hold;

WHEN hold =>

LCD_EN <= '0';

timing_counter <= 3000; -- a 60 microsecond waitguarantees operation execution


WHEN others =>





END CASE;

END IF;

END IF;

END PROCESS;fsm: PROCESS(clock, reset) IS

BEGIN

IF (reset = '1') THEN

timing_mode <= idle;

state <= init;

ELSIF (clock = '1' AND clock'event) THEN

IF (timing_mode /= idle) THEN


ELSIF (timing_done /= '1') THEN

ELSIF (wait_counter > 0) THEN

wait_counter <= wait_counter - 1;

ELSE

CASE state IS

WHEN init =>

i <= 0;


wait_counter <= init_cmds_wait;

state <= init_cmd;

WHEN init_cmd =>LCD_DATA <= init_cmds(i);

timing_mode <= write_cmd;

wait_counter <= init_cmds_wait;

state <= init_cmd_complete;

WHEN init_cmd_complete =>

IF (i = init_cmds_count - 1) THEN

state <= update_dd; -- sai




ELSE

i <= i + 1;

state <= init_cmd;

END IF;WHEN update_dd => -- hien thi lcd 16X2

i <= 0;

j <= 0;

state <= update_dd_addr;

WHEN update_dd_addr =>

LCD_DATA <= "1" & std_logic_vector(to_unsigned(i,1)) & "00" & std_logic_vector(to_unsigned(j, 4));

timing_mode <= write_cmd;

state <= update_dd_addr_complete;

WHEN update_dd_addr_complete =>

state <= update_dd_data;

WHEN update_dd_data =>

LCD_DATA <= dd(i * 16 + j);timing_mode <= write_data;

state <= update_dd_data_complete;

WHEN update_dd_data_complete =>

IF (j = 15) THEN

IF (i = 1) THEN

state <= update_dd; -- quay lai lam lai

ELSE

j <= 0;

i <= i + 1;


END IF;

ELSE

j <= j + 1;





END IF;

WHEN others =>

state <= init;END CASE;

END IF;

END IF;

END PROCESS;

END ARCHITECTURE lcd;

LCD_CONV.VHD

LIBRARY ieee;


PACKAGE lcd_conv_type is

TYPE out_vector is array (0 to 15 ) of std_logic_vector(7 downto 0);

END PACKAGE lcd_conv_type;

LIBRARY ieee;





USE work.lcd_conv_type.all;PACKAGE lcd_conv IS

FUNCTION b162slv(bin: in std_logic_vector(15 downto 0)) RETURNchar_vector;

FUNCTION b82slv(bin: in std_logic_vector(7 downto 0)) RETURNchar_vector;

END lcd_conv;

PACKAGE BODY lcd_conv IS




FUNCTION b162slv(bin: in std_logic_vector(15 downto 0)) RETURN char_vector IS

VARIABLE slv: char_vector (15 downto 0) ;

VARIABLE t: integer;BEGIN

FOR t in 0 to 15 LOOP

CASE bin(t) IS

WHEN '0' => slv(t): = x"30"; -- 0

WHEN others => slv(t): = x"31"; -- 1

END CASE;

END LOOP;

RETURN slv;

END b162slv;

FUNCTION b82slv(bin: in std_logic_vector(7 downto 0)) RETURN char_vector IS

VARIABLE slv: char_vector (15 downto 0);

VARIABLE t: integer;

BEGINFOR t in 0 to 7 LOOP

CASE bin(t) IS

WHEN '0' => slv(t+4): = x"30";

WHEN others => slv(t+4): = x"31";

END CASE;

END LOOP;


slv(t): = x"20"; -- khoang trang

END LOOP;


slv(t): = x"20"; -- khoang trang

END LOOP;

RETURN slv;

END b82slv;




END lcd_conv;

II. Tài liệu tham khảo

[1] John Proakis, Digital Communications (Chapter 8-Block and ConvolutionalChannel Codes), McGraw-Hill Science/ Engineering/ Math, 4th, 2000.

[2] Fu Hua Huang, Evaluation of Soft Output Decoding for TurboCodes(chapter 2_convolution codes), Master's Thesis, 1997.

[3] Mr. Chip Fleming, Tutorial on Convolutional Coding with Viterbi Decoding , Spectrum Applications, 2006.

[4] Wei Chen, RTL implementation of Viterbi decoder, Master’s thesis

performed in Computer Engineering, 2006.

[5] Nguyễn Minh Khánh Ngọc, Luận văn cao học “Thiết kế và thực hiện gảithuật Viterbi trên FPGA”, 2009.

[6] Một số trang web mà nhóm có tham khảo:

http://www.altera.com

http://www.fotech.org

http://www.ngohaibac.net

http://www.mathwork.com

http://en.wikipedia.org

http://www.dsplog.com

http://home.netcom.comhttp://gaussianwaves.blogspot.com

http://home.netcom.com/~chip.f/viterbi/tutorial.html




Documents

DO AN TN_DUY_KHA