TRƯỜNG CAO ĐẲNG NGHỀ CÔNG NGHIỆP HÀ NỘI

------------------------------------------------------------

Biên soạn: Trần Thanh Bình

GIÁO TRÌNH
VI MẠCH SỐ LẬP TRÌNH

LỜI NÓI ĐẦU

Giáo trình vi mạch số lập trình được biên soạn nhằm đáp ứng nhu
cầu giảng dạy và học tập của thầy, trò trường cao đẳng nghề công nghiệp
Hà Nội. Nội dung giáo trình được phát triển dựa trên chương trình đào tạo
mô đun vi mạch số lập trình, nghề Điện tử công nghiệp. Nội dung giáo
trình bao quát toàn bộ chương trình đào tạo đồng thời hướng tới mục tiêu
hình thành và phát triển năng lực thực hiện hoạt động nghề nghiệp cho
người học. Dạy học tích hợp được lựa chọn trong giáo trình nhằm tạo ra
các tình huống liên kết tri thức các môn học, đó là cơ hội phát triển các
năng lực của sinh viên. Khi xây dựng các tình huống vận dụng kiến thức,
Hà Nội 2012
1
 Giáo trình vi mạch số lập trình được biên soạn nhằm đáp ứng nhu
cầu giảng dạy và học tập của thầy, trò trường cao đẳng nghề công nghiệp
Hà Nội. Nội dung giáo trình được phát triển dựa trên chương trình đào tạo
mô đun vi mạch số lập trình, nghề Điện tử công nghiệp. Nội dung giáo
trình bao quát toàn bộ chương trình đào tạo đồng thời hướng tới mục tiêu
hình thành và phát triển năng lực thực hiện hoạt động nghề nghiệp cho
người học. Dạy học tích hợp được lựa chọn trong giáo trình nhằm tạo ra
các tình huống liên kết tri thức các môn học, đó là cơ hội phát triển các
năng lực của sinh viên. Khi xây dựng các tình huống vận dụng kiến thức
người học sẽ phát huy được năng lực tự lực, phát triển tư duy sáng tạo
(kiến thức, kỹ năng, và thái độ nghề nghiệp).
Giáo trình tập trung vào những ứng dụng cụ thể của vi mạch số
EPM7128LSC84-15 của hãng ALTERA đây là loại vi mạch số mới và sẵn
có trên thị trường Việt Nam.
Mặc dù nhóm biên soạn đã cố gắng phát triển giáo trình sao cho phù
hợp và gần gũi nhất với sinh viên cao đẳng nghề Điện tử công nghiệp,
Điện công nghiệp và Điện tử dân dụng nhưng chắc chắn vẫn còn nhiều
thiếu sót.
Chúng tôi mong nhận được những ý kiến đóng góp của bạn đọc và
đồng nghiệp để giáo trình hoàn thiện hơn.
Mọi ý kiến xin được gửi về: Trường cao đẳng nghề Công nghiệp Hà
Nội, 131 Thái Thịnh, Đống Đa, Hà Nội.

NHÓM TÁC GIẢ

2
 Tuyên bố bản quyền

Tài liệu này là loại giáo trình nội bộ dùng trong nhà trường
với mục đích làm tài liệu giảng dạy cho giáo viên và học sinh, sinh
viên nên các nguồn thông tin có thể được tham khảo.

Tài liệu phải do trường Cao đẳng nghề Công nghiệp Hà Nội in
ấn và phát hành.

Việc sử dụng tài liệu này với mục đích thương mại hoặc khác
với mục đích trên đều bị nghiêm cấm và bị coi là vi phạm bản
quyền.

Trường Cao đẳng nghề Công nghiệp Hà Nội xin chân thành
cảm ơn các thông tin giúp cho nhà trường bảo vệ bản quyền của
mình.

Địa chỉ liên hệ:

Trường Cao đẳng nghề Công nghiệp Hà Nội.

131 – Thái Thịnh – Đống Đa – Hà Nội

Điện thoại: (84-4) 38532033

Fax: (84-4) 38533523

Website: hnivc.edu.vn

3
 MỤC LỤC

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

Tuyên bố bản quyền ................................................................................... 3
TỪ VIẾT TẮT DÙNG TRONG GIÁO TRÌNH ......................................... 6
BÀI 1. GIỚI THIỆU CHUNG VỀ VI MẠCH SỐ LẬP TRÌNH ................. 8
1.1. Lịch sử phát triển của vi mạch số lập trình........................................... 8
1.2. Giới thiệu các phần mềm hỗ trợ. ........................................................ 12
BÀI 2. MẢNG LOGIC LẬP TRÌNH........................................................ 15
2.1. Giới thiệu .......................................................................................... 15
2.2. Cấu trúc cơ bản của các họ vi mạch lập trình (PLD) .......................... 15
2.3. Thực hành thiết kế Multiplexer trên MAX7000S ............................... 38
BÀI 3. NGÔN NGỮ VHDL VÀ ABEL ................................................... 51
3.1. Ngôn ngữ VHDL (VHSIC Hardware Description Language) ............ 51
3.1.1. Giới thiệu về VHDL ....................................................................... 51
3.1.2. Giới thiệu công nghệ và ứng dụng thiết kế mạch bằng ngôn ngữ
VHDL ...................................................................................................... 52
3.2.3. Cấu trúc mã .................................................................................... 56
3.2.5. Toán tử và thuộc tính ...................................................................... 81
3.2.6. Mã song song.................................................................................. 88
3.2.7. Mã tuần tự .................................................................................... 102
3.2.8. Signal và Variable ........................................................................ 123
3.2.9. Máy trạng thái .............................................................................. 141
3.2.10. Thực hành thiết kế mạch ............................................................. 161
3.2. Ngôn ngữ ABEL.............................................................................. 190
3.2.1. Giới thiệu...................................................................................... 190
3.2.2. Cấu trúc chung file nguồn ABEL.................................................. 191
3.2.3. Các phát biểu (Statements) ........................................................... 191
3.2.4. Các khai báo (Declarations) .......................................................... 196
3.2.5. Các khai báo khác (OTHER DECLARATIONS) ......................... 197
3.2.6. Các toán tử (OPERATORS) ......................................................... 199
BÀI 4. PHẦN MỀM ISP SYNARIO VÀ QUARTUS II ........................ 203
4.1. Phần mềm Quartus II ....................................................................... 203
4.1.1. Giới thiệu phần mềm .................................................................... 203
4.1.3. Cách nạp chương trình cho Quartus II .......................................... 212
4.2. Phần mềm ISP Synario .................................................................... 221
4.2.1. Giới thiệu...................................................................................... 221
4.2.2. Khởi động Synario ........................................................................ 221
BÀI 5. HỌ CPLD ................................................................................... 227
5.1. Giới thiệu chung .............................................................................. 227
5.2. Vi mạch CPLD (EPM7128) ............................................................. 229
5.2.1 Sơ đồ chân của EPM7128 .............................................................. 230
5.2.2. Sơ đồ cấu trúc của EPM7128 ........................................................ 230

4
5.2.3. Điều kiện hoạt động của EPM7128 ............................................... 234
5. 3. Thực hành trên KIT CPLD ............................................................. 238
5.3.1. Các mạch điện trong bộ thí nghiệm CPLD .................................... 238
5.3.2. Cách nạp chương trình cho EPM7128 ......................................... 242
5.2.2. Viết chương trình, biên dịch và nạp ............................................. 246
5.2.3. Thiết kế các cổng logic cơ bản ...................................................... 252
5.2.4. Thiết kế bộ cộng đầy đủ ................................................................ 262
5.2.5. Triger DFF.................................................................................... 271
5.2.7. Led 7 thanh ................................................................................... 281
5.2.8.Ma trận phím ................................................................................. 291
5.2.9. Điều khiển LCD trên CPLD KIT ................................................. 302
TÀI LIỆU THAM KHẢO ...................................................................... 321

5
 TỪ VIẾT TẮT DÙNG TRONG GIÁO TRÌNH

Tên đầy đủ Viết tắt

Programmable Logic Device/Complex
PLD/CPLD
Programmable Logic Devic
PAL Assembler PALASM2
Programmable Logic Analysis PLAN
Harris Enhanced Language for
HELD
Programmable Logic
Programmble Logic Programming
PLPL
Language
Assembler for Programmable Electrically
APEEL
Erasable Logic
Intel Programmable Logic Devolopmemt
IPLDS II
System II)
Universal Compiler for Programmable
CUPL
Logic
Advanced Boolean Expression Language ABEL
Programmable Read Only Memory PROM
Field Programmable Logic Array FPLA
Field Programmable Logic Sequencer FPLS
Field Programmable Gate Array FPGA
Programmable Array Logic PAL
Generic Array Logic GAL
Programmable Electrially Erasable Logic PEEL
Programmable Macro Logic PML
Logic Cell Array LCA
Erasable Programmable Amplication
ERASIC
Specific IC
Timing and Con trol Bộ điều khiển logic
Program Store Enable PSEN
Address Latch Enable ALE
External Access EA
Reset RST
Bus dữ liệu Data bus
Bus địa chỉ Address bus
Bus điều khiển Control bus
Large Scale Integrated LSI
Very Large Scale Integrated VLSI
Itty Bitty Processor IBP
Khả trình một lần OTP
Input- Output IO

6
 Tên đầy đủ Viết tắt
Automated Map and Zap Equations AMAZE
Universal Compiler for Programmable CUPL
VHSIC Hardware Description Language VHDL
Very High Speed Intergrated Circuit VHSIC
Advanced Boolean Equation Language ABEL

7
 BÀI 1. GIỚI THIỆU CHUNG VỀ VI MẠCH SỐ LẬP TRÌNH

Mục tiêu:
+ Kiến thức:
- Giới thiệu được lịch sử phát triển của vi mạch số lập trình;
- Giải thích được sự cần thiết và ý nghĩa trong thiết kế logic của họ PLDs;
- Giới thiệu được các phần mềm hỗ trợ của vi mạch số lập trình;
+ Kỹ năng:
- Nhận dạng được các phần mềm hỗ trợ lập trình cho vi mạch số lập trình;
+ Thái độ:
- Rèn luyện tư duy kỹ thuật và tác phong công nghiệp,
Các thuật ngữ chuyên môn: Được giải thích chi tiết trong nội dung bài
học
Nội dung:
A. LÝ THUYẾT
1.1. Lịch sử phát triển của vi mạch số lập trình
Trước thời kỳ vi mạch số lập trình (Programmable Logic Device) ra
đời, thiết kế logic số truyền thống thì bao gồm nhiều vi mạch TTL loại MSI
và SSI kết hợp lại để tạo ra các hàm logic mong muốn. Những nhà thiết kế
dựa vào những sách tra cứu các vi mạch số để tìm hiểu các thông số kỹ
thuật, sau đó mới quyết định sử dụng các vi mạch số cần thiết cho yêu cầu
thiết kế của họ. Điều bất lợi của việc thiết kế này là trong một board sử
dụng nhiều vi mạch, do đó khi sửa chữa thì gặp nhiều khó khăn.
Vào năm 1975,công ty SIGNETICS đã giới thiệu vi mạch số lập
trình không có bộ nhớ đầu tiên 82S100 (hiện nay là PLS100) gọi là mảng
logic lập trình trường (Field - Programmable Logic Array). Napoleon
Cavlan, người được gọi là cha đẻ của mạch logic lập trình, lúc bấy giờ là
nhà quản lý những ứng dụng PLA của Signetics đã thực sự hiểu rằng sử
dụng PLA là phương pháp tốt hơn để thiết kế và thay đổi hệ thống số.
Trong khi đó, công ty Harris đã sớm giới thiệu PROM, họ trình bày triển
vọng của PROM và đã ứng dụng vào trong một số mạch logic.
Công ty National Semiconductor đã chế tạo mặt nạ lập trình cho
PLA, cấu tạo của nó gồm một mảng AND lập trình kèm với mảng OR lập
trình, cho phép thực hiện tổ hợp tổng các tích số của hàm logic tiêu chuẩn.
Bằng cách kết hợp công nghệ PROM sử dụng nguyên tắc cầu chì với khái
niệm PLA, Cavian đã thuyết phục được các nhà quản lý công ty Signetics
để đưa dự án PLAvào sản xuất.
Vi mạch PLA đầu tiên 82S100, là thành viên đầu tiên của họ vi mạch
IFL (Intergrated Fuse Logic) có hình dạng 28 chân. Cấu trúc của PLA gồm
một mảng AND lập trình và một mảng OR lập trình, nó cho phép thực hiện
tổ hợp logic tổng của các tích số đơn giản .
Kỹ sư John Martin Birkner là một người quan tâm đến PLA, vì ông
ấy hiểu rằng nhiều phương pháp thiết kế logic được học trong trường thì
không áp dụng được nhiều trong công việc hiện tại. Do đó, vào năm 1975

8
ông ấy đã rời thung lũng Silicon để đến công ty Monolithic Memories
(MMI), đây là công ty chế tạo PROM và các vi mạch logic tiêu chuẩn. Vì
vậy, Birkner có điều kiện hơn trong việc tìm hiểu PLA và công nhận những
ưu điểm của mạch logic lập trình nhưng đồng thời ông cũng nhận ra khuyết
điểm của PLA là có hai mảng lập trình. Sau đó, Birkner đã đưa ra khái
niệm mới về vi mạch số lập trình, vi mạch này cũng tương tự FLA nhưng
thay vì có hai mảng lập trình thì PAL (Programmable Array Logic ) chỉ có
một mảng AND lập trình và theo sau là mảng OR được giữ cố định (không
lập trình ). Như vậy mỗi cổng OR sẽ có một tích số cố định được nối với
ngõ vào của nó, do vậy sẽ giảm được kích thước của vi mạch và cho phép
tín hiệu được truyền nhanh hơn trong khi vẫn cho phép thực hiện các tổ
hợp logic. PAL được đóng vỏ 20 chân. Sau một thời gian thuyết phục các
nhà quản lý của công ty MMI thấy rõ những lợi điểm của PAL và đồng ý
sản xuất. Vi mạch đầu tiên thuộc họ PAL được phổ biến là PAL 16L8, PAL
16R4, PAL 16R6, PAL 16R8. Các vi mạch này có thời gian truyền trì hoãn
35ns. Mỗi vi mạch có 8 ngõ ra và 16 ngõ vào,trong đó ký tự L trong ký
hiệu của vi mạch biểu thị 8 tổ hợp ngõ ra tác động ở mức thấp, ký tự R cho
biết có 4, 6 hay 8 thanh ghi ở ngõ ra tương ứng.
Sau một thời gian khởi đầu chậm, cuối cùng PAL đã được thiết kế
trong hệ thống thực. Những công ty máy tính mini đã nhận thấy được ưu
điểm của PAL là cho phép họ giảm số board cần thiết để thực hiện tốt
những yêu cầu thiết kế, công ty MMI đã chọn phương pháp sản xuất PAL
công đoạn mặt nạ chế tạo theo yêu cầu khách hàng. Vào lúc này MMI lại
giới thiệu một họ vi mạch mới HAL (Hard Array Logic) và để sản xuất
những chi tiết này cho hãng Data General and Digital Equipment. MMI đã
thay đổi cách sắp xếp công đoạn mặt nạ cầu chì và thay vào đó là lớp liên
kết kim loại phù hợp yêu cầu thiết kế của khách hàng. Những chi tiết này
có nhiều lợi ích gồm mang lại những kết quả tốt và kiểm tra dễ dàng hơn.
Đồng thời khách hàng cũng được lợi hơn bởi không phải quan tâm đến lập
trình và kiểm tra các chi tiết. Điều này đã mang lại sự cải tiến về phương
pháp chế tạo PAL, và được sự chấp nhận của thị trường. Vào năm 1978,
MMI đã xuất bản sách hướng dẫn PAL đầu tiên. Đó là một bước khởi đầu
để PAL mở rộng thế giới của những người thiết kế mạch logic. Ngoài ra
trong sách hướng dẫn còn trình bày danh sách chương trình gốc của ngôn
ngữ lập trình FORTRAN cho PALASM (PAL Assembler) đó là phần mềm
dành cho việc thiết kế mạch logic PAL. PALASM có thể biên soạn, định
nghĩa logic cho một khuôn thức. Ngoài ra PALASM cũng có khả năng mô
phỏng sự vận hành trên phương trình mạch logic theo nguyên tắc PAL.
Trong việc liên kết với những nhà thiết kế để định rõ những “vector kiểm
tra”, PALASM có thể là một sự thật phù hợp. Tất cả những đặc điểm của
PAL bao gồm việc khắc phục những khuyết điểm của PLA kết hợp với
việc thúc đẩy sử dụng PAL đã mang đến kết quả tốt đẹp. PAL đã nhanh
chóng vượt qua họ vi mạch IFL của công ty Signetics và được phổ biến
trên thị trường, thuật ngữ PAL đã trở nên đồng nghĩa với PLD.

9
 Trong lúc ấy, công ty Signetics tiếp tục phát triển họ IFL, và vào
năm 1977 Signetics giới thiệu họ vi mạch FPGA (Field Programmable
Gate Array) 82S103, vào năm 1979 là họ FPLS (Field Programmable
Logic Sequencer). Họ FPGA có cấu tạo một mảng AND ở mức đơn với
ngõ vào lập trình được và cực tính ngõ ra cũng vậy cho phép thực hiện các
hàm logic cơ bản (AND, OR, NAND, NOR, INVERT), cấu trúc của họ
FPLS có chức các FlipFlop để thực hiện các trạng thái của hàm tuần tự.
Đồng thời Signetics cũng giới thiệu AMAZE (Automated Map and Zap
Equations) là chương trình biên dịch để hổ trợ cho những vi mạch của họ.
Tương tự, những công ty chế tạo PLD khác đã lần lược giới thiệu những
phần mềm hỗ trợ của họ.
Cả 2 công ty Signetics và MMI tiếp tục giới thiệu những PLD mới
để đáp ứng tính đa dạng theo các yêu cầu thiết kế. Vào giữa năm 1980,
mạch logic lập trình đã được thừa nhận cùng với sự phát triển tính đa dạng
của IFL và PAL đã có nhiều giá trị cho những người thiết kế. Mặc dù sự
khởi đầu thành công của PLD, tuy nhiên chỉ một số ít các nhà thiết kế
quen với việc dùng PLD, một số trường đại học đã đưa vi mạch logic lập
trình vào những khóa học thiết kế của họ.
Tuy thế, kĩ thuật logic lập trình tiếp tục cải tiến và những vi mạch
phát triển ở giai đoạn thứ hai được giới thiệu vào năm 1983. Công ty
Advance Micro Devices ( AMD) đã giới thiệu PAL22V10 với những đặc
điểm đặc biệt là sự linh động của những cổng PLD ở 10 ngõ vào. Mỗi cổng
PLD có khả năng tổ hợp hoặc với thanh ghi ở ngõ ra hoặc một ngõ vào.
Cổng đệm ngõ ra ba trạng thái được điều khiển bởi một tích số riêng cho
phép vận hành hai chiều. Tất cả thanh ghi đều được reset tự động trong
quá trình tắt hay mở và mỗi thanh ghi có khả năng “đặt trước”, đó là đặc
điểm đặc biệt cho việc kiểm tra sau này.
Với những vi mạch mới, được giới thiệu thường xuyên trên thị
trường đã dẫn đến việc cần thiết phải có một phần mềm hỗ trợ trong quá
trình sử dụng PLD để đạt hiệu quả cao.
Bob Osann đã nhận thấy được sự cần thiết của một chương trình biên
dịch PLD vạn năng dùng cho tất cả PLD của những công ty chế tạo khác
nhau.
Vào tháng 9/1983, Công ty Assisted Technology đã đưa ra phiên bản
1.01a của chương trình biên dịch PLD có tên là CUPL ( Universal
Compiler for Programmable). Chương trình này hỗ trợ cho 29 loại vi mạch,
sự ra đời của CUPL đã gây được sự chú ý của nhiều công ty chế tạo. Công
ty Data I/O, nhà chế tạo các vi mạch lập trình lớn nhất trên thế giới
(EPROM, PROM, PLD), đã quyết định phát triển phần mềm hỗ trợ cho
riêng họ. Năm 1984, Data I/O giới thiệu ABEL (Advanced Boolean
Expression Language), đó là chương trình biên dịch PLD có đặc điểm
tương tự như CUPL nhưng nó được đầu tư tiếp thị nên được các nhà thiết
kế chấp nhận. Vì vậy, ABEL đã sớm theo kịp CUPL trên thị trường.

10
 Sự ra đời của chương trình biên dịch vạn năng cho PLD đã thúc đẩy
nền công nghiệp thiết kế số sẵn sàng cho việc áp dụng PLD cho những thiết
kế mới. Những chương trình biên dịch vạn năng này đã được cải tiến hơn
so với các chương trình biên dịch PALASM và AMAZE, nó được cung cấp
cho các nhà thiết kế để thực hiện các mạch logic và mô phỏng những thiết
bị. Đó là những đặc điểm tiêu chuẩn của hai bộ biên dịch vạn năng CUPL
và ABAL. JEDEC (the Joint Electron Device Engineering Council) dự định
sản xuất một bộ biên dịch PLD tạo ra một tiêu chuẩn để sử dụng cho tất cả
các công ty chế tạo PLD hiện nay và tương lai. Vào 10/1983, the JEDEC
Solid State Products Engineering Council đưa ra tiêu chuẩn JEDEC thứ 3
“Tiêu chuẩn khuôn thức chuyển đổi giữa hệ thống tạo dữ liệu và thiết bị lập
trình cho PLD”. Tháng 5/1986, JEDEC tiếp tục đưa ra tiêu chuẩn 3-A, tiêu
chuẩn này trở thành tiêu chuẩn chung cho công nghiệp PLD.
Tháng 7/1984, công ty Altera giới thiệu EP300. Đó là vi mạch sử
dụng công nghệ CMOS của EPROM, nó có đặc tính là công suất tiêu thụ
thấp, có thể xóa được (dùng tia cực tím) cùng một số đặc tính mở rộng
khác.Năm 1985, một họ PLD mới được công ty Lattice Semiconductor
giới thiệu là GAL (Generic Array Logic). Lattice dùng công nghệ CMOS
của EEPROM, có các đặc tính kỹ thuật như công suất thấp, có thể lập trình
nhiều lần ( xóa bằng điện áp với thời gian xóa khoảng vài giây). Vi mạch
đầu tiên của họ GAL được kí hiệu là GAL16V8 có khả năng thay thế hoạt
động của PAL (đối với vi mạch cùng loại).
Ngày càng nhiều công ty tham gia vào thị trường PLD để tạo ra
những vi mạch đặc biệt và sử dụng nhiều công nghệ chế tạo khác nhau.
Vào năm 1985, công ty Xilen tạo ra một họ mới là LCA (Logic Call
Array). Cấu trúc của LCA có 3 đoạn: một ma trận của khối logic được bao
quanh là khối vào ra và một mạng đường dữ liệu nối gián tiếp. Đặc biệt của
LCA là PLD đầu tiên sử dụng tế bào RAM động cho chức năng logic. Ưu
điểm của cấu trúc này là khách hàng có thể kiểm tra được chương trình của
vi mạch, do bản chất dễ xóa của LCA, nên cần phải lưu trữ cấu hình của
LCA ở bộ nhớ ngoài. Vì vậy, LCA không được sử dụng ở những trường
hợp đòi hỏi sự hoạt động ngay lập tức khi khởi động máy. Đi kèm với LCA
là chương trình soạn thảo XACT và bộ mô phỏng giúp cho việc sửa lỗi cho
những thiết kế trên LCA được thuận tiện.
Năm 1985, công ty Signetics với một khái niệm mới là PML
(Programmable Macro Logic). Vi mạch PML đầu tiên của Signetics PMLS
501, vi mạch này sử dụng công nghệ lưỡng cực, và được đóng vỏ 52 chân
Vào năm 1986, công ty ExMicroelectronic giới thiệu họ ERASIC
(Erasable Application Specific 7C) sử dụng công nghệ EEPROM CMOS.
Vi mạch đầu tiên là XL78C00 có dạng 24 chân và điều đặc biệt là
XL78C00 có thể thay thế chức năng cho PAL và EPLA cùng loại (không
tính đến tốc độ), đi kèm là một phần mềm hỗ trợ ERASIC.
Vào năm 1986, công ty Signetics quyết định thay đổi họ IFL thành
họ PLS (Programmable Logic From Signetics). Ví dụ như từ 82S100 thành

11
PLS100, từ 82S157 thành PLS157. Sau đó 2 năm, công ty Actel đã cải tiến
khuyết điểm họ LCA là vi mạch có thể hoạt động không nhất thiết phải có
bộ nhớ ngoài. Đồng thời công ty Gazelle Microcircuit đã công bố phát
minh công nghệ GaAs (Gallium Arsenide). Đặc điểm của công nghệ này là
cải tiến tốc độ , công suất của các vi mạch trên nền tảng là công nghệ
silicon, cho phép vi mạch làm việc với tốc độ nhanh hơn công suất tiêu tán
khi ở mức trung bình.
Ưng dụng đầu tiên của công nghệ GaAs được công ty Gazelle đưa ra
là phiên bản của PAL 22V10. Ưu điểm của mạch này là cho phép vi mạch
GaAs có thể tương hợp với các vi mạchTTL, do đó công nghệ GaAS đã
được ứng dụng rộng rãi. Sau một thời gian cải tiến không ngừng, những
PLD thế hệ sau đã được ứng dụng rộng rãi trong kỹ thuật phần cứng, nó trở
thành công cụ cần thiết cho những kỹ sư thiết kế.
Sự phát triển trong công nghiệp PLD nói riêng và với công nghiệp
bán dẫn nói chung đã tạo nên sự cạnh tranh của các công ty chế tạo PLD
trên thế giới. Do đó, đã có nhiều xung đột xảy ra giữa các công ty trong
việc cạnh tranh thị trường.
Vào năm 1986 công ty MMI đã kiện hai công tyAltera và Lattic vì
đã vi phạm bản quyền PAL. Kết quả là hai công ty này đã chấp nhận thua
kiện và phải mua bản quyền. Sau đó công ty MMI mua cổ phần trong công
ty Xilin và sở hữu bản quyền họ LCA. Sau đó 1 năm công ty MMI hợp với
AMD trở thành một tập đoàn sản xuất các linh kiện bán dẫn hàng đầu trên
thế giới. Tuy đã hợp nhất hai công ty nhưng họ vẫn tiếp tục phát triển các
họ vi mạch hiện có vì những họ PLD này đã trở nên phổ biến trên thị
trường. Vào năm 1987, công ty National Semiconductor đã mua lại công ty
Fairchild và tiếp tục phát triển họ PAL FASTPLA trên thị trường.

1.2. Giới thiệu các phần mềm hỗ trợ.

Các phần mềm hỗ trợ cho các vi mạch lập trình được các công ty
phát triển liên tục, ngày càng có nhiều tính đa dạng, có thể hỗ trợ cho nhiều
loại vi mạch khác nhau nên có tính cạnh tranh mạnh mẽ trong thị trường vi
mạch lập trình.
1.2.1 Phần mềm PALASM 2 (PAL Assembler)
PALASM 2 của công ty MMI là phần mềm tiêu chuẩn cho các vi
mạch lập trình. Đây là bộ biên dịch thế hệ thứ 2 hỗ trợ cho các vi mạch
hoạt động không đồng bộ, như các vi mạch họ PAL của công ty MMI, vi
mạch họ PLA và các vi mạch của công ty AMD.
1.2.2. Phần mềm AMAZE.
Phần mềm AMAZE được công ty Signetics phát triển và nó được
cung cấp cho các khách hàng sử dụng vi mạch lập trình của công ty.
Module chính của phần mềm AMAZE là BLAST ( Boolean logic & State
Transfer) dùng để biên dịch các thông tin ngõ vào chuyển đổi sang các file
chương trình chuẩn của Signetics (các file có phần mở rộng là ‘STD’).

12
AMAZE hỗ trợ để mô phỏng các vectơ kiểm tra để thiết kế theo yêu cầu
của người sử dụng.
1.2.3. Phần mềm PLAN ( Programmable Logic Analysis).
Phần mềm PLAN được công ty National Semiconductor giới thiệu
hỗ trợ cho các vi mạch lập trình cở vừa và nhỏ. PLAN là một ngôn ngữ đơn
giản, dùng để thực hiện các biểu thức của đại số Boolean và có khả năng
giao tiếp với các công cụ lập trình để lập trình cho vi mạch.
1.2.4. Phần mềm HELD (Harris Enhanced Language for Programmable
Logic).
Công ty Harris phát triển phần mềm HELD để hỗ trợ cho các khách
hàng sử dụng vi mạch lập trình của họ. HELD sử dụng giao diện tương tự
như phần mềm PLAN nhưng cũng có những điểm khác biệt. HELD không
có khả năng lựa chọn các vi mạch lập trình nhưng có khả năng kiểm tra lỗi
tổng quát. Ngoài ra HELD còn yêu cầu các phương trình ngõ vào ở dạng
tổng các tích ( SOP).
1.2.5. Phần mềm PLPL (Programmable Logic Programming Language).
PLPL được công ty Avanced Micro Devices giới thiệu vào năm
1984. Đây là phần mềm tiến bộ nhất so với các phấn mềm trước, có những
đặc điểm mới và khả năng cài đặt được mở rộng hơn so với phần mềm
AMAZE. Những đặc điểm mới như cho phép định nghĩa và sử dụng các
chân của vi mạch cho một nhóm tín hiệu cũng như sử dụng các phương
trình của đại số Boolean. PLPL cũng hỗ trợ các phương trình phức tạp có
nhiều cấp logic khác nhau. Ngoài ra bộ biên dịch này cũng để ứng dụng
nguyên lí Demorgan, các hàm của đại số Boolean nhưng không bắt được ở
dạng tổng của các tích do đó cho phép cú pháp linh hoạt hơn.
1.2.6. Phần mềm APEEL (Assembler for Programmable Electrically
Erasable Logic).
Vào năm 1987, Công ty International Cmos Technology giới thiệu
trình biên dịch APEEL. APEEL là một trình biên dịch đơn giản phù hợp
với các yêu cầu thiết kế vừa và nhỏ và có chức năng mô phỏng. APEEL
gồm một chương trình soạn thảo toàn màn hình và ở ngõ ra theo tiêu chuẩn
của JEDEC. Nhưng khuyết điểm của bộ biên dịch này là không hỗ trợ để
tối giản các biểu thức logic. Phần mềm APEEL cài đặt trên các máy tính cá
nhân của công ty IBM và các công ty khác thích hợp với nó.
1.2.7. Phần mềm IPLDS II (Intel Programmable Logic Devolopment
System II).
Phần mềm IPLDS II được công ty Intel giới thiệu để hỗ trợ cho các
vi mạch họ EPLD. Điều cơ bản của phần mềm này là cho phép thiết kế
theo 2 phương pháp là phương pháp dùng phương trình đại số Boolean và
phương pháp liệt kê các lệnh. Để tối giảng các biểu thức logic IPLDS II sử
dụng thuật giải đơn giản ESPRESSO II – MV. Đó là thuật giải được phát
triển bởi đại học California, nó được dùng để thực hiện việc rút gọn các
tích số trong các hàm logic của các vi mạch do công ty Intel sản xuất.

13
 Tương tự như các phần mềm trước, IPLDS II cài đặt được trong các
máy tính của công ty IBM và các máy tính khác có cấu hình thích hợp,
được sử dụng kèm với công cụ lập trình cho vi mạch.
1.2.8. Phần mềm CUPL (Universal Compiler for Programmable Logic)
CUPL được công tyAssited Technology giới thiệu vào năm 1983.
Đây là bộ biên dịch vạn năng được hỗ trợ cho 29 loại vi mạch các loại kể
cả PROM và các công ty chế tạo vi mạch lập trình khác. CUPL là một ngôn
ngữ mạnh hỗ trợ cho các phương trình của đại số Boolean , bảng sự thật và
thiết kế sơ đồ trạng thái, CUPL được sử dụng hầu hết các máy vi tính cá
nhân trên các hệ điều hành khác nhau như trên máy vi tính của công ty
IBM hay CP/M, VAX/ UNIX và VAX/ VMS.
1.2.9. Phần mềm ABEL (Advanced Boolean Expression Language).
ABEL là phần mềm của công ty Data I/0, nó được sử dụng hầu hết
các loại vi mạch lập trình khác nhau kể cả EPROM. Đây là bộ biên dịch
vạn năng có nhiều chức năng hỗ trợ tương tự như CUPL.

B. Thảo luận nhóm

1. Lịch sử phát triển và hướng phát triển của PLD trong tương lai, ưu thế
của PLD so với các vi mạch số thông dụng.
2. Các phần mềm hỗ trợ vi mạch số lập trình được sử dụng nhiều nhất ở thị
trường việt nam.
C. Đánh giá kết quả : (tính theo thang điểm 10)

Mục tiêu Nội dung Điểm chuẩn

- Giới thiệu được lịch sử phát triển của vi

mạch số lập trình;
- Giải thích được sự cần thiết và ý nghĩa
Kiến thức 6
trong thiết kế logic của họ PLDs;
- Giới thiệu được các phần mềm hỗ trợ
của vi mạch số lập trình;

- Nhận dạng được các phần mềm hỗ trợ

lập trình cho vi mạch số lập trình; 2
Kỹ năng

- Rèn luyện tư duy kỹ thuật và tác phong

Thái độ công nghiệp 2

14
 BÀI 2. MẢNG LOGIC LẬP TRÌNH

Mục tiêu:
+ Kiến thức:
- Trình bày được cấu tạo, ý nghĩa thực tế của việc sử dụng mảng logic lập
trình trong các yêu cầu thiết kế phức tạp;
+ Kỹ năng:
- Xác định và sử dụng được các phần mềm hỗ trợ PLA trong thiết kế logic;
- Sử dụng được các mảng lập trình trong quá trình luyện tập;
+ Thái độ:
- Rèn luyện tính tỉ mỉ, chính xác, an toàn và vệ sinh công nghiệp.
Các thuật ngữ chuyên môn: Được giải thích chi tiết trong nội dung bài
học
Nội dung:
A. LÝ THUYẾT
2.1. Giới thiệu
2.2. Cấu trúc cơ bản của các họ vi mạch lập trình (PLD)
Vi mạch số lập trình trải qua thời gian dài phát triển và cải tiến đã
thực sự mở ra một hướng đi mới cho những nhà thiết kế. Ưu điểm của PLD
là giải quyết được vô số những vấn đề thiết kế nhờ vào nhiều họ PLD khác
nhau. Những họ vi mạch này có cấu trúc và công nghệ chế tạo khác nhau,
do đó chúng có những đặc điểm riêng để ứng dụng vào nhiều lĩnh vực
trong công nghiệp. Mặc khác người thiết kế còn quan tâm đến các thông số
kỹ thuật của vi mạch như tốc độ, công suất tiêu thụ, nguồn cung cấp và
công cụ hỗ trợ để lập trình.
2.2.1. Họ vi mạch PROM (Progammable Read Only Memory).
PROM gọi là bộ nhớ chỉ đọc lập trình được. Đây là họ vi mạch đầu
tiên được sử dụng như là những vi mạch số lập trình theo quan điểm của vi
mạch số. Cấu trúc của PROM rất đơn giản bao gồm một mảng tế bào nhớ
với những đường điạ chỉ ngõ vào và nhũng đường dữ liệu ngõ ra. Số đường
điạ chỉ và dữ liệu cho biết ma trận nhớ của PROM. Một PROM đơn giản
được trình bày ở hình 2.1

Hình 2.1: Trình bày một PROM đơn giản

15
 PROM có 5 đường điều khiển ngõ vào cho phép tạo ra 32 tổ hợp
logic và 8 đường dữ liệu ra tạo thành một ma trận nhớ 32x8, vì vậy có tổng
cộng 256 tế bào nhớ. Cấu trúc của PROM gồm một mảng AND cố định
theo sau là mảng OR lập trình.

Hình 2.2: Cấu trúc PROM gồm mảng AND và OR

Chú thích:
- Dấu X trong hình biểu hiện những điểm lập trình (được kết nối
thông qua một cầu chì) .
- Dấu chấm tròn biểu thị nơi đó được nối cố định.
Ở mảng AND cố định có 16 biến được chọn và liên kết với 4 tín hiệu
ngõ vào mảng OR. Do đó bất kì một liên kết nào bị loại bỏ (nghĩa là cầu
chì ở đó bị đứt, thì biến đó sẽ không có mặt ở biểu thức ngõ ra).
Các hàm ở ngõ ra thay đổi tùy thuộc vào sự kết nối của các biến ở
ngõ vào.
16
 PROM thường được sử dụng để giải mã điạ chỉ và ứng dụng để lưu
trữ dữ liệu. Khi thiết kế các PROM, nguời thiết kế phải chú ý đến sự thay
đổi mức logic ngõ vào (xảy ra trong thời gian ngắn) khi địa chỉ ngõ vào
thay đổi. Phương thức ghi của PROM là khi có một tín xung clock đồng bộ
thì mạch ngõ ra chuyển sang trạng thái khác. Đặc điểm này sẽ giúp khắc
phục được vấn đề tạp nhiễm ở PROM.
Khi khảo sát PROM, người ta thường quan tâm đến tốc độ truy xuất
dữ liệu. Thông thường các loại PROM có thời gian truy xuất dưới 60 ns.
Các loại PROM thường sử dụng công nghệ lưỡng cực là nguyên tắc cơ bản
để chế tạo. Tuy nhiên, khoa học tiến bộ đã phát minh ra công nghệ CMOS
cho phép rút ngắn thời gian truy xuất. Công nghệ CMOS được dùng để chế
tạo EPROM, đó là một dạng PROM có thể xóa được bằng tia cực tím. Nó
đã tạo ra một bước tiến đáng kể như: EPROM WS57C256F của công ty
WaferScale Integration có dung lượng 32Kx8 với thời gian truy xuất là 55
ns, công ty Cypress Semicondutor giới thiệu PROM CY7C245 có dung
lượng là 2048x8 với thời gian truy xuất là 25 ns.
2.2.2. Họ vi mạch FPLA (Field Programmable Logic Array)
Họ vi mạch FPLA đầu tiên được công ty Signetics giới thiệu vào
năm 1975. Cấu trúc của FPLA là một mảng AND – OR đơn giản, được
trình bày ở hình 2. 3. Mảng AND – OR có thể lập trình để thực hiện 4 hàm
logic bất kì với hai biến ngõ vào. Mỗi biến ngõ vào được đưa qua cổng
đệm để tạo hai mức logic 0 và 1. Mỗi mức logic này được nối với ngõ vào
cổng AND thông qua một cầu chì lập trình. Tất cả 4 cầu chì được giữ
nguyên.
Nếu tất cả cầu chì đều thông, ví dụ như cổng ANDK thì biểu thức
ngõ ra cho cổng sẽ là:
K = A AND A AND B AND B = AABB
Từ kết quả trên cho thấy ngõ ra của cổng AND luôn ở mức thấp,
điều này không có lợi. Tuy nhiên nếu ta lập trình cho 4 cầu chì trên, ví dụ
ta chọn A x B, lúc này giá trị của 2 biến này sẽ không có trong biểu thức.
Biểu thức ngõ ra cổng AND K là: K= A.B
Nguyên tắc ở đây là lựa chọn những giá trị để lập trình, khi một
cầu chì được chọn nghĩa là giá trị của nó sẽ không có mặt trong biểu thức.

17
 Hình 2.3. Sơ đồ biểu thức ngõ ra của FPLA

Lưu ý mảng OR trong mạch ở hình 2.3 mỗi ngõ ra cổng AND được
nối tới 1 ngõ vào cổng OR thông qua một cầu chì và một Diode. Xét biểu
thức F1 giả sử các cầu chì đều thông, ta có :
F1 = K + L+ M + N
Với K, L, M, N là những tích số của AXB, F1 là tổng các tích so của
hai biến A và B. Bây giờ ta sẽ lập trình bằng cách làm đứt các cầu chì thì
các số hạng ứng với những cầu chì bị đứt sẽ không có mặt trong biểu thức.
Bằng cách lập trình các cầu chì ở mảng AND – OR (nghĩa là loại bỏ giá trị
giá trị của nó trong biểu thức) FPLA có thể tạo ra các hàm logic khác nhau
theo mạch thiết kế chỉ với hai biến ngõ vào. Lưu ý những Diode trong
mảng OR được dùng để bảo vệ ngắn mạch.
Sơ đồ mạch trong hình 2.4 là một ví dụ đơn giản của họ vi mạch
mảng logic lập trình trường. Nếu vi mạch do công ty chế tạo đã được lập
trình bằng công đoạn mặt nạ với công nghệ lưỡng cực thì chương trtình cố
định không thay đổi được. Do đó vi mạch này được gọi là PLA. Nếu vi
mạch được sản xuất để người sử dụng có thể lập trình thì gọi là FPLA.

18
Hình 2.4: Sơ đồ logic của FPLA PLS 153

19
2.2.3. Họ vi mạch FPLS ( Field Programable Logic Sequencer)
Họ FPLS được giới thiệu vào năm 1979, FPLS có cấu trúc mô
phỏng theo cấu trúc của FPLA nhưng được bổ sung thêm những thanh ghi
cho phép “preloading” trạng thái của thiết bị. Một vài thanh ghi ở ngõ ra
được đưa hồi tiếp về mảng AND lập trình và một số khác có những thanh
ghi ngầm (những thanh ghi được bổ sung trên chíp và không nối với chân
của ngõ vào hay ngõ ra) bổ sung với thanh ghi ngõ ra, nó có thể hồi tiếp
hoặc không hồi tiếp.

Hình 2.5: Sơ đồ logic FPLS PLS157

20
 Sơ đồ logic của vi mạch PLS157 được công ty Signetics giới thiệu
được trình bày ở hình 2.5, có hình dáng bên ngoài 20 chân, có cấu trúc
16x45x12. PLS157 có 6 thanh ghi và 6 tổ hợp ở ngõ ra. Các tổ hợp ở ngõ
ra có chức năng nhất, những thanh ghi được cấu tạo bằng những cổng đảo
M(M0-M5). Cấu trúc mới của PLS157 có những đặc điểm đáng lưu ý là
những thanh ghi cho phép chốt [Ứng dụng vi mạch số lập trình
http://www.ebook.edu.vn] những tín hiệu ở ngõ vào và những tín hiệu này
được đưa tới mảng AND. Ngoài ra vi mạch còn được thiết kế một mảng bổ
sung (mảng bù). Đây là tổng số hạng bù và được thực hiện như một ngõ
vào của mảng AND, nó cho phép bổ sung thêm nhiều tổ hợp.
2.2.4. Ho vi mạch FPGA ( Field Progammable Gate Array).
Họ FPGA được Signetics giới thiệu vào năm 1977 được sử dụng để
thay thế cho những cổng nhiều ngõ vào tiêu chuẩn, cấu trúc của nó bao
gồm một mảng AND lập trình, với lập trình cực tính ở ngõ ra. Chỉ với một
cổng AND có thể biến đổi thành cổng NAND, NOR hay cổng OR. Mỗi
cổng AND trong FPGA có thể biến đổi thành các cổng logic khác nhau.
FPGA cũng được bổ sung linh động hơn những cổng tiêu chuẩn
khác. Vi mạch đại diện cho họ FPGA là PLS151, có hình dáng 20 chân
được trình bày ở hình 2.6. PLS151 có 6 ngõ vào, 12 ngõ ra và có tín hiệu
hồi tiếp đưa về mảng AND được sử dụng như những ngõ vào. Có thêm 3
tích số được tạo ra bởi 3 đường điều khiển, các tín hiệu này điều khiển
những cổng đệm ngõ ra 3 trạng thái. FPGA thích hợp trong các thiết kế để
giải mã địa chỉ và được thêm vào các chức năng khác.
2.2.5. Ho vi mạch PAL ( Programmable Array Logic).
PAL là một họ phổ biến nhất trong họ PLD được MONOLITHIC
MEMORIES INC giới thiệu vào năm 1978. PAL được đăng ký bản
quyền về cấu trúc của công ty MMI. Cấu trúc của PAL bao gồm một mảng
AND lập trình theo sau là một mảng OR cố định, cấu trúc này được cải tiến
từ những khuyết điểm của họ FPLA. Hình 2.7 minh họa cho cấu trúc đơn
giản của PAL. Do loại bỏ việc sử dụng cầu chì ở mảng OR, do đó số lượng
tinh thể Silicon được sử dụng giảm, dẫn đến giá thành của PAL thấp hơn
so với FPLA. Mặt khác thời gian trì hoãn của PAL ngắn hơn so với FPLA
do giảm được sự trì hoãn khi truyền qua mảng OR.
Khảo sát PAL16L8 có hình dáng 20 chân sơ đồ logic được trình bày
ở hình 2.8. Vi mạch này có 8 tổ hợp ngõ ra, mỗi ngõ ra được đảo với 7 tích
số của ngõ vào, 6 trong 8 ngõ ra được hồi tiếp về mảng AND, cho phép
những chân này được sử dụng với chức năng I/O. Do PAL16L8 có ngõ ra
tác động ở mức thấp nên nó có thể kết hợp với các IC khác cùng một mức
tác động.

21
Hình 2.6: Sơ đồ logic của FPGA PLS151

22
Hình 2.7: Sơ đồ logic của PAL

23
Hình 2.8. Sơ đồ logic của PAL16L8

24
 PAL16L8 được ứng dụng trong lĩnh vực giải mã địa chỉ, nó thuận
tiện trong việc kết hợp với các bộ vi xử lý và thiết bị ngoại vi vì cùng một
mức tác động. Với những đặc tính như tốc độ tương đối cao, giá thành
thấp, thời gian truyền trì hoãn khoảng 7,5ns nên PAL16L8 rất phổ biến
trong công nghiệp PLD. Ngoài ra PAL16L8 có một đặc điểm mới so với
các họ trước là có cầu chì bảo vệ, nó dùng để chống sự sao chép, giúp bảo
vệ nội dung bên trong. Ngoài PAL16L8 công ty MMI còn giới thiệu các
loại vi mạch khác như PAL16R4, PAL16R6, PAL16R8. Các vi mạch này
có cấu tạo giống như PAL16L8 nhưng ở ngõ ra sử dụng thêm các FF D để
chốt tín hiệu ngõ ra.
Một thế hệ vi mạch PAL được công ty AMD giới thiệu là
PAL22V10 với hình dáng 24 chân được chế tạo bằng công nghệ CMOS
thay thế cho công nghệ lưỡng cực. Đặc trưng của vi mạch này là ở ngõ ra
được cho qua cổng PLD.
Ngoài việc tăng số biến ngõ vào vi mạch này còn có một số đặc điểm
nữa là trong hàm logic các thành phần tích số có thể thay đổi từ 8 đến 16
biến. Điều này sẽ giúp cho vi mạch thực hiện nhiều phương trình phức tạp.
Nhờ vào cấu tạo ở ngõ ra các cổng PLD nên các ngõ ra hoặc vào của vi
mạch có đặc tính giao tiếp 2 chiều, điều này làm tăng khả năng xử lý của
vi mạch và tạo sự thuận lợi cho việc thiết kế. Do những đặc điểm đã được
cải tiến nên các thế hệ vi mạch PAL được phổ biến rộng rãi (đặc biệt là
nhóm vi mạch 20 chân) và PAL được xem là họ vi mạch đại diện cho họ vi
mạch số lập trình.
Ngoài ra các công ty chế tạo PAL có chọn lựa trong việc ký hiệu
các số trên một vi mạch. Điều này cung cấp cho người sử dụng những
thông tin cần thiết có liên quan đến ứng dụng của vi mạch. Các ký hiệu
trong việc đánh số của họ PAL nói chung bao gồm 2 số đếm được tách rời
nhau bởi 1 hay 2 ký tự. Số đần tiên trong tên vi mạch cho biết số ngõ vào
của vi mạch (đây chính là số biến ngõ vào của mảng AND). Số thứ hai biểu
thị số ngõ ra của vi mạch. Ký tự nằm giữa 2 số chỉ ra ý nghĩa các thuộc tính
của ngõ ra. Một số mã ký tự có ý nghĩa là:
H tác động mức thấp.
L tác động mức cao.
P tác động ngõ ra có thể lập trình.
C phần bổ sung các ngõ ra.
S bộ tuần tự.
Các ký hiệu của vi mạch họ PAL được xem là những hướng dẫn cơ
bản của vi mạch. Ngoài ra các công ty chế tạo còn cung cấp bản thông số
kỹ thuật và sơ đồ logic của vi mạch kèm theo để làm tài liệu tham khảo
cho các nhà thiết kế.
2.2.6. Họ vi mạch GAL (Generic Array Logic).

25
 GAL là một nhóm của công nghệ EEPLD, nó được giới thiệu và phát
triển bởi công ty Lattice Semiconductor Comp. Công ty này đã đưa ra một
khái niệm về cổng PLD có ký hiệu là OLMCs (Output Logic Macrocells).

Hình 2.9: Sơ đồ vi mạch GAL16V8

26
 Vi mạch này cũng có những đặc điểm là có thể xóa bằng điện và lập
trình lại bằng các phần mềm và công cụ hỗ trợ. Khảo sát cấu trúc của vi
mạch GAL16V8 được trình bày ở hình 2.9, GAL16V8 có hình dạng 20
chân là một vi mạch phổ biến trong họ GAL.
Mỗi một OLMC có 8 ngõ vào tương đương với 8 tích số trong
một biểu thức. Ngoài ra OLMC cũng có tín hiệu hồi tiếp đưa về để điều
khiển, tín hiệu xung đồng hồ, tín hiệu hồi tiếp về mảng AND. Các vi mạch
GAL đều có hỗ trợ những thanh ghi “Preload”, điều này có ích trong việc
kiểm tra vi mạch. Mặt khác một thế hệ vi mạch mới được phát triển là vi
mạch lập trình hệ thống ký hiệu là ispEELD (In-system Progammable).
Vi mạch đầu tiên là ispGAL16Z8, cấu trúc của nó gần giống với
GAL16V8 nhưng được thêm vào 4 chân để điều khiển lập trình. Trong hệ
thống ispGAL16Z8 cho phép chu kỳ lập trình là 10000 lần và dữ liệu được
giữ cố định trong khoảng thời gian 20 năm. Đó cũng là quy định của những
vi mạch theo nguyên tắc EPROM. Cấu trúc của họ GAL là sự lặp lại cấu
trúc của họ PAL và những đặc điểm của họ GAL đưọc thiết kế để kết hợp
với những vi mạch họ PAL. Điều này được thể hiện qua việc ký hiệu các
vi mạch họ GAL và cấu trúc tế bào bảo vệ của nó.
2.2.7. Họ vi mạch PEEL (Progammable Electrially Erasable Logic).
Họ PEEL được công ty International Cmos Technology INC giới
thiệu. Nó được chế tạo với công nghệ EEPROM. Cấu trúc của PEEL cũng
tương tự như PAL và GAL, nó được xóa bằng điện và lập trình cũng nhờ
vào phần mềm hỗ trợ. Khảo sát vi mạch PEEL18CV8 được trình bày ở
hình 2.10.
Vi mạch có 20 chân với 8 ngõ ra được cấu tạo bởi cổng PLD, mỗi
ngõ ra có 8 tích số trong một hàm của biểu thức và có một tích số riêng để
điều khiển cổng đệm ngõ ra. Cực tính ngõ ra cũng được lập trình các thanh
ghi ở ngõ ra của vi mạch được Reset không đồng bộ, ngoài ra các thanh
ghi có thể được chốt bên trong khi ngõ ra được điều khiển bởi một biểu
thức của tổng các số hạng của ngõ vào. Đặc điểm này được cải tiến hơn số
với các vi mạch PAL16V10 hay GAL16V8.

27
 Hình 2.10: Vi mạch PEEL18CV8

Công ty Altera lần đầu tiên giới thiệu thuật ngữ xóa các PLD bằng
tia cực tím và nó đã trở thành thuật ngữ chung cho công nghệ PLD để tham
khảo cho các vi mạch lập trình xóa bằng tia cực tím. Từ khi khởi đầu, công
ty Altera thay đổi công nghệ chế tạo PLD từ công nghệ lưỡng cực sang
công nghệ CMOS vì công nghệ CMOS đạt được hiệu suất cao về không
28
gian (mật độ tích hợp cao hơn). Như PAL16L8 có mật độ tích hợp từ 100
lên 150 cổng, PAL22V10 có 500 đến 600 cổng và EP310 (là vi mạch đại
diện cho họ EPLD) có trên 1000 cổng. Hình 2.11 trình bày sơ đồ khối của
EP310 có 20 chân cấu trúc gồm 8 cổng PLD, xung xóa không đồng bộ và
có thể đặt trước các tích số.
Cấu trúc của cổng PLD bao gồm cả khối điều khiển cấu trúc I/O.
Cấu hình của ACB giống như cấu trúc của cổng PLD của vi mạch PAL và
GAL nhưng có chức năng hoạt động đơn giản hơn. Trong đó mỗi cổng có 8
biến ngõ vào cùng với một biến để điều khiển cổng đệm ngõ ra. Nhờ vào
cấu trúc ACB I/O mà EP310 có các tín hiệu tổ hợp ngõ ra tác động ở mức
cao hoặc thấp hay các tín hiệu được ghi cũng tác động ở mức cao hoặc
thấp. Đối với tín hiệu hồi tiếp về mảng AND được đưa về từ thanh ghi ở
ngõ ra. Các cổng đệm ngõ ra được điều khiển bằng các biến riêng cho phép
các chân của vi mạch có thể hoạt động hai chiều. Ngoài ra EP310 cũng có
cầu chì bảo vệ chống sao chép và giờ đây cầu chì bảo vệ trở thành một tiêu
chuẩn cho các thế hệ PLD mới. Một số vi mạch tiêu biểu cho họ EPLD là
EP900, có cấu tạo 40 chân, bên trong có 24 khối ACB, mật độ tích hợp hơn
1000 cổng với các tổ hợp ngõ ra có lựa chọn. Nhưng trong tương lai kỹ
thuật ngày càng phát triển thì mật độ tích hợp có thể lên đến hơn 10000
cổng logic trong một chip.
Ngoài vi mạch EP900 thì công ty Altera còn giới thiệu vi mạch
EP1800 có 68 chân với các chức năng được mở rộng hơn so với EP900 vì
số cổng logic trong IC được tăng gấp đôi và số ngõ vào cũng vậy. Vi mạch
EP1800 có thể thực hiện đồng thời 4 chức năng khác nhau, có thể xem như
đó là 4 vi mạch rời. Những vi mạch số lập trình đang hướng đến mật độ
tích hợp trên 1000 cổng logic trong một chip thì đang gây ảnh hưởng đến
các PLD có mật độ tích hợp thấp. Công ty Cypress Semicondutor đang sản
xuất các sản phẩm ứng dụng công nghệ CMOS có tốc độ cao. Sản phẩm
cạnh tranh của họ chủ yếu là các họ PAL thông thường và PAL 22V10 đã
tạo ra thế hệ PAL có công suất thấp, tốc độ cao nên được ứng dụng rộng rãi
vào các lĩnh vực công nghiệp khác nhau. Những vi mạch phổ biến của công
ty Cypress Semicondutor như CY7C330, CY7C331 và CY7C332.

29
Hình 2.11: Sơ đồ logic cổng lập trình của EPLD EP310

30
Hình 2.12: Sơ đồ logic khối cấu trúc điều khiển EPLD EP900

31
2.2.8. Họ vi mạch PML (Programmable Macro Logic).
Họ vi mạch được công ty Signetics sử dụng cấu trúc mới gọi là
“foldback” (gấp về). Mạch logic “foldback” sử dụng một cổng NAND đơn
hay mảng NOR kết hợp với một cấu trúc liên kết lập trình trung tâm cho
phép thực hiện nhiều mức logic khác nhau để liên kết với macro ngõ vào và
ngõ ra. Như trong họ vi mạch PML, một mảng NAND được sử dụng vì
cổng NAND có tốc độ truyền nhanh nhất trong công nghệ lưỡng cực.

Hình 2.13: Mạch lật RS và D sử dụng cấu trúc PML

32
Hình 2.14: Sơ đồ chức năng PLS 501

33
2.2.9. Họ vi mạch ERASIC
(Erasable Programmable Application Specific IC).
Họ vi mạch ERASIC được giới thiệu bởi công ty Exel
Microeletronics có cấu trúc tương tự như họ PML nhưng được chế tạo
bằng công nghệ CMOS EEPROM khác với họ PML dùng công nghệ
lưỡng cực . Một đặc điểm khác biệt nữa là họ ERASIS sử dụng cấu trúc
mảng NOR , vì trong công nghệ CMOS cổng NOR có thời gian truyền
nhanh nhất. Vi mạch đầu tiên của họ này là XL 78C800 có 24 chân với mật
độ thích hợp khoảng 800 cổng.
XL78C800 có 12 ngõ vào và 10 chân I/O được liên kết với các
cổng lập trình. Chân số 1 là đường cung cấp tín hiệu xung clock cho FF JK,
chân 13 dùng để điều khiển các cổng đệm ngõ ra cho các cổng lập trình, 8
ngõ vào được đưa vào mảng NOR thông qua các mạch lật, 2 cổng NOR
được sử dụng để điều khiển mạch lật. Ngõ ra của cổng NOR được cấu tạo
bằng các khối PCE (Polarity Control Element ) để tăng tính linh hoạt.
XL78C800 có 32 biến ở ngõ vào cổng NOR, hai biến dùng để điều
khiển mạch lật và có 30 biến dùng cho cổng lập trình.
Sơ đồ cổng lập trình trên trình bày 3 chế độ làm việc của vi mạch.
Thời gian truyền của vi mạch họ ERASIC là 35 ns cộng với thời gian
truyền qua mảng NOR là 20ns do đó thời gian truyền của vi mạch là 55ns,
dòng tiêu thụ 35mA, so với dòng tiêu thụ của PLHS 501 là 250mA. Qua sự
so sánh trên cho thấy công suất tiêu thụ của họ ERASIC thấp hơn họ PML,
đó là ưu điểm của công nghệ CMOS.

34
 Hình 2.15. Sơ đồ khối cổng lập trình ERASIC XL78C800.

2.2.10. Họ vi mạch LCA ( Logic Cell Array).

Họ LCA được công ty Xillinx giới thiệu dựa theo các cấu trúc của
công ty MMI, đã trình bày một cấu trúc độc đáo trong các họ của PLD. Cấu
trúc truyền thống của các họ vi mạch PAL và FPLA là các mảng AND –
OR. Các cổng lập trình có cấu trúc của họ LCA gọi là cấu trúc lập trình cho
người sử dụng. Đặc biệt là trong cấu tạo của LCA, họ dùng RAM động để
tạo ra các chức năng logic theo yêu cầu thiết kế. Nhược điểm của các tế
bào RAM động thường không ổn định. Do đó các chức năng sẽ trở lại trạng
thái ban đầu khi mất điện.

35
 Để hỗ trợ cho vấn đề này họ sử dụng thêm phương pháp lưu trữ mới
có chức năng tương tự như ROM. Cấu trúc của LCA được mô tả ở hình
2.16 bao gồm một khối IOB bao quanh ma trận của khối LCB.

Hình 2.16. Cấu trúc LCA

Liên kết các đường tín hiệu dọc và ngang giữa 2 khối giúp cho việc
kết nối giữa 2 khối thêm thuận tiện. Vi mạch đầu tiên của họ LCA là XC
2064, có mật độ thích hợp khá phức tạp khoảng 1200 cổng logic, 58 khối
IOB cùng một ma trận 8x8 hàng và cột tạo ra 64 khối CLB. Tạo ra một vi
mạch khác là XC 2018 có mật độ tích hợp khoảng 1800 cổng, có 74 khối
IOB cùng một ma trận 10x10 tạo ra 100 khối CLB. Vi mạch có các đường
tín hiệu xung clock, tín hiệu reset đặc biệt và mạch tạo dao động thạch anh
bên trong IC dùng để kết nối với các phần tử dao động bằng thạch anh bên
ngoài.

36
 Hình 2.17. Cấu hình khối vào / ra ( IOB) của LCA

Hình 2.17 trình bày sơ đồ của khối IOB, bao gồm 1 cổng đệm ngõ
vào, bộ đa hợp IN – MUX và FFD. Mức điện áp ngưỡng ở ngõ vào cổng
đệm thích hợp cho cả hai họ TTL và CMOS. Ngõ ra của FFD được nối với
ngõ vào của bộ đa hợp và ở ngõ ra của bộ đa hợp có thể nối 1 hay nhiều
khối CLB. Ngõ ra của khối IOB gồm 1 cổng đệm 3 trạng thái được nối
thẳng tới chân IC.

37
2.3. Thực hành thiết kế Multiplexer trên MAX7000S
- Bước 1: Tạo Project mới
+ Mở chương trình Quartus II
+ Click File -> New Project Wizard.

38
+ Chọn thông số của vi mạch

39
+ Chọn thiết kế mạch bằng sơ đồ logic

40
+ Chọn các cổng logic và thiết kế mạch

41
+ Tạo biểu tượng cho tệp tin

42
+ Biên dịch thiết kế

43
+ Mô phỏng dạng sóng Vector

44
45
46
47
+ Nạp chương trình thiết kế cho Chíp

48
B. Thực hành
1. Vật tư - Thiết bị - Dụng cụ cho 1 ca thực tập

TT Tên Số lượng
Máy vi tính cài đặt đầy đủ các phần
mềm hỗ trợ có cấu hình tối thiểu:
(Mainboard của Gigabyte, CPU
1 Core i3 hoặc i7, Ram 2GB trở lên, 16
HDD 250GB trở lên, Card màn hình
512MB trở lên, LCD 19")

2 Digital Oscilloscope 09

3 Chíp EPM7128 và bộ nạp 09

4 Thiết bị thí nghiệm PLD 09

2. Quy trình thực hiện:

- Bước 1: Thiết kế vi mạch số lập trình theo yêu cầu bài toán bằng phương
pháp thiết kế sơ đồ logic (block diagram/Schemtic file)
- Bước 2: Kiểm tra sơ đồ thiết kế
- Bước 3: Mô phỏng thiết kế thông qua bảng trạng thái mức logic
input/output, hoặc sử dụng giản đồ thời gian.
- Bước 4: Lựa chọn cầu hình cho vi mạch và nạp chương trình
- Bước 5: Kiểm tra kết quả:
3. Chia nhóm: 2 sinh viên/máy
4. Các dạng sai hỏng thường gặp, nguyên nhân – Biện pháp khắc phục

TT Sai hỏng Nguyên nhân Khắc phục

Chương trình báo Kiểm tra lỗi trên Output
1 Sai cú pháp lệnh
lỗi Window và sửa chữa
Chưa cài đặt
Không nhận diện
2 Drive cho thiết Cài đặt driver cho thiết bị
được thiết bị
bị
Kiểm tra thông số trên
Không nạp được Chọn chưa đúng
3 phần mềm nạp chương
chương trình thông số thiết bị
trình

49
C. Đánh giá kết quả : (tính theo thang điểm 10)

Mục tiêu Nội dung Điểm chuẩn

- Trình bày được cấu tạo, ý nghĩa thực tế

Kiến thức của việc sử dụng mảng logic lập trình 2
trong các yêu cầu thiết kế phức tạp.

- Xác định và sử dụng được các phần

mềm hỗ trợ PLA trong thiết kế logic;
- Sử dụng được các mảng lập trình trong 5
Kỹ năng
quá trình luyện tập;

- Rèn luyện tính tỉ mỉ, chính xác, an toàn

Thái độ 3
và vệ sinh công nghiệp

50
 BÀI 3. NGÔN NGỮ VHDL VÀ ABEL

Mục tiêu:
+ Kiến thức:
- Trình bày được cấu trúc chung của một chương trình VHDL và ABEL
theo nội dung đã học;
- Trình bày được các cú pháp, tính năng các dòng lệnh theo nội dung đã
học;
+ Kỹ năng:
- Thực hiện viết chương trình thiết kế các cổng và các mạch logic cơ bản
theo đúng yêu cầu kỹ thuật;
- Nạp được chương trình cho vi mạch số;
+ Thái độ:
- Rèn luyện tính tỉ mỉ, chính xác, an toàn và vệ sinh công nghiệp
Các thuật ngữ chuyên môn: Được giải thích chi tiết trong nội dung bài
học
Nội dung:
A. LÝ THUYẾT
3.1. Ngôn ngữ VHDL (VHSIC Hardware Description Language)
3.1.1. Giới thiệu về VHDL
VHDL là ngôn ngữ mô tả phần cứng cho các mạch tích hợp tốc độ
rất cao, là một loại ngôn ngữ mô tả phần cứng được phát triển dùng cho
trương trình VHSIC (Very High Speed Itergrated Circuit) của bộ quốc
phòng Mỹ. Mục tiêu của việc phát triển VHDL là có được một ngôn ngữ
mô phỏng phần cứng tiêu chuẩn và thống nhất cho phép thử nghiệm các hệ
thống số nhanh hơn cũng như cho phép dễ dàng đưa các hệ thống đó vào
ứng dụng trong thực tế. Ngôn ngữ VHDL được ba công ty Intermetics,
IBM và Texas Instruments bắt đầu nghiên cứu phát triển vào tháng 7 năm
1983. Phiên bản đầu tiên được công bố vào tháng 8-1985. Sau đó VHDL
được đề xuất để tổ chức IEEE xem xét thành một tiêu chuẩn chung. Năm
1987 đã đưa ra tiêu chuẩn về VHDL (tiêu chuẩn IEEE-1076-1987).
VHDL được phát triển để giải quyết các khó khăn trong việc phát
triển, thay đổi và lập tài liệu cho các hệ thống số. VHDL là một ngôn ngữ
độc lập không gắn với bất kỳ một phương pháp thiết kế, một bộ mô tả hay
công nghệ phần cứng nào. Người thiết kế có thể tự do lựa chọn công nghệ,
phương pháp thiết kế trong khi chỉ sử dụng một ngôn ngữ duy nhất. Và khi
đem so sánh với các ngôn ngữ mô phỏng phần cứng khác ta thấy VHDL có
một số ưu điểm hơn hẳn là:
- Thứ nhất là tính công cộng:
VHDL được phát triển dưới sự bảo trợ của chính phủ Mỹ và hiện
nay là một tiêu chuẩn của IEEE. VHDL được sự hỗ trợ của nhiều nhà sản
xuất thiết bị cũng như nhiều nhà cung cấp công cụ thiết kế mô phỏng hệ
thống.

51
- Thứ hai là khả năng được hỗ trợ bởi nhiều công nghệ và nhiều phương
pháp thiết kế:
VHDL cho phép thiết kế bằng nhiều phương pháp ví dụ phương
pháp thiết kế từ trên xuống, hay từ dưới lên dựa vào các thư viện sẵn có.
VHDL cũng hỗ trợ cho nhiều loại công cụ xây dựng mạch như sử dụng
công nghệ đồng bộ hay không đồng bộ, sử dụng ma trận lập trình được hay
sử dụng mảng ngẫu nhiên.
- Thứ ba là tính độc lập với công nghệ:
VHDL hoàn toàn độc lập với công nghệ chế tạo phần cứng. Một mô
tả hệ thống dùng VHDL thiết kế ở mức cổng có thể được chuyển thành các
bản tổng hợp mạch khác nhau tuỳ thuộc công nghệ chế tạo phần cứng mới
ra đời nó có thể được áp dụng ngay cho các hệ thống đã thiết kế.
- Thứ tư là khả năng mô tả mở rộng:
VHDL cho phép mô tả hoạt động của phần cứng từ mức hệ thống số
cho đến mức cổng. VHDL có khả năng mô tả hoạt động của hệ thống trên
nhiều mức nhưng chỉ sử dụng một cú pháp chặt chẽ thống nhất cho mọi
mức. Như thế ta có thể mô phỏng một bản thiết kế bao gồm cả các hệ con
được mô tả chi tiết.
- Thứ năm là khả năng trao đổi kết quả:
Vì VHDL là một tiêu chuẩn được chấp nhận, nên một mô hình
VHDL có thể chạy trên mọi bộ mô tả đáp ứng được tiêu chuẩn VHDL. Các
kết quả mô tả hệ thống có thể được trao đổi giữa các nhà thiết kế sử dụng
công cụ thiết kế khác nhau nhưng cùng tuân theo tiêu chuẩn VHDL. Cũng
như một nhóm thiết kế có thể trao đổi mô tả mức cao của các hệ thống con
trong một hệ thống lớn (trong đó các hệ con đó được thiết kế độc lập).
- Thứ sáu là khả năng hỗ trợ thiết kế mức lớn và khả năng sử dụng lại các
thiết kế:
VHDL được phát triển như một ngôn ngữ lập trình bậc cao, vì vậy
nó có thể được sử dụng để thiết kế một hệ thống lớn với sự tham gia của
một nhóm nhiều người. Bên trong ngôn ngữ VHDL có nhiều tính năng hỗ
trợ việc quản lý, thử nghiệm và chia sẻ thiết kế. Và nó cũng cho phép dùng
lại các phần đã có sẵn.

3.1.2. Giới thiệu công nghệ và ứng dụng thiết kế mạch bằng ngôn ngữ
VHDL
1. Ứng dụng của công nghệ thiết kế mạch bằng VHDL
Hiện nay 2 ứng dụng chính và trực tiếp của VHDL là các ứng dụng
trong các thiết bị logic có thể lập trình được (Programmable Logic Devices
– PLD) (bao gồm các thiết bị logic phức tạp có thể lập trình được và các
FPGA - Field Programmable Gate Arrays) và ứng dụng trong
ASICs(Application Specific Integrated Circuits).
Khi chúng ta lập trình cho các thiết bị thì chúng ta chỉ cần viết mã
VHDL một lần, sau đó ta có thể áp dụng cho các thiết bị khác nhau (như
Altera, Xilinx, Atmel,…) hoặc có thể để chế tạo một con chip ASIC. Hiện

52
nay, có nhiều thương mại phức tạp (như các vi điều khiển) được thiết kế
theo dựa trên ngôn ngữ VHDL.
2. Quy trình thiết kế mạch bằng VHDL.
Như đề cập ở trên, một trong số lớn các ứng dụng của VHDL là chế
tạo các mạch hoặc hệ thống trong thiết bị có thể lập trình được (PLD hoặc
FPGA) hoặc trong ASIC. Việc chế tao ra vi mạch sẽ được chia thành 3 giai
đoạn như sau:
- Giai đoạn 1
Chúng ta bắt đầu thiết kế bằng viết mã VHDL. Mã VHDL này sẽ
được lưu vào file có đuôi là .vhd và có tên cùng với tên thực thể. Mã
VHDL sẽ được mô tả ở tầng chuyển đổi thanh ghi.

Hình 3.1. Tóm tắt quy trình thiết kế VHDL

- Giai đoạn 2: Giai đoạn chế tạo:

Bước đầu tiên trong quá trình chế tạo là biên dich. Quá trình biên
dịch sẽ chuyển mã VHDL vào một netlist ở tầng cổng.
Bước thứ 2 của quá trình chế tạo là tối ưu. Quá trình tối ưu được
thực hiện trên netlist ở tầng cổng về tốc độ và phạm vi.
Trong giai đoạn này, thiết kế có thể được mô phỏng để kiểm tra phát
hiện những lỗi xảy ra trong quá trình chế tạo.
- Giai đoạn 3: Là giai đoạn ghép nối đóng gói phần mềm. Ở giai đoạn này
sẽ tạo ra sự sắp xếp vật lý cho chip PLD/FPGA hoặc tạo ra mặt nạ cho
ASIC.
3.Công cụ EDA.
Các công cụ phục vụ cho quá trình thiết kế vi mạch sẽ là:
- Công cụ Active – HDL: Tạo mã VHDL và mô phỏng
53
- Công cụ EDA (Electronic Design Automation): là công cụ tự động thiết
kế mạch điện tử. Công cụ này được dùng để phục vụ cho việc chế tạo, thực
thi và mô phỏng mạch sử dụng VHDL.
- Công cụ cho đóng gói: Các công cụ này sẽ cho phép tổng hợp mã VHDL
vào các chip CPLD/FPGA của Altera hoặc hệ ISE của Xilinx, for Xilinx’s
CPLD/FPGA chips).
4. Chuyển mã VHDL vào mạch.
Một bộ cộng đầy đủ được mô tả trong hình dưới đây:

Hinh 3.2.a. Sơ đồ tổng quát về bộ cộng đầy đủ

Trong đó, a , b là các bit vào cho bộ cộng, cin là bit nhớ. Đầu ra s là
bit tổng, cout là bit nhớ ra. Hoạt động của mạch được chỉ ra dưới dạng
bảng chân lý:

Hình 3.2.b. Bảng chân lý của bộ cộng đầy đủ

Bit s và cout được tính như sau:

và
Từ công thức tính s và cout ta viết đoạn mã VHDL như dưới đây:

54
 Hình 3.3. Mã thiết kế bộ cộng

Từ mã VHDL này, mạch vật lý được tạo ra. Tuy nhiên có nhiều cách
để thực hiện phương trình được miêu tả trong ARCHITECTURE OF, vì
vậy mạch thực tế sẽ phụ thuộc vào bộ biên dịch/bộ tối ưu đang được sử
dụng và đặc biệt phụ thuộc mục đích công nghệ. Hình vẽ sau đây thể hiện
một số dạng kiến trúc của mạch cộng:

Hình 3.4.a. Các ví dụ về sơ đồ mạch có thể có ứng với mã như hình 3.3

Trong trường hợp này, nếu mục đích công nghệ của chúng ta là thiết
bị lgic có thê lập trình được (PLD, FPGA), thì 2 kết quả cho cout thoả mãn

55
là ở hình (b) và hình (c) ( ). Còn nếu mục đích công
nghệ là ASIC, thì chúng ta có thể sử dụng hình (d). Sử dụng công nghệ
CMOS với các tầng transistor và các mặt nạ phủ.
Hình dưới đây là mô phỏng kết quả của đoạn chương trình đã viết ở
trên cho mạch bộ cộng đầy đủ ở hình 3.3.

Hình 3.4.b. Kết quả mô phỏng bộ cộng được thiết kế theo hình 3.3

3.2.3. Cấu trúc mã

Trong phần này, chúng ta mô tả các phần cơ bản có chứa cả các đoạn
Code nhỏ của VHDL: các khai báo LIBRARY, ENTITY và
ARCHITECTURE.
1. Các đơn vị VHDL cơ bản.
Một đoạn Code chuẩn của VHDL gồm tối thiểu 3 mục sau:
- LIBRARY: chứa một danh sách của tất cả các thư viện được sử dụng
trong thiết kế. Ví dụ: ieee, std, work, …
- ENTITY: Mô tả các chân vào ra (I/O pins) của mạch
- ARCHITECTURE: chứa mã VHDL, mô tả mạch sẽ họat động như thế
nào.
Một LIBRARY là một tập các đọan Code thường được sử dụng.
Việc có một thư viện như vậy cho phép chúng được tái sử dụng và được
chia sẻ cho các ứng dụng khác. Mã thường được viết theo các định dạng
của FUNCTIONS, PROCEDURES, hoặc COMPONENTS, được thay thế
bên trong PACKAGES và sau đó được dịch thành thư viện đích.
2. Khai báo Library.
- Để khai báo Library, chúng ta cần hai dòng mã sau, dòng thứ nhất chứa
tên thư viện, dòng tiếp theo chứa một mệnh đề cần sử dụng:
LIBRARY library_name;
USE library_name.package_name.package_parts;
Thông thường có 3 gói, từ 3 thư viện khác nhau thường được sử
dụng trong thiết kế:
- ieee.std_logic_1164 (from the ieee library),
- standard (from the std library), and
- work (work library).

56
 Hình 3.5. Các thành phần cơ bản của một đoạn mã VHDL

Hình 3.6. Các phần cơ bản của một Library

Các khai báo như sau:

LIBRARY ieee; -- Dấu chấm phẩy (;) chỉ thị
USE ieee.std_logic_1164.all;--kt của một câu lệnh

LIBRARY std; -- hoặc một khai báo.một dấu 2 gạch

USE std.standard.all; --(--)để bắt đầu 1 chú thích.

LIBRARY work;
USE work.all;

Các thư viện std và work thường là mặc định, vì thế không cần khai
báo chúng, chỉ có thư viện ieee là cần phải được viết rõ ra.
Mục đích của 3 gói/thư viện được kể ở trên là như sau: gói
std_logic_1164 của thư viện ieee cho biết một hệ logic đa mức; std là một
thư viện tài nguyên (kiểu dữ kiệu, i/o text..) cho môi trường thiết kế VHDL
và thư viện work được sủ dụng khi chúng ta lưu thiết kế ( file .vhd, các file
được tạop bởi chương trình dịch và chương trình mô phỏng…).

57
Thực ra, thư viện ieee chứa nhiều gói như sau:
- std_logic_1164: định rõ STD_LOGIC ( 8 mức) và STD_ULOGIC (
9 mức) là các hệ logic đa mức
- std_logic_arith: định rõ các kiểu dữ liệu SIGNED và UNSIGNED,
các giải thuật liên quan và so sánh toán tử. Nó cũng chứa nhiều hàm
chuyển đổi dữ liệu, mà cho phép một kiểu được chuyển đổi thành các kiểu
dữ liệu khác:
conv_integer(p),
conv_unsigned(p,b),
conv_signed(p, b),
conv_std_logic_vector(p, b)
- std_logic_signed: chứa các hàm cho phép làm việc với dữ liệu
STD_LOGIC_VECTOR để được thực hiện chỉ khi dữ liệu là kiểu SIGNED
- std_logic_signed: chứa các hàm cho phép làm việc với dữ liệu
STD_LOGIC_VECTOR để được thực hiện chỉ khi dữ liệu là kiểu
UNSIGNED.
3. Entity ( thực thể).
Một ENTITY là một danh sách mô tả các chân vào/ra ( các PORT)
của mạch điện. Cú pháp như sau:

ENTITY entity_name IS
PORT (
port_name : signal_mode signal_type;
port_name : signal_mode signal_type;
...);
END entity_name;

Chế độ của tín hiệu ( mode of the signal) có thể là IN, OUT, INOUT
hoặc BUFFER. Ví dụ trong hình 3.4b ta có thể thấy rõ các chân IN, OUT
chỉ có một chiều (vào hoặc ra) trong khi INOUT là 2 chiều và BUFFER lại
khác, tín hiệu ra phải được sử dụng từ dữ liệu bên trong.
Kiểu của tín hiệu ( type of the signal) có thể là BIT, STD_LOGIC,
INTEGER, …
Tên của thực thể ( name of the entity) có thể lấy một tên bất kỳ,
ngọai trừ các tù khóa của VHDL.
Ví dụ: Xét cổng NAND ở hình 3.8, khai báo ENTITY như sau:

ENTITY nand_gate IS
PORT (a, b : IN BIT;
x : OUT BIT);
END nand_gate;

58
 Hình 3.7. Các chế độ tín hiệu Hình 3.8. Cổng NAND

4. ARCHITECTURE ( cấu trúc).

ARCHITECTURE là một mô tả mạch dùng để quyết mạch sẽ làm
việc như thế nào ( có chức năng gì).
Cú pháp như sau:

ARCHITECTURE architecture_name OF entity_name IS

[declarations]
BEGIN
(code)
END architecture_name;

Như thấy ở trên, một cấu trúc có 2 phần: phần khai báo ( chức năng),
nơi các tín hiệu và các hằng được khai báo, và phần mã (code - từ BEGIN
trở xuống).
Ví dụ: Xét trở lại cổng NAND của hình 3.8

ARCHITECTURE myarch OF nand_gate IS

BEGIN
x <= a NAND b;
END myarch;

Ý nghĩa của ARCHITECTURE trên là như sau: mạch phải thực hiện
công việc NAND 2 tín hiệu vào (a,b) và gán (<=) kết quả cho chân ra x.
Mỗi một khai báo thực thể đều phải đi kèm với ít nhất một kiến trúc
tương ứng. VHDL cho phép tạo ra hơn một kiến trúc cho một thực thể.
Phần khai báo kiến trúc có thể bao gồm các khai báo về các tín hiệu bên
trong, các phần tử bên trong hệ thống, hay các hàm và thủ tục mô tả hoạt
động của hệ thống. Tên của kiến trúc là nhãn được đặt tuỳ theo người xử
dụng. Có hai cách mô tả kiến trúc của một phần tử ( hoặc hệ thống) đó là
mô hình hoạt động (Behaviour) hay mô tả theo mô hình cấu trúc
(Structure). Tuy nhiên một hệ thống có thể bao gồm cả mô tả theo mô hình
hoạt động và mô tả theo mô hình cấu trúc.
+ Mô tả kiến trúc theo mô hình hoạt động:
Mô hình hoạt động mô tả các hoạt động của hệ thống (hệ thống đáp
ứng với các tín hiệu vào như thế nào và đưa ra kết quả gì ra đầu ra) dưới
dạng các cấu trúc ngôn ngữ lập trình bậc cao. Cấu trúc đó có thể là
PROCESS , WAIT, IF, CASE, FOR-LOOP…
59
Ví dụ 1:
ARCHITECTURE behavior OF nand IS
-- Khai báo các tín hiệu bên trong và các bí danh
BEGIN
c <= NOT(a AND b);
END behavior;
Ví dụ 2:
ARCHITECTURE behavioral of decode2x4 is
BEGIN
Process (A,B,ENABLE)
Variable ABAR,BBAR: bit;
Begin
ABAR := not A;
BBAR := not B;
If ENABLE = ‘1’ then
Z(3) <= not (A and B);
Z(0) <= not (ABAR and BBAR);
Z(2) <= not (A and BBAR);
Z(1) <= not (ABAR and B);
Else
Z <= not (ABAR and B);
End if;
End process;
END arc_behavioral;

+ Mô tả kiến trúc theo mô hình cấu trúc:

Mô hình cấu trúc của một phần tử (hoặc hệ thống) có thể bao gồm
nhiều cấp cấu trúc bắt đầu từ một cổng logic đơn giản đến xây dựng mô tả
cho một hệ thống hoàn thiện. Thực chất của việc mô tả theo mô hình cấu
trúc là mô tả các phần tử con bên trong hệ thống và sự kết nối của các phần
tử con đó.
Mô tả cú pháp:

architecture identifier of entity_name is

Architecture_declarative_part
begin
all_concurrent_statements
end [architecture][architecture_simple_name];
Khai báo các thành phần:
Component
Tên_componemt port [ danh sách ];
End component;

60
 Như với ví dụ mô tả mô hình cấu trúc một flip-flop RS gồm hai cổng
NAND có thể mô tả cổng NAND được định nghĩa tương tự như ví dụ với
cổng NOT, sau đó mô tả sơ đồ móc nối các phần tử NAND tạo thành trigơ
RS
Ví dụ1:

Hình 3.9. Sơ đồ của Trigơ RS

ENTITY rsff IS
PORT( r : IN std_logic;
s : IN std_logic;
q : OUT std_logic;
qb : OUT std_logic);
END rsff;
ARCHITECTURE kien_truc OF rsff IS
COMPONENT nand -- định nghĩa cỗng nand
GENERIC(delay : time);
PORT(a : IN std_logic;
b : IN std_logic;
c : OUT std_logic);
END COMPONENT;
BEGIN
u1: nand -- cài đặt u1 là thành phần nand
GENERIC MAP(5 ns) -- giá trị delay có thể thay đổi
values
PORT MAP(s, qb, q); -- bản đồ I/O cho thành phần
u2: nand -- thiết lập u2 là thành phần nand
GENERIC MAP(5 ns)
PORT MAP(q, r, qb);
END kien_truc;

Ví dụ 2:
Architecture arc_mach_cong of mach_cong is
Component Xor
Port( X,Y : in bit ; Z, T : out bit);
End component;
Component And
Port(L,M :input ;N,P : out bit );
End component;
61
 Begin
G1 : Xor port map (A,B,Sum);
G2 : And port map (A, B, C);
End arc_mach_cong;

+ Mô tả kiến trúc theo mô hình tổng hơp

Đó là mô hình kết hợp của 2 mô hình trên.
Ví dụ:
Entity adder is
Port (A,B,Ci : bit
S, Cout : bit);
End adder;

Architecture arc_mixed of adder is

Component Xor2
Port( P1, P2 : in bit;
PZ : out bit);
End compenent;
Signal S1 :bit;
Begin
X1 : Xor2 port map(A,B,S1);
Process (A,B,Cin)
Variable T1,T2,T3 : bit;
Begin
T1 := A and B;
T2 := B and Cin ;
T3 := A and Cin;
Cout := T1 or T2 or T3 ;
End process;
End arc_mixed ;

5. Một số ví dụ
Trong mục này, chúng ta sẽ trình bày 2 ví dụ đầu tiên về mã VHDL.
Mỗi ví dụ đều được theo kèm bởi các chú thích diễn giải và các kết quả mô
phỏng.
Ví dụ 1: DFF với Reset không đồng bộ:

62
 Hình 3.10. Sơ đồ của DFF không đồng bộ

Hình 3.10 cho thấy sơ đồ của một flip-flop loại D (DFF), xung được
kích theo sườn của tín hiệu đồng hồ (clk), và với một tín hiệu đầu vào reset
không đồng bộ (rst). Khi rst = ‘1’, đầu ra luôn ở mức thấp bất kể clk.
Ngược lại, đầu ra sẽ copy đầu vào ( q<=d) tại thời điểm khi clk chuyển từ
‘0’ lên ‘1’.
Có nhiều cách để thực hiện DFF của hình 3.10, một giải pháp sẽ
được trình bày dưới đây. Sử dụng một PROCESS cho đọan mã sau đây:

1 ---------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------
5 ENTITY dff IS
6 PORT ( d, clk, rst: IN STD_LOGIC;
7 q: OUT STD_LOGIC);
8 END dff;
9 ---------------------------------------
10 ARCHITECTURE behavior OF dff IS
11 BEGIN
12 PROCESS (rst, clk)
13 BEGIN
14 IF (rst='1') THEN
15 q <= '0';
16 ELSIF (clk'EVENT AND clk='1') THEN
17 q <= d;
18 END IF;
19 END PROCESS;
20 END behavior;
21 ---------------------------------------

(Chú ý: VHDL không phân biệt chữ hoa và chữ thường.)

* Kết quả mô phỏng:

Hình 3.11: Kết quả mô phỏng của ví dụ 2.1

63
 Hình 3.11 mô phỏng kết quả từ ví dụ, đồ thị có thể được giải thích dễ
dàng. Cột đầu tiên cho biết tên của tín hiệu, như đã được đinh nghĩa trong
ENTITY. Nó cũng cho biết chế độ ( hướng) của tín hiệu, lưu ý rằng các
mũi tên ứng với rst, d và clk hướng vào trong, đây là phía input, còn q
hướng ra ngoài tương ứng với phía output. Cột thứ hai chứa giá trị của mỗi
tín hiệu ở vị trí tương ứng với nơi con trỏ trỏ tới. Trong trường hợp hiện tại,
con trỏ ở 0ns và tín hiệu nhận giá trị (1,0,0,0). Cột thứ 3 cho thấy sự mô
phỏng của toàn bộ quá trình. Các tín hiệu vào (rst, d, clk) có thể được chọn
một cách tự do và bộ mô phỏng sẽ xác định tín hiệu ngõ ra tương ứng.

Ví dụ 2: DFF kết hợp với cổng NAND

Trong lời giải sau đây, chúng ta đã giới thiệu một cách có chủ định
một tín hiệu không cần thiết (temp), chỉ để minh họa một tín hiệu sẽ được
khai báo như thế nào.

Hình 3.12. DFF kết hợp với cổng NAND

Mã thiết kế:
---------------------------------------
ENTITY example IS
PORT ( a, b, clk: IN BIT;
q: OUT BIT);
END example;
---------------------------------------
ARCHITECTURE example OF example IS
SIGNAL temp : BIT;
BEGIN
temp <= a NAND b;
PROCESS (clk)
BEGIN
IF (clk'EVENT AND clk='1') THEN q<=temp;
END IF;
END PROCESS;
END example;
---------------------------------------
Kết quả mô phỏng từ mạch DFF kết hợp với NAND trên hình 3.12:

64
 Hình 3.13. Kết quả mô phỏng của ví dụ 2

3.2.4. Các kiểu dữ liệu

Để viết mã VHDL một cách hiệu quả, thật cần thiết để biết rằng các
kiểu dữ liệu nào được cho phép, làm thế nào để định rõ và sử dụng chúng.
Trong chương này, tất cả các kiểu dữ liệu cơ bản sẽ được mô tả.
1. Các kiểu dữ liệu tiền định nghĩa.
VHDL bao gồm một nhóm các kiẻu dữ liệu tiền định nghĩa, được
định rõ thông qua các chuẩn IEEE 1076 và IEEE 1164. Cụ thể hơn, việc
định nghĩa kiểu dữ liệu như thế có thể tìm thấy trong các gói/ thư viện sau:
- Gói standard của thư viện std: Định nghĩa các kiểu dữ liệu BIT,
BOOLEAN, INTEGER và REAL.
- Gói std_logic_1164 của thư viện ieee: Định nghĩa kiểu dữ liệu
STD_LOGIC và STD_ULOGIC.
- Gói std_logic_arith của thư viện ieee: Định nghĩa SIGNED và
UNSIGNED, cộng thêm nhiều hàm chuyển đổi dữ liệu ví dụ:
conv_integer(p), conv_unsigned(p, b), conv_signed(p, b), và
conv_std_logic_vector(p, b).
- Gói std_logic_signed và std_logic_unsigned của thư viện ieee:
Chứa các hàm cho phép họat động với dữ liệu STD_LOGIC_VECTOR
được thực hiện khi mà kiểu dữ liệu là SIGNED họăc UNSIGNED.

Tất cả các kiểu dữ liệu tiền định nghĩa đã nêu trên được mô tả như sau:
+ BIT và BIT_VECTOR: 2 mức logic (‘0’, ’1’).
Ví dụ:
SIGNAL x: BIT;
-- x được khai báo như một tín hiệu số kiểu BIT.
SIGNAL y: BIT_VECTOR (3 DOWNTO 0);
-- y là một vec tơ 4 bit, với bit bên trái nhất được gọi là MSB.
SIGNAL w: BIT_VECTOR (0 TO 7);
-- w là một véc tơ8 bit, phía bên phải nhất được gọi là MSB
Dựa vào các tín hiệu ở trên, các phép gán sau đây là hợp lệ ( để gán
một giá trị đến một tín hiệu, toán tử <= được sử dụng):
x <= “1”;
y <= “0111”;
z <= “01110001”;

+ STD_LOGIC ( và STD_LOGIC_VECTOR):
Hệ logic 8 giá trị sau đây được giới tiệu trong chuẩn IEEE 1164:
65
 ‘X’ không xác định ( bắt buộc)
‘0’ mức thấp ( bắt buộc)
‘1’ mức cao ( bắt buộc)
‘Z’ trở kháng cao
‘W’ không xác định (yếu)
‘L’ mức thấp ( yếu)
‘H’ mức cao ( yếu)
‘-’ không quan tâm

Ví dụ:
SIGNAL x: STD_LOGIC;
-- x được khai báo như một ký tự số ( vô hướng), tín hiệu thuộc kiểu
STD_LOGIC
SIGNAL y: STD_LOGIC_VECTOR (3 DOWNTO 0) := "0001";
-- y được khai báo như một vector 4-bit, với bit bên trái cùng là
-- MSB. Giá trị khởi đầu của y là "0001". Lưu ý
-- rằng toán tử ":=" được sử dụng để thiết lập giá trị khởi đầu.

Hầu hết các mức std_logic là vô hướng chỉ đối với quá trình mô
phỏng. Tuy nhiên ‘0’, ‘1’ và ‘Z’ là có thể kết hợp không hạn chế. Đối với
các giá trị “weak”, chúng được giải quyết trong sự ưu tiên của các giá trị
“forcing” trong các nút đa chiều ( Bảng 3.1). Thật vậy, nếu 2 tín hiệu
std_logic bất kỳ được nối đến cùng một node, thì các mức logic đối lập
được tự động giải quyết theo bảng 3.1

Bảng 3.1. Hệ thống logic giải được

+ STD_ULOGIC( STD_ULOGIC_VECTOR): hệ thống logic 9 mức trong

chuẩn IEEE 1164: (‘U’, ‘X’, ‘0’, ‘1’, ‘Z’, ‘W’, ‘L’, ‘H’, ‘–’). Thật vậy, hệ
STD_LOGIC mô tả ở trên là một tập con của STD_ULOGIC. Hệ thống thứ
2 này thêm giá trị logic ‘U’.
- BOOLEAN: đúng/sai
- INTEGER: số nguyên 32 bits ( từ -2.147.483.647 đến +2.147.483.647)
- NATURAL: msố nguyên không âm ( từ 0 đến +2.147.483.647)
- REAL: số thực nằm trong khoảng ( từ -1.0E38 đến +1.0E38).
- Physic literals: sử dụng đối với các đại lượng vật lý, như thời gian, điện
áp,…Hữu ích trong mô phỏng
66
- Character literals: ký tự ASCII đơn hoặc một chuỗi các ký tự như thế
- SIGNED và UNSIGNED: các kiểu dữ liệu được định nghĩa trong gói
std_logic_arith của thư viện ieee.
Chúng có hình thức giống như STD_LOGIC_VECTOR, nhưng
ngọai trừ các toán tử số học, mà tiêu biểu là kiểu dữ liệu INTEGER
Các ví dụ:
x0 <= '0'; -- bit, std_logic, or std_ulogic value '0'
x1 <= "00011111"; -- bit_vector, std_logic_vector,
-- std_ulogic_vector, signed, or unsigned
x2 <= "0001_1111"; -- đường gạch dưới cho phép dễ hình dung hơn
x3 <= "101111" -- biểu diễn nhị phân của số thập phân 47
x4 <= B"101111" -- như trên
x5 <= O"57" -- biểu diễn bát phân của số thập phân 47
x6 <= X"2F" -- biẻu diễn số thập lục phân của số thập phân 47
n <= 1200; -- số nguyên
m <= 1_200; -- số nguyên, cho phép gạch dưới
IF ready THEN... -- Logic, thực hiện nếu ready=TRUE
y <= 1.2E-5; -- real, not synthesizable
q <= d after 10 ns; -- physical, not synthesizable
Ví dụ: Các toán tử được phép và không được phép nằm giữa các kiểu dữ
liệu khác nhau:
SIGNAL a: BIT;
SIGNAL b: BIT_VECTOR(7 DOWNTO 0);
SIGNAL c: STD_LOGIC;
SIGNAL d: STD_LOGIC_VECTOR(7 DOWNTO 0);
SIGNAL e: INTEGER RANGE 0 TO 255;
...
a <= b(5); -- được phép (cùng kiểu vô hướng: BIT)
b(0) <= a; -- được phép (cùng kiểu vô hướng: BIT)
c <= d(5); -- được phép (cùng kiểu vô hướng: STD_LOGIC)
d(0) <= c; -- được phép (cùng kiểu vô hướng: STD_LOGIC)
a <= c; -- không được phép (không thể kết hợp kiểu: BIT x STD_LOGIC)
b <= d; -- không được phép (không thể kết hợp kiểu: BIT_VECTOR x
-- STD_LOGIC_VECTOR)
e <= b; -- không được phép (không thể kết hợp kiểu: INTEGER x
BIT_VECTOR)
e <= d; -- không được phép (không thể kết hợp kiểu: INTEGER x
-- STD_LOGIC_VECTOR)
2. Các kiểu dữ liệu người dùng định nghĩa.
VHDL cũng cho phép người dùng tự định nghĩa các kiểu dữ liệu.
Hai loại kiểu dữ liệu người dùng định nghĩa được chỉ ra dưới đây
bao gồm integer và enumerated.
Kiểu integer người dùng định nghĩa:
TYPE integer IS RANGE -2147483647 TO +2147483647;

67
-- Thực ra kiểu này đã được định nghĩa trước bởi kiểu INTEGER.
TYPE natural IS RANGE 0 TO +2147483647;
-- Thực ra kiểu này được đã định nghĩa trước bởi kiểu NATURAL.
TYPE my_integer IS RANGE -32 TO 32;
-- Một tập con các số integer mà người dùng định nghĩa.
TYPE student_grade IS RANGE 0 TO 100;
-- Một tập con các số nguyên hoặc số tự nhiên người dùng định nghĩa.
_ Các kiểu đếm người dùng đinh nghĩa:
TYPE bit IS ('0', '1');
-- Được định nghĩa trước bởi kiểu BIT
TYPE my_logic IS ('0', '1', 'Z');
-- Một tập con của std_logic mà người dùng định nghĩa
TYPE bit_vector IS ARRAY (NATURAL RANGE <>) OF BIT;
-- đã được định nghĩa trước bởi BIT_VECTOR.
-- RANGE <> được sủ dụng để chỉ thị rằng các mức.không giới hạn.
-- NATURAL RANGE <>, on the other hand, indicates that the only
-- restriction is that the range must fall within the NATURAL
-- range.
TYPE state IS (idle, forward, backward, stop);
-- Một kiểu dữ liệu , điển hình của các máy trạng thái hữu hạn.
TYPE color IS (red, green, blue, white);
-- Kiểu dữ liệu liệt kê khác.
Việc mã hóa các kiểu liệt kê được thực hiện một cách tuần tự và tự
động.
Ví dụ: Cho kiểu màu như ở trên, để mã hóa cần 2 bit ( có 4 trạng
thái), bắt đầu ’00’ được gán cho trạng thái đầu tiên ( red), ‘01’ được gán
cho trạng thái thứ hai (green), ‘10’ kế tiếp (blue) và cuối cùng là trạng thái
‘11’ (while).
3. Các kiểu con (Subtypes).
Kiểu dữ liệu con là một kiểu dữ liệu đi kèm theo điều kiện ràng
buộc. Lý do chính cho việc sử dụng kiểu dữ liệu con để sau đó định ra một
kiểu dữ liệu mới đó là, các thao tác giữa các kiểu dữ liệu khác nhau không
được cho phép, chúng chỉ được cho phép trong trường hợp giữa một kiểu
con và kiểu cơ sở tương ứng với nó.
Ví dụ: kiểu dữ liệu sau đây nhận được các kiểu dữ liệu được giới thiệu
trong các ví dụ phần trước.
SUBTYPE natural IS INTEGER RANGE 0 TO INTEGER'HIGH;
-- NATURAL is a kiểu con (tập con) of INTEGER.
SUBTYPE my_logic IS STD_LOGIC RANGE '0' TO 'Z';
-- Gọi lại STD_LOGIC=('X','0','1','Z','W','L','H','-').
-- Do đó, my_logic=('0','1','Z').
SUBTYPE my_color IS color RANGE red TO blue;
-- khi color=(red, green, blue, white), thì
-- my_color=(red, green, blue).

68
 SUBTYPE small_integer IS INTEGER RANGE -32 TO 32;
-- Một tập con của INTEGER.
Ví dụ: Các phép toán hợp lệ và không hợp lệ giữa các kiểu dữ liệu và các
kiểu dữ liệu con.
SUBTYPE my_logic IS STD_LOGIC RANGE '0' TO '1';
SIGNAL a: BIT;
SIGNAL b: STD_LOGIC;
SIGNAL c: my_logic;
...
b <= a; --không hợp lệ (không thể kết hợp kiểu: BIT với
STD_LOGIC)
b <= c; --hợp lệ (cùng kiểu cơ sở: STD_LOGIC)
4. Mảng (Arrays).
Mảng là một tập hợp các đối tượng có cùng kiểu. Chúng có thể là
một chiều (1D), 2 chiều (2D) họăc một chiều của một chiều (1D x 1D) và
cũng có thể có những kích thước cao hơn.
Hình 3.14 minh họa việc xây dựng một mảng dữ liệu. Một giá trị đơn
( vô hướng được chỉ ra ở (a), một vector ( mảng 1D) ở (b) và một mảng các
vector ( mảng 1Dx1D) ở (c) và mảng của mảng 2D như trong (d)
Thật vậy, các kiểu dữ liệu VHDL được định nghĩa trước đó (mục
3.1) chỉ bao gồm các đại lượng vô hướng-scalar ( bit đơn) và vector ( mảng
một chiểu các bit). Các kiểu dữ liệu có thể kết hợp trong mỗi loại này là
như dưới đây:
_ Scalars: BIT, STD_LOGIC, STD_ULOGIC, and BOOLEAN.
_Vectors:BIT_VECTOR,STD_LOGIC_VECTOR,STD_ULOGIC_VECT
OR,
INTEGER, SIGNED, and UNSIGNED.

Hình 3.14: Minh họa scalar (a), 1D (b), 1Dx1D (c), và 2D (d)
Như có thể thấy, không hề có định nghĩa trước mảng 2D hoặc
1Dx1D, mà khi cần thiết, cần phải được chỉ định bởi người dùng. Để làm
như vậy, một kiểu mới (new TYPE) cần phải được định nghĩa đầu tiên, sau
đó là tín hiệu mới (new SIGNAL), new VARIABLE họăc CONSTANT có
thể được khai báo sử dụng kiểu dữ liệu đó. Cú pháp dưới đây sẽ được dùng:
Để chỉ định một kiểu mảng mới:
TYPE type_name IS ARRAY (specification) OF data_type;
Để tạo sử dụng kiểu mảng mới:

69
 SIGNAL signal_name: type_name [:= initial_value];
Trong cú pháp ở trên, một SIGNAL được khai báo. Tuy nhiên nó
cũng có thể là một CONSTANT hoặc một VARIABLE. Gia trị khởi tạo tùy
chọn.
* Ví dụ mảng 1Dx1D:
Chúng ta muốn xây dựng một mảng chứa 4 vector, mỗi vector có
kích thước là 8 bit, đó là một mảng 1Dx1D ( hình 3.14). Ta gọi mỗi vector
là hàng (row) và mảng hoàn chỉnh là ma trận (matrix). Hơn nữa, chúng ta
muốn bit bên trái cùng của mỗi vector trở thành MSB ( most significant bit)
của nó, và dòng trên cùng trở thành dòng 0. Khi đó sự thực hiện đầy đủ
mảng sẽ là như sau:
TYPE row IS ARRAY (7 DOWNTO 0) OF STD_LOGIC; -- 1D
array
TYPE matrix IS ARRAY (0 TO 3) OF row; -- 1Dx1D array
SIGNAL x: matrix; -- 1Dx1D signal
* Ví dụ mảng 1Dx1D khác:
Cách khác để xây dựng mảng 1Dx1D ở trên còn được thực hiện như
sau:
TYPE matrix IS ARRAY (0 TO 3) OF STD_LOGIC_VECTOR (7
DOWNTO 0);
* Ví dụ mảng 2D:
Mảng sau đây thực sự là hai chiều. Lưu ý rằng việc xây dựng nó dựa
trên các vector, nhưng khá hoàn chỉnh trên các đại lượng vô hướng.
TYPE matrix2D IS ARRAY (0 TO 3, 7 DOWNTO 0) OF STD_LOGIC;
-- 2D array
* Khởi đầu cho mảng:
Như đã thấy trong cú pháp ở trên, giá trị khởi đầu của một SIGNAL
hoặc VARIABLE là tùy chọn. Tuy nhiên, khi việc khởi đầu giá trị được đòi
hỏi, nó có thể được thực hiện như trong ví dụ phía dưới đây:
... :="0001"; -- for 1D array
... :=('0','0','0','1') -- for 1D array
... :=(('0','1','1','1'), ('1','1','1','0')); -- for 1Dx1D or-- 2D array
* Ví dụ: Các phép gán mảng hợp lệ và không hợp lệ
Phép gán trong ví dụ này được dựa trên định nghĩa kiểu và khai báo
các tín hiệu như sau:

TYPE row IS ARRAY (7 DOWNTO 0)OF STD_LOGIC;

-- 1D array
TYPE array1 IS ARRAY (0 TO 3) OF row;
-- 1Dx1D array
TYPE array2 IS ARRAY (0 TO 3) OF STD_LOGIC_VECTOR(7
DOWNTO 0);
-- 1Dx1D

70
 TYPE array3 IS ARRAY (0 TO 3, 7 DOWNTO 0) OF
STD_LOGIC;
-- 2D array
SIGNAL x: row;
SIGNAL y: array1;
SIGNAL v: array2;
SIGNAL w: array3;
--------- Các phép gán vô hướng hợp lệ: ---------------
-- Các phép gán đại lượng vô hướng (bit đơn) dưới đây là hợp lệ,
-- bởi vì kiểu ( vô hướng) cơ bản là STD_LOGIC cho tất cả các tín
hiệu
-- (x,y,v,w).
x(0) <= y(1)(2); -- lưu ý 2 cặp dấu ngoặc đơn
-- (y is 1Dx1D)
x(1) <= v(2)(3); -- 2 cặp dấu ngoặc đơn (v is 1Dx1D)
x(2) <= w(2,1); -- 1 cặp dấu ngoặc đơn (w is 2D)
y(1)(1) <= x(6);
y(2)(0) <= v(0)(0);
y(0)(0) <= w(3,3);
w(1,1) <= x(7);
w(3,0) <= v(0)(3);
--------- Gán vector: ---------------------
x <= y(0); -- hợp lệ (cùng kiểu: ROW)
x <= v(1); -- không hợp lệ (không phù hợp kiểu: ROW và
-- STD_LOGIC_VECTOR)
x <= w(2); -- không hợp lệ (w phải là 2D)
x <= w(2,2 DOWNTO 0);--không hợp lệ (không phù hợp kiểu:
ROW x
-- STD_LOGIC)
v(0)<=w(2,2 DOWNTO 0);--illegal(mismatch:
STD_LOGIC_VECTOR
-- x STD_LOGIC)
v(0) <= w(2); -- illegal (w must have 2D index)
y(1) <= v(3); -- illegal (type mismatch: ROW x
-- STD_LOGIC_VECTOR)
y(1)(7 DOWNTO 3) <= x(4 DOWNTO 0); -- legal (same type,
-- same size)
v(1)(7 DOWNTO 3) <= v(2)(4 DOWNTO 0); -- legal (same type,
-- same size)
w(1,5 DOWNTO 1)<=v(2)(4 DOWNTO 0);-- illegal (type
mismatch)
5. Mảng cổng (Port Array).
Như chúng ta đã biết, không có kiểu dữ liệu được định nghĩa trước
nào có hơn một chiều. Tuy nhiên, trong các đặc điểm của các chân vào

71
hoặc ra (các PORT) của một mạch điện ( mà được xây dựng thành
ENTITY), chúng ta có thể phải cần định rõ các PORT như là mảng các
VECTOR
Khi các khai báo TYPE không được cho phép trong một ENTITY,
giải pháp để khai báo kiểu dữ liệu người dùng định nghĩa trong một
PACKAGE, mà có thể nhận biết toàn bộ thiết kế. Một ví dụ như sau:

------- Package: --------------------------

LIBRARY ieee;
USE ieee.std_logic_1164.all;
----------------------------
PACKAGE my_data_types IS
TYPE vector_array IS ARRAY (NATURAL RANGE <>) OF
STD_LOGIC_VECTOR(7 DOWNTO 0);
END my_data_types;
--------------------------------------------
------- Main code: -------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE work.my_data_types.all; -- user-defined package
---------------------------
ENTITY mux IS
PORT (inp: IN VECTOR_ARRAY (0 TO 3);
... );
END mux;
... ;
--------------------------------------------

Có thể thấy trong ví dụ trên, một kiểu dữ liệu người dùng định nghĩa
được gọi là vector_array, đã được tạo ra, mà nó có thể chứa một số không
xác định các vector, mỗi vector chứa 8 bit. Kiểu dữ liệu được lưu giữ trong
một PACKAGE gọi là my_data_types, và sau đó được sử dụng trong một
ENTITY để xác định một PORT được gọi. Chú ý trong đoạn mã chính bao
gồm thêm cả một mệnh đề USE để thực hiện gói người dùng định nghĩa
my_data_types có thể thấy trong thiết kế.
Chức năng khác cho PACKAGE ở trên sẽ được trình bày dưới đây,
nơi mà có khai báo CONSTANT:
------- Package: -------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
----------------------------
PACKAGE my_data_types IS
CONSTANT b: INTEGER := 7;
TYPE vector_array IS ARRAY (NATURAL RANGE <>) OF

72
 STD_LOGIC_VECTOR(b DOWNTO 0);
END my_data_types;
----------------------------------------------
6. Kiểu bản ghi (Records).
Bản ghi tương tự như mảng, với điểm khác rằng chúng chứa các đối
tượng có kiểu dữ liệu khác nhau.
Ví dụ:

TYPE birthday IS RECORD

day: INTEGER RANGE 1 TO 31;
month: month_name;
END RECORD;

7. Kiểu dữ liệu có dấu và không dấu ( Signed and Unsigned).

Như đã đề cập trước đây, các kiểu dữ liệu này được định nghĩa trong
gói std_logic_arith của thư viện ieee. Cú pháp của chúng được minh họa
trong ví dụ dưới đây:
Ví dụ:
SIGNAL x: SIGNED (7 DOWNTO 0);
SIGNAL y: UNSIGNED (0 TO 3);
Lưu ý rằng cú pháp của chúng tương tự với
STD_LOGIC_VECTOR, không giống như INTEGER.
Một giá trị UNSIGNED là một số không bao giờ nhỏ hơn zero. Ví
dụ, “0101” biểu diễn số thập phân 5, trong khi “1101” là 13. Nhưng nếu
kiểu SIGNED được sử dụng thay vào, giá trị có thể là dương hoặc âm (
theo định dạng bù 2). Do đó, “0101” vẫn biểu diễn số 5, trong khi “1101”
sẽ biểu diễn số -3
Để sử dụng kiểu dữ liệu SIGNED hoặc UNSIGNED, gói
std_logic_arith của thư viện ieee, phải được khai báo. Bất chấp cú pháp của
chúng, kiểu dữ liệu SIGNED và UNSIGNED có hiệu quả chủ yếu đối với
các phép toán số học, nghĩa là, ngược với STD_LOGIC_VECTOR, chúng
chấp nhận các phép toán số học. Ở một khía cạnh khác, các phép toán logic
thì không được phép.
Ví dụ:
Các phép toán hợp lệ và không hợp lệ đối với kiểu dữ liệu
signed/unsigned:
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.std_logic_arith.all; -- gói cần thiết thêm vào
...
SIGNAL a: IN SIGNED (7 DOWNTO 0);
SIGNAL b: IN SIGNED (7 DOWNTO 0);
SIGNAL x: OUT SIGNED (7 DOWNTO 0);
...

73
 v <= a + b; -- hợp lệ (phép toán số học OK)
w <= a AND b; -- không hợp lệ (phép toán logic không OK)

Các phép toán hợp lệ và không hợp lệ với std_logic_vector:

LIBRARY ieee;
USE ieee.std_logic_1164.all; -- không thêm gói đòi hỏi
...
SIGNAL a: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
SIGNAL b: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
SIGNAL x: OUT STD_LOGIC_VECTOR (7 DOWNTO 0);
...
v <= a + b; -- không hợp lệ (phép toán số học không OK)
w <= a AND b; -- hợp lệ (phép toán logic OK)

Ví dụ: Các phép toán số học với std_logic_vector

LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.std_logic_unsigned.all; -- bao gồm gói thêm vào
...
SIGNAL a: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
SIGNAL b: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
SIGNAL x: OUT STD_LOGIC_VECTOR (7 DOWNTO 0);
...
v <= a + b; -- hợp lệ (phép toán số học OK), không dấu
w <= a AND b; -- hợp lệ (phép toán logic OK).

8. Chuyển đổi dữ liệu.

VHDL không cho phép các phép toán trực tiếp ( số học, logic, …)
tác động lên các dữ liệu khác kiểu nhau. Do đó, thường là rất cần thiết đối
với việc chuyển đổi dữ liệu từ một kiểu này sang một kiểu khác. Điều này
có thể được thực hiện trong hai cách cơ bản: hoặc chúng ta viết một ít code
cho điều đó, hoặc chúng ta gọi một FUNCTION từ một gói được định
nghĩa trước mà nó cho phép thực hiện các phép biến đổi cho ta.
Nếu dữ liệu được quan hệ đóng ( nghĩa là 2 toán hạng có cùng kiểu
cơ sở, bất chấp đang được khai báo thuộc về hai kiểu lớp khác nhau), thì
std_logic_1164 của thư viện ieee cung cấp các hàm chuyển đổi dễ thực
hiện.
Ví dụ: các phép toán hợp lệ và không hợp lệ đối với các tập con
TYPE long IS INTEGER RANGE -100 TO 100;
TYPE short IS INTEGER RANGE -10 TO 10;
SIGNAL x : short;
SIGNAL y : long;

74
 ...
y <= 2*x + 5; -- lỗi, không phù hợp kiểu
y <= long(2*x + 5); -- OK, kết quả được chuyển đổi thành kiểu long

Nhiều hàm chuyển đổi dữ liệu có thể được tìm trong gói
std_logic_arith của thư viện ieee:

- conv_integer(p): chuyển đổi một tham số p của kiểu INTEGER,

UNSIGNED, SIGNED, hoặc STD_ULOGIC thành một giá trị INTEGER.
Lưu ý rằng STD_LOGIC_VECTOR không được kể đến.
- conv_unsigned(p, b): chuyển đổi một tham số p của kiểu INTEGER,
UNSIGNED, SIGNED, hoặc STD_ULOGIC thành một giá trị
UNSIGNED với kích cỡ là b bit.
- conv_signed(p, b): chuyển đổi một tham số p của kiểu INTEGER,
UNSIGNED, SIGNED, hoặc STD_ULOGIC thành một giá trị SIGNED
với kích cỡ là b bits.
- conv_std_logic_vector(p, b): chuyển đổi một tham số p thuộc kiểu dữ liệu
INTEGER, UNSIGNED, SIGNED, hoặc STD_LOGIC thành một giá trị
STD_LOGIC_VECTOR với kích thước b bits.
Ví dụ: chuyển đổi dữ liệu:

LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.std_logic_arith.all;
...
SIGNAL a: IN UNSIGNED (7 DOWNTO 0);
SIGNAL b: IN UNSIGNED (7 DOWNTO 0);
SIGNAL y: OUT STD_LOGIC_VECTOR (7 DOWNTO 0);
...
y <= CONV_STD_LOGIC_VECTOR ((a+b), 8);
-- Phép toán hợp lệ: a+b được chuyển đổi từ UNSIGNED thành một
-- giá trị 8-bit STD_LOGIC_VECTOR, sau đó gán cho y.
Một cách khác có thể chọn đã được đề cập đến trong mục trước đây. Nó
bao gồm việc sử dụng các gói std_logic_signed và std_logic_unsigned từ
thư viện ieee. Các gói này cho phép các phép toán với dữ liệu
STD_LOGIC_VECTOR được thực hiện nếu dữ liệu đã là kiểu SIGNED
hoặc UNSIGNED, một cách lần lượt.
9. Tóm tắt.
Các kiểu dữ liệu VHDL tổng hợp cơ bản được tóm tắt trong bảng 3.2

75
 Bảng 3.2. Tổng hợp các kiểu dữ liệu.

10. Một vài ví dụ

* Ví dụ 10.1: Sự phân chia đối với các kiểu dữ liệu
Các phép gán hợp lệ và không hợp lệ được trình bày kế tiếp được
dựa trên các định nghĩa kiểu và các khai báo tín hiệu sau đây:

TYPE byte IS ARRAY (7 DOWNTO 0) OF STD_LOGIC; -- 1D

-- array
TYPE mem1 IS ARRAY (0 TO 3, 7 DOWNTO 0) OF
STD_LOGIC; -- 2D
-- array
TYPE mem2 IS ARRAY (0 TO 3) OF byte; -- 1Dx1D
-- array
TYPE mem3 IS ARRAY (0 TO 3) OF STD_LOGIC_VECTOR(0 TO 7); --
1Dx1D
-- array
SIGNAL a: STD_LOGIC; -- scalar signal
SIGNAL b: BIT; -- scalar signal
SIGNAL x: byte; -- 1D signal
SIGNAL y: STD_LOGIC_VECTOR (7 DOWNTO 0); -- 1D signal
SIGNAL v: BIT_VECTOR (3 DOWNTO 0); -- 1D signal
SIGNAL z: STD_LOGIC_VECTOR (x'HIGH DOWNTO 0); -- 1D
signal
SIGNAL w1: mem1; -- 2D signal
SIGNAL w2: mem2; -- 1Dx1D signal
SIGNAL w3: mem3; -- 1Dx1D signal
-------- Legal scalar assignments: ---------------------
x(2) <= a; -- same types (STD_LOGIC), correct indexing
y(0) <= x(0); -- same types (STD_LOGIC), correct indexing
z(7) <= x(5); -- same types (STD_LOGIC), correct indexing
b <= v(3); -- same types (BIT), correct indexing
w1(0,0) <= x(3); -- same types (STD_LOGIC), correct indexing
Table 3.2
76
 Synthesizable data types.
Data types Synthesizable values
BIT, BIT_VECTOR ‘0’, ‘1’
STD_LOGIC, STD_LOGIC_VECTOR ‘X’, ‘0’, ‘1’, ‘Z’ (resolved)
STD_ULOGIC, STD_ULOGIC_VECTOR ‘X’, ‘0’, ‘1’, ‘Z’
(unresolved)
BOOLEAN True, False
NATURAL From 0 to þ2, 147, 483, 647
INTEGER From _2,147,483,647 to þ2,147,483,647
SIGNED From _2,147,483,647 to þ2,147,483,647
UNSIGNED From 0 to þ2,147,483,647
User-defined integer type Subset of INTEGER
User-defined enumerated type Collection enumerated by user
SUBTYPE Subset of any type (pre- or user-defined)
ARRAY Single-type collection of any type above
RECORD Multiple-type collection of any types above
Data Types 39
TLFeBOOK
w1(2,5) <= y(7); -- same types (STD_LOGIC), correct indexing
w2(0)(0) <= x(2); -- same types (STD_LOGIC), correct indexing
w2(2)(5) <= y(7); -- same types (STD_LOGIC), correct indexing
w1(2,5) <= w2(3)(7); -- same types (STD_LOGIC), correct indexing
------- Illegal scalar assignments: --------------------
b <= a; -- type mismatch (BIT x STD_LOGIC)
w1(0)(2) <= x(2); -- index of w1 must be 2D
w2(2,0) <= a; -- index of w2 must be 1Dx1D
------- Legal vector assignments: ----------------------
x <= "11111110";
y <= ('1','1','1','1','1','1','0','Z');
z <= "11111" & "000";
x <= (OTHERS => '1');
y <= (7 =>'0', 1 =>'0', OTHERS => '1');
z <= y;
y(2 DOWNTO 0) <= z(6 DOWNTO 4);
w2(0)(7 DOWNTO 0) <= "11110000";
w3(2) <= y;
z <= w3(1);
z(5 DOWNTO 0) <= w3(1)(2 TO 7);
w3(1) <= "00000000";
w3(1) <= (OTHERS => '0');
w2<=((OTHERS=>'0'),(OTHERS=>'0'),(OTHERS=>'0'),(OTHERS
=>'0'));
w3 <= ("11111100", ('0','0','0','0','Z','Z','Z','Z',),
(OTHERS=>'0'), (OTHERS=>'0'));

77
 w1 <= ((OTHERS=>'Z'), "11110000" ,"11110000",
(OTHERS=>'0'));
------ Illegal array assignments: ----------------------
x <= y; -- type mismatch
y(5 TO 7) <= z(6 DOWNTO 0); -- wrong direction of y
w1 <= (OTHERS => '1'); -- w1 is a 2D array
w1(0, 7 DOWNTO 0) <="11111111"; -- w1 is a 2D array
w2 <= (OTHERS => 'Z'); -- w2 is a 1Dx1D array
w2(0, 7 DOWNTO 0) <= "11110000"; -- index should be 1Dx1D
-- Example of data type independent array initialization:
FOR i IN 0 TO 3 LOOP
FOR j IN 7 DOWNTO 0 LOOP
x(j) <= '0';
y(j) <= '0'
40 Chapter 3
TLFeBOOK
z(j) <= '0';
w1(i,j) <= '0';
w2(i)(j) <= '0';
w3(i)(j) <= '0';
END LOOP;
END LOOP;
---------------------------------------------------------
* Ví dụ 10.2: Bit đơn và bit vector
Ví dụ này minh họa sự khác nhau giữa phép gán một bit đơn và phép
gán một bit vector (nghĩa là, BIT với BIT_VECTOR, STD_LOGIC với
STD_LOGIC_VECTOR, hoặc STD_ULOGIC với
STD_ULOGIC_VECTOR).
Hai đoạn mã VHDL được giới thiệu phía dưới. Cả hai thực hiện
phép toán AND giữa các tín hiệu vào và gán kết quả đến tín hiệu ra. Chỉ có
một sự khác biệt giữa chúng đó là số lượng bit ở cổng vào và cổng ra ( một
bit trong ví dụ đấu tiên, 4 bits trong ví dụ thứ hai). Mạch điện suy ra từ các
đoạn mã này được biểu diễn trên hình 3.15:
-- code 1---------------------
--------------------------------------------------------
ENTITY and2 IS
PORT (a, b: IN BIT;
x: OUT BIT);
END and2;
--------------------------------------------------------
ARCHITECTURE and2 OF and2 IS
BEGIN
x <= a AND b;
END and2;

78
 --------------------------------------------------------
----code 2---------------
ENTITY and2 IS
PORT (a, b: IN BIT_VECTOR (0 TO 3);
x: OUT BIT_VECTOR (0 TO 3));
END and2;
---------------------------------------------------------------
ARCHITECTURE and2 OF and2 IS
BEGIN
x <= a AND b;
END and2

Hình 3.15. Mạch được suy ra từ mã của ví dụ 10.2

Kết quả mô phỏng trên Active HDL 6.1:
Code 1:

Hình 3.16. Kết quả mô phỏng cho đoạn mã 1 của ví dụ 3.2

Code 2:

Hình 3.17. Kết quả mô phỏng cho đoạn mã 1 của ví dụ 3.2

* Ví dụ 10.3: Bộ cộng ( Adder)

79
 Hình 3.18. Bộ cộng 4 bit

Hình 3.18 cho thấy giản đồ mức đỉnh của một bộ cộng 4 bit, mạch
điện có 2 đầu vào (a,b) và một đầu ra (sum). Có 2 giải pháp được đề cập.
Thứ nhất, tất cả các tín hiệu có kiểu dữ liệu SIGNED, trong khi ở giải pháp
thứ hai đầu ra có kiểu INTEGER. Lưu ý trong giải pháp thứ hai có một
hàm chuyển đổi (conversion function) được sử dụng ở dòng 13, để kiểu của
(a+b) phù hợp với kiểu của tổng. Lưu ý cần bao gồm cả gói std_logic_arith
(dòng 4 của mỗi giải pháp), có mô tả kiểu dữ liệu SIGNED. Nhớ lại rằng
một giá trị SIGNED được mô tả giống như một vector, nghĩa là, tương tự
như STD_LOGIC_VECTOR, không giống INTEGER.
Code:
----------------------------------------
1 ----- Solution 1: in/out=SIGNED ----------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 USE ieee.std_logic_arith.all;
5 ------------------------------------------
6 ENTITY adder1 IS
7 PORT ( a, b : IN SIGNED (3 DOWNTO 0);
8 sum : OUT SIGNED (4 DOWNTO 0));
9 END adder1;
10 ------------------------------------------
11 ARCHITECTURE adder1 OF adder1 IS
12 BEGIN
13 sum <= a + b;
14 END adder1;
15 ------------------------------------------
------------------------------------------------
1 ------ Solution 2: out=INTEGER -----------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 USE ieee.std_logic_arith.all;
5 ------------------------------------------
6 ENTITY adder2 IS
7 PORT ( a, b : IN SIGNED (3 DOWNTO 0);
8 sum : OUT INTEGER RANGE -16 TO 15);
9 END adder2;
10 ------------------------------------------
11 ARCHITECTURE adder2 OF adder2 IS
80
 12 BEGIN
13 sum <= CONV_INTEGER(a + b);
14 END adder2;
15 ------------------------------------------

* Kết quả mô phỏng trên Active HDL 6.1

Hình 3.19. Kết quả mô phỏng

3.2.5. Toán tử và thuộc tính

1.Toán tử.
VHDL cung cấp một số toán tử sau:
 Toán tử gán.
 Toán tử logic.
 Toán tử toán học.
 Toán tử so sánh.
 Toán tử dịch.
Sau đây chúng ta sẽ xem xét cụ thể từng toán tử một.
a. Toán tử gán.
VHDL định nghĩa ba loại toán tử gán sau:
<=: Dùng gán giá trị cho SIGNAL.
:= : Dùng gán giá trị cho VARIABLE, CONSTANT,GENERIC.
=>: Dùng gán giá trị cho thành phần các vector và các loại giá trị
khác.
Ví dụ:
SIGNAL x : STD_LOGIC;
VARIABLE y : STD_LOGIC_VECTOR(3 DOWNTO 0);
SIGNAL w: STD_LOGIC_VECTOR(0 TO 7);
x <= '1';
y := "0000
w <= "10000000";
w <= (0 =>'1', OTHERS =>'0');
b. Toán tử Logic.
VHDL định nghĩa các toán tử logic sau:
NOT, AND, OR, NAND, NOR, XOR, XNOR
Dữ liệu cho các toán tử này phải là kiểu: BIT, STD_LOGIC,
STD_ULIGIC, BIT_VECTOR, STD_LOGIC_VECTOR,
STD_ULOGIC_VECTOR.
Ví dụ:

81
 y <= NOT a AND b;
y <= NOT (a AND b);
y <= a NAND b;
c. Toán tử toán học.
Các toán tử này dùng cho các kiểu dữ liệu số như là:INTEGER,
SIGNED, UNSIGNED, REAL. Các toán tử bao gồm:
+ Toán tử cộng.
- Toán tử trừ.
* Toán tử nhân.
/ Toán tử chia.
** Toán tử lấy mũ.
MOD Phép chia lấy phần nguyên.
REM Phép chia lấy phần dư.
ABS Phép lấy giá trị tuyệt đối.
d. Toán tử so sánh.
Có các toán tử so sánh sau:
= So sánh bằng
/= So sánh không bằng.
< So sánh nhỏ hơn.
> So sánh lớn hơn.
<= So sánh nhỏ hơn hoặc bằng.
>= So sánh lớn hơn hoặc bằng.
e. Toán tử dịch.
Cú pháp sử dụng toán tử dịch là:
<left operand> <shift operation> <right operand>
Trong đó <left operand> có kiểu là BIT_VECTOR, còn <right
operand> có kiểu là INTEGER. Có hai toán tử dịch:
Sll Toán tử dịch trái. Điền 0 vào phía phải.
Rll Toán tử dịch phải. Điền 0 vào phía trái.

2. Thuộc tính.
a. Thuộc tính dữ liệu.
VHDL cung cấp các thuộc tính sau.
d’LOW Trả về giá trị nhỏ nhất của chỉ số mảng.
d’HIGH Trả về chỉ số lớn nhất của mảng.
d’LEFT Trả về chỉ số bên trái nhất của mảng.
d’RIGHT Trả về chỉ số bên phải nhất của mảng.
d’LENGTH Trả về kích thước của mảng.
d’RANGE Trả về mảng chứa chỉ số.
d’REVERSE_RANGE Trả về mảng chứa chỉ số được đảo
ngược.
Ví dụ: Nếu d là một vector được khai báo như sau:
SIGNAL d : STD_LOGIC_VECTOR(0 TO 7)

82
 Ta sẽ có:
d'LOW = 0, d'HIGH = 7, d'LEFT = 7, d'RIGHT = 0, d'LENGTH = 8,
d'RANGE = (7 downto 0), d'REVERSE_RANGE = (0 to 7).
Các thuộc tính này có thể dùng trong các vòng lặp:
FOR i IN RANGE (0 TO 7) LOOP ...
FOR i IN x'RANGE LOOP ...
FOR i IN RANGE (x'LOW TO x'HIGH) LOOP ...
FOR i IN RANGE (0 TO x'LENGTH-1) LOOP ...
Nếu tín hiệu có kiểu liệt kê thì:
d’VAL(pos) Trả về giá trị tại pos.
d’POS(val) Trả về vị trí có giá trị là val.
d’LEFTOF(value) Trả về giá trị ở vị trí bên trái của value.
d’VAL(row,colum) Trả về giá trị ở một vị trí đặc biệt.
b. Thuộc tính tín hiệu.
Các thuộc tính loại này chỉ được áp dụng đối với dữ liệu SIGNAL.
Nếu s là một SIGNAL thì ta có :
s’EVENT : Trả về true khi một sự kiện xảy ra đối với s.
s’STABLE: Trả về true nếu không có sự kiện nào xảy ra đối
với s.
s’ACTIVE: Trả về true khi s = 1.
s’QUIET<time>: Trả về true khi trong khoảng thời gian time khong
có sự kiện nào xảy ra.
s’LAST_EVENT: Trả về thời gian trôi qua kể từ sự kiện cuối
cùng
s’LAST_ACTIVE: Trả về thới gian kể từ lần cuối cùng s = 1
s’LAST_VALUE: Trả về giá trị của s trước sự kiện trước đó.

Trong các thuộc tính trên thì thuộc tính s’EVENT là hay được dùng
nhất.

Vi dụ: Đây là ví dụ với tín hiệu đồng hồ.

IF (clk'EVENT AND clk='1')...
IF (NOT clk'STABLE AND clk='1')...
WAIT UNTIL (clk'EVENT AND clk='1');
IF RISING_EDGE(clk)...

3. Thuộc tính được định nghĩa bởi người dùng.

VHDL, ngoài việc cung cấp các thuộc tính có sẵn nó còn cho phép
người dùng tự định nghĩa các thuộc tính. Các thuộc tính này muốn sử dụng
cần phải khai báo và mô tả rõ ràng theo cấu trúc sau:

ATTRIBUTE <attribute_name>:< attribute_type>;

ATTRIBUTE <attribute_name> OF< target_name>: <class> IS
<value>;

83
 Trong đó
+ attribute_type là kiểu dữ liệu.
+ Class : SIGNAL, TYPE, FUNCTION.
Ví dụ :
ATTRIBUTE number_of_inputs: INTEGER;
ATTRIBUTE number_of_inputs OF nand3: SIGNAL IS 3;
4. Chồng toán tử.
Cũng giống như các thuộc tính được định nghĩa bởi người dùng.
Trong VHDL ta cũng có thể xây dựng chồng các toán tử toán học. Để xây
dựng chồng các toán tử này ta cần phải chỉ rõ loại dữ liệu tham gia. Ví dụ
như toán tử + ở trên chỉ áp dụng cho các loại dữ liệu cùng kiểu số.Bây giờ
ta xây dựng toán tử + dùng để cộng một số INTEGER với một BIT.

FUNCTION "+" (a: INTEGER, b: BIT) RETURN INTEGER IS

BEGIN
IF (b='1') THEN RETURN a+1;
ELSE RETURN a;
END IF;
END "+";

5. GENERIC.
GENERIC là một cách tạo các tham số dùng chung (giống như các
biến static trong các ngôn ngữ lập trình). Mục đích là để cho các đoạn code
mềm dẻo và dễ sử dụng lại hơn.
Một đoạn GENERIC khi được sử dụng cần phải được mô tả trong
ENTITY. Các tham số phải được chỉ rõ. Cấu trúc như sau:

GENERIC (parameter_name : parameter_type :=

parameter_value);

Ví dụ: Ví dụ sau sẽ định nghĩa biến n có kiểu INTEGER và là

GENERIC nó có giá trị mặc định là 8. Khi đó khi n được gọi ở bất kỳ đâu,
trong một ENTITY hay một ARCHITECTURE theo sau đó giá trị của nó
luôn là 8.
ENTITY my_entity IS
GENERIC (n : INTEGER := 8);
PORT (...);
END my_entity;
ARCHITECTURE my_architecture OF my_entity IS
...
END my_architecture;
Có thể có nhiều hơn 1 tham số GENERIC được mô tả trong một
ENTITY. Ví dụ:

84
 GENERIC (n: INTEGER := 8; vector: BIT_VECTOR :=
"00001111");

6. Một số ví dụ.
Để làm rõ hơn các vấn đề đã nói ở trên chúng ta sẽ xem xét một vài
ví dụ sau:
Ví dụ 1: Generic Decoder.
Hình vẽ sau đây mô phỏng một bộ giải mã có hai đầu vào. Một tín
hiệu vào dữ liệu sel gồm m bít và một tín hiệu là ena. Nó có một đầu ra dữ
liệu gồm n bít. Có m = log2(n).

Hình 3.20. Bộ mã hoá

Khi tín hiệu ena = ‘0’ thì tất cả các bít đầu ra x = ‘1’. Đầu ra được
chọn theo đầu vào sel. Chương trình sau đây mô tả về đối tượng này với 3
đầu vào sel và phía đầu ra có 8 đường x.

LIBRARY ieee;
USE ieee.std_logic_1164.all;
ENTITY decoder IS
PORT ( ena : IN STD_LOGIC;
sel : IN STD_LOGIC_VECTOR (2 DOWNTO 0);
x : OUT STD_LOGIC_VECTOR (7 DOWNTO 0));
END decoder;

ARCHITECTURE generic_decoder OF decoder IS

BEGIN
PROCESS (ena, sel)
VARIABLE temp1 : STD_LOGIC_VECTOR (x'HIGH
DOWNTO 0);
VARIABLE temp2 : INTEGER RANGE 0 TO x'HIGH;
BEGIN
temp1 := (OTHERS => '1');
temp2 := 0;
IF (ena='1') THEN
FOR i IN sel'RANGE LOOP

85
 IF (sel(i)='1') THEN
temp2:=2*temp2+1;
ELSE
temp2 := 2*temp2;
END IF;
END LOOP;
temp1(temp2):='0';
END IF;
x <= temp1;
END PROCESS;
END generic_decoder;

Hình sau đây mô tả kết quả hoạt động của bộ giải mã trên.

Hình 3.21. Mô phỏng kết quả của bộ mã hoá

Như chúng ta thấy khi ena =0 thì tất cả các bít phía đầu ra đều bằng 1. Khi
ena = 1 thì chỉ một bít phía đầu ra được chọn tức là bằng 0. Ví dụ như khi
sel=’000’ thì đầu ra x = ‘11111110’, sel = ‘001’ x = ‘11111101’….
Trong ví dụ trên ta đã sử dụng các toán tử +, * , các toán tử gán và
thuộc tính RANGE.

Ví dụ 2 : Generic parity detector.

Ví dụ sau đây mô phỏng một mạch phát hiện tính parity. Nó bao gồm
một đầu vào n bít và một đầu ra. Đầu ra sẽ có giá trị bằng 0 khi số đầu vào
có giá trị là một là một số chẵn và bằng 1 trong các trường hợp còn lại.

Hình 3.22. Bộ phát hiện bít chãn lẻ

Sau đây là mã nguồn mô tả mạch trên.

86
 ENTITY parity_det IS
GENERIC (n : INTEGER := 7);
PORT ( input: IN BIT_VECTOR (n DOWNTO 0);
output: OUT BIT);
END parity_det;

ARCHITECTURE parity OF parity_det IS

BEGIN
PROCESS (input)
VARIABLE temp: BIT;
BEGIN
temp := '0';
FOR i IN input'RANGE LOOP
temp := temp XOR input(i);
END LOOP;
output <= temp;
END PROCESS;
END parity;
Trong đoạn mã trên chúng ta đã sử dụng một mệnh để GENERIC
định nghĩa n =7. Khi đó tất cả các lần n xuất hiện nó đều có giá trị là 7.
Kết quả của mạch được biểu diễn bởi hình sau. Khi đầu vào input
=’00000000’ thì đầu ra output =’0’. Khi input =’00000001’ thì đầu ra
output = ‘1’ vì số đầu vào là 1 là một số lẻ.

Hình 3.23. Mô phỏng kết quả của hình 4.2

Ví dụ 3: Parity Generator

Mạch sau sẽ thêm một bít parity vào tín hiệu input. Bít này là 0 khi
số đầu vào =1 của input là một số chẵn và bằng 0 trong trường hợp ngược
lại. Như vậy mạch sẽ gồm n-1 đầu vào dữ liệu và n đầu ra, trong đó n-1 đầu
ra bên phải giống như n-1 đầu vào, đầu ra còn lại là giá trị kiểm tra parity.

Hình 3.24. Bộ phát bit chẵn lẻ

ENTITY parity_gen IS

87
 GENERIC (n : INTEGER := 7);
PORT ( input: IN BIT_VECTOR (n-1 DOWNTO 0);
output: OUT BIT_VECTOR (n DOWNTO 0));
END parity_gen;

ARCHITECTURE parity OF parity_gen IS

BEGIN
PROCESS (input)
VARIABLE temp1: BIT;
VARIABLE temp2: BIT_VECTOR (output'RANGE);
BEGIN
temp1 := '0';
FOR i IN input'RANGE LOOP
temp1 := temp1 XOR input(i);
temp2(i) := input(i);
END LOOP;
temp2(output'HIGH) := temp1;
output <= temp2;
END PROCESS;
END parity;

Kết quả:
50 100 150 200 250 300 350 400 450 500 ns

input 00 01 02 03 04 05

output 00 81 82 03 84 05

Hình 3.25. Mô phỏng kết quả của ví dụ 4.3

Như ta thấy khi đầu vào input =’0000000’ thì đầu ra output =
‘00000000’. Khi đầu vào input =’0000001’ thì đầu ra output = ‘10000001’.

3.2.6. Mã song song

1. Song song và tuần tự.
Đầu tiên chúng ta sẽ xem xét sự khác biệt giữa mạch tổ hợp và mạch
dãy sau đó sẽ xem sét sự khác biệt giữa mã nguồn tuần tự và mã song song.
a. Mạch tổ hợp và mạch dãy.
Mạch tổ hợp là mạch mà đầu ra của mạch chỉ phụ thuộc vào đầu vào
của hệ tại thời điểm hiện tại. Từ đó ta thấy, hệ này không cần yêu câu bộ
nhớ và chúng được tạo thành chỉ từ các cổng logic cơ bản.
Mạch dãy là mạch mà đầu ra của mạch còn phụ thuộc vào cả đầu vào
trong quá khứ của mạch. Từ đó ta thấy đối với hệ này cần phải có bộ nhớ
và một vòng phản hồi tín hiệu. Hính sau đây mô tả hai loại mạch này.

88
 Hình 3.26. Mạch tổ hợp và mạch dãy

b. Mã song song và mã tuần tự.

Mã nguồn VHDL là song song. Chỉ các đoạn mã trong một
PROCESS, FUNCTION, PROCEDURE là tuần tự. Các khối này được
thực hiện một cách tuần tự. Mã song song đươc gọi là mã luồng dữ liệu (
dataflow code).
Ví dụ. Một đoạn mã gồm ba khối lệnh song song ( stat1, stat 2,
stat3). Khi đó các đoạn sau sẽ thực hiện cùng một lúc trong mạch vật lý.

Hình 3.27. Mã gồm 3 khối lệnh song song

Các đoạn mã song song không thể sử dụng các thành phần của mạch
đồng bộ ( hoạt động chỉ xảy ra khi có sự đồng bộ của xung đồng hồ.). Một
cách khác chúng ta chỉ có thể xây dựng dựa trên các mạch tổ hợp. Trong
mục này chúng ta tìm hiểu về các đoạn mã song song. Chúng ta chỉ tìm
hiểu các đoạn mã được sử dụng bên ngoài PROCESS, FUNCTION,
PROCEDURES. Chúng là các khối lện WHEN và GENERATE. Bên cạnh
đó, các phép gán dùng các toán tử được sử dụng để tạo các mạch tổ hợp.
Cuối cùng một loại khối lện đặc biệt được gọi là BLOCK sẽ được sử dụng.

2. Sử dụng các toán tử.

Đây là cách cơ bản nhất dùng để tạo các đoạn mã song song. Các
toán tử (AND, OR, ..) được tìm hiểu ở trên sẽ được liệt kê ở bảng dưới đây.
Các toán tử có thể được sử dụng như là một thành phần của mạch tổ hợp.
Tuy nhiên để rõ ràng. Các mạch hoàn chỉnh sẽ sử dụng cách viết tuần tự
mặc dù các mạch không chứa các phần tử tuần tự. Các ví dụ sau đây được
thiết kế chỉ sử dụng các thành phần logic cơ bản.

89
 Bảng 3.3. Các toán tử
Ví dụ : Bộ dồn kênh 4 -1.

Hình 3.28. Bộ dồn kênh

Bộ dồn kênh có 4 đầu vào dữ liệu, hai đầu vào điều khiển và một đầu
ra. Tín hiệu đầu ra sẽ là tín hiệu của một trong 4 đầu vào tuỳ theo giá trị
của hai đầu vào điều khiển s0,s1. Sau đây là chương trình mô phỏng.

LIBRARY ieee;
USE ieee.std_logic_1164.all;
---------------------------------------------
ENTITY mux IS
PORT ( a, b, c, d, s0, s1: IN STD_LOGIC;
y: OUT STD_LOGIC);
END mux;
---------------------------------------------
ARCHITECTURE pure_logic OF mux IS
BEGIN
y <= (a AND NOT s1 AND NOT s0) OR
(b AND NOT s1 AND s0) OR
(c AND s1 AND NOT s0) OR
(d AND s1 AND s0);
END pure_logic;
Kết qủa mô phỏng.

90
 50 100 150 200 250 300 350 400 450 500 ns

s0

s1

Hình 3.29. Mô phỏng kết quả

3. Mệnh đề WHEN.
WHEN là môt thành phần của các khối lện song song. Nó xuất hiện
trong hai trường hợp. WHEN / ELSE và WITH / SELECT / WHEN. Cú
pháp được trình bấy như sau.

Ví dụ 1:
------ With WHEN/ELSE -------------------------
outp <= "000" WHEN (inp='0' OR reset='1') ELSE
"001" WHEN ctl='1' ELSE
"010";
---- With WITH/SELECT/WHEN --------------------
WITH control SELECT
output <= "000" WHEN reset,
"111" WHEN set,

UNAFFECTED WHEN OTHERS;

Ví dụ 2: Bộ dồn kênh 4 -1.

Nguyên tắc hoạt động của mạch này ta đã nói ở trên. Ở đây chúng ta
sẽ dùng mệnh đề WHEN thay cho cá toán tử. Chúng ta có thể dùng theo cả
hai cách. Để dễ hiểu chúng ta sẽ xem xét cả hai cách sử dụng mệnh đề
WHEN.
91
 Hình 3.30. Bộ dồn kênh ví dụ 2

------- Sử dụng WHEN/ELSE --------

LIBRARY ieee;
USE ieee.std_logic_1164.all;
-------------------------------------------
ENTITY mux IS
PORT ( a, b, c, d: IN STD_LOGIC;
sel: IN STD_LOGIC_VECTOR (1 DOWNTO 0);
y: OUT STD_LOGIC);
END mux;
-------------------------------------------
ARCHITECTURE mux1 OF mux IS
BEGIN
y <= a WHEN sel="00" ELSE
b WHEN sel="01" ELSE
c WHEN sel="10" ELSE
d;
END mux1;
-------------------------------------------

--- Sử dụng WITH/SELECT/WHEN -----

LIBRARY ieee;
USE ieee.std_logic_1164.all;
-------------------------------------------
ENTITY mux IS
PORT ( a, b, c, d: IN STD_LOGIC;
sel: IN STD_LOGIC_VECTOR (1 DOWNTO 0);
y: OUT STD_LOGIC);
END mux;
-------------------------------------------
ARCHITECTURE mux2 OF mux IS
BEGIN
WITH sel SELECT
y <= a WHEN "00",
b WHEN "01",

92
 c WHEN "10",
d WHEN OTHERS;
END mux2;
--------------------------------------------
Ví dụ 3: Bộ đệm 3 trạng thái.

Hình 3.31. Bộ đệm 3 trạng thái

Mạch bộ đệm 3 trạng thái cho đẩu ra output = input khi ena = 0 và
trở kháng cao khi ena = 1.

LIBRARY ieee;
USE ieee.std_logic_1164.all;
----------------------------------------------
ENTITY tri_state IS
PORT ( ena: IN STD_LOGIC;
input: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
output: OUT STD_LOGIC_VECTOR (7 DOWNTO 0));
END tri_state;
----------------------------------------------
ARCHITECTURE tri_state OF tri_state IS
BEGIN
output <= input WHEN (ena='0') ELSE
(OTHERS => 'Z');
END tri_state;
----------------------------------------------

Kết quả mô phỏng

50 100 150 200 250 300 350 400 450 500 ns

ena

input 01 00 01 00

output 01 00 ZZ 01 ZZ

Hình 3.32. Kết quả mô phỏng cho ví dụ 3

93
Ví dụ 4: Encoder.

Hình 3.33. Bộ mã hoá cho ví dụ 4

Một bộ ENCODER có n đầu vào, m đầu ra với m = log2 (n). Tại một
thời điểm chỉ có một bít đầu vào bằng 1. Sau đây là chương trình mô phỏng
sử dụng WHEN theo cả hai cách dùng WHEN / ELSE,và WITH / SELECT
/ WHEN.
---- sử dụng WHEN/ELSE -------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
---------------------------------------------
ENTITY encoder IS
PORT ( x: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
y: OUT STD_LOGIC_VECTOR (2 DOWNTO 0));
END encoder;
---------------------------------------------
ARCHITECTURE encoder1 OF encoder IS
BEGIN
y <= "000" WHEN x="00000001" ELSE
"001" WHEN x="00000010" ELSE
"010" WHEN x="00000100" ELSE
"011" WHEN x="00001000" ELSE
"100" WHEN x="00010000" ELSE
"101" WHEN x="00100000" ELSE
"110" WHEN x="01000000" ELSE
"111" WHEN x="10000000" ELSE
"ZZZ";
END encoder1;
---------------------------------------------
---- Sử dụng WITH/SELECT/WHEN ------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
---------------------------------------------
ENTITY encoder IS
PORT ( x: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
y: OUT STD_LOGIC_VECTOR (2 DOWNTO 0));
END encoder;

94
 ---------------------------------------------
ARCHITECTURE encoder2 OF encoder IS
BEGIN
WITH x SELECT
y <= "000" WHEN "00000001",
"001" WHEN "00000010",
"010" WHEN "00000100",
"011" WHEN "00001000",
"100" WHEN "00010000",
"101" WHEN "00100000",
"110" WHEN "01000000",
"111" WHEN "10000000",
"ZZZ" WHEN OTHERS;
END encoder2;
---------------------------------------------
Kết quả mô phỏng:

100 200 300 400 500 600 700 800 900 1000 ns

x 00 01 02 03 04 05 06 07 08 09 0A 0B

y Z 0 1 Z 2 Z 3 Z

Hình 3.34. Kết quả mô phỏng cho ví dụ 4

Ví dụ 5: ALU.

Hình 3.35. ALU

Mạch ALU thực hiện các phép toán logic và toán học đối với hai đầu
vào a và b. Chúng được điều khiển bới 4 bít sel(3:0). Tuỳ thuộc vào giá trị
của sel mà khối sẽ thực hiện thao tác nào với dữ liệu. Bảng dưới đây mô tả
các thao tác của ALU.

95
 Hình 3.36. Hoạt động chinh của các phần tử ALU

Mã nguồn thực hiện mô phỏng:

----------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.std_logic_unsigned.all;
----------------------------------------------
ENTITY ALU IS
PORT (a, b: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
sel: IN STD_LOGIC_VECTOR (3 DOWNTO 0);
cin: IN STD_LOGIC;
y: OUT STD_LOGIC_VECTOR (7 DOWNTO 0));
END ALU;
----------------------------------------------
ARCHITECTURE dataflow OF ALU IS
SIGNAL arith, logic: STD_LOGIC_VECTOR (7 DOWNTO 0);
BEGIN
----- Arithmetic unit: ------
WITH sel(2 DOWNTO 0) SELECT
arith <= a WHEN "000",
a+1 WHEN "001",
a-1 WHEN "010",
b WHEN "011",
b+1 WHEN "100",
b-1 WHEN "101",
a+b WHEN "110",
a+b+cin WHEN OTHERS;
----- Logic unit: -----------
WITH sel(2 DOWNTO 0) SELECT
logic <= NOT a WHEN "000",
NOT b WHEN "001",
96
 a AND b WHEN "010",
a OR b WHEN "011",
a NAND b WHEN "100",
a NOR b WHEN "101",
a XOR b WHEN "110",
NOT (a XOR b) WHEN OTHERS;
-------- Mux: ---------------
WITH sel(3) SELECT
y <= arith WHEN '0',
logic WHEN OTHERS;
END dataflow;
----------------------------------------------

Kết quả mô phỏng.

50 100 150 200 250 300 350 400 450 500 ns

a 00 01 02 03 04 05

arith 00 02 02 04 03 05

b 00 01 02 03 04 05

cin

logic FF FE FD FC 04 05

sel 0 1 0 1 2 3

y 00 02 02 04 03 05

Hình 3.37. Kết quả mô phỏng của ví dụ 5

4. GENERATE.
GENERATE là một khối lệnh song song khác. Nó tương đương với
khối lệnh tuần tự LOOP trong việc cho phép các đoạn lệnh được thực hiện
lặp lại một số lần nào đó. Mẫu dùng của nó là FOR / GENERATE.

label: FOR identifier IN range GENERATE

(concurrent assignments)
END GENERATE;
Một cách khác sử dụng GENERATE là dùng IF. Ở đây mệnh đề
ELSE không được sử dụng. Một cách hay được sử dụng là dùng IF trong
FOR/GENERATE.
Mẫu sử dụng như sau.
label1: FOR identifier IN range GENERATE
...
label2: IF condition GENERATE
(concurrent assignments)
END GENERATE;
...
END GENERATE;
Ví dụ:
SIGNAL x: BIT_VECTOR (7 DOWNTO 0);
SIGNAL y: BIT_VECTOR (15 DOWNTO 0);
97
 SIGNAL z: BIT_VECTOR (7 DOWNTO 0);
...
G1: FOR i IN x'RANGE GENERATE
z(i) <= x(i) AND y(i+8);
END GENERATE;
Một điều cần phải chú ý là giới hạn của dãy phải được khai báo là
static nếu không sẽ không hợp lệ. Trong ví dụ sau choice không được khai
báo là static nên không hợp lệ:
NotOK: FOR i IN 0 TO choice GENERATE
(concurrent statements)
END GENERATE;

Để hiểu rõ hơn về khối lệnh GENERATE chúng ta sẽ xét ví dụ sau:

Ví dụ: Vector shifter.
Ví dụ sau minh hoạ cho việc sử dụng GENERATE. Trong đó
đầu vào sẽ được dịch đi một bít và tạo thành đầu ra. Ví dụ đầu vào có 4
đường và giá trị ban đầu là 1111 thì đầu ra sẽ được mô tả như sau:
row(0): 0 0 0 0 1 1 1 1
row(1): 0 0 0 1 1 1 1 0
row(2): 0 0 1 1 1 1 0 0
row(3): 0 1 1 1 1 0 0 0
row(4): 1 1 1 1 0 0 0 0
Chương trình mô phỏng.
------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
------------------------------------------------
ENTITY shifter IS
PORT ( inp: IN STD_LOGIC_VECTOR (3 DOWNTO 0);
sel: IN INTEGER RANGE 0 TO 4;
outp: OUT STD_LOGIC_VECTOR (7 DOWNTO 0));
END shifter;
------------------------------------------------
ARCHITECTURE shifter OF shifter IS
SUBTYPE vector IS STD_LOGIC_VECTOR (7 DOWNTO 0);
TYPE matrix IS ARRAY (4 DOWNTO 0) OF vector;
SIGNAL row: matrix;
BEGIN
row(0) <= "0000" & inp;
G1: FOR i IN 1 TO 4 GENERATE
row(i) <= row(i-1)(6 DOWNTO 0) & '0';
END GENERATE;
outp <= row(sel);
END shifter;

98
 Kết quả mô phỏng:

50 100 150 200 250 300 350 400 450 500 ns

inp 0 1 0 0

outp 00 01 02 03 04

sel 0 1 2 3 4

Hình 3.38. Kết quả mô phỏng của ví dụ 6

Như hình ta thấy, nếu input = “0011”thì đầu ra output =”00000011” khi sel
= 0. output = “00000110” khi sel = 1. output = 00001100 nếu sel = 2.

5. BLOCK.
Có hai loại khối lệnh BLOCK : Simple và Guarded.
a. Simple BLOCK
Khối lệnh BLOCK cho phép đặt một khối lệnh song song vào một
đoạn, điều đó giúp cho các đoạn lệnh dễ đọc và dễ quản lý hơn. Cấu trúc
của chúng như sau:
label: BLOCK
[declarative part]
BEGIN
(concurrent statements)
END BLOCK label;
Các khối lệnh BLOCK đặt liên tiếp nhau như ví dụ sau:
------------------------
ARCHITECTURE example ...
BEGIN
...
block1: BLOCK
BEGIN
...
END BLOCK block1
...
block2: BLOCK
BEGIN
...
END BLOCK block2;
...
END example;
------------------------
Ví dụ:
b1: BLOCK
SIGNAL a: STD_
99
 BEGIN
a <= input_sig
END BLOCK b1;

Một đoạn BLOCK có thể được đặt trong một đoạn BLOCK khác,
khi đó cú pháp như sau:
label1: BLOCK
[declarative part of top block]
BEGIN
[concurrent statements of top block]
label2: BLOCK
[declarative part nested block]
BEGIN
(concurrent statements of nested block)
END BLOCK label2;
[more concurrent statements of top block]
END BLOCK label1;

b. Guarded BLOCK
Một Guarded BLOCK là một khối BLOCK đặc biệt. Nó chứa một
điều kiện và BLOCK chỉ được thực hiện khi điều kiện đó có giá trị là
TRUE.
Cấu trúc như sau:
label: BLOCK (guard expression)
[declarative part]
BEGIN
(concurrent guarded and unguarded statements)
END BLOCK label;
Để tìm hiểu rõ hơn về khối BLOCK ta đi xét ví dụ sau:
Vídụ 1:
Chốt sử dụng Guarded BLOCK. Trong ví dụ này khi nào clk = ‘1’
thì khối đươc hoạt động khi đó khối lệnh sẽ đựơc thực hiện.
-------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
-------------------------------
ENTITY latch IS
PORT (d, clk: IN STD_LOGIC;
q: OUT STD_LOGIC);
END latch;
-------------------------------
ARCHITECTURE latch OF latch IS
BEGIN
b1: BLOCK (clk='1')

100
 BEGIN
q <= GUARDED d;
END BLOCK b1;
END latch;
-------------------------------
Kết quả mô phỏng

100 200 300 400 500 600 700 800 900 1000 ns

clk

Hình 3.39. Kết quả mô phỏng cho ví dụ 5.7

Ví dụ 2:
DFF dùng Guarded BLOCK.Trong ví dụ này chúng ta sẽ xem xét
hoạt động của một Triger T hoạt động đồng bộ sườn dương.
-------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
-------------------------------
ENTITY dff IS
PORT ( d, clk, rst: IN STD_LOGIC;
q: OUT STD_LOGIC);
END dff;
-------------------------------
ARCHITECTURE dff OF dff IS
BEGIN
b1: BLOCK (clk'EVENT AND clk='1')
BEGIN
q <= GUARDED '0' WHEN rst='1' ELSE d;
END BLOCK b1;
END dff;
------------------------------
Kết quả mô phỏng:

100 200 300 400 500 600 700 800 900 1000 ns

clk

rst

Hình 3.40. Kết quả mô phỏng của ví dụ 5.8

101
3.2.7. Mã tuần tự
1. PROCESS
PROCESS là phần tuần tự của mã VHDL. Nó được mô tả bởi các
câu lệnh IF, WAIT, CASE, hoặc LOOP, và bởi danh sách nhạy (ngoại trừ
WAIT được sử dụng). PROCESS phải được cài đặt trong mã chính, và
được thực thi ở mọi thời điểm một tín hiệu trong danh sách nhạy thay đổi.
Cú pháp:

[label:] PROCESS (sensitivity list)

[VARIABLE name type [range] [:= initial_value;]]
BEGIN
(sequential code)
END PROCESS [label];

VARIABLES là tuỳ chọn. Nếu sử dụng, chúng phải được khai báo
trong phần khai báo của PROCESS (trước từ khoá BEGIN). Giá trị khởi
tạo không thể kết hợp, chỉ lấy để đại diện khi mô phỏng.
Nhãn cũng được sử dụng tuỳ chọn, mục đích là nâng cao khả
năng đọc được của mã. Nhãn có thể là bất kỳ từ nào, ngoại trừ từ khoá.

Ví dụ 1:

Hình 3.41. DFF với tín hiệu reset không đồng bộ

10 20 30 40 50 60 70 80 90 ns

rst

clk

Hình 3.42. Kết quả mô phỏng

library IEEE;
use IEEE.STD_LOGIC_1164.all;

entity DFF is
Port(d,clk,rst:in std_logic;

102
 q:out std_logic);
end DFF;

architecture Behaviour of DFF is

begin
process(clk,rst)
begin
-- wait on rst,clk;
if (rst='1') then
q <= '0';
elsif (clk'Event and clk='1') then
q <= d;
end if;
end process;
end Behaviour;

2. Signals và Variables.
VHDL có hai cách định nghĩa các giá trị không tĩnh: bằng SIGNAL
hoặc bằng VARIABLE. SIGNAL có thể được khai báo trong PACKAGE,
ENTITY hoặc ARCHITECTURE (trong phần khai báo của nó), trong khi
VARIABLE có thể được mô tả bên trong một phần của mã tuần tự (trong
PROCESS). Do đó, trong khi giá trị của phần ở trước có thể là toàn cục,
phần ở sau luôn là cục bộ.
Giá trị của VARIABLE có thể không bao giờ định nghĩa ngoài
PROCESS một cách trực tiếp, nếu cần, thì nó phải được gán thành
SIGNAL. Trong cách xử lý khác, cập nhật VARIABLE là tức thì, ta có thể
tính toán tức thì giá trị mới của nó trong dòng lệnh tiếp theo. Điều đó
không phải là trường hợp của SIGNAL (khi được sử dụng trong
PROCESS), giá trị mới của nó chỉ tổng quát được bảo toàn để có thể dùng
được sau khi kết thúc quá trình chạy hiện tại của PROCESS.
Phép toán gán cho SIGNAL là “<=” (sig <= 5), trong khi với
VARIABLE là “:=” (var := 5).

3. IF.
IF, WAIT, CASE, và LOOP là các câu lệnh đối với mã tuần tự. Do
đó, chúng chỉ có thể được sử dụng bên trong PROCESS, FUNCTION hoặc
PROCEDURE.
Về nguyên tắc, có một kết quả phủ định, tổng hợp sẽ tối ưu hoá cấu
trúc và tránh đi sâu vào phần cứng.
Cú pháp:

IF conditions THEN assignments;

ELSIF conditions THEN assignments;
...

103
 ELSE assignments;
END IF;

Ví dụ:

IF (x<y) THEN temp:="11111111";

ELSIF (x=y AND w='0') THEN temp:="11110000";
ELSE temp:=(OTHERS =>'0');

Ví dụ:

Hình 3.43. Bộ đếm chữ số thập phân

10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160 ns

clk

digit 0 1 2 3 4 5 6 7 8 9

Hình 3.44. Kết quả mô phỏng

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY counter IS
PORT (clk : IN STD_LOGIC;
digit : OUT INTEGER RANGE 0 TO 9);
END counter;

ARCHITECTURE counter OF counter IS

BEGIN
count: PROCESS(clk)
VARIABLE temp : INTEGER RANGE 0 TO 10;
BEGIN
IF (clk'EVENT AND clk='1') THEN
temp := temp + 1;
IF (temp=10) THEN temp := 0;
END IF;
END IF;

104
 digit <= temp;
END PROCESS count;
END counter;

Ví dụ:

Hình 3.45. Thanh ghi dịch 4 bit

50 100 150 200 250 300 350 400 450 500 550 600 650 ns

clk

rst

internal U ? ? ? C 6 3 1 0

Hình 3.46. Kết quả mô phỏng

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY shiftreg IS
GENERIC (n: INTEGER := 4); -- # of stages
PORT (d, clk, rst: IN STD_LOGIC;
q: OUT STD_LOGIC);
END shiftreg;

ARCHITECTURE behavior OF shiftreg IS

SIGNAL internal: STD_LOGIC_VECTOR (n-1 DOWNTO 0);
BEGIN
PROCESS (clk, rst)
BEGIN
IF (rst='1') THEN
internal <= (OTHERS => '0');
ELSIF (clk'EVENT AND clk='1') THEN
internal <= d & internal(internal'LEFT DOWNTO 1);
END IF;
END PROCESS;
q <= internal(0);
END behavior;
105
4. WAIT.
Phép toán WAIT đôi khi tương tự như IF. Tuy nhiên, nhiều hơn một
định dạng có thể dùng được. Hơn nữa, khi IF, CASE, hoặc LOOP được sử
dụng, PROCESS không thể có một danh sách nhạy khi WAIT được sử
dụng.

Cú pháp:

WAIT UNTIL signal_condition;

WAIT ON signal1 [, signal2, ... ];
WAIT FOR time;

Câu lệnh WAIT UNTIL nhận chỉ một tín hiệu, do đó thích hợp cho
mã đồng bộ hơn là mã không đồng bộ. Khi PROCESS không có danh sách
nhạy trong trường hợp này, WAIT phải là câu lệnh đầu tiên trong
PROCESS. PROCESS được thực hiện mọi thời điểm khi gặp điều kiện.

Ví dụ:
Thanh ghi 8 bit với tín hiệu reset đồng bộ

PROCESS -- no sensitivity list

BEGIN
WAIT UNTIL (clk'EVENT AND clk='1');
IF (rst='1') THEN
output <= "00000000";
ELSIF (clk'EVENT AND clk='1') THEN
output <= input;
END IF;
END PROCESS;

WAIT ON, trong cách xử lý khác, nhận nhiều tín hiệu. PROCESS
được đặt giữ cho đến khi bất kỳ tín hiệu nào thay đổi. PROCESS sẽ tiếp tục
thực hiện bất kỳ khi nào một thay đổi trong rst hoặc clk xuất hiện.

Ví dụ:
Thanh ghi 8 bit với tín hiệu reset không đồng bộ

PROCESS
BEGIN
WAIT ON clk, rst;
IF (rst='1') THEN
output <= "00000000";
ELSIF (clk'EVENT AND clk='1') THEN

106
 output <= input;
END IF;
END PROCESS;

WAIT FOR chỉ dùng để mô phỏng. Ví dụ: WAIT FOR 5ns;

Ví dụ:
DFF với tín hiệu reset không đồng bộ
5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 ns

rst

clk

Hình 3.47. Kết quả mô phỏng

library IEEE;
use IEEE.STD_LOGIC_1164.all;

entity DFF is
Port(d,clk,rst:in std_logic;
q:out std_logic);
end DFF;

architecture DFF of DFF is

begin
process
begin
wait on rst,clk;
if (rst='1') then
q <= '0';
elsif (clk'Event and clk='1') then
q <= d;
end if;
end process;
end DFF;

Ví dụ:
Bộ đếm một chữ số thập phân 0  9  0
10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160 ns

clk

digit 0 1 2 3 4 5 6 7 8 9

Hình 3.48. Kết quả mô phỏng

107
 LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY counter IS
PORT (clk : IN STD_LOGIC;
digit : OUT INTEGER RANGE 0 TO 9);
END counter;

ARCHITECTURE counter OF counter IS

BEGIN
PROCESS -- no sensitivity list
VARIABLE temp : INTEGER RANGE 0 TO 10;
BEGIN
WAIT UNTIL (clk'EVENT AND clk='1');
temp := temp + 1;
IF (temp=10) THEN
temp := 0;
END IF;
digit <= temp;
END PROCESS;
END counter;

5. CASE.
CASE là lệnh duy nhất cho mã tuần tự (đi kèm với IF, LOOP, và WAIT).
Cú pháp:

CASE identifier IS
WHEN value => assignments;
WHEN value => assignments;
...
END CASE;
Ví dụ:
CASE control IS
WHEN "00" => x<=a; y<=b;
WHEN "01" => x<=b; y<=c;
WHEN OTHERS => x<="0000"; y<="ZZZZ";
END CASE;
Lệnh CASE (tuần tự) tương tự với WHEN (kết hợp). Tất cả sự hoán
vị đều phải được kiểm tra, vì vậy từ khoá OTHERS rất hữu ích. Từ khoá
quan trọng khác là NULL (bản sao của UNAFFECTED), nên được sử dụng
khi không có hoạt động nào thay thế. Ví dụ: WHEN OTHERS => NULL;.
Tuy nhiên, CASE cho phép nhiều phép gán với mỗi điều kiện kiểm tra,
trong khi WHEN chỉ cho phép một.

108
 Giống như trong trường hợp của WHEN, ở đây “WHEN value” có
thể có 3 dạng:

WHEN value -- single value

WHEN value1 to value2 -- range, for enumerated data types
-- only
WHEN value1 | value2 |... -- value1 or value2 or ...

WHEN CASE
Kiểu lệnh Đồng thời Tuần tự
Chỉ ngoài PROCESS, Chỉ trong PROCESS,
Sử dụng FUNCTION, hoặc FUNCTION, hoặc
PROCEDURE PROCEDURE
Tất cả sự hoán vị phải Có với
Có
được kiểm tra WITH/SELECT/WHEN
Số phép gán lớn nhất
1 Bất kỳ
cho mỗi kiểm tra
Từ khoá không kích
UNAFFECTED NULL
hoạt

Bảng 3.49. So sánh giữa WHEN và CASE

Ví dụ:
Với WHEN:

WITH sel SELECT

x <= a WHEN "000",
b WHEN "001",
c WHEN "010",
UNAFFECTED WHEN OTHERS;

Với CASE:

CASE sel IS
WHEN "000" => x<=a;
WHEN "001" => x<=b;
WHEN "010" => x<=c;
WHEN OTHERS => NULL;
END CASE;

Ví dụ:
Bộ dồn kênh MUX 4-1

109
 Với IF:

IF (sel="00") THEN x<=a;

ELSIF (sel="01") THEN x<=b;
ELSIF (sel="10") THEN x<=c;
ELSE x<=d;

Với CASE:

CASE sel IS
WHEN "00" => x<=a;
WHEN "01" => x<=b;
WHEN "10" => x<=c;
WHEN OTHERS => x<=d;
END CASE;

Ví dụ:
DFF với tín hiệu reset không đồng bộ
5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 ns

rst

clk

Hình 3.50. Kết quả mô phỏng

LIBRARY ieee; -- Unnecessary declaration, -- because

USE ieee.std_logic_1164.all; -- BIT was used instead of
-- STD_LOGIC
ENTITY dff IS
PORT (d, clk, rst: IN BIT;
q: OUT BIT);
END dff;
ARCHITECTURE dff3 OF dff IS
BEGIN
PROCESS (clk, rst)
BEGIN
CASE rst IS
WHEN '1' => q<='0';
WHEN '0' =>
IF (clk'EVENT AND clk='1') THEN
q <= d;
END IF;

110
 WHEN OTHERS => NULL;-- Unnecessary,rst is of
-- type BIT
END CASE;
END PROCESS;
END dff3;

Ví dụ:
Bộ đếm hai chữ số thập phân 0  99  0, đầu ra là 2 LED 7 thanh

Hình 3.51. Bộ đếm 2 chữ số thập phân

20 40 60 80 100 120 140 160 180 200 220 240 260 280 300 ns

reset

clk

temp1 0 1 0 1 0 1 2 3 4 0 1

temp2 0

digit1 7E 30 7E 30 7E 30 6D 79 33 7E 30

digit2 7E

Hình 3.52. Kết quả mô phỏng

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY counter IS
PORT (clk, reset : IN STD_LOGIC;
digit1, digit2 : OUT STD_LOGIC_VECTOR (6 DOWNTO 0));
END counter;

ARCHITECTURE counter OF counter IS

BEGIN
PROCESS(clk, reset)
VARIABLE temp1: INTEGER RANGE 0 TO 10;
VARIABLE temp2: INTEGER RANGE 0 TO 10;
111
BEGIN
---------------------- counter: ----------------------
IF (reset='1') THEN
temp1 := 0;
temp2 := 0;
ELSIF (clk'EVENT AND clk='1') THEN
temp1 := temp1 + 1;
IF (temp1=10) THEN
temp1 := 0;
temp2 := temp2 + 1;
IF (temp2=10) THEN
temp2 := 0;
END IF;
END IF;
END IF;
---- BCD to SSD conversion: --------
CASE temp1 IS
WHEN 0 => digit1 <= "1111110"; --7E
WHEN 1 => digit1 <= "0110000"; --30
WHEN 2 => digit1 <= "1101101"; --6D
WHEN 3 => digit1 <= "1111001"; --79
WHEN 4 => digit1 <= "0110011"; --33
WHEN 5 => digit1 <= "1011011"; --5B
WHEN 6 => digit1 <= "1011111"; --5F
WHEN 7 => digit1 <= "1110000"; --70
WHEN 8 => digit1 <= "1111111"; --7F
WHEN 9 => digit1 <= "1111011"; --7B
WHEN OTHERS => NULL;
END CASE;
CASE temp2 IS
WHEN 0 => digit2 <= "1111110"; --7E
WHEN 1 => digit2 <= "0110000"; --30
WHEN 2 => digit2 <= "1101101"; --6D
WHEN 3 => digit2 <= "1111001"; --79
WHEN 4 => digit2 <= "0110011"; --33
WHEN 5 => digit2 <= "1011011"; --5B
WHEN 6 => digit2 <= "1011111"; --5F
WHEN 7 => digit2 <= "1110000"; --70
WHEN 8 => digit2 <= "1111111"; --7F
WHEN 9 => digit2 <= "1111011"; --7B
WHEN OTHERS => NULL;
END CASE;
END PROCESS;
END counter;

112
6. LOOP.
LOOP hữu ích khi một phần của mã phải được thể hiện nhiều lần.
Giống như IF, WAIT, và CASE, LOOP là duy nhất đối với mã tuần tự, vì
vậy nó cũng có thể được sử dụng bên trong PROCESS, FUNCTION, hay
PROCEDURE.
Có nhiều cách sử dụng LOOP.
Cú pháp:

FOR/LOOP: vòng lặp được lặp lại một số lần cố định.

[label:] FOR identifier IN range LOOP

(sequential statements)
END LOOP [label];

WHILE/LOOP: vòng lặp được lặp cho đến khi điều kiện không thảo
mãn.

[label:] WHILE condition LOOP

(sequential statements)
END LOOP [label];

EXIT: sử dụng để kết thúc vòng lặp.

[label:] EXIT [label] [WHEN condition];

NEXT: sử dụng để bỏ qua các bước vòng lặp.

[label:] NEXT [loop_label] [WHEN condition];

Ví dụ:
Với FOR/LOOP:
FOR i IN 0 TO 5 LOOP
x(i) <= enable AND w(i+2);
y(0, i) <= w(i);
END LOOP;

Một đặc điểm quan trọng của FOR/LOOP (tương tự tạo với
GENERATE) là giới hạn tối thiểu phải là tĩnh. Do đó, một khai báo kiểu
“FOR i IN 0 TO choice LOOP”, với choice là một tham số đầu vào (không
tĩnh), không kết hợp tổng quát được.
Ví dụ:
Với WHILE/LOOP
WHILE (i < 10) LOOP
WAIT UNTIL clk'EVENT AND clk='1';

113
 (other statements)
END LOOP;

Ví dụ:
Với EXIT
FOR i IN data'RANGE LOOP
CASE data(i) IS
WHEN '0' => count:=count+1;
WHEN OTHERS => EXIT;
END CASE;
END LOOP;

Ví dụ:
Với NEXT
FOR i IN 0 TO 15 LOOP
NEXT WHEN i=skip; -- jumps to next iteration
(...)
END LOOP;

Ví dụ 6:
Bộ cộng có nhớ 8 bit không dấu.

Hình 3.53. Bộ cộng có nhớ 8 bit không dấu

20 40 60 80 100 120 140 160 180 200 220 240 260 280 300 ns

cin

a 92 40 04 31 86 C6 32

b 24 81 09 63 0D 8D 65

s B7 C2 0D 94 93 53 97

cout

Hình 3.54. Kết quả mô phỏng

Mỗi phần tử của sơ đồ là một bộ cộng đầy đủ.

sj = aj XOR bj XOR cj
cjþ1 = (aj AND bj) OR (aj AND cj) OR (bj AND cj)

114
Cách 1:
Dùng Generic với các VECTOR

----- Solution 1: Generic, with VECTORS --------

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY adder IS
GENERIC (length : INTEGER := 8);
PORT ( a, b: IN STD_LOGIC_VECTOR (length-1 DOWNTO 0);
cin: IN STD_LOGIC;
s: OUT STD_LOGIC_VECTOR (length-1 DOWNTO 0);
cout: OUT STD_LOGIC);
END adder;

ARCHITECTURE adder OF adder IS

BEGIN
PROCESS (a, b, cin)
VARIABLE carry : STD_LOGIC_VECTOR (length DOWNTO 0);
BEGIN
carry(0) := cin;
FOR i IN 0 TO length-1 LOOP
s(i) <= a(i) XOR b(i) XOR carry(i);
carry(i+1) := (a(i) AND b(i)) OR (a(i) AND
carry(i)) OR (b(i) AND carry(i));
END LOOP;
cout <= carry(length);
END PROCESS;
END adder;

Cách 2:
Dùng non-generic với các INTEGER

---- Solution 2: non-generic, with INTEGERS ----

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY adder IS
PORT ( a, b: IN INTEGER RANGE 0 TO 255;
c0: IN STD_LOGIC;
s: OUT INTEGER RANGE 0 TO 255;
c8: OUT STD_LOGIC);
END adder;

115
 ARCHITECTURE adder OF adder IS
BEGIN
PROCESS (a, b, c0)
VARIABLE temp : INTEGER RANGE 0 TO 511;
BEGIN
IF (c0='1') THEN temp:=1;
ELSE temp:=0;
END IF;
temp := a + b + temp;
IF (temp > 255) THEN
c8 <= '1';
temp := temp; ---256
ELSE c8 <= '0';
END IF;
s <= temp;
END PROCESS;
END adder;

Ví dụ:
Bộ dịch đơn giản: dịch vector đầu vào (kích thước 8) ‘0’ hoặc ‘1’ về
phía trái. Khi dịch, bit LSB phải được điền ‘0’. Nếu shift = 0 thì outp = inp;
nếu shift = 1 thì outp(0) = ‘0’ và outp(i) = inp(i-1) với 1  i  7.

Hình 3.55. Bộ dịch đơn giản

116
Kết quả mô phỏng:
20 40 60 80 100 120 140 160 180 200 220 240 260 280 300 ns

inp 00 14 28 3C 50 64 78

shift 0 1

outp 00 14 28 3C A0 C8 F0

Hình 3.56. Kết quả mô phỏng

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY barrel IS
GENERIC (n: INTEGER := 8);
PORT ( inp: IN STD_LOGIC_VECTOR (n-1 DOWNTO 0);
shift: IN INTEGER RANGE 0 TO 1;
outp: OUT STD_LOGIC_VECTOR (n-1 DOWNTO 0));
END barrel;

ARCHITECTURE RTL OF barrel IS

BEGIN
PROCESS (inp, shift)
BEGIN
IF (shift=0) THEN
outp <= inp;
ELSE
outp(0) <= '0';
FOR i IN 1 TO inp'HIGH LOOP
outp(i) <= inp(i-1);
END LOOP;
END IF;
END PROCESS;
END RTL;

Ví dụ:
Bộ đếm số số ‘0’ của một vector nhị phân, bắt đầu từ bên trái
50 100 150 200 250 300 350 400 450 500 550 600 ns

data 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D

zeros 8 7 6 5 4

Hình 3.57. Kết quả mô phỏng

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY LeadingZeros IS
117
 PORT ( data: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
zeros: OUT INTEGER RANGE 0 TO 8);
END LeadingZeros;

ARCHITECTURE behavior OF LeadingZeros IS

BEGIN
PROCESS (data)
VARIABLE count: INTEGER RANGE 0 TO 8;
BEGIN
count := 0;
FOR i IN data'RANGE LOOP
CASE data(i) IS
WHEN '0' => count := count + 1;
WHEN OTHERS => EXIT;
END CASE;
END LOOP;
zeros <= count;
END PROCESS;
END behavior;

7. Bad Clocking.
Trình biên dịch nói chung không có khả năng tổng hợp các mã chứa
các phép gán cho tín hiệu giống nhau tại cả chuyển tiếp của tín hiệu đồng
hồ (clock) tham chiếu (tại sườn dương cộng tại sườn âm). Trong trường
hợp này, trình biên dịch có thể thông báo một thông điệp “signal does not
hold value after clock edge” hoặc tương tự.

Ví dụ:
Bộ đếm phải được tăng tại mọi sự chuyển tiếp của tín hiệu clock
(sườn dương cộng sườn dương)

PROCESS (clk)
BEGIN
IF (clk'EVENT AND clk='1') THEN
counter <= counter + 1;
ELSIF(clk'EVENT AND clk='0') THEN
counter <= counter + 1;
END IF;
...
END PROCESS;

Trình biên dịch có thể còn thông báo rằng tín hiệu counter bị nhân
dồn. Trong trường hợp này, việc biên dịch sẽ bị treo.

118
 Khía cạnh quan trọng khác là thuộc tính EVENT phải có liên quan
tới điều kiện kiểm tra. Ví dụ: lệnh IF (clk’EVENT and clk=’1’) là đúng,
nhưng chỉ sử dụng IF (clk’EVENT) có thể trình biên dịch giả sử một giá trị
kiểm tra mặc định (and clk=’1’) hoặc thông báo một thông điệp “clock not
locally stable”.

PROCESS (clk)
BEGIN
IF (clk'EVENT) THEN
counter := counter + 1;
END IF;
...
END PROCESS;

Khi PROCESS được chạy mọi thời điểm clk thay đổi, bộ đếm có thể
được tăng hai trên mỗi chu kỳ clock. Tuy nhiên, điều này không xảy ra.
Nếu trình biên dịch giả thiết một giá trị mặc định, một mạch lỗi sẽ được
tổng hợp, bởi vì chỉ một sườn của clk sẽ được quan tâm; nếu không có giá
trị mặc định giả thiết, thì một thông điệp lỗi và không có sự biên dịch được
mong muốn.
Nếu một tín hiệu xuất hiện trong danh sách nhạy, nhưng không xuất
hiện trong bất kỳ phép gán nào của PROCESS, thì xem như trình biên dịch
sẽ bỏ qua. Tuy nhiên, một thông điệp “ignored unnecessary pin clk” có thể
được thông báo.

PROCESS (clk)
BEGIN
counter := counter + 1;
...
END PROCESS;

Hai đoạn mã PROCESS sau sẽ được tổng hợp chính xác bởi bất kỳ
trình biên dịch nào. Tuy nhiên, chú ý rằng sử dụng một tín hiệu khác nhau
trong mỗi PROCESS.

PROCESS (clk)
BEGIN
IF (clk'EVENT AND clk='1') THEN
x <= d;
END IF;
END PROCESS;

PROCESS (clk)
BEGIN

119
 IF (clk'EVENT AND clk='0') THEN
y <= d;
END IF;
END PROCESS;

Ví dụ:
RAM (Random Acess Memory), dung lượng 16 từ nhớ x 8 bit

Hình 3.58. RAM

50 100 150 200 250 300 350 400 450 500 550 600 ns

wr_ena

clk

addr 3 4 5 2 3 4 5

data_in 32 33 34 35 36 37 38

data_out UU 32 UU 33 UU 34 UU 32 33 34

Hình 3.59. Kết quả mô phỏng

Mạch có bus dữ liệu vào (data_in), bus dữ liệu ra (data_out), bus địa
chỉ (addr), cộng tín hiệu clock (clk) và các chân cho phép ghi (wr_ena).
Khi wr_ena được xác nhận, tại sườn dương tiếp theo của clk, vector có mặt
tại data_in phải được lưu trữ tại địa chỉ được mô tả bởi addr. Đầu ra,
data_out, bằng cách xử lý khác, phải hiển thị liên tục dữ liệu chọn bởi addr.
Khi wr_ena ở mức thấp, q được nối với đầu vào của flip-flop, và d
được mở, vì vậy không có dữ liệu mới sẽ được ghi vào bộ nhớ. Khi wr_ena
trở về mức cao, d được nối với đầu vào của thanh ghi, vì vậy tại sườn
dương tiếp theo của clk, d sẽ ghi đè giá trị liền trước.

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY ram IS
GENERIC ( bits: INTEGER := 8;-- # of bits per word
words: INTEGER := 16);--#of words in the mem
PORT ( wr_ena, clk: IN STD_LOGIC;
addr: IN INTEGER RANGE 0 TO words-1;
120
 data_in: IN STD_LOGIC_VECTOR (bits-1 DOWNTO 0);
data_out: OUT STD_LOGIC_VECTOR (bits-1 DOWNTO 0));
END ram;

ARCHITECTURE ram OF ram IS

TYPE vector_array IS ARRAY (0 TO words-1) OF
STD_LOGIC_VECTOR (bits-1 DOWNTO 0);
SIGNAL memory: vector_array;
BEGIN
PROCESS (clk, wr_ena)
BEGIN
IF (wr_ena='1') THEN
IF (clk'EVENT AND clk='1') THEN
memory(addr) <= data_in;
END IF;
END IF;
END PROCESS;
data_out <= memory(addr);
END ram;

8. Sử dụng mã tuần tự để thiết kế các mạch tổ hợp.

Mã tuần tự có thể được sử dụng để thực hiện các hệ dãy hay tổ hợp.
Trong trường hợp hệ dãy, các thanh ghi là cần thiết, vì vậy sẽ được suy ra
bởi trình biên dịch. Tuy nhiên, điều này sẽ không xảy ra trong trường hợp
hệ tổ hợp. Hơn nữa, nếu mã được dùng cho hệ tổ hợp, thì bảng thật đầy đủ
nên được môt tả rõ ràng trong mã.
Để thoả mãn các tiêu chuẩn trên có các luật được xét:
- Luật 1: Đảm bảo tất cả tín hiệu đầu vào sử dụng trong PROCESS xuất
hiện trong danh sách nhạy của nó. Trình biên dịch đưa ra cảnh báo nếu một
tín hiệu đầu vào đã cho không được chứa trong danh sách nhạy, và sau đó
xử lý nếu tín hiệu đã được chứa.
- Luật 2: Đảm bảo tất cả tổ hợp các tín hiệu đầu vào/đầu ra được bao gồm
trong mã, bảng thật đầy đủ của mạch có thể được chứa (điều này đúng với
cả mã tuần tự và mã đồng thời). Các đặc tả không đầy đủ của các tín hiệu
đầu ra có thể gây cho việc tổng hợp để suy ra các chốt để giữ các giá trị liền
trước.

Ví dụ:
Thiết kế mạch tổ hợp sai

121
 Hình 3.60. Mạch tổ hợp sai và các bảng thật
50 100 150 200 250 300 350 400 450 500 550 600 ns

sel 0 3 1

Hình 3.61. Kết quả mô phỏng

x hoạt động như một bộ dồn kênh, y = 0 khi sel = “00”, hoặc = 1 nếu
sel = “01”. Tuy nhiên các đặc tả được cung cấp cho y không dầy đủ.

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY example IS
PORT (a, b, c, d: IN STD_LOGIC;
sel: IN INTEGER RANGE 0 TO 3;
x, y: OUT STD_LOGIC);
END example;

ARCHITECTURE example OF example IS

BEGIN
PROCESS (a, b, c, d, sel)
BEGIN
IF (sel=0) THEN
x<=a;
y<='0';
ELSIF (sel=1) THEN
x<=b;
y<='1';
ELSIF (sel=2) THEN
x<=c;
ELSE
x<=d;

122
 END IF;
END PROCESS;
END example;

Sau khi biên dịch, các file báo cáo thể hiện không có flip-flop nào
được suy ra. Giá trị giống nhau của đầu vào (sel = 3 = “11”), hai kết quả
khác nhau cho y (khi sel =3 được đi trước sel = 0, kết quả y = ‘0’, trong khi
y = ‘1’ khi sel = 3 được đi trước sel = 1).
y = (sel(0) AND sel(1)) OR (sel(0) AND y) OR (sel(1) AND y)
Do đó, một chốt (sử dụng các cổng AND/OR) đã được thực hiện, trả
về bảng thật 2. Để tránh sử dụng chốt, nên sử dụng ‘X’ là giá trị không xác
định, lệnh “y <= ‘X’;” phải được chứa dưới các dòng 22 và 24, do đó y =
sel(0).

3.2.8. Signal và Variable

VHDL cung cấp hai đối tượng để giải quyết các giá trị dữ liệu không
tĩnh (non-static): SIGNAL và VARIABLE. Nó còn cung cấp các cách để
thiết lập các giá trị mặc định (static): CONSTANT và GENERIC.
CONSTANT và GENERIC có thể là toàn cục và có thể được sử
dụng trong cả kiểu mã, đồng thời hoặc tuần tự. VARIABLE là cục bộ,
chỉ có thể được sử dụng bên trong một phần của mã tuần tự (trong
PROCESS, FUNCTION, hoặc PROCEDURE).
1. CONSTANT.
CONSTANT phục vụ cho việc thiết lập các giá trị mặc định.
Cú pháp:
CONSTANT name : type := value;
Ví dụ:

CONSTANT set_bit : BIT := '1';

CONSTANT datamemory : memory := (('0','0','0','0'),
('0','0','0','1'),
('0','0','1','1'));

CONSTANT có thể được khai báo trong PACKAGE, ENTITY và

ARCHITECTURE. Khi khai báo trong gói (package), nó là toàn cục, gói
có thể được sử dụng bởi nhiều thực thể (entity). Khi khai báo trong thực thể
(sau PORT), nó là toàn cục với tất cả các kiến trúc (architecture) theo thực
thể. Khi khai báo trong kiến trúc (trong phần khai báo của nó), nó chỉ toàn
cục với mã của kiến trúc đó.
2. SIGNAL.
SIGNAL phục vụ giải quyết các giá trị vào và ra của mạch, cũng như
là giữa các đơn vị bên trong của nó. Tín hiệu biểu diễn cho việc kết nối
mạch (các dây). Thể hiện là, tất cả các PORT của ENTITY là các tín hiệu
mặc định.

123
Cú pháp:
SIGNAL name : type [range] [:= initial_value];

Ví dụ:
SIGNAL control: BIT := '0';
SIGNAL count: INTEGER RANGE 0 TO 100;
SIGNAL y: STD_LOGIC_VECTOR (7 DOWNTO 0);
Khai báo của SIGNAL có thể được tạo ra ở các chỗ giống nhau như
là khai báo CONSTANT.
Khía cạnh quan trọng của SIGNAl, khi sử dụng bên trong một phần
của mã tuần tự (PROCESS), sự cập nhật nó không tức thì. Giá trị mới của
không nên được đợi để được đọc trước khi kết thúc PROCESS,
FUNCTION, hoặc PROCEDURE tương ứng.
Phép toán gán cho SIGNAL là “<=” (count <= 35;). Giá trị khởi tạo
không thể tổng hợp được, chỉ được xét khi mô phỏng.
Khía cạnh khác ảnh hưởng đến kết quả khi nhiều phép gán được tạo
cùng SIGNAL. Trình biên dịch có thể thông báo và thoát sự tổng hợp, hoặc
có thể suy ra mạch sai (bằng cách chỉ xét phép gán cuối cùng). Do đó, việc
xét lập các giá trị khởi tạo, nên được thực hiện với VARIABLE.

Ví dụ:

Bộ đếm số số ‘1’ trong một vector nhị phân

20 40 60 80 100 120 140 160 180 200 220 240 260 280 300 ns

din 00 01 02 03 04 05 06

temp 0 1 2 3 4 5 6

ones 0 1 2 3 4 5

Hình 3.62. Kết quả mô phỏng

LIBRARY ieee;
USE ieee.std_logic_1164.all;
ENTITY count_ones IS
PORT ( din: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
ones: OUT INTEGER RANGE 0 TO 8);
END count_ones;

ARCHITECTURE not_ok OF count_ones IS

SIGNAL temp: INTEGER RANGE 0 TO 8;
BEGIN
PROCESS (din)
BEGIN
temp <= 0;
FOR i IN 0 TO 7 LOOP
124
 IF (din(i)='1') THEN
temp <= temp + 1;
END IF;
END LOOP;
ones <= temp;
END PROCESS;
END not_ok;
3. VARIABLE
Ngược lại với CONSTANT và SIGNAL, VARIABLE chỉ biểu diễn
thông tin cục bộ. Nó chỉ có thể được sử dụng bên trong PROCESS,
FUNCTION, hay PROCEDURE (trong mã tuần tự). Việc cập nhật giá trị
của nó là tức thì, vì vậy giá trị mới có thể được lập tức sử dụng trong dòng
lệnh tiếp theo của mã.
Cú pháp:
VARIABLE name : type [range] [:= init_value];
Ví dụ:
VARIABLE control: BIT := '0';
VARIABLE count: INTEGER RANGE 0 TO 100;
VARIABLE y: STD_LOGIC_VECTOR (7 DOWNTO 0) :=
"10001000";

Khi VARIABLE chỉ có thể được sử dụng trong mã tuần tự, khai báo
của nó chỉ có thể được thực hiện trong phần khai báo của PROCESS,
FUNCTION, hay PROCEDURE.
Phép toán gán của VARIABLE là “:=” (count:=35;). Cũng giống
như trường hợp của SIGNAl, giá trị khởi tạo không thể tổng hợp được, chỉ
được xét khi mô phỏng.

Ví dụ: Bộ đếm số số ‘1’ của một vector nhị phân

Khi cập nhật biến là tức thì, giá trị khởi tạo được thiết lập chính xác
và không có thông báo nào về nhiều phép gán do trình biên dịch.
50 100 150 200 250 300 350 400 450 500 550 600 ns

din 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D

ones 0 1 2 1 2 3 1 2 3 2 3

Hình 3.63. Kết quả mô phỏng

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY count_ones IS
PORT ( din: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
ones: OUT INTEGER RANGE 0 TO 8);
END count_ones;

125
ARCHITECTURE ok OF count_ones IS
BEGIN
PROCESS (din)
VARIABLE temp: INTEGER RANGE 0 TO 8;
BEGIN
temp := 0;
FOR i IN 0 TO 7 LOOP
IF (din(i)='1') THEN
temp := temp + 1;
END IF;
END LOOP;
ones <= temp;
END PROCESS;
END ok;

SIGNAL VARIABLE
Phép gán <= :=
Tính năng Biểu diễn sự kết nối Biểu diễn thông tin
các mạch (các dây) cục bộ
Phạm vi Có thể là toàn cục (trênCục bộ (chỉ trong
toàn bộ mã) PROCESS,
FUNCTION, hay
PROCEDURE tương
ứng)
Hoạt động Cập nhật không tức thì Cập nhật tức thì (giá
trong mã tuần tự (giá trị mới có thể được sử
trị mới chỉ có thể dùng dụng trong dòng lệnh
lúc kết thúc tiếp theo của mã)
PROCESS,
FUNCTION, hay
PROCEDURE)
Sử dụng Trong PACKAGE, Chỉ trong mã tuần tự,
ENTITY, hay trong PROCESS,
ARCHITECTURE. FUNCTION, hay
Trong ENTITY, tất cả PROCEDURE
các PORT là các
SIGNAL mặc định

Bảng 3.4. So sánh giữa SIGNAL và VARIABLE

126
Ví dụ: Bộ dồn kênh 4-1

Hình 3.64. Bộ dồn kênh 4-1

Cách 1: Sử dụng SIGNAL (không đúng)

-- Solution 1: using a SIGNAL (not ok) --

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY mux IS
PORT ( a, b, c, d, s0, s1: IN STD_LOGIC;
y: OUT STD_LOGIC);
END mux;
ARCHITECTURE not_ok OF mux IS
SIGNAL sel : INTEGER RANGE 0 TO 3;
BEGIN
PROCESS (a, b, c, d, s0, s1)
BEGIN
sel <= 0;
IF (s0='1') THEN sel <= sel + 1;
END IF;
IF (s1='1') THEN sel <= sel + 2;
END IF;
CASE sel IS
WHEN 0 => y<=a;
WHEN 1 => y<=b;
WHEN 2 => y<=c;
WHEN 3 => y<=d;
END CASE;
END PROCESS;
END not_ok;

Cách 2: Sử dụng VARIABLE (đúng)

-- Solution 2: using a VARIABLE (ok) ----
LIBRARY ieee;
127
 USE ieee.std_logic_1164.all;

ENTITY mux IS
PORT ( a, b, c, d, s0, s1: IN STD_LOGIC;
y: OUT STD_LOGIC);
END mux;

ARCHITECTURE ok OF mux IS
BEGIN
PROCESS (a, b, c, d, s0, s1)
VARIABLE sel : INTEGER RANGE 0 TO 3;
BEGIN
sel := 0;
IF (s0='1') THEN sel := sel + 1;
END IF;
IF (s1='1') THEN sel := sel + 2;
END IF;
CASE sel IS
WHEN 0 => y<=a;
WHEN 1 => y<=b;
WHEN 2 => y<=c;
WHEN 3 => y<=d;
END CASE;
END PROCESS;
END ok;

Một lỗi thường xuyên khi sử dụng SIGNAL là không nhớ nó có thể
yêu cầu một khoảng thời gian để cập nhật. Do đó, phép gán sel <= sel + 1
(dòng 16) trong cách 1, kết quả cộng thêm 1 bất kể giá trị vừa được tạo liền
trước cho sel, với phép gán sel <= 0 (dòng 15) có thể không có thời gian để
tạo. Điều này đúng với với sel <= sel +2 (dòng 18). Đây không là vấn đề
khi sử dụng VARIABLE, phép gán của nó luôn tức thì.
Khía cạnh thứ 2 có thể là một vấn đề trong cách 1 là hơn một phép
toán đang được tạo cho cùng SIGNAL (sel, dòng 15, 16, và 18), có thể
không được chấp nhận. Tóm lại, chỉ một phép gán với SIGNAL được phép
bên trong PROCESS, vì vậy phần mềm chỉ xét phép gán cuối cùng (sel <=
sel +2) hoặc đơn giản là đưa ra thông báo lỗi và kết thúc việc biên dịch.
Đây cũng không bao giờ là vấn đề khi sử dụng VARIABLE.

128
 20 40 60 80 100 120 140 160 180 200 220 240 260 280 300 ns

s0

s1

50 100 150 200 250 300 350 400 450 500 550 600 ns

s0

s1

Hình 3.65. Kết quả mô phỏng cách 1 và 2

Ví dụ: DFF với q và qbar

Hình 3.65. DFF

Cách 1: Không đúng

---- Solution 1: not OK ---------------

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY dff IS
PORT ( d, clk: IN STD_LOGIC;
q: BUFFER STD_LOGIC;
qbar: OUT STD_LOGIC);
END dff;

ARCHITECTURE not_ok OF dff IS

BEGIN
PROCESS (clk)
BEGIN
IF (clk'EVENT AND clk='1') THEN
q <= d;
qbar <= NOT q;
129
 END IF;
END PROCESS;
END not_ok;
Cách 2: Đúng
---- Solution 2: OK -------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY dff IS
PORT ( d, clk: IN STD_LOGIC;
q: BUFFER STD_LOGIC;
qbar: OUT STD_LOGIC);
END dff;
ARCHITECTURE ok OF dff IS
BEGIN
PROCESS (clk)
BEGIN
IF (clk'EVENT AND clk='1') THEN
q <= d;
END IF;
END PROCESS;
qbar <= NOT q;
END ok;
Trong cách 1, các phép gán q<=d (dòng 16) và qbar<=NOT q (dòng
17) đều đồng bộ, vì vậy các giá trị mới của chúng sẽ chỉ được dùng lúc kết
thúc PROCESS. Đây là vấn đề đối với qbar, bởi vì giá trị mới của q không
vừa mới tạo ra. Do đó, qbar sẽ nhận giá trị đảo giá trị cũ của q. Giá trị
đúng của qbar sẽ bị trễ một chu kỳ đồng hồ, gây cho mạch làm việc không
chính xác.
Trong cách 2, thay qbar<=NOT q (dòng 30) bên ngoài PROCESS,
do đó phép tính như một biểu thức đồng thời đúng.
50 100 150 200 250 300 350 400 450 500 550 600 ns

clk

qbar

50 100 150 200 250 300 350 400 450 500 550 600 ns

clk

qbar

Hình 3.66. Kết quả mô phỏng cách 1 và 2

130
Ví dụ: Bộ chia tần, chia tần số clock bởi 6.

Hình 3.67. Bộ chia tần

Thực hiện hai đầu ra, một là dựa trên SIGNAL (count1), và một dựa
trên VARIABLE (count2).
20 40 60 80 100 120 140 160 180 200 220 240 260 280 300 ns

clk

count1 0 1 2 3 4 5 6 7

count2 0 1 2 3 4

out1

out2

Hình 3.68. Kết quả mô phỏng

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY freq_divider IS
PORT ( clk : IN STD_LOGIC;
out1, out2 : BUFFER STD_LOGIC);
END freq_divider;

ARCHITECTURE example OF freq_divider IS

SIGNAL count1 : INTEGER RANGE 0 TO 7;
BEGIN
PROCESS (clk)
VARIABLE count2 : INTEGER RANGE 0 TO 7;
BEGIN
IF (clk'EVENT AND clk='1') THEN
count1 <= count1 + 1;
count2 := count2 + 1;
IF (count1 = 7 ) THEN
out1 <= NOT out1;
count1 <= 0;
END IF;
IF (count2 = 7 ) THEN
out2 <= NOT out2;
count2 := 0;
131
 END IF;
END IF;
END PROCESS;
END example;
4. Số thanh ghi.
Số flip-flop được suy ra từ mã bởi trình biên dịch. Mục đích là không
chỉ hiểu tiếp cận yêu cầu số thanh ghi tối thiểu, mà còn đảm bảo đoạn mã
thực hiện mạch mong muốn.
Một SIGNAL sinh một flip-flop bất cứ khi nào một phép gán được
tạo ra tại sự chuyển tiếp của tín hiệu khác, khi một phép gán đồng bộ xảy
ra. Phép gán đồng bộ, có thể chỉ xảy ra bên trong PROCESS, FUNCTION,
hay PROCEDURE (thường là một khai báo kiểu “IF signal’EVENT …”
hoặc “WAIT UNTIL …”).
Một VARIABLE sẽ không sinh các flip-flop cần thiết nếu giá trị của
nó không bao giờ rời PROCESS (hoặc FUNCTION, hoặc PROCEDURE).
Tuy nhiên, nếu một giá trị được gán cho một biến tại sự chuyển tiếp của tín
hiệu khác, và giá trị thậm chí được đưa tới một tín hiệu (rời PROCESS), thì
các flip-flop sẽ được suy ra. Một VARIABLE còn sinh một thanh ghi khi
nó được sử dụng trước một giá trị vừa được gán cho nó.
Ví dụ:
Trong PROCESS, output1 và output2 đều sẽ được lưu trữ (suy ra các
flip-flop), bởi vì cả hai đều được gán tại sự chuyển tiếp của tín hiệu khác
(clk).

PROCESS (clk)
BEGIN
IF (clk'EVENT AND clk='1') THEN
output1 <= temp; -- output1 stored
output2 <= a; -- output2 stored
END IF;
END PROCESS;

Trong PROCESS tiếp theo, chỉ output1 được lưu trữ (output2 sẽ tạo
cách sử dụng các cổng logic).

PROCESS (clk)
BEGIN
IF (clk'EVENT AND clk='1') THEN
output1 <= temp; -- output1 stored
END IF;
output2 <= a; -- output2 not stored
END PROCESS;

Trong PROCESS, biến temp sẽ gây ra tín hiệu x để lưu trữ

132
 PROCESS (clk)
VARIABLE temp: BIT;
BEGIN
IF (clk'EVENT AND clk='1') THEN
temp <= a;
END IF;
x <= temp; -- temp causes x to be stored
END PROCESS;
Ví dụ: DFF với q và qbar
Cách 1 có 2 phép gán SIGNAL đồng bộ (dòng 16-17), vì vậy 2 flip-
flop sẽ được sinh. Cách 2 có một trong các phép gán là đồng bộ, việc tổng
hợp sẽ luôn suy ra chỉ một flip-flop

Hình 3.69. Các mạch suy ra từ mã của cách 1 và 2

50 100 150 200 250 300 350 400 450 500 550 600 ns

clk

qbar

50 100 150 200 250 300 350 400 450 500 550 600 ns

clk

qbar

Hình 3.70. Kết quả mô phỏng cách 1 và 2

Cách 1: Sinh hai DFF

---- Solution 1: Two DFFs ---------------

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY dff IS
133
 PORT ( d, clk: IN STD_LOGIC;
q: BUFFER STD_LOGIC;
qbar: OUT STD_LOGIC);
END dff;

ARCHITECTURE two_dff OF dff IS

BEGIN
PROCESS (clk)
BEGIN
IF (clk'EVENT AND clk='1') THEN
q <= d; -- generates a register
qbar <= NOT d; -- generates a register
END IF;
END PROCESS;
END two_dff;

Cách 2: Sinh một DFF

---- Solution 2: One DFF ----------------

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY dff IS
PORT ( d, clk: IN STD_LOGIC;
q: BUFFER STD_LOGIC;
qbar: OUT STD_LOGIC);
END dff;

ARCHITECTURE one_dff OF dff IS

BEGIN
PROCESS (clk)
BEGIN
IF (clk'EVENT AND clk='1') THEN
q <= d; -- generates a register
END IF;
END PROCESS;
qbar <= NOT q; -- uses logic gate (no register)
END one_dff;

Ví dụ: Bộ đếm 0 - 7

134
 Hình 3.71. Bộ đếm 0 – 7
Cách 1:
Một phép gán VARIABLE đồng bộ được tao ra (dòng 14-15). Một
VARIABLE có thể sinh các thanh ghi bởi vì phép gán của nó (dòng 15) tại
sự chuyển tiếp của tín hiệu khác (clk, dòng 14) và giá trị của nó không rời
PROCESS (dòng 17).

------ Solution 1: With a VARIABLE --------

ENTITY counter IS
PORT ( clk, rst: IN BIT;
count: OUT INTEGER RANGE 0 TO 7);
END counter;

ARCHITECTURE counter OF counter IS

BEGIN
PROCESS (clk, rst)
VARIABLE temp: INTEGER RANGE 0 TO 7;
BEGIN
IF (rst='1') THEN
temp:=0;
ELSIF (clk'EVENT AND clk='1') THEN
temp := temp+1;
END IF;
count <= temp;
END PROCESS;
END counter;

Cách 2:
Một phép gán SIGNAL đồng bộ xảy ra (dòng 13-14). Chỉ sử dụng
các SIGNAL. Chú ý, khi không có tín hiệu phụ được sử dụng, count cần
được khai báo như kiểu BUFFER (dòng 14), bởi vì nó được gán một giá trị
và cũng được đọc (sử dụng) nội tại (dòng 14). Một SIGNAL, giống như
một VARIABLE, có thể cũng được tăng khi sử dụng trong mã tuần tự.

------ Solution 2: With SIGNALS only -------

ENTITY counter IS

135
 PORT ( clk, rst: IN BIT;
count: BUFFER INTEGER RANGE 0 TO 7);
END counter;

ARCHITECTURE counter OF counter IS

BEGIN
PROCESS (clk, rst)
BEGIN
IF (rst='1') THEN
count <= 0;
ELSIF (clk'EVENT AND clk='1') THEN
count <= count + 1;
END IF;
END PROCESS;
END counter;

Từ 2 cách trên, 3 flip-flop được suy ra (để giữ 3 bit tín hiệu đầu ra count).
50 100 150 200 250 300 350 400 450 500 550 600 ns

rst

clk

count 0 1 2 3 4 5 6 7

50 100 150 200 250 300 350 400 450 500 550 600 ns

rst

clk

count 0 1 2 3 4 5 6 7

Hình 3.72. Kết quả mô phỏng cách 1 và 2

Ví dụ 7.4c: Thanh ghi dịch 4 cấp

Hình 3.73. Thanh ghi dịch 4 cấp

Cách 1:
3 VARIABLE được sử dụng (a, b, và c, dòng 10). Tuy nhiên các
biến được sử dụng trước các giá trị được gán cho chúng (đảo ngược thứ tự,
bắt đầu với dout, dòng 13, và kết thúc với din, dòng 16). Kết quả là, các
flip-flop sẽ được suy ra, lưu trữ các giá trị từ phép chạy liền trước của
PROCESS.

136
 -------- Solution 1: -----------------
ENTITY shift IS
PORT ( din, clk: IN BIT;
dout: OUT BIT);
END shift;

ARCHITECTURE shift OF shift IS

BEGIN
PROCESS (clk)
VARIABLE a, b, c: BIT;
BEGIN
IF (clk'EVENT AND clk='1') THEN
dout <= c;
c := b;
b := a;
a := din;
END IF;
END PROCESS;
END shift;

Cách 2:
Các biến được thay thế bởi các SIGNAL (dòng 8), và các phép gán
được tạo ra trong thứ tự trực tiếp (từ din-dout, dòng 13-16). Khi các phép
gán tín hiệu tại sự chuyển tiếp tín hiệu khác sinh các thanh ghi, mạch đúng
sẽ được suy ra.

-------- Solution 2: -----------------

ENTITY shift IS
PORT ( din, clk: IN BIT;
dout: OUT BIT);
END shift;

ARCHITECTURE shift OF shift IS

SIGNAL a, b, c: BIT;
BEGIN
PROCESS (clk)
BEGIN
IF (clk'EVENT AND clk='1') THEN
a <= din;
b <= a;
c <= b;
dout <= c;
END IF;
END PROCESS;

137
 END shift;
Cách 3:
Các biến giống nhau của cách 1 đã bị chiếm, nhưng trong thứ tự trực
tiếp (từ din-dout, dòng 13-16). Tuy nhiên, một phép gán cho một biến là
tức thì, và khi các biến đang được sử dụng trong thứ tự trực tiếp (sau khi
các giá trị vừa được gán cho chúng), dòng 13-15 thành 1 dòng, tương
đương với c:=din. Giá trị của c rời PROCESS trong dòng tiếp theo (dòng
16), khi một phép gán tín hiệu (dout <= c) xảy ra tại sự chuyển tiếp của clk.
Do đó, một thanh ghi sẽ được suy ra từ cách 3, nên không tạo kết quả mạch
chính xác.

-------- Solution 3: -----------------

ENTITY shift IS
PORT ( din, clk: IN BIT;
dout: OUT BIT);
END shift;

ARCHITECTURE shift OF shift IS

BEGIN
PROCESS (clk)
VARIABLE a, b, c: BIT;
BEGIN
IF (clk'EVENT AND clk='1') THEN
a := din;
b := a;
c := b;
dout <= c;
END IF;
END PROCESS;
END shift;

Đầu ra dout là bốn sườn clock dương sau đầu vào din ở cách 1,
nhưng chỉ một sườn dương sau đầu vào ở cách 2.
50 100 150 200 250 300 350 400 450 500 550 600 ns

din

clk

dout

50 100 150 200 250 300 350 400 450 500 550 600 ns

din

clk

dout

138
 50 100 150 200 250 300 350 400 450 500 550 600 ns

din

clk

dout

Hình 3.74. Kết quả mô phỏng cách 1, 2, và 3

Ví dụ: Thanh ghi dịch 4 bit

Hình 3.75. Thanh ghi dịch 4 bit

Bit ra (q) phải là 4 sườn clock dương sau bit vào (d). Reset phải là
không đồng bộ, xoá tất cả các đầu ra flip-flop về ‘0’ khi kích hoạt.
Cách 1:
Sử dụng một SIGNAL để sinh các flip-flop. Các thanh ghi được tạo
bởi vì một phép gán cho một tín hiệu được tạo ra tại sự chuyển tiếp của tín
hiệu khác (dòng 17-18).

---- Solution 1: With an internal SIGNAL ---

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY shiftreg IS
PORT ( d, clk, rst: IN STD_LOGIC;
q: OUT STD_LOGIC);
END shiftreg;

ARCHITECTURE behavior OF shiftreg IS

SIGNAL internal: STD_LOGIC_VECTOR (3 DOWNTO 0);
BEGIN
PROCESS (clk, rst)
BEGIN
IF (rst='1') THEN
internal <= (OTHERS => '0');
ELSIF (clk'EVENT AND clk='1') THEN
internal <= d & internal(3 DOWNTO 1);
END IF;
END PROCESS;
139
 q <= internal(0);
END behavior;

Cách 2:
Sử dụng một VARIABLE. Phép gán tại sự chuyển tiếp của tín hiệu
khác được tạo ra cho một biến (dòng 17-18), nhưng khi giá trị của nó rời
PROCESS (nó được chuyển đến một port trong dòng 20), nó cũng suy ra
các thanh ghi.

-- Solution 2: With an internal VARIABLE ---

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY shiftreg IS
PORT ( d, clk, rst: IN STD_LOGIC;
q: OUT STD_LOGIC);
END shiftreg;

ARCHITECTURE behavior OF shiftreg IS

BEGIN
PROCESS (clk, rst)
VARIABLE internal: STD_LOGIC_VECTOR (3 DOWNTO 0);
BEGIN
IF (rst='1') THEN
internal := (OTHERS => '0');
ELSIF (clk'EVENT AND clk='1') THEN
internal := d & internal(3 DOWNTO 1);
END IF;
q <= internal(0);
END PROCESS;
END behavior;

Các mạch được tổng hợp là giống nhau (4 flip-flop được suy ra).
50 100 150 200 250 300 350 400 450 500 550 600 ns

clk

rst

internal 0 1 0 1 0 1 0 1 0

Hình 3.76. Kết quả mô phỏng

140
3.2.9. Máy trạng thái
Một thiết kế mạch số có thể được chia làm 2 thành phần: bộ xử lý dữ
liệu và bộ điều khiển. Mối quan hệ giữa bộ điều khiển và bộ xử lý dữ liệu
trong mạch được biểu diễn
Máy trạng thái hữu hạn (FSM) là một công nghệ mô hình hoá đặc
biệt cho các mạch logic tuần tự. Mô hình đó có thể rất được giúp đỡ trong
thiết kế của những loại hệ thống nào đó, đặc biệt là các thao tác của những
hệ thống đó theo khuôn dạng tuần tự hoàn toàn xác định.
1. Giới thiệu.
Hình sau đây chỉ ra sơ đồ khối của một máy trạng thái một pha.
Trong hình này, phần mạch dãy chứa các mạch dãy (flip-flops), phần cao
chứa mạch logic tổ hợp.

Hình 3.77. Sơ đồ máy trạng thái

Phần mạch tổ hợp có 2 đầu vào và 2 đầu ra:

+ Đầu vào thứ nhất: là đầu vào trạng thái hiện tại của máy.
+ Đầu vào thứ 2: là đầu vào từ bên ngoài.
+ Đầu ra thứ nhất: là đầu ra phía ngoài
+ Đầu ra thứ 2: là trạng thái tiếp theo của máy.
Phần mạch dãy có:
+ 3 đầu vào: clock, reset, và trạng thái tiếp theo
+ 1 đầu ra: trạng thái hiện tại.
Tất cả các flip-flop đều nằm trong phần này, các tín hiệu clock và
reset phải được kết nối với các flip – flop để thực hiện việc điều khiển.
Như vậy, một máy ôtômát hữu hạn là một bộ 6 thông số <X, Y, S, s0,
, >, trong đó:
 X - Tập hợp các tín hiệu vào của ôtômat:
X = { x1(t),…,xn(t)}
 Tập các tín hiệu ra của ôtômat:
Y = {y1(t),…,ym(t)}

141
  Tập hợp các trạng thái của ôtômat:
S = {s1(t),…,ss(t)}
 Hàm (s, x) – hàm chuyển trạng thái của ôtômat
 Hàm (s,x) – hàm đầu ra của ôtômat.

Tương ứng với các phương pháp tính toán hàm chuyển trạng thái và
hàm ra, chúng ta có các loại ôtômat khác nhau. Hai dạng ôtômat hữu hạn
chuyên dụng là: ôtômat Moore và ôtômat Mealy.
Quay lại với hình vẽ trên, mạch cần thiết kế được chia làm hai đoạn.
Việc chia đoạn như thế này sẽ giúp chúng ta thiết kế tốt hơn. Chúng ta sẽ
thiết kế 2 phần theo những cách khác nhau. Cụ thể trong môi trường
VHDL, phần mạch dãy chúng ta sẽ thực hiện trong PROCESS và phần
mạch tổ hợp chúng ta có thể thực hiện theo cấu trúc hoặc tuần tự hoặc kết
hợp cả cấu trúc lẫn tuần tự. Tuy nhiên mã tuần tự có thể áp dụng cho cả 2
loại logic: tổ hợp và tuần tự.
Thông thường các tín hiệu clock và các tín hiệu reset trong phần
mạch dãy sẽ xuất hiện trong PROCESS (trừ khi tín hiệu reset là đồng bộ
hoặc không được sử dụng, tín hiệu WAIT được sử dụng thay cho lệnh IF).
Khi tín hiệu reset được xác nhận, trạng thái hiện tại sẽ được thiết lập cho
trạng thái khởi tạo của hệ thống. Mặt khác, tại sườn đồng hồ thực tế, các
flip-flop sẽ lưu trữ trạng thái tiếp theo, do đó sẽ chuyển nó tới đầu ra của
phần mạch dãy (trạng thái hiện tại).
Một điều quan trọng liên quan tới phương pháp FSM là : về nguyên
tắc chung là bất kỳ một mạch dãy nào cũng có thể được mô hình hoá thành
1 máy trạng thái, nhưng điều này không phải luôn luôn thuận lợi. Vì có
nhiều trường hợp (đặc biệt là các mạch thanh ghi như: bộ đếm,…) nếu thiết
kế theo phương pháp FSM thì mã nguồn có thể trở nên dài hơn, phức tạp
hơn, mắc nhiều lỗi hơn so với phương pháp thông thường.
Như thành một quy tắc nhỏ, phương pháp FSM thì thích hợp với các
hệ thống mà thao tác của nó là một dãy hoàn toàn được cấu trúc, ví dụ: các
mạch điều khiển số. Vì đối với các hệ thống loại này thì tất cả các trạng
thái của nó có thể dễ dàng được liệt kê. Khi soạn thảo mã VHDL, thì các
trạng thái này sẽ được khai báo trong phần đầu của phần
ARCHITECTURE dưới dạng kiểu dữ liệu liệt kê được định nghĩa bởi
người sử dụng.

2. Thiết kế theo kiểu 1 (thiết kế theo mô hình may moore).

Có vài phương pháp có thể được hình thành để thiết kế một FSM.
Chúng ta sẽ mô tả chi tiết một ví dụ mẫu mà mạch hoàn toàn được cấu trúc
và dễ dàng áp dụng. Trong đó phần mạch dãy của máy trạng thái sẽ tách
biệt với phần mạch tổ hợpcủa nó (hình vẽ trên).
Tất cả các trạng thái của máy luôn luôn được khai báo rõ ràng bằng
cách sử dụng kiểu dữ liệu liệt kê.

142
Thiết kế phần mạch dãy:
Trên hình trên, các flip-flop nằm ở phần mạch dãy. Các đầu vào từ
bên ngoài của phần này là các tín hiệu clock và reset. Các tín hiệu này được
nối với các Flip-flop. Một đầu vào khác (bên trong) là trạng thái tiếp theo.
Đầu ra duy nhất của phần này là trang thái hiện tại. Để xây dựng cho phần
mạch dãy này, ta cần sử dụng cấu trúc PROCESS. Trong cấu trúc của
PROCESS chúng ta co thể sẽ sử dụng các câu lệnh tuần tự như lệnh IF,
WAIT, CASE, LOOP.
Khuôn mẫu thiết kế của phần mạch dãy sẽ như sau:

PROCESS (reset, clock)

BEGIN

IF reset = ‘1’ THEN

Trang_thai_hien_tai <= Trang_thai_0 ;

ELSIF (clock ‘EVENT and clock = ‘’) THEN

Mã chỉ ra ở đây là rất đơn giản. Nó chỉ chứa một tín hiệu reset đồng
bộ. Tín hiệu reset này sẽ xác định trạng thái khởi đầu của hệ thống, sau đó
là lưu trữ đồng bộ trạng thái tiếp theo (tại sườn dương đông hồ),và đưa ra
đầu ra của phần mạch dãy trạng thái hiện tại.
Việc thiết kế cho phần mạch dãy này thì đơn giản vì nó là một chuẩn
cơ bản, và số lượng các thanh ghi là tối thiểu. Ở phần 7.5, chúng ta biết
rằng số lượng các flip – flop sẽ tính dựa vào số bits cần thiết để mã hoá tất
cả các trạng thái của FSM. Bởi vậy nếu mẫu được mã hoá theo cách mặc
định (mã hoá nhị phân) thì, chúng ta sẽ cần log2n Flip-flop, với n là số
trạng thái.

Thiết kế phần mạch tổ hợp:

Ở hình 1, thì phần mạch tổ hợp là đầy đủ, vì vậy mã của nó sẽ không
cần thiết theo tuần tự. Tốt nhất, chúng ta nên sử dụng mã đồng thời. Song
trong ví dụ mẫu dưới đây chúng ta sẽ sử dụng mã tuần tự với câu lệnh
CASE đóng vai trò trung tâm.

PROCESS (input, pr_state)

BEGIN
CASE pr_state IS
WHEN state0 =>
IF (input = ...) THEN
output <= <value>;
nx_state <= state1;
ELSE ...
143
 END IF;
WHEN state1 =>
IF (input = ...) THEN
output <= <value>;
nx_state <= state2;
ELSE ...
END IF;
WHEN state2 =>
IF (input = ...) THEN
output <= <value>;
nx_state <= state2;
ELSE ...
END IF;
...
END CASE;
END PROCESS;

Đoạn mã ở đây cũng rất đơn giản, và nó sẽ thực hiện 2 công việc chính:
+ Gán giá trị cho đầu ra.
+ Thiết lập trang thái tiếp theo.

Mẫu máy trạng thái cho kiểu thiết kế 1:

Dưới đây là khuôn mẫu hoàn chỉnh về kiểu thiết kế 1:
LIBRARY ieee;
USE ieee.std_logic_1164.all;
-----------------------------------------------------
ENTITY <entity_name> IS
PORT ( input: IN <data_type>;
reset, clock: IN STD_LOGIC;
output: OUT <data_type>);
END <entity_name>;
-----------------------------------------------------
ARCHITECTURE <arch_name> OF <entity_name> IS
TYPE state IS (state0, state1, state2, state3, ...);
SIGNAL pr_state, nx_state: state;
BEGIN
---------- Phần mạch dãy: ------------------------
PROCESS (reset, clock)
BEGIN
IF (reset='1') THEN
pr_state <= state0;
ELSIF (clock'EVENT AND clock='1') THEN
pr_state <= nx_state;
END IF;

144
 END PROCESS;
---------Phần mạch tổ hợp: ------------------------
PROCESS (input, pr_state)
BEGIN
CASE pr_state IS
WHEN state0 =>
IF (input = ...) THEN
output <= <value>;
nx_state <= state1;
ELSE ...
END IF;
WHEN state1 =>
IF (input = ...) THEN
output <= <value>;
nx_state <= state2;
ELSE ...
END IF;
WHEN state2 =>
IF (input = ...) THEN
output <= <value>;
nx_state <= state3;
ELSE ...
END IF;
...
END CASE;
END PROCESS;
END <arch_name>;

Ví dụ: Bộ đếm BCD

Một bộ đếm là một ví dụ của máy Moore, đầu ra chỉ phụ thuộc vào
kết quả của trạng thái hiện tại. Giống như một mạch thanh ghi và một mạch
dãy đơn giản. Để thiết kế mạch này, chúng ta có thể dùng phương pháp
thông thường như những phần mạch mạch tổ hợp, nhưng ở đây ta sẽ dùng
phương pháp FSM.
Giả sử ta cần thiết kế bộ đếm modul 10. Như vậy chúng ta sẽ cần có
một máy có 10 trang thái. Các trạng thái ở đây được gọi là zero,
one,…,nine. Đồ hình trạng thái của máy được cho như sau:

145
 Hình 3.78. Sơ đồ trạng thái của bộ đếm BCD

Mã VHDL cũng giống như khuôn mẫu của thiết kế mẫu 1. Trong đó:
kiểu dữ liệu liệt kê sẽ xuất hiện ở dòng 11 – 12, thiết kế của phần mạch dãy
sẽ từ dòng 16 đến dòng 23, thiết kế của phần mạch tổ hợp (mạch tổ hợp) sẽ
xuất hiện từ dòng 25 – 29. Do có 10 trang thái nên số lượng cac thanh ghi
bằng là [log210 ]= 4.

Mã thiết kế sẽ như sau:

-------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
-------------------------------------------------
ENTITY counterBCD IS
PORT ( clk, rst: IN STD_LOGIC;
count: OUT STD_LOGIC_VECTOR (3 DOWNTO 0));
END counterBCD;
-------------------------------------------------
ARCHITECTURE state_machine OF counterBCD IS
TYPE state IS (zero, one, two, three, four,
five, six, seven, eight, nine);
SIGNAL pr_state, nx_state: state;
BEGIN
------------- Phan mach day: -----------------
PROCESS (rst, clk)
BEGIN
IF (rst='1') THEN
pr_state <= zero;
ELSIF (clk'EVENT AND clk='1') THEN
pr_state <= nx_state;
END IF;

146
 END PROCESS;
------------- Phan mach to hop: -----------------
PROCESS (pr_state)
BEGIN
CASE pr_state IS
WHEN zero =>
count <= "0000";
nx_state <= one;
WHEN one =>
count <= "0001";
nx_state <= two;
WHEN two =>
count <= "0010";
nx_state <= three;
WHEN three =>
count <= "0011";
nx_state <= four;
WHEN four =>
count <= "0100";
nx_state <= five;
WHEN five =>
count <= "0101";
nx_state <= six;
WHEN six =>
count <= "0110";
nx_state <= seven;
WHEN seven =>
count <= "0111";
nx_state <= eight;
WHEN eight =>
count <= "1000";
nx_state <= nine;
WHEN nine =>
count <= "1001";
nx_state <= zero;
END CASE;
END PROCESS;
END state_machine;
-------------------------------------------------
Mô phỏng kết quả:

147
 Hình 3.79. Kết quả mô phỏng của bộ đếm BCD

Ví dụ: Máy trạng thái kết thúc kiểu 1

Hình 3.80 là sơ đồ khối của 1 FSM đơn giản. Hệ thống có 2 trạng
thái: trạng thái A và trạng thái B. Máy phải chuyển trạng thái khi nhận
được d = 1 và đầu ra mong muốn là x = a khi máy ở trạng thái A hoặc x = b
khi máy ở trạng thái B.

Hình 3.80. Máy trạng thái

Mã thiết kế sẽ như sau:

-------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
----------------------------------------------
ENTITY vd_FSM IS
PORT ( a, b, d, clk, rst: IN BIT;
x: OUT BIT);
END vd_FSM;
----------------------------------------------
ARCHITECTURE state_machine OF vd_FSM IS
TYPE state IS (stateA, stateB);
SIGNAL pr_state, nx_state: state;
BEGIN
---------- Phan mach day: ----------------------
PROCESS (rst, clk)
BEGIN
IF (rst='1') THEN
pr_state <= stateA;
ELSIF (clk'EVENT AND clk='1') THEN
pr_state <= nx_state;
148
 END IF;
END PROCESS;
---------- Phan mach to hop: -----------------
PROCESS (a, b, d, pr_state)
BEGIN
CASE pr_state IS
WHEN stateA =>
x <= a;
IF (d='1') THEN nx_state <= stateB;
ELSE nx_state <= stateA;
END IF;
WHEN stateB =>
x <= b;
IF (d='1') THEN nx_state <= stateA;
ELSE nx_state <= stateB;
END IF;
END CASE;
END PROCESS;
END state_machine;
----------------------------------------------

Kết quả mô phỏng:

Hình 3.81. Kết quả mô phỏng cho ví dụ

3. Thiết kế kiểu 2.
Như chúng ta thấy trong kiểu thiết kế 1 thì chỉ có trạng thái hiện tại
được lưu trữ. Trong trường hợp này nếu mạch là máy Mealy (đầu ra của nó
phụ thuộc vào đầu vào hiện tại), đầu ra có thể thay đổi khi đầu vào thay đổi
(đầu ra không đồng bộ).
Trong nhiều ứng dụng, tín hiệu được yêu cầu là đồng bộ, thì đầu ra
sẽ chỉ cập nhật khi thay đổi sườn clock. Để tạo ra máy đồng bộ Mealy, đầu
ra phải được lưu trữ tốt.

149
 Hình 3.82. Sơ đồ mạch kiểu 1

Hình 3.83. Sơ đồ mạch kiểu 2

Để thực hiện cấu trúc mới này, chúng ta cần có vài sự thay đổi so với
thiết kế kiểu 1. Ví dụ, chúng ta có thể sử dụng một tín hiệu thêm (như tín
hiệu trung gian) để tính toán giá trị đầu ra (đoạn trên), nhưng chỉ chuyển
các giá trị của nó thành tín hiệu đầu ra khi sự kiện clock thay đổi (phần
mạch dãy). Sự thay đổi này chúng ta sẽ thấy trong khuôn mẫu chỉ ra dưới
đây:
Khuôn mẫu máy trạng thái của thiết kế 2

LIBRARY ieee;

USE ieee.std_logic_1164.all;

-----------------------------------------------------
--

ENTITY <ent_name> IS

PORT (input: IN <data_type>;

reset, clock: IN STD_LOGIC;

output: OUT <data_type>);

END <ent_name>;

-----------------------------------------------------
--

ARCHITECTURE <arch_name> OF <ent_name> IS

TYPE states IS (state0, state1, state2, state3, ...);

SIGNAL pr_state, nx_state: states;

150
 ---------- Phan mach to hop: ------------------------
--

PROCESS (pr_state)

BEGIN

CASE pr_state IS

WHEN state0 =>

temp <= <value>;

IF (condition) THEN nx_state <=

state1;

...

END IF;

WHEN state1 =>

So sánh khuôn mẫu của thiết kế kiểu 2 với thiết kế kiểu 1, chúng ta
thấy chỉ có một sự khác nhau duy nhất, đó là xuất hiện tín hiệu trung gian
temp. Tín hiệu này sẽ có tác dụng lưu trữ đầu ra của máy. Chỉ cho các giá
trị chuyển thành đầu ra khi khi có sự thay đổi sự kiện clock.

Ví dụ:
Chúng ta sẽ nhìn lại thiết kế của ví dụ trên. Tuy nhiên ở đây chúng ta
muốn đầu ra là đồng bộ (chỉ thay đổi khi có sự kiện thay đổi clock). Vì vậy
trong ví dụ này chúng ta sẽ thiết kế theo kiểu 2.

----------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.all;
----------------------------------------------
ENTITY VD_FSM2 IS
PORT ( a, b, d, clk, rst: IN BIT;
x: OUT BIT);
END VD_FSM2;
----------------------------------------------
ARCHITECTURE VD_FSM2 OF VD_FSM2 IS
TYPE state IS (stateA, stateB);
SIGNAL pr_state, nx_state: state;
SIGNAL temp: BIT;
BEGIN
151
 ----- Phan mach day: ----------------------
PROCESS (rst, clk)
BEGIN
IF (rst='1') THEN
pr_state <= stateA;
ELSIF (clk'EVENT AND clk='1') THEN
x <= temp;
pr_state <= nx_state;
END IF;
END PROCESS;
---------- Phan mach to hop: -----------------
PROCESS (a, b, d, pr_state)
BEGIN
CASE pr_state IS
WHEN stateA =>
temp <= a;
IF (d='1') THEN nx_state <= stateB;
ELSE nx_state <= stateA;
END IF;
WHEN stateB =>
temp <= b;
IF (d='1') THEN nx_state <= stateA;
ELSE nx_state <= stateB;
END IF;
END CASE;
END PROCESS;
END VD_FSM2;
----------------------------------------------

Ở đây chúng ta thấy có 2 flip – flop được sử dụng, một cái để mã hoá
trạng thái của máy, một cái để lưu trữ đầu ra.
Bộ mô phỏng kết quả được chỉ ra trong hình dưới đây:

Hình 3.84. Kết quả mô phỏng

152
Ví dụ. Bộ phát hiện chuỗi
Chúng ta muốn thiết kế một mạch mà đầu vào là luồng bit nối tiếp và
đầu ra là 1 khi đầu có xuât hiện chuỗi “111”, là 0 trong các trường hợp còn
lại
Đồ hình trạng thái của máy được chỉ ra trong hình 8. Ở đây chúng ta
có 4 trạng thái và chúng ta quy ước là trạng thái zero, one, tow, three.
+ Trang thái 0 là trạng thái chờ 1 đầu tiên.
+ Trang thai 1 là trang thái đã có 1 và chờ 1 thứ 2
+ Trạng thái 2 là trạng thái đã có 11 và đang chờ 1 thứ 3.
+ Trạng thái 3 là trạng thái thu đựơc xâu 111.

Hình 3.85. Sơ đồ trạng thái của bộ phát hiện chuỗi

Mã của máy được thiết kế như sau:

----------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.all;
----------------------------------------------
ENTITY Bo_doan_xau IS
PORT ( d, clk, rst: IN BIT;
q: OUT BIT);
END Bo_doan_xau;
--------------------------------------------
ARCHITECTURE state_machine OF Bo_doan_xau IS
TYPE state IS (zero, one, two, three);
SIGNAL pr_state, nx_state: state;
BEGIN
--------- Phan mach day: --------------------
PROCESS (rst, clk)
BEGIN
IF (rst='1') THEN
pr_state <= zero;
ELSIF (clk'EVENT AND clk='1') THEN
pr_state <= nx_state;

153
 END IF;
END PROCESS;
---------- Phan mach to hop: ---------------
PROCESS (d, pr_state)
BEGIN
CASE pr_state IS
WHEN zero =>
q <= '0';
IF (d='1') THEN nx_state <= one;
ELSE nx_state <= zero;
END IF;
WHEN one =>
q <= '0';
IF (d='1') THEN nx_state <= two;
ELSE nx_state <= zero;
END IF;
WHEN two =>
q <= '0';
IF (d='1') THEN nx_state <= three;
ELSE nx_state <= zero;
END IF;
WHEN three =>
q <= '1';
IF (d='0') THEN nx_state <= zero;
ELSE nx_state <= three;
END IF;
END CASE;
END PROCESS;
END state_machine;
--------------------------------------------
Kết quả mô phỏng sẽ như sau:

Hình 3.86. .Kết quả mô phỏng cho bộ đoán nhận xâu.

Ví dụ: Bộ điều khiển đèn giao thông (TLC)
Như đã giới thiệu ở phần mạch mạch tổ hợp, bộ điều khiển số là
mạch ví dụ tốt để có thể thực hiện hiệu quả khi mô hình hoá máy trạng thái.
Trong ví dụ này, chúng ta sẽ thiết kế một TLC với những đặc điểm được
tóm lược như trong hình :
154
 Hình 3.87. Sơ đồ nguyên lý hoạt động của TLC

Hình 3.88. Đồ hình trạng thái của TLC

Ở đây chúng ta thấy có 3 chế độ thao tác:
+ Chế độ bình thường: Ở chế độ này, mạch có 4 trạng thái, mỗi trạng
thái là độc lập, thời gian lập trình ….?
+ Chế độ kiểm tra: Cho phép tất cả thời gian được lập trình trước
được viết lên với 1 giá trị nhỏ, do vậy hệ thống có thể dễ dàng được kiểm
tra trong suốt quá trình baỏ dưỡng.
+ Chế độ Standby: Nếu thiết lập hệ thống sẽ kích hoạt đèn vàng
trong khi tín hiệu standby được kích hoạt.
Đồng thời 1 đông hồ tần số 60 HZ luôn hoạt động.
Mã thiết kế:

------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.all;
ENTITY Bodk_den_giao_thong IS
PORT ( clk, stby, test: IN STD_LOGIC;
r1, r2, y1, y2, g1, g2: OUT STD_LOGIC);
END Bodk_den_giao_thong;
-------------------------------------------------

155
ARCHITECTURE state_machine_be OF Bodk_den_giao_thong IS
CONSTANT timeMAX : INTEGER := 2700;
CONSTANT timeRG : INTEGER := 1800;
CONSTANT timeRY : INTEGER := 300;
CONSTANT timeGR : INTEGER := 2700;
CONSTANT timeYR : INTEGER := 300;
CONSTANT timeTEST : INTEGER := 60;
TYPE state IS (RG, RY, GR, YR, YY);
SIGNAL pr_state, nx_state: state;
SIGNAL time : INTEGER RANGE 0 TO timeMAX;
BEGIN
-------------Phan mach day: ----
PROCESS (clk, stby)
VARIABLE count : INTEGER RANGE 0 TO timeMAX;
BEGIN
IF (stby='1') THEN
pr_state <= YY;
count := 0;
ELSIF (clk'EVENT AND clk='1') THEN
count := count + 1;
IF (count = time) THEN
pr_state <= nx_state;
count := 0;
END IF;
END IF;
END PROCESS;
----------- Phan mach to hop: ----
PROCESS (pr_state, test)
BEGIN
CASE pr_state IS
WHEN RG =>
r1<='1';r2<='0';y1<='0'; y2<='0'; g1<='0'; g2<='1';
nx_state <= RY;
IF (test='0') THEN time <= timeRG;
ELSE time <= timeTEST;
END IF;
WHEN RY =>
r1<='1';r2<='0';y1<='0';y2<='1';g1<='0'; g2<='0';
nx_state <= GR;
IF (test='0') THEN time <= timeRY;
ELSE time <= timeTEST;
END IF;
WHEN GR =>
r1<='0';r2<='1';y1<='0';y2<='0';g1<='1'; g2<='0';

156
 nx_state <= YR;
IF (test='0') THEN time <= timeGR;
ELSE time <= timeTEST;
END IF;
WHEN YR =>
r1<='0';r2<='1';y1<='1'; y2<='0'; g1<='0'; g2<='0';
nx_state <= RG;
IF (test='0') THEN time <= timeYR;
ELSE time <= timeTEST;
END IF;
WHEN YY =>
r1<='0';r2<='0';y1<='1'; y2<='1'; g1<='0'; g2<='0';
nx_state <= RY;
END CASE;
END PROCESS;
END state_machine_be;
----------------------------------------------------
Như ta thấy, số lượng Flip-flop đã dùng để thực hiện mạch là 15 cái:
3 cái cho lưu trữ trạng thái hiện tại, 12 cái còn lại cho bộ đếm.
Để có thể dễ dàng thấy kết quả mô phỏng, ở đây ta thực hiện giảm
thời gian thực tế đi 100 lần.
Kết quả mô phỏng được chỉ ra trong hình dưới đây:
+ Ở chế độ hoạt động bình thường (stby = 0, test = 0):

Hình 3.89. Kết quả mô phỏng TLC ở chế độ hd bình thường

+ Ở chế độ kiểm tra:

157
 Hình 3.90. Kết quả mô phỏng TLC ở chế độ kiểm tra

Ví dụ: Bộ phát tín hiệu:

Chúng ta muốn thiết kế một mạch mà từ tín hiệu clock clk đưa ra tín
hiệu như trong hình dưới đây:

Hình 3.91. Dạng tín hiệu cần tạo.

Ở đây mạch phải hoạt động ở cả 2 sườn của tín hiệu clk.

Mã chương trình:
-----------------------------------------
ENTITY Bo_phat_tin_hieu IS
PORT ( clk: IN BIT;
outp: OUT BIT);
END Bo_phat_tin_hieu;
-----------------------------------------
ARCHITECTURE state_machine OF Bo_phat_tin_hieu IS
TYPE state IS (one, two, three);
SIGNAL pr_state1, nx_state1: state;
SIGNAL pr_state2, nx_state2: state;
SIGNAL out1, out2: BIT;

158
BEGIN
----- Phan mach day cua may 1: ---
PROCESS(clk)
BEGIN
IF (clk'EVENT AND clk='1') THEN
pr_state1 <= nx_state1;
END IF;
END PROCESS;
----- Phan mach day cua may 2: ---
PROCESS(clk)
BEGIN
IF (clk'EVENT AND clk='0') THEN
pr_state2 <= nx_state2;
END IF;
END PROCESS;
---- Phan mach to hop cua may 1: -----
PROCESS (pr_state1)
BEGIN
CASE pr_state1 IS
WHEN one =>
out1 <= '0';
nx_state1 <= two;
WHEN two =>
out1 <= '1';
nx_state1 <= three;
WHEN three =>
out1 <= '1';
nx_state1 <= one;
END CASE;
END PROCESS;
---- Phan mac«pt hop cua may 2: -----
PROCESS (pr_state2)
BEGIN
CASE pr_state2 IS
WHEN one =>
out2 <= '1';
nx_state2 <= two;
WHEN two =>
out2 <= '0';
nx_state2 <= three;
WHEN three =>
out2 <= '1';
nx_state2 <= one;
END CASE;

159
 END PROCESS;
outp <= out1 AND out2;
END state_machine;
------------------------------------------
Kết quả mô phỏng:

Hình 3.92. Kết quả mô phỏng

4. Kiểu mã hoá: từ nhị phân sang Onehot.

Để mã hoá trạng thái của máy trạng thái, chúng ta có thể chọn một
trong vài kiểu có sẵn. Kiểu mã hoá mặc định là nhị phân. Ưu điểm của kiểu
mã hoá này là nó yêu cầu số lượng flip-flop ít nhất. Trong trường hợp này,
với n mạch flip-flop thì có thể chúng ta có thể mã hoá được 2n trạng thái.
Nhược điểm của kiểu mã hoá này là nó yêu cầu về logic nhiều hơn và nó
chậm hơn so với những kiểu khác.
Cái cuối cùng là kiểu mã hoá onehot, với kiểu mã hoá này, chúng ta
cần sử dụng 1 flip-flop cho 1 trạng thái. Vì vậy, nó đòi hỏi số lượng flip-
flop lớn nhất. Trong trường hợp này, với n flip-flop (n bit) chỉ có thể mã
hoá được n trạng thái. Nhưng bù lại, phương pháp này lại yêu cầu tính toán
logic it nhất, và tốc độ nhanh nhất.
Một kiểu nằm giữa 2 kiểu trên là kiểu mã hoá twohot (trong một
trạng thái chỉ có 2 bit 1). Vì vậy với n flip-flop (n bit), thì chúng ta có thể
mã hoá được n(n-1)/2 trạng thái.
Kiểu mã hoá onehot được giới thiệu trong các ứng dụng mà số lượng
các flip-flop nhiều như trong các chip FPGA. Nhưng trong các mạch ASIC
thì mã nhị phân lại được ưu tiên hơn.
Ví dụ: Giả sử chúng ta có một máy trạng thái có 8 trang thái như trong
bảng dưới đây:

Bảng 3.5. Mã hoá trạng thái cho máy FSM 8 trạng thái

160
 Với 8 trạng thái của máy này thì số lượng flip-flop được yêu cầu ứng
với các kiểu mã hoá sẽ bằng:
+ 3 (=log28), ứng với kiểu mã hoá nhị phân.
+ 5 ( n(n-1)/2= 8 => n = 5 ), ứng với kiểu mã hoá twohot
+ 8, ứng với kiểu mã hoá onehot.

3.2.10. Thực hành thiết kế mạch

Phần này chúng ta sẽ trình bày các mạch sau:
+ Barrel shifter
+ Bộ so sánh không dấu và có dấu.
+ Bộ cộng
+ Bộ chia dấu chấm tĩnh.
+ Bộ điều khiển máy bán hàng.
+ Bộ nhận dữ liệu nối tiếp.
+ Bộ chuyển đổi song song sang nối tiếp.
+ SSD
+ Bộ phát tín hiệu
+ Bộ nhớ

1. Barrel Shifter.
Sơ đồ của mạch của bộ dịch barrel được chỉ ra trong hình dưới. Đầu
vào là vector 8 bit. Đầu ra là phiên bản dịch của đầu vào, với lượng dịch
được định nghĩa bởi 8 đầu vào “shift” (từ o đến 7). Mạch gồm có 3 bộ dịch
barrel riêng lẻ. Nhưng chúng ta phải chu ý rằng, barrel đầu tiên có chỉ có 1
đầu “0” được kết nối với một bộ dồn kênh, trong khi barrel thứ 2 có 2 đầu
vào “0” và barrel cuối cùng có tới 4 đầu vào “0”. Để vector lớn hơn thì
chúng ta phải dữ 2 đầu vào là “0”. Ví dụ nếu shift = “001” thì chỉ barrel
đầu tiên gây ra dịch, còn nếu shift = “111” thì tất các đều gây ra dịch.

161
 Hình 3.93. Bộ dịch barrel

Mã thiết kế sẽ như sau:

---------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
---------------------------------------------
ENTITY barrel IS
PORT ( inp: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
shift: IN STD_LOGIC_VECTOR (2 DOWNTO 0);
outp: OUT STD_LOGIC_VECTOR (7 DOWNTO 0));
END barrel;
---------------------------------------------
ARCHITECTURE behavior OF barrel IS
BEGIN
PROCESS (inp, shift)
VARIABLE temp1: STD_LOGIC_VECTOR (7 DOWNTO 0);
VARIABLE temp2: STD_LOGIC_VECTOR (7 DOWNTO 0);
BEGIN
---- Bo dich thu nhat -----
IF (shift(0)='0') THEN
temp1 := inp;
ELSE
temp1(0) := '0';

162
 FOR i IN 1 TO inp'HIGH LOOP
temp1(i) := inp(i-1);
END LOOP;
END IF;
---- Bo dich thu 2 -----
IF (shift(1)='0') THEN
temp2 := temp1;
ELSE
FOR i IN 0 TO 1 LOOP
temp2(i) := '0';
END LOOP;
FOR i IN 2 TO inp'HIGH LOOP
temp2(i) := temp1(i-2);
END LOOP;
END IF;
---- Bo dich thu 3 -----
IF (shift(2)='0') THEN
outp <= temp2;
ELSE
FOR i IN 0 TO 3 LOOP
outp(i) <= '0';
END LOOP;
FOR i IN 4 TO inp'HIGH LOOP
outp(i) <= temp2(i-4);
END LOOP;
END IF;
END PROCESS;
END behavior;
---------------------------------------------

Kết quả mô phỏng:

Hình 3.94. Kết quả mô phỏng cho bộ dịch barrel

2. Bộ so sánh không dấu và có dấu.

Hình dưới thể hiện sơ đồ của bộ so sánh. Kích thước của vector
được so sánh là generic (n+1). 3 đầu ra phải được cung cấp là: 1 đầu ra là
163
a>b, 1 đầu ra là a = b, đầu ra còn lại là a < b. 3 giải pháp được giới thiệu :
đầu tiên xét a và b là các số có dấu, trong khi 2 giải pháp còn lại là các số
không dấu. Kết quả mô phỏng sẽ cho chúng ta thấy rõ hơn.

Hình 3.95. Mô hình của bộ so sánh

Bộ so sánh có dấu:
Để làm việc với số có dấu hoặc số không dấu thì chúng ta đều phải
khai báo gói std_logic_arith (cụ thể chúng ta sẽ thấy trong đoạn mã dưới
đây).
Mã thiết kế bộ so sánh có dấu:
---- Bo so sanh co dau: ----------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.std_logic_arith.all; -- can thiet!
----------------------------------------
ENTITY Bo_so_sanh_co_dau IS
GENERIC (n: INTEGER := 7);
PORT (a, b: IN SIGNED (n DOWNTO 0);
x1, x2, x3: OUT STD_LOGIC);
END Bo_so_sanh_co_dau;
----------------------------------------
ARCHITECTURE arc OF Bo_so_sanh_co_dau IS
BEGIN
x1 <= '1' WHEN a > b ELSE '0';
x2 <= '1' WHEN a = b ELSE '0';
x3 <= '1' WHEN a < b ELSE '0';
END arc;
----------------------------------------

Kết quả mô phỏng:

164
 Hình 3.95. Kết quả mô phỏng bộ so sánh có dấu

Bộ so sánh không dấu 1:

Phần mã VHDL sau đây là bản sao của phần mã đã được trình bày (ở
bộ so sánh không dấu).

---- Bo so sanh khong dau 1: -----------

LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.std_logic_arith.all; --rat can thiet!
----------------------------------------
ENTITY Bo_so_sanh_khong_dau1 IS
GENERIC (n: INTEGER := 7);
PORT (a, b: IN UNSIGNED (n DOWNTO 0);
x1, x2, x3: OUT STD_LOGIC);
END Bo_so_sanh_khong_dau1;
----------------------------------------
ARCHITECTURE arc OF Bo_so_sanh_khong_dau1 IS
BEGIN
x1 <= '1' WHEN a > b ELSE '0';
x2 <= '1' WHEN a = b ELSE '0';
x3 <= '1' WHEN a < b ELSE '0';
END arc;
----------------------------------------

Kết quả:

Hình 3.96. Kết quả bộ so sánh không dấu 1

Bộ so sánh không dấu 2:

Bộ so sánh không dấu có thể cũng được thực hiện với
STD_LOGIC_VECTORS, trong trường hợp này không cần thiết phải khai
báo std_logic_arith.

Mã thiết kế sẽ như sau:

165
 ---- Bo so sanh khong dau: -----------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
----------------------------------------
ENTITY comparator IS
GENERIC (n: INTEGER := 7);
PORT (a, b: IN STD_LOGIC_VECTOR (n DOWNTO 0);
x1, x2, x3: OUT STD_LOGIC);
END comparator;
----------------------------------------
ARCHITECTURE unsigned OF comparator IS
BEGIN
x1 <= '1' WHEN a > b ELSE '0';
x2 <= '1' WHEN a = b ELSE '0';
x3 <= '1' WHEN a < b ELSE '0';
END unsigned;
Mô phỏng kết quả:

Hình 3.9.7. Kết quả của bộ so sánh không dấu2

3. Bộ cộng Carry Ripple và bộ cộng Carry Look Ahead.

Carry ripple và carry look ahead là 2 phương pháp cổ điển để thiết kế
cácc bộ cộng. Phương pháp đầu tiên có thuận lợi là yêu cầu phần cứng ít,
trong khi cái thứ hai lại nhanh hơn.

a. Bộ cộng carry ripple:

Hình 3.98 chỉ ra 1 bộ cộng ripple carry 4 bit không dấu:

Hình 3.98. Sơ đồ bộ cộng ripple carry

Trên sơ đồ ta có thể thấy, với mỗi bit, một đơn vị bộ cộng đầy đủ sẽ
được thực hiện. Bảng thật của bộ cộng đầy đủ được chỉ ra bên cạnh sơ đồ,

166
trong đó a, b là các bít đầu vào, cin là bit nhớ vào, s là bit tổng, cout là bit
nhớ ra. Từ bảng thật ta dễ dàng tính được:
s = a xor b xor cin
cout = (a and b) xor (a and cin) xor (b xor cin)
Từ công thức trên ta xây dựng chương trình VHDL như sau
(Ở đây chúng ta có thể áp dụng cho bất kỳ số lượng đầu vào nào):

LIBRARY ieee;
USE ieee.std_logic_1164.all;
---------------------------------------------
ENTITY Bo_cong_carry_ripple IS
GENERIC (n: INTEGER := 4);
PORT ( a, b: IN STD_LOGIC_VECTOR (n-1 DOWNTO 0);
cin: IN STD_LOGIC;
s: OUT STD_LOGIC_VECTOR (n-1 DOWNTO 0);
cout: OUT STD_LOGIC);
END Bo_cong_carry_ripple;
---------------------------------------------
ARCHITECTURE arc OF Bo_cong_carry_ripple IS
SIGNAL c: STD_LOGIC_VECTOR (n DOWNTO 0);
BEGIN
c(0) <= cin;
G1: FOR i IN 0 TO n-1 GENERATE
s(i) <= a(i) XOR b(i) XOR c(i);
c(i+1) <= (a(i) AND b(i)) OR
(a(i) AND c(i)) OR
(b(i) AND c(i));
END GENERATE;
cout <= c(n);
END arc;
---------------------------------------------
Kết quả mô phỏng:

Hình 3.99. Kết quả mô phỏng cho bộ cộng ripple carry

b. Bộ cộng carry look ahead:

Sơ đồ bộ cộng carry look ahead 4 bit được chỉ ra trong hình dưới đây:
167
 Hình 3.100. Sơ đồ bộ cộng carry look ahead

Mạch được hoạt động dựa trên các khái niêm generate và propagate.
Chính đặc điểm này đã làm cho bộ cộng này thực hiện với tốc độ nhanh
hơn so với bộ cộng trước.
Giả sử 2 đầu vào là 2 bit a,b thì 2 tín hiệu p(propagate) và
g(generate) được tính như sau:
g = a and b
p = a or b
Nếu chúng ta xem a, b là các vector:
a = a(n-1)…a(1)a(0) ; b = b(n-1)…b(1)b(0)
thì g, p được tính như sau:
p = p(n-1)…p(1)p(0); g = g(n-1)…g(1)g(0)
Trong đó:
g(i) = a(i) and b(i)
p(i) = a(i) or b(i)
Lúc này vector nhớ sẽ là: c = c(n-1)…c(1)c(0), trong đó:
c(0) = cin
c(1) = c(0)p(0) + g(0)
c(2) = c(0)p(0)p(1) + g(0)p(1) + g(1)
c(i) = c(i-1)p(i-1) + g(i-1)

Từ công thức tình trên, chúng ta viết chương trình thiết kế bộ cộng
carry look ahead 4 bit như sau:

---------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
---------------------------------------------
ENTITY Bo_cong_carry_look_ahead IS
PORT ( a, b: IN STD_LOGIC_VECTOR (3 DOWNTO 0);
cin: IN STD_LOGIC;
s: OUT STD_LOGIC_VECTOR (3 DOWNTO 0);
168
 cout: OUT STD_LOGIC);
END Bo_cong_carry_look_ahead;
---------------------------------------------
ARCHITECTURE Bo_cong_carry_look_ahead OF
Bo_cong_carry_look_ahead IS
SIGNAL c: STD_LOGIC_VECTOR (4 DOWNTO 0);
SIGNAL p: STD_LOGIC_VECTOR (3 DOWNTO 0);
SIGNAL g: STD_LOGIC_VECTOR (3 DOWNTO 0);
BEGIN
---- PGU: ---------------------------------
G1: FOR i IN 0 TO 3 GENERATE
p(i) <= a(i) XOR b(i);
g(i) <= a(i) AND b(i);
s(i) <= p(i) XOR c(i);
END GENERATE;
---- CLAU: --------------------------------
c(0) <= cin;
c(1) <= (cin AND p(0)) OR
g(0);
c(2) <= (cin AND p(0) AND p(1)) OR
(g(0) AND p(1)) OR
g(1);
c(3) <= (cin AND p(0) AND p(1) AND p(2)) OR
(g(0) AND p(1) AND p(2)) OR
(g(1) AND p(2)) OR g(2);
c(4) <= (cin AND p(0) AND p(1) AND p(2) AND p(3)) OR
(g(0) AND p(1) AND p(2) AND p(3)) OR
(g(1) AND p(2) AND p(3)) OR
(g(2) AND p(3)) OR g(3);
cout <= c(4);
END Bo_cong_carry_look_ahead;
---------------------------------------------
Kết quả mô phỏng:

Hình 3.101. Kết quả mô phỏng cho bộ cộng carry look ahead

169
4. Bộ chia dấu chấm tĩnh.
Trước khi đi vào thiết kế, chúng ta cần phải nhắc lại thuật toán chia:
- Thuật toán chia:
Mục đích của thuật toán là chúng ta cần tính y = a/b trong đó a, b là
những số cùng có (n+1) bit.
Thuật toán được thể hiện trong bảng dưới, trong đó a = “1011” ( =
(11)10) và b = “0011” (=(3)10). Kết quả sẽ thu được: thương y = “0011”
(=(3)10) và số dư r = “0010” (=(2)10).

Chỉ số Đầu vào a So sánh Đầu vào b y Thao tác cho cột a
1011 0 Không làm gì
3 < 0011000
1011 0 Không làm gì
2 < 0001100
1011 1 Trừ cột a cho cột
1 > 0000110
0101 1 b
0 > 0000011
Trừ cột a cho cột
0010
b

Bảng thuật toán chia

Giải thích thuật toán:

+ Đầu tiên chuyển số chia thành số 2n+1 bit bằng cách thêm vào sau
n -1 bit 0 , số bị chia vẫn giữ nguyên.
+ So sánh số bị chia với số chia . Nếu số bị chia lớn hơn hoặc bằng
số chia thì gán y =1 và thay số bị chia bằng hiệu của số bị chia với số chia.
Ngược lại thì y =0
+ Quá trình thực hiện liên tục cho đến khi hết n lần.
+ Thương là dãy bit của y, số dư là sô bị chia cuối cùng.
Để thiết kế bộ chia này thì chúng ta có 2 phương pháp: Cả 2 phương
pháp đều thực hiện theo mã tuần tự: Phương pháp thứ nhất chỉ thực hiện
bằng câu lện if, phương pháp thứ 2 thực hiện bằng cả câu lện if và loop.

Mã thiết kế bộ chia sẽ như sau:

Thiết kế theo phương pháp 1:

----- Phuong phap 1: step-by-step -------------------

LIBRARY ieee;
USE ieee.std_logic_1164.all;
--------------------------------------------------
ENTITY Bo_chia IS
PORT ( a, b: IN INTEGER RANGE 0 TO 15;
y: OUT STD_LOGIC_VECTOR (3 DOWNTO 0);
rest: OUT INTEGER RANGE 0 TO 15;
err : OUT STD_LOGIC);
END Bo_chia;
170
--------------------------------------------------
ARCHITECTURE arc OF Bo_chia IS
BEGIN
PROCESS (a, b)
VARIABLE temp1: INTEGER RANGE 0 TO 15;
VARIABLE temp2: INTEGER RANGE 0 TO 15;
BEGIN
----- Khoi tao vaµ bat loi: -------
temp1 := a;
temp2 := b;
IF (b=0) THEN err <= '1';
ELSE err <= '0';
END IF;
----- y(3): ---------------------------
IF (temp1 >= temp2 * 8) THEN
y(3) <= '1';
temp1 := temp1 - temp2*8;
ELSE y(3) <= '0';
END IF;
----- y(2): ---------------------------
IF (temp1 >= temp2 * 4) THEN
y(2) <= '1';
temp1 := temp1 - temp2 * 4;
ELSE y(2) <= '0';
END IF;
----- y(1): ---------------------------
IF (temp1 >= temp2 * 2) THEN
y(1) <= '1';
temp1 := temp1 - temp2 * 2;
ELSE y(1) <= '0';
END IF;
----- y(0): ---------------------------
IF (temp1 >= temp2) THEN
y(0) <= '1';
temp1 := temp1 - temp2;
ELSE y(0) <= '0';
END IF;
----- Phan du: ----------------------
rest <= temp1;
END PROCESS;
END arc;
--------------------------------------------------
Kết quả mô phỏng:

171
 Hình 3.103. Kết quả mô phỏng bộ chia

Thiết kế theo phương pháp 2:

------ Phuong phap 2:-----------------------------

LIBRARY ieee;
USE ieee.std_logic_1164.all;
--------------------------------------------------
ENTITY Bo_chia2 IS
GENERIC(n: INTEGER := 3);
PORT ( a, b: IN INTEGER RANGE 0 TO 15;
y: OUT STD_LOGIC_VECTOR (3 DOWNTO 0);
rest: OUT INTEGER RANGE 0 TO 15;
err : OUT STD_LOGIC);
END Bo_chia2;
--------------------------------------------------
ARCHITECTURE arc OF Bo_chia2 IS
BEGIN
PROCESS (a, b)
VARIABLE temp1: INTEGER RANGE 0 TO 15;
VARIABLE temp2: INTEGER RANGE 0 TO 15;
BEGIN
----- Khoi tao gia tri va bat loi: -------
temp1 := a;
temp2 := b;
IF (b=0) THEN err <= '1';
ELSE err <= '0';
END IF;
----- thuong: ------------------------------
FOR i IN n DOWNTO 0 LOOP
IF(temp1 >= temp2 * 2**i) THEN
y(i) <= '1';
temp1 := temp1 - temp2 * 2**I;
ELSE y(i) <= '0';
END IF;
END LOOP;
----- phan du: ----------------------
172
 rest <= temp1;
END PROCESS;
END arc;
--------------------------------------------------
Kết quả mô phỏng:

Hình 3.104. Kết quả mô phong bộ chia thứ 2

5. Bộ điều khiển máy bán hàng.

Trong ví dụ này, chúng ta sẽ thiết kế bộ điều khiển máy bán hàng,
máy bán hàng sẽ bán các thanh kẹo với giá 25 xu. Chúng ta sẽ thiết kế theo
mô hình máy FSM. Đầu ra và đầu vào của bộ điều khiển được thể hiện
trong hình dưới.
Tín hiệu vào là nickel_in, dime_in, và quarter_in thông báo rằng một
đồng tiền tương ứng được gửi vào tài khoản. Ngoài ra còn có 2 đầu vào
điều khiển: đầu vào reset (rst) và đầu vào clock (clk). Bộ điều khiển trả lời
bằng 3 tín hiệu đầu ra: candy_out (để phân phát thanh kẹo), nickel_out và
dime_out(cập nhật lại thay đổi).
Trên hình 3.105 cũng chỉ ra đồ hình trạng thái của máy FSM. Các số
bên trong các vòng tròn biểu diễn tổng tài khoản của khách hàng (chỉ có
các nickel, dime và quarter là được chấp nhận).

173
 Hình 3.105. Đồ hình trạng thái của bộ điều khiển máy bán hàng

Trạng thái 0 là trạng thái là trạng thái không làm gì cả. Từ đó nếu 1
đồng nickel được gửi vào tài khoản, máy sẽ chuyển trạng thái đến trạng
thái 5, nếu 1 đồng dime được gửi vào tài khoản thì máy chuyển tới trạng
thái 10 hoặc nếu 1 đồng quarter thì máy sẽ chuyển đến trạng thái 25. Tình
huống tương tự sẽ được lặp lại cho tất cả các trạng thái, cho tới trạng thai
20. Nếu trạng thái 25 được xác nhận, thì thanh kẹo được phân phát và
không chuyển đổi. Tuy nhiên nếu trạng thái 40 được xác nhận thì a nickel
được trả lại, bởi vậy trạng thái sẽ chuyển tới trạng thái 35, đó là 1 trạng thái
mà 1 dime được trả lại và 1 candy bar được phân phát. Có 3 trạng thái tạo
ra chu trình kép, đó là từ 1 thanh kẹo được phân phát và máy trở lại trạng
thái 0. Bài toán này sẽ được chia thành 2 phần:
+ Trong phần đầu: diện mạo cơ bản liên quan đến thiết kế bộ điều
khiển máy bán hàng như trong hình 3.105.
+ Trong phần 2: Các chức năng mở rộng được thêm vào.
Ở đây chúng ta chỉ nghiên cứu phần một của bài toán: Nhìn vào đồ
hình trạng thái của máy ở hình 3.105, chúng ta thấy có 10 trạng thái, như
vậy cần có 4 bit để mã hoá các trạng thái, tức là cần sử dụng 4 flip-flop.

Mã thiết kế sẽ như sau:

174
------------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
------------------------------------------------------
ENTITY Bo_dieu_khien_may_bh IS
PORT ( clk, rst: IN STD_LOGIC;
nickel_in, dime_in, quarter_in: IN BOOLEAN;
candy_out, nickel_out, dime_out: OUT STD_LOGIC);
END Bo_dieu_khien_may_bh;
------------------------------------------------------
ARCHITECTURE state_machine OF Bo_dieu_khien_may_bh IS
TYPE state IS (st0, st5, st10, st15, st20, st25,
st30, st35, st40, st45);
SIGNAL present_state, next_state: STATE;
BEGIN
---- Lower section of the FSM (Sec. 8.2): ---------
PROCESS (rst, clk)
BEGIN
IF (rst='1') THEN
present_state <= st0;
ELSIF (clk'EVENT AND clk='1') THEN
present_state <= next_state;
END IF;
END PROCESS;
---- Upper section of the FSM (Sec. 8.2): ---------
PROCESS (present_state, nickel_in, dime_in, quarter_in)
BEGIN
CASE present_state IS
WHEN st0 =>
candy_out <= '0';
nickel_out <= '0';
dime_out <= '0';
IF (nickel_in) THEN next_state <= st5;
ELSIF (dime_in) THEN next_state <= st10;
ELSIF (quarter_in) THEN next_state <= st25;
ELSE next_state <= st0;
END IF;
WHEN st5 =>
candy_out <= '0';
nickel_out <= '0';
dime_out <= '0';
IF (nickel_in) THEN next_state <= st10;
ELSIF (dime_in) THEN next_state <= st15;
ELSIF (quarter_in) THEN next_state <= st30;

175
ELSE next_state <= st5;
END IF;
WHEN st10 =>
candy_out <= '0';
nickel_out <= '0';
dime_out <= '0';
IF (nickel_in) THEN next_state <= st15;
ELSIF (dime_in) THEN next_state <= st20;
ELSIF (quarter_in) THEN next_state <= st35;
ELSE next_state <= st10;
END IF;
WHEN st15 =>
candy_out <= '0';
nickel_out <= '0';
dime_out <= '0';
IF (nickel_in) THEN next_state <= st20;
ELSIF (dime_in) THEN next_state <= st25;
ELSIF (quarter_in) THEN next_state <= st40;
ELSE next_state <= st15;
END IF;
WHEN st20 =>
candy_out <= '0';
nickel_out <= '0';
dime_out <= '0';
IF (nickel_in) THEN next_state <= st25;
ELSIF (dime_in) THEN next_state <= st30;
ELSIF (quarter_in) THEN next_state <= st45;
ELSE next_state <= st20;
END IF;
WHEN st25 =>
candy_out <= '1';
nickel_out <= '0';
dime_out <= '0';
next_state <= st0;
WHEN st30 =>
candy_out <= '1';
nickel_out <= '1';
dime_out <= '0';
next_state <= st0;
WHEN st35 =>
candy_out <= '1';
nickel_out <= '0';
dime_out <= '1';
next_state <= st0;

176
 WHEN st40 =>
candy_out <= '0';
nickel_out <= '1';
dime_out <= '0';
next_state <= st35;
WHEN st45 =>
candy_out <= '0';
nickel_out <= '0';
dime_out <= '1';
next_state <= st35;
END CASE;
END PROCESS;
END state_machine;
------------------------------------------------------

Kết quả mô phỏng:

Hình 3.106. Kết quả mô phỏng bộ điều khiển máy bán hàng

6. Bộ nhận dữ liệu nối tiếp.

Sơ đồ khối của bộ nhận dữ liệu nối tiếp được chỉ ra trong hình 3.107.
Nó bao gồm một đầu vào dữ liệu nối tiếp (din) và một đầu ra dữ liệu song
song (data(6:0)). Ngoài ra còn có tín hiệu điều khiển clk (tín hiệu clock).
Hai tín hiệu giám sát được tạo ra bởi mạch là: tín hiệu err (error) và tín hiệu
data_valid. Đầu vào xử lý chứa 10 bít. Bit đầu tiên là bit bắt đầu, nếu bit là
1 thì mạch bắt đầu nhận dữ liệu. 7 bit tiếp theo là các bit dữ liệu hoạt động.
Bit thứ 9 là bit chẵn lẻ: bit này = ‘0’ nếu số lượng các bit 1 trong dữ liệu la
chẵn và bằng ‘1’ trong trường hợ còn lại. Bit 10 là bit stop: bit này sẽ
mang giá trị là 1 nếu quá trình chuyển đổi là đúng. Một lỗi được phát hiện
khi bit chẵn lẻ không được kiểm tra hoặc bit stop không phải la ‘1’. Khi
quá trình nhận kết thúc mà không có lỗi nào được phát hiện thì dữ liệu
được lưu trữ trong các thanh ghi bên trong sẽ chuyển vào data(6:0) và đầu
ra data_valid được xác nhận.

177
 Hình 3.107. Sơ đồ bộ nhận dữ liệu nối tiếp

Để thiết kế mạch này chúng ta sẽ sử dụng một vài biến để làm các
biến đếm, biến xác nhận số bit nhận được, biến lưu trữ dữ liệu, biến tính
toán lỗi và biến trung gian.

Mã thiết kế bộ nhận dữ liệu nối tiếp sẽ như sau:

---------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
---------------------------------------------
ENTITY Bo_nhan_du_lieu_nt IS
PORT ( din, clk, rst: IN BIT;
data: OUT BIT_VECTOR (6 DOWNTO 0);
err, data_valid: OUT BIT);
END Bo_nhan_du_lieu_nt;
---------------------------------------------
ARCHITECTURE arc OF Bo_nhan_du_lieu_nt IS
BEGIN
PROCESS (rst, clk)
VARIABLE count: INTEGER RANGE 0 TO 10;
VARIABLE reg: BIT_VECTOR (10 DOWNTO 0);
VARIABLE temp : BIT;
BEGIN
IF (rst='1') THEN
count:=0;
reg := (reg'RANGE => '0');
temp := '0';
err <= '0';
data_valid <= '0';
ELSIF (clk'EVENT AND clk='1') THEN
IF (reg(0)='0' AND din='1') THEN
reg(0) := '1';
ELSIF (reg(0)='1') THEN
count := count + 1;
IF (count < 10) THEN
reg(count) := din;
ELSIF (count = 10) THEN
temp := (reg(1) XOR reg(2) XOR reg(3) XOR
178
 reg(4) XOR reg(5) XOR reg(6) XOR
reg(7) XOR reg(8)) OR NOT reg(9);
err <= temp;
count := 0;
reg(0) := din;
IF (temp = '0') THEN
data_valid <= '1';
data <= reg(7 DOWNTO 1);
END IF;
END IF;
END IF;
END IF;
END PROCESS;
END arc;
-------------------------------------------------
Kết quả mô phỏng:

Hình 3.108. Kết quả mô phỏng bộ nhận dữ liệu

7. Bộ chuyển song song thành nối tiếp.

Bộ chuyển song song thành nối tiếp là một loại ứng dụng của thanh
ghi dịch. Bộ chuyển đổi này sẽ thực hiện việc gửi đi một khối dữ liệu nối
tiếp. Việc sử dụng bộ chuyển đổi này là rất cần thiết ví dụ: Trong các con
chip ASIC, khi không có đủ các chân dư để cho ra đồng thời tất cả các bit
dữ liệu. Khi đó chúng ta cần thiết phải sử dụng bộ chuyển đổi song song
thành nối tiếp.
Sơ đồ khối của bộ chuyển đổi song song thánh nối tiếp được trình
bày trong hình 3.109.

179
 Hình 3.110. Bộ chuyển song song thành nối tiếp

Trong đó:
+ d(7:0) là vector dữ liệu để gửi đi
+ dout là đầu ra thực tế.
+ clk: Đầu vào của xung clock
+ load: Đầu vào xác nhận

Vector d được lưu trữ đồng bộ trong thanh ghi dịch reg. Khi load ở
trạng thái cao thì dữ liệu được nạp vào thanh ghi dịch theo thư tự bit MSB
là bít gần đầu ra nhất, và đầu ra là d(7). Mỗi khi load trả lại “0” thì bit tiếp
theo được xuất hiện tại đầu ra của mỗi sườn dương của xung đồng hồ. Sau
khi tất cả 8 bit được gửi đi, đầu ra trở lại mức thấp cho đến lần chuyển đổi
tiếp theo.
Mã thiết kế như sau:

LIBRARY ieee;
USE ieee.std_logic_1164.all;
-------------------------------------------------
ENTITY Bo_chuyen_dl_ss_nt IS
PORT ( d: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
clk, load: IN STD_LOGIC;
dout: OUT STD_LOGIC);
END Bo_chuyen_dl_ss_nt;
-------------------------------------------------
ARCHITECTURE Bo_chuyen_dl_ss_nt OF Bo_chuyen_dl_ss_nt IS
SIGNAL reg: STD_LOGIC_VECTOR (7 DOWNTO 0);
BEGIN
PROCESS (clk)
BEGIN
IF (clk'EVENT AND clk='1') THEN
IF (load='1') THEN reg <= d;
ELSE reg <= reg(6 DOWNTO 0) & '0';
END IF;
END IF;
END PROCESS;
dout <= reg(7);
END Bo_chuyen_dl_ss_nt;
-------------------------------------------------
Kết quả mô phỏng:
180
 Hình 3.111. Kết quả mô phỏng cho bộ chuyển song song thành nối
tiếp

8. Ứng dụng trên led 7 thanh.

Chúng ta thiết kế trò chơi với SSD (seven – segment display). Sơ đồ
của mạch được chỉ ra trong hình 9.17. Nó bao gồm 2 đầu vào là clk và stop,
và một đầu ra là dout(6:0), đầu ra này sẽ được hiển thị trên SSD. Chúng ta
phải đảm bảo rằng fdk = 1khz

Hình 3.112. Sơ đồ của SSD

Mạch của chúng ta sẽ tạo ra một sự chuyển động liên tục theo chiều
kim đồng hồ của các đoạn SSD. Đồng thời nó còn tạo ra sự dịch chuyển
chồng lắp giữa các thanh kề nhau. Chúng ta có thể biểu diễn quy trình của
nó như sau:
a->ab->b->bc->c->cd->d->de->e->ef->f->fa->a.

181
 Hình 3.113. Đồ hình trạng thái

Quá trình sẽ dừng lại khi có tín hiệu Stop, và khi đó mạch sẽ trở lại
trạng thái a và chờ cho đến khi stop xuống thấp trở lại. Hệ thống của chúng
ta sẽ giữ lại ở các trạng thái a, b, c, d , e, f trong khoảng thời gian time1 =
80ms và ở các trạng thái ab, bc, cd, de, ef, fa là time2 = 30ms.

Mã chương trình của chúng ta sẽ như sau:

--------------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
--------------------------------------------------------
ENTITY Trochoiled7thanh IS
PORT ( clk, stop: IN BIT;
dout: OUT BIT_VECTOR (6 DOWNTO 0));
END Trochoiled7thanh;
--------------------------------------------------------
ARCHITECTURE arc OF Trochoiled7thanh IS
CONSTANT time1: INTEGER := 4; -- Gia tri thuc te hien thi la 80
CONSTANT time2: INTEGER := 2; -- Gia tri thuc te hien thi is 30
TYPE states IS (a, ab, b, bc, c, cd, d, de, e, ef, f, fa);
SIGNAL present_state, next_state: STATES;
SIGNAL count: INTEGER RANGE 0 TO 5;
SIGNAL flip: BIT;
BEGIN
------- Phan mach day cua arc : ------------
PROCESS (clk, stop)
BEGIN
IF (stop='1') THEN
present_state <= a;
ELSIF (clk'EVENT AND clk='1') THEN
IF ((flip='1' AND count=time1) OR
(flip='0' AND count=time2)) THEN
count <= 0;
present_state <= next_state;
ELSE count <= count + 1;
END IF;
END IF;
END PROCESS;
------- Phan mach to hop: ------------
PROCESS (present_state)
BEGIN
CASE present_state IS
WHEN a =>

182
dout <= "1000000"; -- Decimal 64
flip<='1';
next_state <= ab;
WHEN ab =>
dout <= "1100000"; -- Decimal 96
flip<='0';
next_state <= b;
WHEN b =>
dout <= "0100000"; -- Decimal 32
flip<='1';
next_state <= bc;
WHEN bc =>
dout <= "0110000"; -- Decimal 48
flip<='0';
next_state <= c;
WHEN c =>
dout <= "0010000"; -- Decimal 16
flip<='1';
next_state <= cd;
WHEN cd =>
dout <= "0011000"; -- Decimal 24
flip<='0';
next_state <= d;
WHEN d =>
dout <= "0001000"; -- Decimal 8
flip<='1';
next_state <= de;
WHEN de =>
dout <= "0001100"; -- Decimal 12
flip<='0';
next_state <= e;
WHEN e =>
dout <= "0000100"; -- Decimal 4
flip<='1';
next_state <= ef;
WHEN ef =>
dout <= "0000110"; -- Decimal 6
flip<='0';
next_state <= f;
WHEN f =>
dout <= "0000010"; -- Decimal 2
flip<='1';
next_state <= fa;
WHEN fa =>

183
 dout <= "1000010"; -- Decimal 66
flip<='0';
next_state <= a;
END CASE;
END PROCESS;
END arc;
--------------------------------------------------------

Kết quả mô phỏng:

Hình 3.114. Kết quả mô phỏng cho trò chơi trên SSD

9. Bộ phát tín hiệu.

Từ một tín hiệu clock, chúng ta mong muốn thu được một tín hiệu có
dang sóng như trong hình 3.115. Với bài toán loại này, chúng ta có thể sử
dụng phương pháp FSM hoặc phương pháp truyền thống. Cả 2 phương
pháp đều được chúng ta trình bày dưới đây:

Phương pháp FSM:

Hình 3.115. Hình dạng sóng cần phát

Tín hiệu của hình 3.115 có thể được mô hình như một FSM 8 trạng
thái. Sử dụng bộ đếm từ 0 đến 7. Chúng ta có thể thiết lập một sóng bằng
‘0’ khi biến đếm = ‘0’ (ở xung thứ nhất) và bằng 1 khi biến đếm = ‘1’
(xung thứ hai),…vv…như trong hình. Để thực thi được bộ tạo sóng này thì
yêu cầu 4 flip-flop: trong đó có 3 cái để lưu trữ số đếm (3 bit), một cái để
lưu trữ sóng (1 bit ). Để thiết kế bộ tạo sóng này, chúng ta thiết kế theo kiểu
2, cụ thể sẽ như sau:
-----------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
-----------------------------------------------------
ENTITY Bo_phat_tin_hieu IS
184
 PORT (clk: IN STD_LOGIC;
wave: OUT STD_LOGIC);
END Bo_phat_tin_hieu;
-----------------------------------------------------
ARCHITECTURE arc OF Bo_phat_tin_hieu IS
TYPE states IS (zero, one, two, three, four, five, six, seven);
SIGNAL present_state, next_state: STATES;
SIGNAL temp: STD_LOGIC;
BEGIN
--- Phan mach day: ---
PROCESS (clk)
BEGIN
IF (clk'EVENT AND clk='1') THEN
present_state <= next_state;
wave <= temp;
END IF;
END PROCESS;
--- Phan mach to hop: ---
PROCESS (present_state)
BEGIN
CASE present_state IS
WHEN zero => temp<='0'; next_state <= one;
WHEN one => temp<='1'; next_state <= two;
WHEN two => temp<='0'; next_state <= three;
WHEN three => temp<='1'; next_state <= four;
WHEN four => temp<='1'; next_state <= five;
WHEN five => temp<='1'; next_state <= six;
WHEN six => temp<='0'; next_state <= seven;
WHEN seven => temp<='0'; next_state <= zero;
END CASE;
END PROCESS;
END arc;
-----------------------------------------------------
Kết quả mô phỏng:

Hình 3.116. Kết quả mô phỏng tạo sóng

Phương pháp truyền thống:
Chúng ta thiết kế bộ phát tín hiệu theo phương pháp truyền thống với
câu lệnh IF như sau:
185
 ---------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
---------------------------------------
ENTITY Bo_phat_tin_hieu2 IS
PORT (clk: IN BIT;
wave: OUT BIT);
END Bo_phat_tin_hieu2;
---------------------------------------
ARCHITECTURE arc OF Bo_phat_tin_hieu2 IS
BEGIN
PROCESS
VARIABLE count: INTEGER RANGE 0 TO 7;
BEGIN
WAIT UNTIL (clk'EVENT AND clk='1');
CASE count IS
WHEN 0 => wave <= '0';
WHEN 1 => wave <= '1';
WHEN 2 => wave <= '0';
WHEN 3 => wave <= '1';
WHEN 4 => wave <= '1';
WHEN 5 => wave <= '1';
WHEN 6 => wave <= '0';
WHEN 7 => wave <= '0';
END CASE;
if count = 7 then
count := 0;
else
count := count + 1;
end if ;
END PROCESS;
END arc;
---------------------------------------
Kết quả mô phỏng:

Hình 3.117. Kết quả mô phỏng tạo sóng theo phương pháp truyền thống

10. Thiết kế bộ nhớ.

Trong đoạn này, chúng ta sẽ thiết kế các mạch bộ nhớ sau:
+ ROM
186
 + RAM với bus dữ liệu vào ra tách rời.
+ ROM với bus dữ liệu vào ra hai chiều
ROM (Read Only Memory): Bộ nhớ chỉ đọc và ghi: Sơ đồ của ROM
được chỉ ra trong hình 3.117. Vì ROM là bộ nhớ chỉ đọc, không có tín hiệu
clock, chân cho phép ghi, nó chỉ có tín hiệu vào bus địa chỉ và tín hiệu ra là
bus dữ liệu.

Hình 3.117. Sơ đồ của ROM

Mã thiết kế ROM như sau:

---------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
---------------------------------------------------
ENTITY rom IS
GENERIC ( bits: INTEGER := 8; -- # of bits per word
words: INTEGER := 8); -- # of words in the memory
PORT ( addr: IN INTEGER RANGE 0 TO words-1;
data: OUT STD_LOGIC_VECTOR (bits-1 DOWNTO 0));
END rom;
---------------------------------------------------
ARCHITECTURE rom OF rom IS
TYPE vector_array IS ARRAY (0 TO words-1) OF
STD_LOGIC_VECTOR (bits-1 DOWNTO 0);
CONSTANT memory: vector_array := ( "00000000",
"00000010",
"00000100",
"00001000",
"00010000",
"00100000",
"01000000",
"10000000");
BEGIN
data <= memory(addr);
END rom;
---------------------------------------------------
Kết quả mô phỏng:

187
 Hình 3.118. Kết quả mô phỏng thiết kế ROM

RAM với đường bus vào ra riêng biệt: Sơ đồ của RAM với đường
bus vào ra riêng biệt được thể hiện trong hình 3.119

Hình 3.119. RAM với đường dữ liệu tách rời

Như chúng ta thấy trên hình, RAM có các bus dư liệu vào data_in,
bus dữ liệu ra data_out, bus địa chỉ, tín hiệu clk và tín hiệu cho phép
đọc/ghi. Khi tín hiệu cho phép ghi/đọc được xác nhận là ghi thì tại mỗi
xung lên tiếp theo của clk thì dữ liệu đầu vào (data_in) phải được lưu trữ tại
vị trí addr, và dữ liệu ra phải được đọc từ địa chỉ addr.
Mã thiết kế RAM sẽ như sau:
-----------------------------------------------------------------------------------
---
library IEEE;
use IEEE.STD_LOGIC_1164.all;
---------------------------------------------------
ENTITY ram IS
GENERIC ( bits: INTEGER := 8; -- # of bits per word
words: INTEGER := 16); -- # of words in the
-------- memory----------
PORT ( wr_ena, clk: IN STD_LOGIC;
addr: IN INTEGER RANGE 0 TO words-1;
data_in: IN STD_LOGIC_VECTOR (bits-1 DOWNTO 0);
data_out: OUT STD_LOGIC_VECTOR (bits-1 DOWNTO 0));
END ram;
---------------------------------------------------
ARCHITECTURE ram OF ram IS
TYPE vector_array IS ARRAY (0 TO words-1) OF
STD_LOGIC_VECTOR (bits-1 DOWNTO 0);
188
 SIGNAL memory: vector_array;
BEGIN
PROCESS (clk, wr_ena)
BEGIN
IF (wr_ena='1') THEN
IF (clk'EVENT AND clk='1') THEN
memory(addr) <= data_in;
END IF;
END IF;
END PROCESS;
data_out <= memory(addr);
END ram;
---------------------------------------------------

Kết quả mô phỏng:

Hình 3.120. Kết quả mô phỏng RAM có đương dữ liệu vào ra khác nhau.

RAM với đường bus song song:

Sơ đồ của RAM với đường bus song song được thể hiện trong hình
3.121. Dữ liệu được ghi vào RAM hay được đọc từ RAM thực hiện trên
cùng 1 đường bus.

Hình 3.122. RAM với đường dữ liệu chung

Mã thiết kế sẽ như sau:

189
 -------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
-------------------------------------------------
ENTITY ramc IS
GENERIC ( bits: INTEGER := 8; -- # of bits per word
words: INTEGER := 16); -- # of words in the
-- memory
PORT ( clk, wr_ena: IN STD_LOGIC;
addr: IN INTEGER RANGE 0 TO words-1;
bidir: INOUT STD_LOGIC_VECTOR (bits-1 DOWNTO 0));
END ramc;
-------------------------------------------------
ARCHITECTURE arc OF ramc IS
TYPE vector_array IS ARRAY (0 TO words-1) OF
STD_LOGIC_VECTOR (bits-1 DOWNTO 0);
SIGNAL memory: vector_array;
BEGIN
PROCESS (clk, wr_ena)
BEGIN
IF (wr_ena='0') THEN
bidir <= memory(addr);
ELSE
bidir <= (OTHERS => 'Z');
IF (clk'EVENT AND clk='1') THEN
memory(addr) <= bidir;
END IF;
END IF;
END PROCESS;
END arc;
-------------------------------------------------
3.2. Ngôn ngữ ABEL
3.2.1. Giới thiệu
Cũng giống như ROM hay PROM, một PLD cũng được lập trình để
tạo ra các file đôt các cầu chì hay diode.
Ngôn ngữ sử dụng để lập trình cho PLD trong chương trình này là
ABEL (Advanced Boolean Equation Languale) là một trong những ngôn
ngữ lập trinh rất mạnh cho PLD, hỗ trợ cho nhiều ngõ vào, bao gồm cả cả
sơ đồ trạng thái và bảng sự thật. Trình biên dịch cua ABEL có khả năng mô
phỏng và tạo file fuse map (cầu chì) cho PLD. Trong phụ lục này chỉ tóm
tắt hướng dẫn sử dụng các phần cấu trúc và cú pháp về phát biểu, khai báo,
chỉ dẫn ... Chủ yếu nhất để phục vụ cho các bài thí nghiệm sau đó. Để hiểu
sâu hơn về ngôn ngữ này, sinh viên nên kham khảo thêm các tài liệu khác
hoặc phần help trong ngôn ngữ

190
Ngoài ABLE còn có các ngôn ngữ khác như VHDL,AHDL ...
3.2.2. Cấu trúc chung file nguồn ABEL
---------------------------------------------------------------
Module module name
Title string
deviceID device deviceType
pin declarations
other declaraitons
equations
equations
test_vectors
end module name
---------------------------------------------------------------
Module: Tên chương trình và các thông số hình thức
Title: Dùng để mô tả module
Declaration: Mô tả các module cấp thấp hơn, định nghĩa các khối chức
năng như devive, pin, node, constant, macro, các tập hợp ....
Equations: Sử dụng các hàm, các lưu đồ trạng thái hay bảng sự thật để mô
tả các thiết kế logic.
Test_vectors: Test_secvtors sử dụng trong các file mo phỏng JEDEC
End: Kết thúc một module.
Lưu ý: Cấu trúc ở trên bao gồm các thành phần cơ bản của một
chương trình ABLE, tùy vào những ứng dụng cụ thể có thể vẽ các phát biểu
khác như máy trạng thái, v.v.v...
3.2.3. Các phát biểu (Statements)
1. Phát biểu Module
Cú pháp: module modname [(dummy_arg[,...])]
Mục đích: Phát biểu module các định điểm bắt đầu của một chương
tình và phải có phát biểu END để xác định điểm để kết thúc của module
Sử dụng: Modname là một danh hiệu hợp lệ được đặt làm tên gọi cho
module chương trình
Danh hiệu hợp lệ là một chuỗi dài tối đa 31 kí tự ( chữ cái, chữ số, dấu
gạch dưới’_’), được bắt đầu bằng chữ cái hay dấu gạch dưới ‘_’. Danh hiệu
phân biệt chữ hoa hay chữ thường.
Dummy_arg (có thể có ) : là một thông số hình thức ( tương tự như trong
ngôn ngữ hợp dịch)

Ví dụ MODULE My_Example
....
END My_Example

Module có tên My_Example và phát biểu END My_Example kết thúc

module này. Trong module này không sử dụng thông số hình thức.

191
MODULE My_Example(A,B)
....
C=A+B
END My_Example
Trong module này có sử dụng hai thông số hình thức A và B, biểu thức
C = A+ B, với A,B được trả về gí trị thực (từ module khác) khi biên dich

2. Phát biểu Tile

Cú pháp: title ‘string’
Mục đích: Phát biểu title đặt cho module một tựa đề (header) để minh
họa đặc điểm chức năng do người lập trình tạo ra chuỗi ký tự này sẽ xuất
hiện trong cả file dữ liệu và file fusemap sau khi biên dịch.
Sử sụng: string : là chuỗi ký tự nằm trong hai dấu nháy đơn (‘) và
giới hạn 324 ký tự, sử dụng phát biểu ký tự tilte là tùy chọn
Ví dụ: module m6809a
tilte ‘ 6809 memory decode
Jean Designer
Data I/O Corp Redmond WA’
3. Phát biểu equations:
Cú pháp: Equations
Element [?] = condition;
When-then_eles_statement;
Mục đính:
Phát biểu equations định chỗ bắt đầu của hay một nhóm biểu thức
boole biểu diễn hàm logic ngõ ra theo ngõ vào
Sử dụng:
Condition. Một mô tả
Element. Tên danh định của một tín hiệu,tập các tín hiệu hay tín hiệu thực
mà mô tả giá trị của nó được gán
When-then-eles_statement: phát biểu when-then-else
Sau mỗi biểu thức phải có dấu chấm phẩy (;)
Ví dụ: Equations
A=B và C# A;
[W,Y] = 3;
! F = (B= =C);
4. Phát biểu truth_table:
Cú pháp: truth_table (inputs -> outputs)
Hay truth_table (inputs : > reg_outs)
Mục đích:
Truth_table trình bày bảng sự thật minh họa ngõ ra như một hàm tổ
hợp của các ngõ vào
Các bảng sự thật có thể thay thế hoặc bổ sung thêm cho các biểu
thức (trong equations) hay sơ đồ trạng thái (trong state_diagram)
Sử dụng:

192
Inputs : Là ngõ vào của hàm logic
Outputs : Là ngõ ra của hàm logic
Reg_outs : Là các ngõ ra của các thanh ghi (FF)
Dấu -> biểu diễn hệ tổ hợp
Dấu :> biểu diễn hệ tuần tự
Ví dụ:
Truth_table ([A,B] -> C)
[0,1] -> 1;
[1,0] -> 1:
[1,1] -> 0;
[0,0] -> 0;
Rõ ràng truth_table biểu diễn biểu thức C = A + B
5. Phát biểu state_diagram:
Cú pháp:
state_diagram state variables
State state_exp : [ equations] ;
[Trans-stmt...];
Mục đích:
Phát biểu state_diagram định nghĩa các biến trạng thái bắt đầu sự mô tả
hoạt động của máy trạng thái (tương tự như đồ thị trạng thái hay lưu đồ
trạng thái )
Sử dụng:
State_variables : Là tập hợp các biến trạng thái trong máy trạng thái
State : Là từ khóa để biểu diễn sự chuyển biến từ trạng thái hiện tại
sang trạng thái kế tiếp và ngõ ra hiện tại
State_exp: Là các biểu thức hay hằng số định nghĩa trạng thái hiện tại
Equations : Là các biểu thức logic ngõ ra hiện tại của máy trạng thái
Trans_stmt : Là một phát biểu dạng IF - THEN – ELSE , GOTO ,
CASE (tùy chọn) để mô tả sự chuyển biến từ trạng thái hiện tại sang trạng
thái kế tiếp theo điều kiện tác động của ngõ vào
Ví du:
Giả sử ta có hai ngõ vào x1, x2 ngõ ra là z, máy trạng thái có 3 trạng
thái ký hiệu S0 , S1 , S2 Hai biến trạng thái Q = [Q0 , Q1] (hai ngõ ra của FF)
State_diagram Q
State S0 : if (x1 và x2 = = 0 ) then S2
Else S1
State S1 : z = 1
Go to S2;
State S2 : z = 0
Go to S0;

6. Phát biểu go to:

Cú pháp : Go to_state_exp

193
Mục đích: Phát biểu goto biểu diễn sự chuyển biến không điều kiện từ
trạng thái hiện tại sang trạng thái kế tiếp là state_exp
Sử dụng: state_exp: là biểu diễn trạng thái kế tiếp
Ví dụ: Si: goto sj: nhảy đến trạng thái sj

7. If – then - else
Cú pháp:
If exps then state_exp1
[else state_exp2];
Hay if exp1 exp2 then state_exp2
[else if..]
Else state_expn;
Mục đích: Phát biểu IF-THEN-ELSE: Mô tả sự chuyển hóa trạng thái theo
điều kiện ngõ vào.
Nếu biểu thức ngay sau từ khóa if là đúng, chuyển biến hướng trạng
thái ngay sau từ khóa then; nến sai chuyển biến hướng đến trạng thái ngay
sau từ khóa else.
Sử dụng:
exp: là biểu thức bất kì hợp lệ nào
State_exp1,state_exp2... là biểu thức biểu diễn trạng thái kế tiếp. các
phát biểu if-then-else có thể được nối với nhau liên tiếp nhưng kết thúc
phải là dấu chấm phẩy.
Vidụ:
State 1: IF(A == B) then 2; “ nếu a = b chuyển đến trạng thái 2
State 2: if A then 3 else 4; “ nếu a đúng (#0) chuyển đến trạng thái 3
Nếu a sai (=0) chuyển đến trạng thái 4
State 0: If a then 1
Else if b then 2
Else if c then 3
Else 0;

8. Phát biểu case

Cú pháp:
case [ exps1 : state + exp1;]
[expsi: state_expi;]
End case;
Mục đích:
Phát biểu case mô tả sự chuyển biến trạng thái trong trường hợp có
nhiều điều kiện tác động
Sử dụng:
Tránh không để 2 điều kiện xảy ra cùng 1 lúc và tránh trường hợp kết
quả trạng thái kế không đoán trước được
Ví dụ:
STATE S0

194
 CASE (sel == 0): s0;
(sel == 1): s1;
ENDCASE
9. Phát biểu test_vectors:
Cú pháp:
Text vecters[‘note’]] (inputs -> outputs)
[invalues -> out values]
Mục đích:
Các test_vectors dùng để mô phỏng hoạt động của hệ và kiểm tra các
chức năng hoạt động của hệ khi chạy chương trình mô phỏng
Sử dung:
Note : là một chuỗi ký tự để mô tả các test_vectors
Inputs : Là một danh định hay tập hợp các danh định tên các tín hiệu
vào hay hồi tiếp về ngõ vào của hệ
Outputs : Là một danh định hay tập hợp các danh định tên các tín hiệu
ra của hệ
Invalues : là một hay tập hợp các giá trị vào
Outvalues : Là một hay tập hợp các giá trị ra là hàm logic của các giá
tri vào và các giá trị trạng thái (hệ tuần tự)
Ví du:
Equations
C = A&B; “C = A.B
D = A#B; “D = A+B
Text_vector ([A,B] -> [C,D])
[0,0] -> [0,0]
[0,1] -> [0.1]
[1,0] -> [0.1]
[1,1] -> [1,1]

10. Phát biểu istype

Cú pháp:
Signal [ , signal] ... istype ‘ attr [,attr]...’;
Hay signal [,signal]....pin istype ‘attr[,attr]... ‘;
Mục đích:
Phát biểu istype định nghĩa các thuộc tính của pin hay node lập trình
được của các công cụ (PLD).
Các thuộc tính của pin hay node có thể khai bào cùng một dòng
Sử dụng:
Signal : là một danh hiệu pin hay node
Attr : là một chuỗi các ký tự xác dịnh các thuộc tính của signal
Các thuộc tính hợp lệ là:
‘buffer’ : đệm
‘com’ : hệ tổ hợp
‘invert’ : đảo

195
 ‘neg’ : tích cực mức thấp
‘pos’ : tích cực mức cao
‘reg’ : thanh ghi hệ tuần tự
‘reg_D’, ‘reg_T’. ‘ reg_JK’, ‘reg_SR’ : các FF,D,T,SR
Ví dụ:
F0, A istype ‘neg,reg’;
Istype định nghĩa F0,A là tín hiệu của thanh ghi, tác động mức thấp outputs
pin 15 istype ‘reg, invert’
Tín hiệu output chân 15 của thanh ghi rõ đảo (ngõ ra Q đảo)
11. Phát biểu end
Cú pháp:
END
Hay end modname
Mục đích :
Dùng kết hợp với các phát biểu module để mở đầu và kết thúc
module chương trình
Sử dụng :
Signal : là một danh hiệu pin hay node
Attr : Là một chuỗi ký tự xác định các thuộc tính của các signal
Các thuộc tính hợp lệ :
‘buffer’ : đệm
‘com’ : hệ tổ hợp
‘invert’ : đảo
‘neg’ : tích cực mức thấp
‘pos’ : tích cực mức cao
‘reg’ : thanh ghi hệ tuần tự
‘reg_D’, ‘reg_T’. ‘ reg_JK’, ‘reg_SR’ : các FF,D,T,SR
Ví dụ:
F0, A istype ‘neg,reg’;
Istype định nghĩa F0,A là tín hiệu của thanh ghi, tác động mức thấp
outputs pin 15 istype ‘reg, invert’
Tín hiệu output chân 15 của thanh ghi rõ đảo (ngõ ra Q đảo)
3.2.4. Các khai báo (Declarations)
1. Pin
Cú pháp:
[!]pin_id[,[1]pin_id...]pin[pin#[,pin#]] istype ‘ attr’];
Mục đích:
Từ khóa pin dùng để khai báo các tín hiệu input và output, là nhưng
tín hiệu in/out quy định sẵn trên dụng cụ (theo cửa sổ tra cứu). Khai báo
cũng có thể định nghĩa thuộc tính chân, khi 1 danh sách định chân và số
chân có trong cùng một khai báo chân, sẽ có sự tương ứng 1-1 giữa danh
định chân và số chân
Sử dụng:
Pin_id: là một danh hiệu dùng để đặt tên cho 1 chân

196
 Pin # : là số thứu tự chân trên dụng cụ (PLD) thật
Attr : là một chuỗi xác định các thuộc tính chân
! : ký hiệu NOT,tích cực mức thấp
Ví dụ:
!clock,reset,S1 pin 12,15,3;
Khai báo nàygán tên chân: clock chân 12,reset chân 15,S1 chân 3
!clock : tích cực mức 0
2. Node
Cú pháp:
[!]node_id[,[!]node_id...]node[node#[node#...][istype’attr’];
Mục đích:
Từ khóa node dùng để khai báo những tín hiệu gán cho những nút ấn
trong dụng cụ
Sử dụng:
Node_id : là một danh hiệu dùng để đặt tên cho 1 nút
Nodu# : là số thứ tự nút trên dụng cụ thật(nút tương đương như chân
ẩn trong dụng cụ và số nút được cho trong sổ tay tra cứu)
Ví dụ:
B node istype’reg’ : xác định nút B là một ngõ của FF trong dụng cụ
A,B node 25,26 : gán tên A là nút 25 , gán tên B là nút 26. Số nút này do
nhà sản xuất quy định trong sổ tay tra cứu
3. Dụng cụ (Device)
Cú pháp: Device-id device real_device
Mục đích:
Khai báo device cho một PLD thật. Trong qua trình biên dịch, các hàm
logic sẽ được đưa về dạng theo cấu trúc cổng đúng như của dụng cụ thật.
Sử dụng:
Device-id : là một danh hiệu, chính là ten file fusemap
Real-device : mô tả mã số dụng cụ (PLD) đặt giữa 2 dấu nháy đơn (‘)
Phải đặt dấu ; sau khai bao
Ví dụ: D1 sevice ‘P16R4’: khai bào này cho biết D1 là loại PLD PAL 16R4

3.2.5. Các khai báo khác (OTHER DECLARATIONS)

1. Hằng (constant)
Cú pháp :
Id[,id]...= expr[,expr]ư...;
Mục đích:
Khai báo hằng định nghĩa những hằng số được dùng trong một module
Sử dụng:
Id: là một danh hiệu đặt tên cho 1 hằng
Expr: xác định giá trị hằng
Ví dụ:
X = .X.; “ X mang ý nghĩa không xác định
Z = .Z.; “ Z mang ý nghĩa tổng trở cao

197
C = .C.; “ C mang ý nghĩa tác động cạnh lên
A = ^b01; “ số nhị phân
B= ^h16 ; “ số hex
C = 10; “ số thập phân
2. Tập hợp (set)
Định nghĩa : Tập hợp là tập hợp những tín hiệu và hằng số mà tác vụ thực
hiện như là một đơn vị
Bất cứ tác vụ nào áp dụng cho một tập hợp sẽ được áp dụng cho mỗi
phẩn tử trong tập hợp
Tập hợp sẽ làm đơn giản việc mô tả logic và các test-vectors bằng
cách chỉ cần dùng tên gọi tập hợp
Sử dụng: Một tập hợp được đại diện bởi một danh sách các hằng số và tín
hiệu bằng các dấu phẩy hay dấu khoảng (..), đặt trong dấu ngoặc vuông ([
]). Sau mỗi khai báo tập hợp phải có dấu chấm phẩy
Ví dụ:
MULOUT = [B0,B1,B2,B3,B4,B5,B6,B7];
Hay MULOUT = [ B0...B7]Ư;
MULOUT là khai báo là tên một tập hợp gồm 8 tín hiệu từ B0 đến B7
BCD = [D,C,B,A]Ư
LED=[g,f,e,d,c,b,a]ư
Test-sectors (BCD -> LED)
[0,0,0,0] -> [1,0,0,0,0,0,0]
BCD là 1 tập hợp gồm các tín hiệu D,C,B,A
LED là 1 tạp hợp gồm các tín hiệu D,C,B,A
LED là 1 tập hơp gồm các tín hiệu g,f,e,d,c,b,a
3. macro
Cú pháp:
Macro_id macro [(dummy_arg [,dummy_arg]..)]{block};
Mục đích:
Khai báo macro định nghĩa 1 macro thực hiện các chức năng, các phép
toán, biểu thức logic trong một khối.
Chỉ định nghĩa macro 1 lần trong phần khai báo macro trong module
và sẽ được dùng bất cứ nơi nào trong module
Khai báo macro tương tự như trong trình hợp ngữ
Macro chỉ có thể được dùng trong module mà nó được khai báo
Sử dụng:
Macro_id: là một danh hiêuh đắt tên cho macro
Dummy_arg : là một thong số hình thức
Block: là các biểu thức logic
Ví du:
NAND3 macro (A,B,C) {!(A&B&C)}
NAND3 là macro thực hiện chức năng hàm logic A,B,C đảo với A,B,C là
các thông số hình thức
Sau đó trong các module khái bào macro này ta có khai báo:

198
D = NAND3 (Clock, Hello , busy);
Kết quả là D = !(Clock,Hello,Busy) khi biên dịch

4. Enable
Cú pháp:
Enable output_id = [!]expr;

Mục đích:
Khái bào enable cho các ngoc ra 3 trạng thái hoạt động theo tín hiệu điều
khiển bởi giá trị của expr
Sử dụng khai báo này theo sau phát biểu equations

Sử dụng:
Output_id : là danh hiệu đặt tên cho một ngõ ra hoặc một tập hợp ngõ ra
Expr : là một biểu thức logic
Ví dụ:
OE pin 11;
F0,F1,F2,F3 pin 19,18,17,16;
Count = [F0,F1,F2,F3];
Equations
Enable count = !OE
Các ngõ ra từ F0 đến F3 trong tập hợp các count là các ngõ ra 3 trạng thái,
sẽ hoạt động khi OE = 0 và sẽ ở trạng thái high-Z khi OE = 1
Có thể sử dụng tiếp vĩ ngữ. OE thay cho các khai bào enable ( xem phần
tiếp vĩ ngữ)

3.2.6. Các toán tử (OPERATORS)

1. Toán tử chuẩn (standard)
! NOT = toán tử gắn cho biểu thức tổ hợp
# OR = toán tử gán cho biểu thức thanh ghi (tuần tự)
& AND
$ XOR
!$ XNOR
Ngoài ra các từ khoa s@ALTERNATE báo cho trình biên dịch biết bộ toán
tử tương đương (alternate) thay thế cho bộ toán tử chuẩn (các ký hiệu dễ
nhớ hơn)
Bộ toán tử thay thế (phải có từ khóa @ALTERNATE ở đầu module
chương trình)
/ NOT
* AND
+ OR
:+: XOR
:*: XNOR

199
2. Toán tử so sánh
== bằng
!= không bằng
< nhỏ hơn
> lớn hơn
<= nhỏ hơn hoặc bằng
>= lớn hơn hoặc bằng
Ngoài ra còn cho phép viết các biểu thức điều kiện , biểu thức này sẽ trả về
1 nếu thỏa điều kiện và trả về 0 nếu không thỏa điều kiện
Ví dụ
Q = (P = = 1); “Q sẽ bằng 1 nếu P=1 và Q sẽ bằng 0 nếu P khác 1

5. Các tiếp đầu ngữ (Prefix), tiếp vĩ ngữ (suffix)

- Tiếp đầu ngữ:
Toán tử Not (! Hay /) được dùng như tiếp đầu ngữ để báo trình biên
dịc biết tín hiệu hoạt động (tích cực) ở mức logic
Ví dụ :
!Q0 pin 15; tương đương với Q0 pin 15 istypr;-neg’;
- Tiếp vĩ ngữ:
Các tiếp vĩ ngữ thường được dùng trong chế độ thanh ghi để truy
xuất đến từng chân nội trong thanh ghi
Ví dụ:
Q0.Ck truy xuất đến chân clock của tín hiệu ra Q0 ở chế độ thanh ghi
Tương tự đối với .RE,.PR.D,.T....lần lượt truy xuất đến các chân
reset,preset,D,T của thanh ghi
Tiếp vĩ ngữ .OE cho phép xuất ở ngõ ra 3 trạng thái

Ví dụ:
Out.oe = !ena;
Ena =0 -> ngõ ra out đươc phép xuất
Ena =1 -> ngõ ra out ở trạng thái high-Z

200
B. Thực hành
1. Vật tư - Thiết bị - Dụng cụ cho 1 ca thực tập

TT Tên Số lượng
Máy vi tính cài đặt đầy đủ các phần
mềm hỗ trợ có cấu hình tối thiểu:
(Mainboard của Gigabyte, CPU
1 Core i3 hoặc i7, Ram 2GB trở lên, 16
HDD 250GB trở lên, Card màn hình
512MB trở lên, LCD 19")

2 Digital Oscilloscope 09

3 Chíp EPM7128 và bộ nạp 09

4 Thiết bị thí nghiệm PLD 09

2. Quy trình thực hiện:

- Bước 1: Sử dụng ngôn ngữ VHDL Thiết kế vi mạch số lập trình theo yêu
cầu bài toán (VHDL file)
- Bước 2: Kiểm tra chương trình thiết kế mạch logic
- Bước 3: Mô phỏng thiết kế thông qua bảng trạng thái mức logic
input/output, hoặc sử dụng giản đồ thời gian.
- Bước 4: Lựa chọn cầu hình cho vi mạch và nạp chương trình
- Bước 5: Kiểm tra kết quả:
3. Chia nhóm: 2 sinh viên/máy
4. Các dạng sai hỏng thường gặp, nguyên nhân – Biện pháp khắc phục

TT Sai hỏng Nguyên nhân Khắc phục

Chương trình báo Kiểm tra lỗi trên Output
1 Sai cú pháp lệnh
lỗi Window và sửa chữa
Chưa cài đặt
Không nhận diện
2 Drive cho thiết Cài đặt driver cho thiết bị
được thiết bị
bị
Kiểm tra thông số trên
Không nạp được Chọn chưa đúng
3 phần mềm nạp chương
chương trình thông số thiết bị
trình

201
C. Đánh giá kết quả : (tính theo thang điểm 10)

Mục tiêu Nội dung Điểm chuẩn

+ Kiến thức:
- Trình bày được cấu trúc chung của một
chương trình VHDL và ABEL theo nội
Kiến thức dung đã học; 2
- Trình bày được các cú pháp, tính năng
các dòng lệnh theo nội dung đã học;

- Thực hiện viết chương trình thiết kế

các cổng và các mạch logic cơ bản theo
5
Kỹ năng đúng yêu cầu kỹ thuật.
- Nạp được chương trình cho vi mạch số.
- Rèn luyện tính tỉ mỉ, chính xác, an toàn
Thái độ 3
và vệ sinh công nghiệp

202
 BÀI 4. PHẦN MỀM ISP SYNARIO VÀ QUARTUS II

Mục tiêu:
+ Kiến thức:
- Trình bày được cách sử dụng công cụ phần mềm phát triển hệ điều khiển
PLD;
+ Kỹ năng:
- Cài đặt được phần mềm Quartus II và ISP Synario theo đúng quy trình kỹ
thuật;
- Sử dụng phần mềm Quartus II và ISP Synario để thực hiện mô hình cụ
thể PLD theo yêu cầu;
+ Thái độ:
- Rèn luyện tính tỉ mỉ, chính xác, an toàn và vệ sinh công nghiệp
Các thuật ngữ chuyên môn: Được giải thích chi tiết trong nội dung bài
học
Nội dung:
A. LÝ THUYẾT
4.1. Phần mềm Quartus II
4.1.1. Giới thiệu phần mềm
Quartus II là phần mềm hỗ trợ tất cả mọi quá trình thiết kế một mạch
logic ; bao gồm quá trình thiết kế, tổng hợp, placement và routing (sắp xếp
và chạy dây), mô phỏng (simulation), và lập trình lên thiết bị (DE2).
4.1.2. Cài đặt phần mềm
Khởi động chương trình cài đặt trên đĩa cài, hoặc bộ cài lưu trong máy

203
Chọn I accept the terms of the license agreement

Chọn ổ lưu trữ chương trình sẽ cài đặt, nếu không mặc định lưu ở ổ C
204
Chọn Complete nếu cài đầy đủ ứng dụng hoặc chọn Custom nếu cài rút gọn

205
206
Bắt đầu quá trình cài đặt (khoảng 10 phút với công đoạn này)

207
208
209
Chọn Yes nếu muốn hiện shortcut trên màn hình, chọn No nếu không muốn
hiện shortcut trên màn hình

210
Kết thúc quá trình cài đặt, trên màn hình như sau

211
4.1.3. Cách nạp chương trình cho Quartus II
Các bước thể hiện quy trình thiết kế số trên các IC có thể lập trình
(FPGA/CPLD) như sau:

Nhập thiết kế: Mạch logic mong muốn được mô tả bằng ngôn ngữ
mô tả phần cứng như VHDL/Verilog hoặc bằng sơ đồ mạch.
- Tổng hợp: Công cụ thực hiện chuyển các biểu diễn mạch điện ở
trên thành dạng tệp netlist, trong đó biểu diễn các thành phần logic cần cho
mạch cùng các kết nối giữa các thành phần logic.
- Mô phỏng chức năng: Mạch đã tổng hợp được kiểm tra để phân
tích tính chính xác về chức năng; trình mô phỏng không quan tâm đến vấn
đề thời gian.
- Fitting: Công cụ CAD Fitter xác định vị trí đặt các thành phần logic
đã đưa ra trong tệp netlist vào
trong FPGA, đồng thời xác định các đường đi dây trong FPGA để
kết nối các thành phần logic.
- Phân tích thời gian: Trễ đường truyền theo các đường khác nhau
trong mạch đã được fit ở trên được phân tích để xác định khả năng hoạt
động mong muốn của mạch.

212
 - Mô phỏng thời gian: Mạch đã được fit được kiểm tra để phân tích
cả về chức năng và cả về mặt thời gian.
- Lập trình và cấu hình: Mạch logic mong muốn được triển khai trên
FPGA/CPLD thực tế thông qua chương trình nạp và cấu hình cho
FPGA/CPLD.

1. Tạo một Project

Bước 1: Chọn mục File > New Project Wizard để mở cửa sổ tạo mới
dự án giống như Hình 2. Chú ý là dự án cần có tên giống với tên của thực
thể thiết kế, nó cho thấy thực thể là mức đỉnh. Chọn tên light làm tên cho
dự án và thực thể mức đỉnh, nhấp chọn Next.

Bước 2: Trong cửa sổ Family & Device Settings, chúng ta sẽ chọn

loại chip, là chip FPGA Cyclone EP2C20F484C7N có trên kit DE1 mà
chúng ta sử dụng trong bài thí nghiệm. Nhấp chọn Next để chuyển sang cửa
sổ chọn kế tiếp.

213
 Bước 3: Trong của sổ kế tiếp, chúng ta có thể chọn lựa bất kỳ công
cụ của hãng thứ ba nào cần dùng. Công cụ CAD thông dụng dùng cho phần
mềm thiết kế mạch điện tử là EDA tools. Vì chúng ta không cần thay đổi gì
trong việc lựa chọn công cụ, nhấp chọn Next.
Bước 4: Quan sát bảng tổng kết các thiết lập vừa thực hiện. Nhấp
chọn Finish để quay trở về màn hình chính của phần mềm Quartus II.

2. Viết chương trình và biên dịch

a. Nhập thiết kế dùng mã VHDL
Trong bài thí nghiệm này, chúng ta sẽ tạo một mạch điều khiển đèn
hai chiều như trong Hình 4. Mạch có thể dùng để điều khiển một đèn LED
khi một trong hai chuyển mạch x1 hoặc x2 đóng, tương ứng với mức logic
“1”. Chú ý rằng chỉ cần dùng hàm XOR cho hai đầu vào x1 và x2, tuy
nhiên chúng ta sẽ xây dựng lại bằng các cổng logic rời rạc.

214
 Bước 1: Chọn mục File > New, trong cửa sổ New, chọn VHDL File,
và nhấp chọn OK. Sau khi nhấp chọn OK thì cửa sổ soạn thảo sẽ hiện ra.
Nhập vào mã VHDL như dưới đây vào trong cửa sổ soạn thảo văn bản.

library IEEE;
use IEEE.STD_LOGIC_1164.all;
entity light is
port( x1, x2: in std_logic;
f : out std_logic);
end light;
architecture Behavioral of light is
begin
f <= (x1 and not x2) or (not x1 and x2);
end Behavioral;

Bước 2: Chọn mục File > Save As để mở cửa sổ Save As. Trong
phần Save as type chọn VHDL File. Trong phần File name nhập light.
Nhấp chọn Save để đưa tệp này vào trong thư mục của dự án.

b. Thêm các tệp thiết kế vào một dự án

Bước 1: Chọn mục Assignments > Settings > Files, điều này dẫn đến
cửa sổ như trong Hình 4. Một cách khác là chọn Project > Add/Remove
Files trong Project. Nếu bạn dùng trình soạn thảo để tạo tệp và chọn vào
hộp có nhãn Add file to current project, thì tệp light.vhd đã có trong dự án,
ngược lại tệp này cần thêm vào dự án.

215
 Bước 2: Nhấp chọn nút … bên cạnh phần File name để có cửa sổ
chọn tệp cần thêm vào. Nhấp chọn tệp light.vhd và nhấp chọn Open. Tệp đã
chọn sẽ hiện tên trên phần File name. Nhấp chọn Add và OK để đưa tệp
này vào dự án.

c. Biên dịch mã VHDL

Bước 1: Nhấp chọn mục Processing > Start Complication. Biên dịch
thành công (hay không thành công) sẽ được thông báo trên hộp thoại bung
ra sau khi quá trình biên dịch kết thúc. Xác nhận bằng cách nhấp nút OK.
Bước 2: Khi biên dịch hoàn thành, một báo cáo biên dịch được đưa
ra. Cửa sổ này cũng có thể mở ra bất kỳ lúc nào bằng cách nhấp chọn
Processing > Complication Report. Trong báo cáo này bao gồm một số
danh mục ở bên trái cửa sổ, nhấp vào các danh mục này để thấy thông tin
chi tiết của danh mục này hiện lên ở bên phải cửa sổ.

d. Sửa các lỗi

Bước 1: Mở tệp light.vhd, dòng có câu lệnh gán biểu thức logic cho
f, ta bỏ dấu chấm phẩy ở cuối dòng lệnh, lưu thay đổi với tệp light.vhd rồi
biên dịch lại dự án. Lúc này phần mềm sẽ thông báo là biên dịch không
thành công và báo cáo tổng hợp đưa ra kết quả biên dịch dự án bị hỏng.
216
 Bước 2: Chọn mục Analysis & Synthesis > Messages để hiển thị
thông báo lỗi. Nhấp đôi vào thông báo lỗi đầu tiên, dòng lệnh lỗi sẽ được
đánh dấu trên trình soạn thảo văn bản, sửa lại cho đúng rồi biên dịch lại dự
án.

e. Gán chân
Chúng ta sẽ gán các chuyển mạch gạt SW0 và SW1 làm các đầu vào
x1 và x2 cho mạch điện. Các chuyển mạch này nối với các chân L22 và L21
của FPGA. Và chúng ta sẽ gán đầu ra f tới LEDG0, được kết nối với chân
U22 của FPGA.
Bước 1: Nhấp chọn Assignments > Assignment Editor. Trong
Category chọn Pin. Nhấp đôi vào <<new>>. Nhấp chọn x1 từ danh sách
trải xuống làm chân đầu tiên được gán. Tiếp đến nhấp đôi vào hộp bên phải
hộp dành cho x1 (cột Location). Chọn chân PIN_L22 từ danh mục hoặc có
thể gõ trực tiếp L22 vào hộp Location.

Bước 2: Tương tự như trên, thực hiện gán chân cho đầu vào x2 cho
chân L21 và đầu ra f cho chân U22.
Bước 3: Sau khi hoàn thành việc gán chân, nhấp chọn File > Save.
Đóng cửa sổ Assignment Editor, nhấp chọn Yes và biên dịch lại mạch.

3. Mô phỏng mạch thiết kế

Bước 1: Mở cửa sổ Waveform Editor bằng cách nhấp File > New,
trong cửa sổ chọn dạng tệp, chọn Vector Waveform File và nhấp OK.Cửa
sổ Waveform Editor sẽ hiện ra trên giao diện chính. Lưu tệp này với tên
Light.vwf.
Bước 2: Nhấp chọn Edit > End Time và nhập vào 200 ns trong hộp
thoại bung ra, điều này cho phép thời gian mô phỏng từ 0 dến 200 ns. Nhấp
chọn View > Fit in Window để nhìn thấy toàn bộ phần mô phỏng từ 0 đến
200 ns.
Bước 3: Nhấp chọn Edit > Insert > Insert Node or Bus để mở cửa sổ
nhập các đầu vào ra. Nhấp nút Node Finder để mở cửa sổ như trong hình 7,
217
đặt phần Filter là Pins: all. Nhấp chọn nút List để tìm các đầu vào và ra trên
phần bên trái cửa sổ.

Bước 4: Nhấp chọn các đầu vào ra bên cửa sổ bên trái rồi nhấp nút >
để đưa đầu tín hiệu đó vào dạng sóng kiểm tra. Khi đã có đủ các đầu vào và
ra, nhấp chọn OK để quay trở lại cửa sổ Waveform Editor.

Bước 5: Đặt x1 bằng ‘0’ trong đoạn từ 0 ns đến 100 ns, tiếp đến đặt
x1 bằng ‘1’ trong đoạn từ 100 ns đến 200 ns bằng cách đặt chuột ở vị trí bắt
đầu đoạn này và nhấp kéo đến hết để đánh dấu vùng đặt giá trị, và chọn giá
trị ‘1’ trên thanh công cụ. Tương tự như vậy đặt x2 bằng 1 từ 50 ns đến 100
ns và từ 150 ns đến 200 ns.
Bước 6: Thực hiện mô phỏng

218
 Mô phỏng chức năng Nhấp chọn Assignments > Settings. Bên trái
của cửa sổ Settings nhấp chọn Simulator Settings để có cửa sổ như trong
Hình 8, chọn Functional trong mục chọn chế độ mô phỏng, và nhấp OK

219
 Nhấp chọn Processing > Generate Functional Simulation Netlist.
Sau đó nhấp chọn Processing >
Start Simulation để thực hiện mô phỏng. Kiểm tra dạng song đầu ra f
có đúng theo chức năng của
mạch hay không

Mô phỏng thời gian

- Nhấp chọn Assignments > Settings. Bên trái của cửa sổ Settings
nhấp chọn Simulator Settings để có
cửa sổ như trong Hình 9, chọn Timing trong mục chọn chế độ mô
phỏng, và nhấp OK.
- Sau đó thực hiện mô phỏng theo cách vừa thực hiện như trên, quan
sát dạng sóng đầu ra f và nhận
xét sự khác biệt so với dạng sóng này khi thực hiện mô phỏng chức
năng.

4. Nạp và cấu hình của FPGA

Bước 1: Gạt chuyển mạch RUN/PROG sang vị trí RUN. Nhấp chọn
Tools > Programmer để có cửa sổ như trong Hình 11. Đánh dấu vào tùy
chọn Program/Configue để cho phép nạp tệp cấu hình light.sof.

220
 Bước 2: Nhấp nút Start bên trái cửa sổ để nạp tệp cấu hình này
xuống FPGA. Sau khi nạp thành công xuống
FPGA, hãy kiểm tra mạch điện này thực hiện trên FPGA có chạy
đúng theo chức nămg mong muốn hay
không bằng cách dùng các chuyển mạch SW0 và SW1 để nhập đầu
vào rồi quan sát đầu ra hiển thị trên
LEDG

4.2. Phần mềm ISP Synario

4.2.1. Giới thiệu
Phần mềm Synario của công ty Lattice Semiconductor Corporation
cho phép lập trình các vi mạch PLD đến 14.000 cổng, chương trình có thể
được soạn thảo dưới dạng sơ đồ mạch logic hoặc bằng ngôn ngữ HDL.

4.2.2. Khởi động Synario

Gọi chương trình bẳng cách kích đúp vào biểu tượng ISP Synario,
màn hình chính của
Synario xuất hiện như hình dưới đây:

Bắt đầu soạn thảo bằng cách chọn source - new như màn hình dưới đây.

221
 Chọn cách soạn thảo bằng sơ đồ bằng cách chọn Schematic hay lập
trình ngôn ngữ HDL chọn ABEL-HDL Module.

Màn hình soạn thảo ngôn ngữ HDL.

222
Chọn tên module, tên file, title.

223
 Màn hình soạn thảo sơ đồ mạch logic

Trên màn hình chính có chứa sơ đồ tên ”donghoso”.Bên phải màn

hình có 3 đề mục lệnh nhằm mục đích kiểm tra, đơn giản và thiết lập sơ đồ
logic trong vi mạch.

224
B. Thực hành
1. Vật tư - Thiết bị - Dụng cụ cho 1 ca thực tập

TT Tên Số lượng
Máy vi tính cài đặt đầy đủ các phần
mềm hỗ trợ có cấu hình tối thiểu:
(Mainboard của Gigabyte, CPU
1 Core i3 hoặc i7, Ram 2GB trở lên, 16
HDD 250GB trở lên, Card màn hình
512MB trở lên, LCD 19")

2 Digital Oscilloscope 09

3 Chíp EPM7128 và bộ nạp 09

4 Thiết bị thí nghiệm PLD 09

2. Quy trình thực hiện:

- Bước 1: Sử dụng ngôn ngữ VHDL và phần mềm Quartus II Thiết kế vi
mạch số lập trình theo yêu cầu của các bài toán.
- Bước 2: Kiểm tra chương trình thiết kế mạch logic
- Bước 3: Mô phỏng thiết kế thông qua bảng trạng thái mức logic
input/output, hoặc sử dụng giản đồ thời gian.
- Bước 4: Lựa chọn cầu hình cho vi mạch và nạp chương trình
- Bước 5: Kiểm tra kết quả:

3. Chia nhóm: 2 sinh viên/máy

4. Các dạng sai hỏng thường gặp, nguyên nhân – Biện pháp khắc phục

TT Sai hỏng Nguyên nhân Khắc phục

Chương trình báo Kiểm tra lỗi trên Output
1 Sai cú pháp lệnh
lỗi Window và sửa chữa
Chưa cài đặt
Không nhận diện
2 Drive cho thiết Cài đặt driver cho thiết bị
được thiết bị
bị
Kiểm tra thông số trên
Không nạp được Chọn chưa đúng
3 phần mềm nạp chương
chương trình thông số thiết bị
trình

225
C. Đánh giá kết quả : (tính theo thang điểm 10)

Mục tiêu Nội dung Điểm chuẩn

- Trình bày được cách sử dụng công cụ

phần mềm phát triển hệ điều khiển PLD;

- Cài đặt được phần mềm Quartus II và

ISP Synario theo đúng quy trình kỹ thuật;
Kiến thức 2
- Sử dụng phần mềm Quartus II và ISP
Synario để thực hiện mô hình cụ thể PLD
theo yêu cầu;
- Rèn luyện tính tỉ mỉ, chính xác, an toàn
và vệ sinh công nghiệp

- Cài đặt được phần mềm Quartus II và

ISP Synario theo đúng quy trình kỹ thuật;
- Sử dụng phần mềm Quartus II và ISP
5
Kỹ năng Synario để thực hiện mô hình cụ thể PLD
theo yêu cầu;

- Rèn luyện tính tỉ mỉ, chính xác, an toàn

Thái độ và vệ sinh công nghiệp 3

226
 BÀI 5. HỌ CPLD

Mục tiêu:
+ Kiến thức:
- Trình bày được cấu trúc logic của họ CPLD thông dụng;
- Trình bày được các tính năng cần thiết của thiết bị để khai thác và sử
dụng thiết bị hiệu quả theo yêu cầu kỹ thuật;
+ Kỹ năng:
- Sử dụng thành thạo ngôn ngữ VHDL, phần mềm Quartus II cho vi mạch
CPLD EMP7128;
- Sử dụng thành thạo kit thí nghiệm CPLD sử dụng vi mạch EMP7128;
+ Thái độ:
- Rèn luyện tính tỉ mỉ, chính xác, an toàn và vệ sinh công nghiệp
Các thuật ngữ chuyên môn: Được giải thích chi tiết trong nội dung bài
học
Nội dung:
A. LÝ THUYẾT
5.1. Giới thiệu chung
CPLD là tên gọi tổng quát của một IC số mà người ta có thể lập trình
được nó để thực hiện các hàm logic khác nhau. Nó là một chip chứa các
cấu trúc mạch có qui luật cho phép người thiết kế tạo các ứng dụng cụ thể.
Cấu trúc mạch trong CPLD thông thường là một dãy các ô nhớ đồng dạng
mà có thể lập trình từng ô nhớ được (các dãy OR hoặc dãy AND hoặc cả
hai).
CPLD là sự phát triển tiếp của PLD như PLA ,PAL. Phần tử cơ bản
của CPLD là các MACROCELL (tế bào vĩ mô).
CPLD gồm nhiều khối tương tự PAL, chứa 2 đến 100 khối mỗi khối
16 macrocel, mỗi macrocell có 20 cổng logic. CPLD có các đặc điểm sau:
- Khả năng tích hợp lớn: Bạn có thể giảm khối lượng về mạch thiết kế
trong khi vẫn có thể tăng chức năng cho mạch của bạn.
- Tiết kiệm năng lượng: Sử dụng công nghệ CMOS và một số ít hơn các
mạch kết hợp sẽ làm giảm đáng kể công suất nguồn cung cấp.
- Độ tin cậy cao: Nguồn cung cấp thấp và việc giảm tối đa các mạch liên
kết ở ngoài làm cho việc truyền giữa các khối đáng tin cậy hơn.
- Giá thành thấp.
- Dễ sử dụng.
- Dễ dàng thay đổi. Khi bạn cần có sự thay đổi trong thiết kế của bạn, bạn
không cần phải thêm thắt các “dây nối”, tất cả là thay đổi bên trong của
CPLD và bạn có thể thực hiện các thay đổi đó một cách nhanh chóng.
CPLD được ứng dụng rất rộng rãi trong nhiều lĩnh vực: Hàng không
vũ trụ & quốc phòng, ô tô, công nghiệp/khoa học & y tế, truyền thông
không dây và có dây, công nghệ video số, kiểm tra và đo lường, hàng tiêu
dùng ...
Một số ứng dụng chính của công nghệ IC khả trình:

227
228
5.2. Vi mạch CPLD (EPM7128)

229
5.2.1 Sơ đồ chân của EPM7128

EPM7128S có các thông số kỹ thuật sau: Có thể sử dụng 2500 cổng,

128 macrocells, 8 khối logic mảng, 100 cổng vào/ra, tPD (không có điện trở
nối đầu vào đầu ra) = 6 ns, tSU (thời gian cài đặt xung ) = 3.4 ns, tFSU (thời
gian cài đặt xung của đầu vào nhanh) = 2.5 ns, tCO1 (xung tới đầu ra trễ) =
4 ns, fCNT (tần số xung nội bộ lớn nhất) = 147.1MHz.

5.2.2. Sơ đồ cấu trúc của EPM7128

a. Sơ đồ cấu trúc

230
 Cấu trúc của EMP1728 đươc cấu thành từ các kiên kết linh hoạt với
hiêu suất cao. Modul mảng logic được gọi là khối mảng logic (LABs: logic
array blocks). LABs bao gồm 16 mảng macrocell. Nhiều LABs được liên
kết với nhau thông qua việc lập trình kết nối mảng (PIA: programmable
interconnect array), một bus được cung cấp bằng tất cả các đầu vào chuyên
dụng, cực vào/ra, và các macrocell.
Mỗi LAB được cung cấp bằng các tín hiệu sau đây:
- 36 tín hiệu từ các PIA được sử dụng cho các đầu vào logic chung.
- Các điều khiển tổng thể được sử dụng cho các chức năng thanh ghi không
quan trọng.
- Các đường đầu vào trực tiếp từ các chân vào/ra tới thanh ghi mà được sử
dụng cho thời gian thiết lập nhanh.

b. Macrocell của EPM7128

Macrocell có thể thực hiện SOP (tổng của tích ) với 40 đầu vào; có
thể cấu hình như DFF,TFF, thanh ghi, LATCH; có thể nhận tín hiệu từ
IMD, trực tiếp từ I/O PIN. Ngoài ra Macrocell hoạt động cho mạch tổ hợp,
mạch tuần tự.
Cấu trúc của Macrocell:

231
: (programmable cell) Tế bào lập trình
PTA,B,C: (product term signals) Cấu trúc tín hiệu
CTS: (control term set) Đặt cấu trúc điều khiển
CTR: (control term reset) Đặt lại cấu trúc điều khiển
CTC: (control term clock) Cấu trúc điều khiển xung clock
GSR: (global set/reset signal) Đặt/đặt lại tín hiệu tổng quát.
Phía bên trái là mảng PLA. Bên phải có một FF và các bộ dồn kênh hình
thang. Bộ dồn kênh MUX ES không thể hiện rõ đường lựa chọn của chúng
khi các bít làm việc, sự lựa chọn được lưu trong bộ nhớ và được thay đổi
bởi sự lập trình bên trong các tế bào nhớ. FF có thể được cấu hình như loại
D,T, chốt lý tưởng. Clock có thể xảy ra theo sườn khác nhau(either edge).
Nguồn có thể là riêng lẻ hoặc chế độ DualEDGE. Set có thể chọn từ GND,
GSR, CTS, hoặc PTA.

Hình trên tập trung vào cấu trúc Mux/OR/EX-OR và đầu vào của OR, của
MUX. MUX điều khiển một chân EX-OR cung cấp lựa chọn Vcc(1) hoặc
GND(0). MUX có thể gán trực tiếp p-term hoặc đảo của nó. Một p-term có
thể trực tiếp thông qua mux đi ra EX-OR(going out) or đảo của nó exit EX-
OR.
232
Tín hiệu này sau đó gán cho flop hoặc đi vòng tới cực I/O. Tốc độ được lợi
3ns. Chú ý rằng cấu truc sản phẩm cho macocell 1 khác cho 2, 3 hay
macrocell 16.
Macrocell được ứng dụng để điều khiển động cơ bước, giao tiếp có dây và
không dây, video số và trong các thiết bị sách tay như: điện thoại, MP3,
PDA...

Macrocell có thể được định dạng riêng lẻ cho cả hai hoạt động logic
tổ hợp hoặc tuần tự. Macrocell bao gồm ba khối chức năng: mảng logic, ma
trận chọn sản phẩm giới hạn, và thanh ghi lập trình.
Logic tổ hợp được thực hiện trong các mảng logic, mà cung cấp năm
sản phẩm giới hạn từ macrocell. Ma trận chọn sản phẩm giới hạn phân bổ
các sản phẩm các sản phẩm giới hạn này cho việc sử dụng 1 trong 2 đầu
vào logic cơ bản (cổng OR hoặc XOR) để thực hiện chức năng tổ hợp;
hoặc là cho các đầu vào không quan trọng để thanh ghi của macrocell có
thể xóa, cài đặt trước, tạo xung, và điều khiển xung. Hai loại sản phẩm giới
hạn mở rộng được sẵn để bổ sung nguồn logic macrocell:
- Các bộ mở rộng có thể chia sẻ (Shareable expanders) là các sản phẩm đảo
giới hạn mà được cung cấp trở lại bên trong mảng logic.
- Các bộ mở rộng song song, là sản phẩm giới hạn được mượn từ các
macrocell liền kề.
Hệ thống phát triển tự động tối ưu hóa sản phẩm giới hạn phân bổ
theo các yêu cầu logic của thiết kế.
Đối với các thanh ghi chức năng, mỗi macrocell flipflop có thể được
lập trình riêng rẽ để thực hiện hoạt động D, T, JK, hoặc SR với điều khiển
lập trình xung. Flipflop có thể được bỏ qua cho các hoạt động tổ hợp.Trong
mục thiết kế, nhà thiết kế chỉ định loại flipflop mong muốn; cácAltera phát

233
triển phần mềm sau đó chọn flipflop hoạt động hiệu quả nhất đối với mỗi
thanh ghi chức năng để tối ưu hóa việc sử dụng nguồn bổ sung.
Mỗi thanh ghi lập trình đăng ký có thể ghi tốc độ trong ba chế độ
khác nhau:
- Bằng một tín hiệu đồng hồ. Chế độ này đạt được hiệu suất đầu ra nhanh
nhất.
- Bằng một tín hiệu đồng tổng thể và được kích hoạt bởi một đồng hồ đang
hoạt động mức cao. Chế độ này cung cấp thứ có thể trên mỗi flipflop trong
khi vẫn còn đạt được hiệu suất đầu ra nhanh của đồng tổng thể .
- Bằng một đồng hồ mảng được triển khai thực hiện với một sản phẩm giới
hạn. Trong chế độ này , flipflop có thể được khóa bằng các tín hiệu từ các
macrocell đã cất giấu hay các cực vào/ra.

5.2.3. Điều kiện hoạt động của EPM7128

234
Ghi chú:
- Những giá trị này được quy định theo các điều kiện hoạt động
khuyến cáo được hiển thị trong bảng sau:

235
- Xem hình dưới đây để biết thêm thông tin về chuyển đổi dạng sóng:

236
- Mối quan hệ của dòng điện so với tần số:

237
5. 3. Thực hành trên KIT CPLD
5.3.1. Các mạch điện trong bộ thí nghiệm CPLD
- Mạch cổng truyền thông

- Khối Card mở rộng

238
- Khối Led 7 thanh

- Khối nguồn

239
- Khối CPU

240
- Khối Input

241
- Sơ đồ tổng quát

5.3.2. Cách nạp chương trình cho EPM7128

a. Tạo một project
Bước 1. Vào Menu File chọn New Project Wizard

242
Bước 2. Ấn Next để tiếp tục

Bước 3. Ta chọn thư mục để chứa project và đặt tên cho project, xem hình
dưới

243
Bước 4. Sau đó ta chọn hãng sản xuất chip và tên loại chip trên mạch

244
Bước 5. Cuối cùng chọn Finish để hoàn tất

245
5.2.2. Viết chương trình, biên dịch và nạp
Bước 1. Vào Menu File chọn New

Bước 2. Sau đó chọn loại file mà chúng ta muốn viết chương trình. Ở đây
ta chọn loai file Verilog HDL

Bước 3. Dưới đây là một đoạn chương trình demo: tính hàm f = x1 OR x2

246
Bước 4. Sau khi viết xong thì ta phải lưu tên file trùng với tên module của
chương trình

Chú ý: Chọn Add file to current project

247
Bước 5. Sau khi lưu file xong phải thiết lập cho file là top-level thì mới
biên dịch được

Bước 6. Biên dịch chương trình lần 1: Chọn Processing/Start Compilation

248
Bước 7. Đặt cấu hình vào/ra chân chip: Vào Assignments chọn Pins

249
250
Bước 8. Biên dịch chương trình lần 2:

Bước 9. Gọi chương trình nạp:

251
Bước 9. Ấn Start để nạp chương trình:

5.2.3. Thiết kế các cổng logic cơ bản

Mã code:
Library IEEE ;
use IEEE.std_logic_1164.all ;
use IEEE.std_logic_arith.all ;
use IEEE.std_logic_unsigned.all ;
entity logicgate is
Port
(
A: in std_logic_vector(7 downto 0);
B: in std_logic_vector(7 downto 0);
Y: out std_logic_vector(7 downto 0)
);
end logicgate;
architecture Behaviour of logicgate is
begin
-- cong OR them phu dinh
process (A(0),B(0))
begin
Y(0)<= not (A(0) OR B(0));
end process;
-- cong NOR
252
 process (A(1),B(1))
begin
Y(1)<= not (A(1) OR B(1));
end process;
-- cong AND them phu dinh
process (A(2),B(2))
begin
Y(2)<= not (A(2) AND B(2));
end process;
-- cong NAND them phu dinh
process (A(3),B(3))
begin
Y(3)<= (A(3) AND B(3));
end process;
-- cong XOR them phu dinh
process (A(4),B(4))
begin
Y(4)<= NOT (A(4) XOR B(4));
end process;
-- cong XOR them phu dinh
process (A(5),B(5))
begin
Y(5)<= (A(5) XOR B(5));
end process;
-- cong NOT them phu dinh
process (A(6))
begin
Y(6)<= A(6);
end process;
-- cong NOT them phu dinh
process (A(7))
begin
Y(7)<= A(7);
end process;
end Behaviour;

Phần 1 : Tạo mới một dự án

Bước 1: Khởi động phần mềm Quartus II và kích đúp chuột vào Create a
New Project để mở cửa sổ tạo mới dự án. Chú ý là dự án cần có tên giống
với tên mà ta đã khai báo trên code. Ở ví dụ 1 ta chọn tên logicgate làm tên
dự án , nhấp chọn Next .

253
254
Bước 2: Trong cửa sổ Family – Device settings chúng ta chọn loại chip , là
chip MAX7000S/EPM7128SLC84-15 mà chúng ta sử dụng trong bài.
Nhấp chọn Next để chuyển sang cửa sổ chọn kế tiếp, quan sát bảng tổng kết
vừa thiếp lập và nhấp chọn finish để quay trở về màn hình chính

Phần 2: Nhập thiết kế dùng mã VHDL

Bước 1: Trên màn hình chính ta chọn mục File > New, trong cửa sổ New
chọn VHDL File và nhấp chọn OK. Sau khi nhấp chọn OK cửa sổ soạn thảo
sẽ hiện ra để nhập mã VHDL.

255
Bước 2: Chọn File > Save As để mở cửa sổ Save As Trong phần Save as
type chọn VHDL File. Trong phần File name Nhập logicgate . Nhấp chọn
Save
Phần 3: Thêm các tệp thiết kế vào một dự án .
Bước 1: Chọn mục Assignments > Settings > File ta có cách 2 là chọn
Project > Add/Remove File trong Project
Bước 2: Nhấp chọn nút …. Bên cạnh phần File name để có cửa sổ chọn tệp
vào . Nhấp chọn tệp logicgate.vhd
Chọn Open . Tệp đã chọn sẽ hiện tên lên phần File name. Nhấp chọn Add
và Ok để đưa tệp này vào dự án.

256
Phần 4: Biên dịch mã VHDL
Bước 1: Nhấp chọn mục Processing > Start Complication. Biên dịch thành
công “ Hay không thành công” sẽ được thông báo trên hộp thoại bung ra
sau khi quá trìng biên dịch kết thúc . Xác nhận bằng cách nhấp nút OK
Bước 2: Khi biên dịch hoàn thành , một báo cáo biên dịch được đưa ra .
Nhấp chọn Processing > Complication Report để xem thong tin về lỗi sai
cần sửa.

257
Phần 5: Gán chân
Bước 1: Nhấp chọn Assignments > Assignment Editor. Trong Category
chọn pin. Nhấp đúp vào <<new>> cột To nhấp chọn từ A trải xuống tiếp
đến nhấp đúp vào <<new>> ở cột location và chọn chân.

258
Bước 2: sau khi hoàn thành việc gán chân, ta nhấp chọn File > Save và
biên dịch lại
Phần 7: Mô phỏng mạch thiết kế
Bước 1; Mở cửa sổ Waveform Editor Bằng cách nhấp File > New. Trong
cửa sổ chọn dạng tệp , chọn Vector Waveform file và nhấp chọn Ok. Cửa sổ
Waveform File sẽ hiện ra trên giao diện chính. Lưu tệp này với tên
logicgate.vwf
Bước 2: Nhấp chọn Edit > End Time và nhập vào 200 ns trong hộp thoại .
Điều này cho phép thời gian mô phỏng từ 0 đến 200ns và nhấp chọn View
> Fit in Window để nhìn thấy toàn bộ phần mô phỏng từ 0 đên 200ns

259
Bước 3: Nhấp chọn Edit > Insert > Insert Node or Bus để mở cửa sổ nhập
các đầu vào ra . Nhấp chọn nút Node Finder đặt phần Filter là Pin : all.
Nhấp chọn List để tìm các đầu vào và ra rùi nhầp nút >> để chuyển các
chân ở ô bên trái sang bên phải chon OK > OK

260
Bước 4: Đặt các giá trị cho đầu vào

Bước 5 : Tiến hành mô phỏng

Nhấp chọn File > Save sau đó nhấp chọn processing > Start Simulation để
thực hiện mô phỏng và xem kết quả mô phỏng

261
5.2.4. Thiết kế bộ cộng đầy đủ
CODE:
Library IEEE ;
use IEEE.std_logic_1164.all ;
use IEEE.std_logic_arith.all ;
use IEEE.std_logic_unsigned.all ;
entity fulladder is
port (
X: in bit;
Y: in bit;
Cin: in bit;
Cout: out bit;
Sum: out bit
);
end fulladder;
architecture concurrent of fulladder is
begin
--MUC LOGIC 0 DEN SUM SANG
Sum <= NOT(X xor Y xor Cin);
--MUC LOGIC 0 DEN COUT SANG
Cout <= NOT ((X and Y) or (X and Cin) or (Y and Cin));
end concurrent;

Phần 1 : Tạo mới một dự án

Bước 1: Khởi động phần mềm Quartus II và kích đúp chuột vào Create a
New Project để mở cửa sổ tạo mới dự án. Chú ý là dự án cần có tên giống
với tên mà ta đã khai báo trên code. Ở ví dụ 1 ta chọn tên fulladder làm
tên dự án , nhấp chọn Next .

262
Bước 2: Trong cửa sổ Family – Device settings chúng ta chọn loại chip , là
chip MAX7000S/EPM7128SLC84-15 mà chúng ta sử dụng trong bài.

263
Nhấp chọn Next để chuyển sang cửa sổ chọn kế tiếp, quan sát bảng tổng kết
vừa thiếp lập và nhấp chọn finish để quay trở về màn hình chính

Phần 2: Nhập thiết kế dung mã VHDL

Bước 1: Trên màn hình chính ta chọn mục File > New, trong cửa sổ New
chọn VHDL File và nhấp chọn OK. Sau khi nhấp chọn OK cửa sổ soạn thảo
sẽ hiện ra , nhập mã VHDL.

264
Bước 2: Chọn File > Save As để mở cửa sổ Save As Trong phần Save as
type chọn VHDL File. Trong phần File name Nhập fulladder . Nhấp chọn
Save

Phần 3: Thêm các tệp thiết kế vào một dự án .

Bước 1: Chọn mục Assignments > Settings > File / ta có cách 2 là chọn
Project > Add/Remove File trong Project
Bước 2: Nhấp chọn nút …. Bên cạnh phần File name để có cửa sổ chọn tệp
vào . Nhấp chọn tệp fulladder.vhd
Chọn Open . Tệp đã chọn sẽ hiện tên lên phần File name. Nhấp chọn Add
và Ok để đưa tệp này vào dự án.

265
Phần 4: Biên dịch mã VHDL

Bước 1: Nhấp chọn mục Processing > Start Complication. Biên dịch thành
công “ Hay không thành công” sẽ được thông báo trên hộp thoại mở ra sau
khi quá trìng biên dịch kết thúc . Xác nhận bằng cách nhấp nút OK
Bước 2: Khi biên dịch hoàn thành , một báo cáo biên dịch được đưa ra .
Nhấp chọn Processing > Complication Report để xem thông tin về lỗi sai
cần sửa.

266
Phần 6; Gán chân

Bước 1: Nhấp chọn Assignments > Assignment Editor. Trong Category

chọn pin. Nhấp đúp vào <<new>> cột To nhấp chọn từ A trải xuống tiếp
đến nhấp đúp vào <<new>> ở cột location và chọn chân.

267
Bước 2: sau khi hoàn thành việc gán chân, ta nhấp chọn File > Save và
biên dịch lại

Phần 7 Mô phỏng mạch thiết kế

Bước 1; Mở cửa sổ Waveform Editor Bằng cách nhấp File > New. Trong
cửa sổ chọn dạng tệp , chọn Vector Waveform file và nhấp chọn Ok. Cửa sổ
Waveform File sẽ hiện ra trên giao diện chính. Lưu tệp này với tên
fulladder.vwf
Bước 2: Nhấp chọn Edit > End Time và nhập vào 200 ns trong hộp thoại .
Điều này cho phép thời gian mô phỏng từ 0 đến 200ns và nhấp chọn View
> Fit in Window để nhìn thấy toàn bộ phần mô phỏng từ 0 đến 200ns

268
Bước 3: Nhấp chọn Edit > Insert > Insert Node or Bus để mở cửa sổ nhập
các đầu vào ra . Nhấp chọn nút Node Finder đặt phần Filter là Pin : all.
Nhấp chọn List để tìm các đầu vào và ra rùi nhầp nút >> để chuyển các
chân ở ô bên trái sang bên phải chon OK > OK

269
Bước 4 Đặt các giá trị cho đầuvào

Bước 5 : Tiến hành mô phỏng

Nhấp chọn File > Save sau đó nhấp chọn processing > Start Simulation để
thực hiện mô phỏng và xem kết quả mô phỏng

270
5.2.5. Triger DFF
CODE:
Library IEEE ;
use IEEE.std_logic_1164.all ;
use IEEE.std_logic_arith.all ;
use IEEE.std_logic_unsigned.all ;
entity DFF is
Port
(
d,clk,rst:in std_logic;
q:out std_logic
);
end DFF;
architecture Behaviour of DFF is
begin
process(clk,rst)
begin
-- wait on rst,clk;
if (rst='1') then
q <= '0';
elsif (clk'Event and clk='1') then
q <= d;
end if;
end process;
end Behaviour;

5.2.6. Giải mã 10 4

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity encode is
Port (
Q : out STD_LOGIC_VECTOR (8 downto 0);
R : out STD_LOGIC_VECTOR (3 downto 0);
A : in STD_LOGIC;
B : in STD_LOGIC;
C : in STD_LOGIC;
D : in STD_LOGIC;
E : in STD_LOGIC;
F : in STD_LOGIC;
G : in STD_LOGIC;
H : in STD_LOGIC;
I : in STD_LOGIC;
271
J : in STD_LOGIC;
K : in STD_LOGIC;
L : in STD_LOGIC;
M : in STD_LOGIC);
end encode;
architecture decoder_arch of encode is
signal AIN_DATA : STD_LOGIC_VECTOR(3 downto 0);
signal BIN_DATA : STD_LOGIC_VECTOR(8 downto 0);
begin
AIN_DATA <= D & C & B & A;
BIN_DATA <= M & L & K & J & I & H & G & F & E;
process( AIN_DATA ) begin
case AIN_DATA is
when "0000" => Q <= "000000001";
when "0001" => Q <= "000000010";
when "0010" => Q <= "000000100";
when "0011" => Q <= "000001000";
when "0100" => Q <= "000010000";
when "0101" => Q <= "000100000";
when "0110" => Q <= "001000000";
when "0111" => Q <= "010000000";
when "1000" => Q <= "100000000";
when others => Q <= "000000001";
end case;
end process;
process( BIN_DATA ) begin
case BIN_DATA is
when "000000001" => R <= "0000";
when "000000010" => R <= "0001";
when "000000100" => R <= "0010";
when "000001000" => R <= "0011";
when "000010000" => R <= "0100";
when "000100000" => R <= "0101";
when "001000000" => R <= "0110";
when "010000000" => R <= "0111";
when "100000000" => R <= "1000";
when others => R <= "0000";
end case;
end process;
end decoder_arch;

272
Phần 1 : Tạo mới một dự án

Bước 1: Khởi động phần mềm Quartus II và kích đúp chuột vào Create a
New Project để mở cửa sổ tạo mới dự án giống như hình 2. Chú ý là dự án
cần có tên giống với tên mà ta đã khai báo trên code. Ở ví dụ 1 ta chọn tên
encode làm tên dự án , nhấp chọn Next .

273
Bước 2: Trong cửa sổ Family – Device settings chúng ta chọn loại chip , là
chip MAX7000S/EPM7128SLC84-15 mà chúng ta sử dụng trong bài.
Nhấp chọn Next để chuyển sang cửa sổ chọn kế tiếp, quan sát bảng tổng kết
vừa thiếp lập và nhấp chọn finish để quay trở về màn hình chính

274
Phần 2: Nhập thiết kế dung mã VHDL

Bước 1: Trên màn hình chính ta chọn mục File > New, trong cửa sổ New
chọn VHDL File và nhấp chọn OK. Sau khi nhấp chọn OK cửa sổ soạn thảo
sẽ hiện ra , nhập mã VHDL.

275
Bước 2: Chọn File > Save As để mở cửa sổ Save As Trong phần Save as
type chọn VHDL File. Trong phần File name Nhập encode . Nhấp chọn
Save

Phần 3: Thêm các tệp thiết kế vào một dự án .

Bước 1: Chọn mục Assignments > Settings > File / ta có cách 2 là chọn
Project > Add/Remove File trong Project
Bước 2: Nhấp chọn nút …. Bên cạnh phần File name để có cửa sổ chọn tệp
vào . Nhấp chọn tệp encode.vhd
Chọn Open . Tệp đã chọn sẽ hiện tên lên phần File name. Nhấp chọn Add
và Ok để đưa tệp này vào dự án

Phần 4: Biên dịch mã VHDL

Bước 1: Nhấp chọn mục Processing > Start Complication. Biên dịch thành
công “ Hay không thành công” sẽ được thông báo trên hộp thoại bung ra
sau khi quá trìng biên dịch kết thúc . Xác nhận bằng cách nhấp nút OK
Bước 2: Khi biên dịch hoàn thành , một báo cáo biên dịch được đưa ra .
Nhấp chọn Processing > Complication Report để xem thông tin về lỗi sai
cần sửa.

276
Phần 6; Gán chân

Bước 1: Nhấp chọn Assignments > Assignment Editor. Trong Category

chọn pin. Nhấp đúp vào <<new>> cột To nhấp chọn từ A trải xuống tiếp
đến nhấp đúp vào <<new>> ở cột location và chọn chân

277
Bước 2: sau khi hoàn thành việc gán chân, ta nhấp chọn File > Save và
biên dịch lại

278
Phần 7 Mô phỏng mạch thiết kế

Bước 1; Mở cửa sổ Waveform Editor Bằng cách nhấp File > New. Trong
cửa sổ chọn dạng tệp , chọn Vector Waveform file và nhấp chọn Ok. Cửa sổ
Waveform File sẽ hiện ra trên giao diện chính. Lưu tệp này với tên
encode.vwf
Bước 2: Nhấp chọn Edit > End Time và nhập vào 200 ns trong hộp thoại .
Điều này cho phép thời gian mô phỏng từ 0 đến 200ns và nhấp chọn View
> Fit in Window để nhìn thấy toàn bộ phần mô phỏng từ 0 đến 200ns

Bước 3: Nhấp chọn Edit > Insert > Insert Node or Bus để mở cửa sổ nhập
các đầu vào ra . Nhấp chọn nút Node Finder đặt phần Filter là Pin : all.
Nhấp chọn List để tìm các đầu vào và ra rùi nhầp nút >> để chuyển các
chân ở ô bên trái sang bên phải chon OK > OK

279
Bước 4 Đặt các giá trị cho đầuvào

Bước 5 : Tiến hành mô phỏng

Nhấp chọn File > Save sau đó nhấp chọn processing > Start Simulation để
thực hiện mô phỏng và xem kết quả mô phỏng
280
5.2.7. Led 7 thanh
Library IEEE ;
use IEEE.std_logic_1164.all ;
use IEEE.std_logic_arith.all ;
use IEEE.std_logic_unsigned.all ;
ENTITY LED7C0TO9 IS
PORT
(
clk, reset : IN STD_LOGIC;
digit1: OUT STD_LOGIC_VECTOR (3 DOWNTO 0)
);
END LED7C0TO9;
ARCHITECTURE counter OF LED7C0TO9 IS
BEGIN
PROCESS(clk, reset)
VARIABLE temp1: INTEGER RANGE 0 TO 10;
BEGIN
---------------------- counter: ----------------------
IF (reset='1') THEN
temp1 := 0;
ELSIF (clk'EVENT AND clk='1') THEN
temp1 := temp1 + 1;
281
 IF (temp1=10) THEN
temp1 := 0;
END IF;
END IF;
---- BCD to SSD conversion: --------
CASE temp1 IS
WHEN 0 => digit1 <= "0000";
WHEN 1 => digit1 <= "0001";
WHEN 2 => digit1 <= "0010";
WHEN 3 => digit1 <= "0011";
WHEN 4 => digit1 <= "0100";
WHEN 5 => digit1 <= "0101";
WHEN 6 => digit1 <= "0110";
WHEN 7 => digit1 <= "0111";
WHEN 8 => digit1 <= "1000";
WHEN 9 => digit1 <= "1001";
WHEN OTHERS => NULL;
END CASE;
END PROCESS;
END counter;

Bước 1: Khởi động phần mềm Quartus II và kích đúp chuột vào Create a
New Project để mở cửa sổ tạo mới dự án. Chú ý là dự án cần có tên giống
với tên mà ta đã khai báo trên code. Ở ví dụ 1 ta chọn tên LED7C0TO9
làm tên dự án , nhấp chọn Next .

282
283
Bước 2: Trong cửa sổ Family – Device settings chúng ta chọn loại chip , là
chip MAX7000S/EPM7128SLC84-15 mà chúng ta sử dụng trong bài.
Nhấp chọn Next để chuyển sang cửa sổ chọn kế tiếp, quan sát bảng tổng kết
vừa thiếp lập và nhấp chọn finish để quay trở về màn hình chính

Phần 2: Nhập thiết kế dung mã VHDL

Bước 1: Trên màn hình chính ta chọn mục File > New, trong cửa sổ New
chọn VHDL File và nhấp chọn OK. Sau khi nhấp chọn OK cửa sổ soạn thảo
sẽ hiện ra . Nhập mã VHDL như hình 4

284
Bước 2: Chọn File > Save As để mở cửa sổ Save As Trong phần Save as
type chọn VHDL File. Trong phần File name Nhập LED7C0TO9 . Nhấp
chọn Save

Phần 3: Thêm các tệp thiết kế vào một dự án .

Bước 1: Chọn mục Assignments > Settings > File / ta có cách 2 là chọn
Project > Add/Remove File trong Project
Bước 2: Nhấp chọn nút …. Bên cạnh phần File name để có cửa sổ chọn tệp
vào . Nhấp chọn tệp LED7C0TO9.vhd
Chọn Open . Tệp đã chọn sẽ hiện tên lên phần File name. Nhấp chọn Add
và Ok để đưa tệp này vào dự án.

285
Phần 4: Biên dịch mã VHDL

Bước 1: Nhấp chọn mục Processing > Start Complication. Biên dịch thành
công “ Hay không thành công” sẽ được thông báo trên hộp thoại bung ra
sau khi quá trìng biên dịch kết thúc . Xác nhận bằng cách nhấp nút OK
Bước 2: Khi biên dịch hoàn thành , một báo cáo biên dịch được đưa ra .
Nhấp chọn Processing > Complication Report để xem thong tin về lỗi sai
cần sửa.

286
Phần 6; Gán chân

Bước 1: Nhấp chọn Assignments > Assignment Editor. Trong Category

chọn pin. Nhấp đúp vào <<new>> cột To nhấp chọn từ A trải xuống tiếp
đến nhấp đúp vào <<new>> ở cột location và chọn chân hình7

287
Bước 2: sau khi hoàn thành việc gán chân, ta nhấp chọn File > Save và
biên dịch lại

Phần 7 Mô phỏng mạch thiết kế

Bước 1; Mở cửa sổ Waveform Editor Bằng cách nhấp File > New. Trong
cửa sổ chọn dạng tệp , chọn Vector Waveform file và nhấp chọn Ok. Cửa sổ
Waveform File sẽ hiện ra trên giao diện chính. Lưu tệp này với tên
LED7C0TO9.vwf
Bước 2: Nhấp chọn Edit > End Time và nhập vào 200 ns trong hộp thoại .
Điều này cho phép thời gian mô phỏng từ 0 đến 200ns và nhấp chọn View
> Fit in Window để nhìn thấy toàn bộ phần mô phỏng từ 0 đến 200ns

288
Bước 3: Nhấp chọn Edit > Insert > Insert Node or Bus để mở cửa sổ nhập
các đầu vào ra . Nhấp chọn nút Node Finder đặt phần Filter là Pin : all.
Nhấp chọn List để tìm các đầu vào và ra rùi nhầp nút >> để chuyển các
chân ở ô bên trái sang bên phải chon OK > OK

289
Bước 4 Đặt các giá trị cho đầu vào

Bước 5 : Tiến hành mô phỏng

Nhấp chọn File > Save sau đó nhấp chọn processing > Start Simulation để
thực hiện mô phỏng và xem kết quả mô phỏng

290
5.2.8.Ma trận phím
Ma trận phím là một phần quan trọng của giao tiếp người dùng với board
CPLD. Về cơ bản việc thực thi ma trận phím dựa trên một ma trận hàng và
cột. Sự kiện một phím được nhấn hoặc thả có thể được ghi lại bằng cách
điều khiển và đọc trạng thái của các hàng và các cột trong ma trận phím.

Trong thuật toán chương trình thì các hàng được cấu hình là các giá trị ngõ
vào và các cột là các giá trị ngõ ra.
Các cột sẽ được quét liên tục, lần lượt từng cột sẽ được set về mức logic
thấp (mức 0) khi nó được quét.
Đồng thời tiến hành kiểm tra một cách liên tục giá trị đầu vào (các hàng).
Bất cứ khi nào một phím được nhấn, thì giá trị của hàng tương ứng với
phím đó sẽ được set về mức logic thấp (mức 0).
Kết hợp giữa giá trị các cột và các hàng ta có thể xác định được phím được
nhấn trên ma trận phím là phím nào.
Có thể delay một khoảng thời gian, sau đó kiểm tra lại giá trị các cột, hàng.
Nếu vẫn là phím đó được nhấn thì giá trị các hàng, cột này không thay đổi.
Và ta có xác định chính xác giá trị phím được nhấn.
Sơ đồ khối chương trình:

291
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity KEYPADV1 is
Port
(
SW0: IN BIT;
R: OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
LEDS: OUT STD_LOGIC_VECTOR(9 DOWNTO 0);
DKLED: OUT STD_LOGIC_VECTOR(2 DOWNTO 0);
LEDCODE: OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
C: IN STD_LOGIC_VECTOR(3 DOWNTO 0) --COT CUA MA TRAN
PHIM
);
end KEYPADV1;
architecture KEYPAD of KEYPADV1 is
----------------------------------------------
BEGIN
PROCESS (SW0)
BEGIN
IF(SW0='1') THEN
LEDS<="0000000000";
ELSE
LEDS<="1111111111";
END IF;
END PROCESS;
---------------------------------------------
-- QUET THEO COT OK
PROCESS (C)
BEGIN
R<="0000";
DKLED<="000";
LEDCODE<="0100";
IF(C="1110") THEN
292
DKLED<="000";
LEDCODE<="0001";
END IF;
IF(C="1101") THEN
DKLED<="001";
LEDCODE<="0010";
END IF;
IF(C="1011") THEN
DKLED<="010";
LEDCODE<="0011";
END IF;
IF(C="0111") THEN
DKLED<="011";
LEDCODE<="0100";
END IF;
END PROCESS;
----------------------------------------------
end KEYPAD;

Phần 1 : Tạo mới một dự án

Bước 1: Khởi động phần mềm Quartus II và kích đúp chuột vào Create a
New Project để mở cửa sổ tạo mới dự án. Chú ý là dự án cần có tên giống
với tên mà ta đã khai báo trên code. Ở ví dụ 1 ta chọn tên KEYPAD làm
tên dự án , nhấp chọn Next .

293
294
Bước 2: Trong cửa sổ Family – Device settings chúng ta chọn loại chip , là
chip MAX7000S/EPM7128SLC84-15 mà chúng ta sử dụng trong bài.
Nhấp chọn Next để chuyển sang cửa sổ chọn kế tiếp, quan sát bảng tổng kết
vừa thiếp lập và nhấp chọn finish để quay trở về màn hình chính

Phần 2: Nhập thiết kế dung mã VHDL

Bước 1: Trên màn hình chính ta chọn mục File > New, trong cửa sổ New
chọn VHDL File và nhấp chọn OK. Sau khi nhấp chọn OK cửa sổ soạn thảo
sẽ hiện ra , nhập mã VHDL.

295
Bước 2: Chọn File > Save As để mở cửa sổ Save As Trong phần Save as
type chọn VHDL File. Trong phần File name Nhập KEYPADV1 . Nhấp
chọn Save

Phần 3: Thêm các tệp thiết kế vào một dự án .

Bước 1: Chọn mục Assignments > Settings > File / ta có cách 2 là chọn
Project > Add/Remove File trong Project
Bước 2: Nhấp chọn nút …. Bên cạnh phần File name để có cửa sổ chọn tệp
vào . Nhấp chọn tệp KEYPADV1.vhd
Chọn Open . Tệp đã chọn sẽ hiện tên lên phần File name. Nhấp chọn Add
và Ok để đưa tệp này vào dự án.

296
Phần 4: Biên dịch mã VHDL

Bước 1: Nhấp chọn mục Processing > Start Complication. Biên dịch thành
công “ Hay không thành công” sẽ được thông báo trên hộp thoại bung ra
sau khi quá trìng biên dịch kết thúc . Xác nhận bằng cách nhấp nút OK
Bước 2: Khi biên dịch hoàn thành , một báo cáo biên dịch được đưa ra .
Nhấp chọn Processing > Complication Report để xem thong tin về lỗi sai
cần sửa.

297
Phần 6; Gán chân

Bước 1: Nhấp chọn Assignments > Assignment Editor. Trong Category

chọn pin. Nhấp đúp vào <<new>> cột To nhấp chọn từ A trải xuống tiếp
đến nhấp đúp vào <<new>> ở cột location và chọn chân hình7

298
Bước 2: sau khi hoàn thành việc gán chân, ta nhấp chọn File > Save và
biên dịch lại

299
Phần 7 Mô phỏng mạch thiết kế

Bước 1; Mở cửa sổ Waveform Editor Bằng cách nhấp File > New. Trong
cửa sổ chọn dạng tệp , chọn Vector Waveform file và nhấp chọn Ok. Cửa sổ
Waveform File sẽ hiện ra trên giao diện chính. Lưu tệp này với tên
KEYPADV1.vwf
Bước 2: Nhấp chọn Edit > End Time và nhập vào 200 ns trong hộp thoại .
Điều này cho phép thời gian mô phỏng từ 0 đến 200ns và nhấp chọn View
> Fit in Window để nhìn thấy toàn bộ phần mô phỏng từ 0 đến 200ns

Bước 3: Nhấp chọn Edit > Insert > Insert Node or Bus để mở cửa sổ nhập
các đầu vào ra . Nhấp chọn nút Node Finder đặt phần Filter là Pin : all.
Nhấp chọn List để tìm các đầu vào và ra rùi nhầp nút >> để chuyển các
chân ở ô bên trái sang bên phải chon OK > OK

300
Bước 4 Đặt các giá trị cho đầuvào

Bước 5 : Tiến hành mô phỏng

Nhấp chọn File > Save sau đó nhấp chọn processing > Start Simulation để
thực hiện mô phỏng và xem kết quả mô phỏng

301
5.2.9. Điều khiển LCD trên CPLD KIT
- CPLD Challenge Kit có hỗ trợ màn hình LCD phục vụ cho việc hiển thị
thông tin trong các ứng dụng trên CPLD.
- Điều khiển LCD có thể thao tác ở chế độ 4 bit hoặc 8 bit. Ở chế độ 4 bit
dữ liệu được ghi vào LCD thông qua 2 thao tác ghi 4 bit trên các chân DB4
đến DB7. Bốn bít cao trong byte dữ liệu được ghi trước sau đó đến bốn bít
thấp. Ở chế độ ghi 8 bit thì dữ liệu được ghi trên cả 8 chân DB0 đến DB7
của LCD.

Sơ Đồ CPLD điều khiển LCD thông qua giao tiếp 8 bit.

302
 Bảng các lệnh điều khiển việc hiển thị:

Giới thiệu chương trình hiển thị LCD giao tiếp 8 bit:
- Sơ đồ khối chương trình hiển thị lên LCD: Chương trình sẽ điều khiển
hiển thị chuỗi “FPGA” trên màn hình LCD.
- Có ba bước chính được dùng để hiển thị ký tự trên LCD.
Bước khởi tạo:
1. Đợi khoảng 15ms hoặc lâu hơn, đây là thời gian để FPGA hoàn thành
việc cấu hình trước khi tiến hành việc hiển thị trên LCD.
2. Ghi SF_D [7:0] = 0x38, set LCD_E lên mức cao trong 12 chu kỳ clock.
3. Đợi 4,1ms hoặc lâu hơn, tương đương với 205,000 xung clock tại tần số
50MHZ.
4. Ghi SF_D [7:0] = 0x38, set LCD_E lên mức cao trong 12 chu kỳ clock.

303
5. Đợi 100us hoặc lâu hơn, tương đương với 5000 xung clock tại tần số
50MHZ.
6. Ghi SF_D [7:0] = 0x38, set LCD_E lên mức cao trong 12 chu kỳ clock.
7. Đợi 40us hoặc lâu hơn, tương đương với 2000 xung clock tại tần số
50MHZ.
Bước cấu hình:
1. Function Set command: ghi vào SF_D[7:0] = 0x38.
2. Đợi 40us, tương đương với 2000 xung clock (50MHZ).
3. Set Display command: ghi vào SF_D[7:0] = 0x0C.
4. Đợi 40us, tương đương với 2000 xung clock (50MHZ).
5. Clear Display command: ghi vào SF_D[7:0] = 0x01.
6. Đợi 40us, tương đương với 2000 xung clock (50MHZ).
7. Entry Set command: ghi vào SF_D[7:0] = 0x06.
8. Đợi 1.64ms, tương đương với 82000 xung clock (50MHZ).
Giữa các bước cấu hình: Function Set, Set Display, Clear Display, Entry
Set đều phải đợi ít nhất là 40us, vì đây là thời gian tối thiểu để LCD nhận
dữ liệu hợp lệ trước khi dữ liệu mới được ghi vào.
Bước hiển thị:
1. Set DD-Ram Address command: ghi vào SF_D[7:0] = 0x80.
2. Lần lượt ghi vào SF_D các giá trị mã ASCII hiển thị cho các chữ
C,P,L,D.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity lcd is
port(
clk, reset : in bit;
SF_D : out bit_vector(7 downto 0);
LCD_E, LCD_RS, LCD_RW : out bit
);
end lcd;
-- an nut re set de chay
architecture behavior of lcd is
type tx_sequence is (setup, hold, fortyus, done);
signal tx_state : tx_sequence := done;
signal tx_byte : bit_vector(7 downto 0);
signal tx_init : bit := '0';
type init_sequence is (idle, fifteenms, one, two, three, four, five, six, done);
signal init_state : init_sequence := idle;
signal init_init, init_done : bit := '0';
signal i : integer range 0 to 750000 := 0;
signal i2 : integer range 0 to 2000 := 0;

304
signal i3 : integer range 0 to 82000 := 0;
signal SF_D0, SF_D1 : bit_vector(7 downto 0);
signal LCD_E0, LCD_E1 : bit;
signal mux : bit;
type display_state is (init, function_set, set_display, clr_display, entry_set,
pause, set_addr, char_f, char_p, char_g, char_a, done);
signal cur_state : display_state := init;
begin
LCD_RW <= '0'; --write only

with cur_state select

tx_init <= '0' when init | pause | done,
'1' when others;

with cur_state select

mux <= '1' when init,
'0' when others;

with cur_state select

init_init <= '1' when init,
'0' when others;

with cur_state select

LCD_RS <= '0' when
function_set|entry_set|set_display|clr_display|set_addr,
'1' when others;

with cur_state select

--FPJA
tx_byte <= "00111000" when function_set,
"00001100" when set_display,
"00000001" when clr_display,
"00000110" when entry_set,
"10000000" when set_addr,

"01000011" when char_f,--c

"01010000" when char_p,--p
"01001100" when char_g,--l
"01000100" when char_a,--d

"00000000" when others;

display: process(clk, reset)

begin

305
 if(reset='1') then
cur_state <= function_set;
elsif(clk='1' and clk'event) then
case cur_state is

when init =>

if(init_done = '1') then
cur_state <= function_set;
else
cur_state <= init;
end if;
--every other state but pause uses the transmit state machine
when function_set =>
if(i2 = 2000) then
cur_state <= set_display;
else
cur_state <= function_set;
end if;

when set_display =>

if(i2 = 2000) then
cur_state <= clr_display;
else
cur_state <= set_display;
end if;

when clr_display =>

i3 <= 0;
if(i2 = 2000) then
cur_state <= entry_set;
else
cur_state <= clr_display;
end if;

when entry_set =>

if(i2 = 2000) then
cur_state <= pause;
else
cur_state <= entry_set;
end if;

when pause =>

if(i3 = 82000) then
cur_state <= set_addr;

306
 i3 <= 0;
else
cur_state <= pause;
i3 <= i3 + 1;
end if;

when set_addr =>

if(i2 = 2000) then
cur_state <= char_f;
else
cur_state <= set_addr;
end if;

when char_f =>

if(i2 = 2000) then
cur_state <= char_p;
else
cur_state <= char_f;
end if;

when char_p =>

if(i2 = 2000) then
cur_state <= char_g;
else
cur_state <= char_p;
end if;

when char_g =>

if(i2 = 2000) then
cur_state <= char_a;
else
cur_state <= char_g;
end if;

when char_a =>

if(i2 = 2000) then
cur_state <= done;
else
cur_state <= char_a;
end if;

when done =>

cur_state <= done;

307
 end case;
end if;
end process display;

with mux select

SF_D <= SF_D0 when '0', --transmit
SF_D1 when others; --initialize
with mux select
LCD_E <= LCD_E0 when '0', --transmit
LCD_E1 when others; --initialize

--specified by datasheet
transmit : process(clk, reset, tx_init)
begin
if(reset='1') then
tx_state <= done;
elsif(clk='1' and clk'event) then
case tx_state is
when setup => --40ns
LCD_E0 <= '0';
SF_D0 <= tx_byte;
if(i2 = 2) then
tx_state <= hold;
i2 <= 0;
else
tx_state <= setup;
i2 <= i2 + 1;
end if;

when hold => --230ns

LCD_E0 <= '1';
SF_D0 <= tx_byte;
if(i2 = 12) then
tx_state <= fortyus;
i2 <= 0;
else
tx_state <= hold;
i2 <= i2 + 1;
end if;

when fortyus =>

LCD_E0 <= '0';
if(i2 = 2000) then
tx_state <= done;

308
 i2 <= 0;
else
tx_state <= fortyus;
i2 <= i2 + 1;
end if;

when done =>

LCD_E0 <= '0';
if(tx_init = '1') then
tx_state <=setup;
i2 <= 0;
else
tx_state <= done;
i2 <= 0;
end if;

end case;
end if;
end process transmit;

--specified by datasheet
power_on_initialize: process(clk, reset, init_init) --power on initialization
sequence
begin
if(reset='1') then
init_state <= idle;
init_done <= '0';
elsif(clk='1' and clk'event) then
case init_state is
when idle =>
init_done <= '0';
if(init_init = '1') then
init_state <= fifteenms;
i <= 0;
else
init_state <= idle;
i <= i + 1;
end if;

when fifteenms =>

init_done <= '0';
if(i = 750000) then
init_state <= one;
i <= 0;

309
 else
init_state <= fifteenms;
i <= i + 1;
end if;

when one =>

SF_D1 <= "00111000";
LCD_E1 <= '1';
init_done <= '0';
if(i = 11) then
init_state<=two;
i <= 0;
else
init_state<=one;
i <= i + 1;
end if;

when two =>

LCD_E1 <= '0';
init_done <= '0';
if(i = 205000) then
init_state<=three;
i <= 0;
else
init_state<=two;
i <= i + 1;
end if;

when three =>

SF_D1 <= "00111000";
LCD_E1 <= '1';
init_done <= '0';
if(i = 11) then
init_state<=four;
i <= 0;
else
init_state<=three;
i <= i + 1;
end if;

when four =>

LCD_E1 <= '0';
init_done <= '0';
if(i = 5000) then

310
 init_state<=five;
i <= 0;
else
init_state<=four;
i <= i + 1;
end if;

when five =>

SF_D1 <= "00111000";
LCD_E1 <= '1';
init_done <= '0';
if(i = 11) then
init_state<=six;
i <= 0;
else
init_state<=five;
i <= i + 1;
end if;

when six =>

LCD_E1 <= '0';
init_done <= '0';
if(i = 2000) then
init_state<=done;
i <= 0;
else
init_state<=six;
i <= i + 1;
end if;

when done =>

init_state <= done;
init_done <= '1';

end case;

end if;
end process power_on_initialize;
end behavior;

Phần 1 : Tạo mới một dự án

Bước 1: Khởi động phần mềm Quartus II và kích đúp chuột vào Create a
New Project để mở cửa sổ tạo mới dự án. Chú ý là dự án cần có tên giống

311
với tên mà ta đã khai báo trên code. Ở ví dụ 1 ta chọn tên lcd làm tên dự án
, nhấp chọn Next .

Bước 2: Trong cửa sổ Family – Device settings chúng ta chọn loại chip , là
chip MAX7000S/EPM7128SLC84-15 mà chúng ta sử dụng trong bài.
Nhấp chọn Next để chuyển sang cửa sổ chọn kế tiếp, quan sát bảng tổng kết
vừa thiếp lập và nhấp chọn finish để quay trở về màn hình chính
312
Phần 2: Nhập thiết kế dung mã VHDL
Bước 1: Trên màn hình chính ta chọn mục File > New, trong cửa sổ New
chọn VHDL File và nhấp chọn OK. Sau khi nhấp chọn OK cửa sổ soạn thảo
sẽ hiện ra . Nhập mã VHDL như

313
Bước 2: Chọn File > Save As để mở cửa sổ Save As Trong phần Save as
type chọn VHDL File. Trong phần File name Nhập lcd . Nhấp chọn Save

Phần 3: Thêm các tệp thiết kế vào một dự án .

Bước 1: Chọn mục Assignments > Settings > File / ta có cách 2 là chọn
Project > Add/Remove File trong Project
Bước 2: Nhấp chọn nút …. Bên cạnh phần File name để có cửa sổ chọn tệp
vào . Nhấp chọn tệp lcd.vhd
Chọn Open . Tệp đã chọn sẽ hiện tên lên phần File name. Nhấp chọn Add
và Ok để đưa tệp này vào dự án.

Phần 4: Biên dịch mã VHDL

Bước 1: Nhấp chọn mục Processing > Start Complication. Biên dịch thành
công “ Hay không thành công” sẽ được thông báo trên hộp thoại bung ra
sau khi quá trìng biên dịch kết thúc . Xác nhận bằng cách nhấp nút OK
Bước 2: Khi biên dịch hoàn thành , một báo cáo biên dịch được đưa ra .
Nhấp chọn Processing > Complication Report để xem thong tin về lỗi sai
cần sửa.

314
Phần 6: Gán chân
Bước 1: Nhấp chọn Assignments > Assignment Editor. Trong Category
chọn pin. Nhấp đúp vào <<new>> cột To nhấp chọn từ A trải xuống tiếp
đến nhấp đúp vào <<new>> ở cột location và chọn chân hình7

315
Bước 2: sau khi hoàn thành việc gán chân, ta nhấp chọn File > Save và
biên dịch lạ
Phần 7 Mô phỏng mạch thiết kế
Bước 1; Mở cửa sổ Waveform Editor Bằng cách nhấp File > New. Trong
cửa sổ chọn dạng tệp , chọn Vector Waveform file và nhấp chọn Ok. Cửa sổ
Waveform File sẽ hiện ra trên giao diện chính. Lưu tệp này với tên lcd.vwf
Bước 2: Nhấp chọn Edit > End Time và nhập vào 200 ns trong hộp thoại .
Điều này cho phép thời gian mô phỏng từ 0 đến 200ns và nhấp chọn View
> Fit in Window để nhìn thấy toàn bộ phần mô phỏng từ 0 đến 200ns

316
Bước 3: Nhấp chọn Edit > Insert > Insert Node or Bus để mở cửa sổ nhập
các đầu vào ra . Nhấp chọn nút Node Finder đặt phần Filter là Pin : all.
Nhấp chọn List để tìm các đầu vào và ra rùi nhầp nút >> để chuyển các
chân ở ô bên trái sang bên phải chon OK > OK

Bước 4 Đặt các giá trị cho đầuvào

317
Bước 5 : Tiến hành mô phỏng
Nhấp chọn File > Save sau đó nhấp chọn processing > Start Simulation để
thực hiện mô phỏng và xem kết quả mô phỏng

318
B. Thực hành
1. Vật tư - Thiết bị - Dụng cụ cho 1 ca thực tập

TT Tên Số lượng
Máy vi tính cài đặt đầy đủ các phần
mềm hỗ trợ có cấu hình tối thiểu:
(Mainboard của Gigabyte, CPU
1 Core i3 hoặc i7, Ram 2GB trở lên, 16
HDD 250GB trở lên, Card màn hình
512MB trở lên, LCD 19")

2 Digital Oscilloscope 09

3 Chíp EPM7128 và bộ nạp 09

4 Thiết bị thí nghiệm PLD 09

2. Quy trình thực hiện:

- Bước 1: Sử dụng ngôn ngữ VHDL và phần mềm Quartus II Thiết kế vi
mạch số lập trình theo yêu cầu của các bài toán.
- Bước 2: Kiểm tra chương trình thiết kế mạch logic
- Bước 3: Mô phỏng thiết kế thông qua bảng trạng thái mức logic
input/output, hoặc sử dụng giản đồ thời gian.
- Bước 4: Lựa chọn cầu hình cho vi mạch và nạp chương trình
- Bước 5: Kiểm tra kết quả:
3. Chia nhóm: 2 sinh viên/máy
4. Các dạng sai hỏng thường gặp, nguyên nhân – Biện pháp khắc phục

TT Sai hỏng Nguyên nhân Khắc phục

Chương trình báo Kiểm tra lỗi trên Output
1 Sai cú pháp lệnh
lỗi Window và sửa chữa
Chưa cài đặt
Không nhận diện
2 Drive cho thiết Cài đặt driver cho thiết bị
được thiết bị
bị
Kiểm tra thông số trên
Không nạp được Chọn chưa đúng
3 phần mềm nạp chương
chương trình thông số thiết bị
trình

319
C. Đánh giá kết quả : (tính theo thang điểm 10)

Mục tiêu Nội dung Điểm chuẩn

- Trình bày được cấu trúc logic của họ

CPLD thông dụng;
Kiến thức - Trình bày được các tính năng cần thiết 2
của thiết bị để khai thác và sử dụng thiết
bị hiệu quả theo yêu cầu kỹ thuật;

- Sử dụng thành thạo ngôn ngữ VHDL,

phần mềm Quartus II cho vi mạch CPLD
EMP7128;
5
Kỹ năng - Sử dụng thành thạo kit thí nghiệm
CPLD sử dụng vi mạch EMP7128;

- Rèn luyện tính tỉ mỉ, chính xác, an toàn

Thái độ 3
và vệ sinh công nghiệp

320
 TÀI LIỆU THAM KHẢO

1. Đề cương môđun/môn học nghề Sửa chữa thiết bị điện tử công nghiệp „
Dự án Giáo dục kỹ thuật và Dạy nghề (VTEP), Tổng cục Dạy Nghề, Hà
Nội, 2003
2. Kỹ thuật điện tử số - Đặng văn Chuyết - NXB KHKT 2003
3. Kỹ thuật điều khiển- NXB Lao Động 2004
4. Mạch điện tử- NXB Lao Động 2002
5. Mạch điện tử trong công nghiệp - Nguyễn Tấn Phước - NXBKhoa học kỹ
thuật 2004
6. Baugruppen de Mikroelektronik III - Pflaum Verlag Muenchen.
7. Xilinx - ABEL Design Software Refernce Mannual - Data I/O
Corp..1993
8. D. Vanden Bout, ‘ Xilinx FPGA Student Manua” - Prentice Hall,
Englewoods Cliff, NJ, 1997
9. Bài giảng VHDL – Nguyễn Trọng Hải, Đại học KTCN thành phố
Hồ Chí Minh
10. FPGA CPLD and ASIC from Altera – www.Altera.com

321