Báo Cáo Đ Án 1 (Design For Test)

ĐẠI HỌC QUỐC GIA TP.
HỒ CHÍ MINH
TRƯỜNG ĐẠI HỌC BÁCH KHOA
KHOA ĐIỆN – ĐIỆN TỬ
BỘ MÔN ĐIỆN TỬ
---------------o0o---------------
BÁO CÁO ĐỒ ÁN MÔN HỌC
ĐỀ TÀI: DESIGN FOR TEST
GVHD: Nguyễn Phan Hải Phú

Bùi Lê Quốc Doanh
SVTH: Hoàng Đức Thắng

MSSV: 1915222
TP. HỒ CHÍ MINH, THÁNG 03 NĂM 2023

Lời cảm ơn GVHD: Nguyễn Phan Hải Phú
LỜI CẢM ƠN
Trong thời gian làm đồ án tốt nghiệp, em đã nhận được nhiều sự giúp đỡ, đóng
góp ý kiến và chỉ bảo nhiệt tình của thầy cô, gia đình và bạn bè. Em xin gửi lời cảm ơn
chân thành đến thầy Bùi Lê Quốc Doanh, thầy Nguyễn Phan Hải Phú giảng viên Bộ
môn Điện Tử - trường đại học Bách Khoa TPHCM người đã tận tình hướng dẫn, chỉ
bảo em trong suốt quá trình làm đồ án.
Em cũng xin chân thành cảm ơn các thầy cô giáo trong trường nói chung, các
thầy cô trong Bộ môn nói riêng đã dạy dỗ cho em kiến thức về các môn đại cương
cũng như các môn chuyên ngành, giúp em có được cơ sở lý thuyết vững vàng và tạo
điều kiện giúp đỡ em trong suốt quá trình học tập.
Cuối cùng, em xin chân thành cảm ơn gia đình và bạn bè, đã luôn tạo điều kiện,
quan tâm, giúp đỡ, động viên em trong suốt quá trình học tập và hoàn thành khoá luận
tốt nghiệp. Với điều kiện thời gian cũng như kinh nghiệm còn hạn chế của một học
viên, luận văn này không thể tránh được những thiếu sót. Em rất mong nhận được sự
chỉ bảo, đóng góp ý kiến của các thầy cô để tôi có điều kiện bổ sung, nâng cao ý thức
của mình, phục vụ tốt hơn công tác thực tế sau này
Tp. Hồ Chí Minh, ngày 9 tháng 3 năm 2023.
Sinh viên
Hoàng Đức Thắng
i
Đồ án môn học GVHD: Nguyễn Phan Hải Phú
TÓM TẮT ĐỒ ÁN
Đồ án này trình bày về kĩ thuật Design for test (DFT), bao gồm tìm hiểu về lý
thuyết và thực hiện mô phỏng thiết kế kiểm tra cho mạch Logic và Memory cũng như
các chip đã được gắn trên board mạch. Trong phần lý thuyết chúng ta sẽ đi tìm hiểu về
hệ thống các lỗi sẽ thường xuyên xảy ra và các phương pháp để xác định các lỗi đó
cùng với một số các ví dụ và bài tập để xác định rõ phương pháp kiểm tra. Trong phần
thiết kế thì ta sẽ tiến hành tạo ra các mạch thực tế, các khối kiểm thử dựa trên lý thuyết
sau đó tiến hành chạy kiểm thử, so sánh với kết quả lý thuyết. Từ đó đưa ra kết luận
cũng như phương pháp khắc phục và tối ưu tốt nhất cho mạch.
ii
MỤC LỤC
1. GIỚI THIỆU .............................................................................................................1
1.1 Tổng quan .........................................................................................................1
1.2 Nhiệm vụ đề tài .................................................................................................2
2. LÝ THUYẾT ............................................................................................................3
2.1 Design for test là gì (DFT)................................................................................3
2.2 Fault Mode (physical fault) ..............................................................................3
2.2.1 Stuck-at Fault (SAF) ...................................................................................3
2.2.2 Bridging Fault (BF) .....................................................................................6
2.2.3 Delay Fault (DF) .........................................................................................7
2.3 Các thuật toán sử dụng trong DFT ...................................................................8
2.3.1 Thuật toán Ad-hoc.......................................................................................8
2.3.2 Thuật toán Scan .........................................................................................11
2.3.3 JTAG .........................................................................................................19
2.3.4 JTAG instruction .......................................................................................31
2.4 BIST ................................................................................................................39
2.4.1 MBIST .......................................................................................................40
3. THIẾT KẾ PHẦN CỨNG ......................................................................................52
3.1 Thiết kế mạch kiểm tra Scan ..........................................................................52
3.1.1 Kiểm tra lỗi stuck-at ..................................................................................52
3.1.2 Kiểm tra lỗi transition delay ......................................................................54
4. THIẾT KẾ GIẢI THUẬT MBIST CHO SRAM ...................................................56
5. KẾT LUẬN VÀ HƯỚNG PHÁT TRIỂN.............................................................. 58
5.1 Kết luận ...........................................................................................................58
5.2 Hướng phát triển ............................................................................................. 59
iii
6. TÀI LIỆU THAM KHẢO ......................................................................................59
iv
DANH SÁCH HÌNH MINH HỌA
Hình 1.1: Các lỗi vật lý có thể sinh ra trong quá trình sản xuất chip ............................ 2
Hình 2.2.1.1: Các lỗi kẹt đơn tại các ngõ vào ra của cổng AND ...................................4
Hình 2.2.1.2: Lỗi kẹt đơn Fanout và Branches trên mạch ..............................................5
Hình 2.2.2.1: Các lỗi Bridging thực tế ............................................................................6
Hình 2.2.2.2: Mô hình lỗi Wired-OR và Wired-AND ......................................................6
Hình 2.2.3: Hình mô phỏng lỗi hở điện trở .....................................................................7
Hình 2.3.1: Chèn điểm kiểm tra ....................................................................................10
Hình 2.3.2: Chèn điểm quan sát ....................................................................................10
Hình 2.3.2.1: Chế độ hoạt động của Scan flip flop .......................................................11
Hình 2.3.2.2: Sơ đồ chuyển đổi mạch tuần tự sang mạch tổ hợp .................................13
Hình 2.3.2.3: Mô tả chế độ hoạt động của Muxed DFF ...............................................14
Hình 2.3.3.1: Kiểm tra board mạch bằng JTAG ........................................................... 20
Hình 2.3.3.2: Kiến trúc của JTAG .................................................................................22
Hình 2.3.3.3: Sơ đồ máy trạng thái của tap controller .................................................23
Hình 2.3.3.4: Kiến trúc register trong JTAG ................................................................ 24
Hình 2.3.3.5: Kiến trúc ngõ vào Boundary scan cells ..................................................25
Hình 2.3.3.6: Kiến trúc ngõ vào Boundary scan cells chế độ Normal .......................... 26
Hình 2.3.3.7: Kiến trúc ngõ vào Boundary scan cells chế độ Scan .............................. 27
Hình 2.3.3.8: Kiến trúc ngõ vào Boundary scan cells chế độ Update .......................... 27
Hình 2.3.4.1: Sơ đồ kiến trúc quá trình kiểm tra EXTEST ............................................32
Hình 2.3.4.2: Cấu trúc output BSC và máy trạng thái hoạt động của chip1 ................33
Hình 2.3.4.3: Cấu trúc input BSC và máy trạng thái hoạt động của chip2 ..................34
Hình 2.4: Kiến trúc built in selt test ..............................................................................40
Hình 2.4.1: kiến trúc MBIST .........................................................................................40
v
Hình 3.1: Sơ đồ khối scan flip flop ................................................................................52
Hình 3.1.1: Sơ đồ mạch test stuck at trên candence .....................................................53
Hình 3.1.2: Kết quả dạng sóng biểu thị mẫu thử scanff ................................................54
Hình 3.1.3: Sơ đồ mạch kiểm tra lỗi delay transition trên candence............................ 55
Hình 3.1.4: Kết quả tín hiệu dạng sóng mạch kiểm tra lỗi transition ........................... 55
Hình 4.1: Kiến trúc MBIST cho bộ nhớ ........................................................................56
Hình 4.2: Mô hình trạng thái máy của giải thuật MarchC- ..........................................57
vi
DANH SÁCH BẢNG SỐ LIỆU
Bảng 2.2.1.1: Bảng giá trị các lỗi đơn tại ngõ vào ra của cổng AND ............................ 4
Bảng 2.2.1.2: Bảng giá trị biểu hiện Lỗi kẹt đơn Fanout và Branches trên mạch .........5
Bảng 2.2.2.1: Bảng biểu thị giá trị của mô hình lỗi Wired-OR và Wired-AND .............7
Bảng 2.3.3.1: Tóm tắt tín hiệu điều khiển các chế độ hoạt động ngõ vào ....................28
Bảng 2.3.3.2: Bảng tóm tắt tín hiệu của các chế độ hoạt động ngõ ra JTAG ..............29
Bảng 4.1: Các giá trị trạng thái MarchC- ....................................................................57
Bảng 4.2: Sự chuyển trạng thái trong MarchC-............................................................ 57
vii
1. GIỚI THIỆU
1.1 Tổng quan
Ngày nay các kĩ thuật kiểm tra mạch VLSI đang đối mặt với nhiều thách thức
thú vị và phức tạp. Trong thời đại các hệ thống lớn được nhúng trong một hệ thống
trên chip (SOC) duy nhất và được chế tạo liên tục trong công nghệ thu hẹp, điều này
quan trọng là phải đảm bảo hành vi đúng đắn của toàn bộ hệ thống. Vì thế trường hợp
tốt nhất cho hoàn cảnh hiện tại đó là tạo ra một môi trường thử nghiệm thuận lợi trên
chip bằng cách sử dụng kĩ thuật Design For Test (DFT).
DFT là một kỹ thuật giúp cho một thiết kế có thể được kiểm tra (test) dễ dàng
và đầy đủ hơn sau khi sản xuất thành chip mà không cần quan tâm đến chức năng của
mạch (thiết kế). Một quy trình sản xuất không thể đảm bảo toàn bộ chip được sản xuất
ra đều đạt chất lượng và không có lỗi. Lỗi ở đây là lỗi vật lý (physical fault) sinh ra so
quá trình sản xuất, không phải lỗi chức năng hay lỗi logic (logical fault) do thiết kế
sai.
Một số lỗi vật lý có thể gặp như nối đất GND (stuck-at-0, s-a-0), nối nguồn với
VCC (stuck-at-1, s-a-1), ngắn mạch(short), hở mạch (open). Một lỗi vật lý sinh ra sẽ
làm cho hoạt động của chip bị sai hoặc không thể hoạt động (hình 1.1). Lỗi chức năng
Reduce test cost do thiết kế sai phải được phát hiện khi mô phỏng và kiểm tra trước
khi sản xuất.
Để dễ hình dung, các bạn hãy liên tưởng đến việc kiểm tra các bo mạch in
(PCB), một bo mạch in sau khi sản xuất phải được kiểm tra xem các đường mạch có
bị nối GND, VCC, ngắn mạch hay hở mạch (bị đứt) hay không. Chip cũng cần được
kiểm tra các lỗi như vậy. Một chip gồm hai phần logic là user logic và DFT logic.
Trong đó, user (function) logic là thành phần xử lý các chức năng dành cho người
dùng chip, DFT logic dùng để test chip.
1
Hình 1.1: Các lỗi vật lý có thể sinh ra trong quá trình sản xuất chip
Tóm lại, kỹ thuật DFT là kỹ thuật giúp kiểm tra chip dễ dàng và đầy đủ hơn
bằng cách thêm các logic dùng cho việc test vào trong chip. Nếu không có DFT, một
chip vẫn có thể được kiểm tra thông qua đo đạc và chạy các test chức năng (function
test) trên chip nhưng thời gian test rất lâu và không đảm bảo toàn bộ chip được test
đầy đủ (coverage thấp). Ví dụ, một chip không có DFT, nếu chạy các test chức năng
có thể mất 30 giây (hoặc nhiều hơn) cho một chip thì tổng thời gian test cho một lô
sản phẩm 100.000 chip là khoảng 35 ngày, cho 1 triệu chip là 347 ngày. Nhưng với kỹ
thuật DFT, tổng thời gian test có thể giảm hơn 10 lần. Tuy nhiên, việc áp dụng kỹ
thuật DFT sẽ làm kích thước chip lớn hơn do phải thêm các logic phục vụ việc test.
1.2 Nhiệm vụ đề tài
Trong đề tài này chúng ta tập trung vào các nội dung chính như sau:
Nội dung 1: Tìm hiểu nguyên lý, lý thuyết về DFT
Nội dung 2: Nghiên cứu các phương pháp và giải thuật sử dụng trong DFT
Nội dung 3: Thiết kế bộ scan flip flop để test các lỗi vật lý đúng với lý thuyết
đề ra và giải thích sơ đồ máy trạng thái của memory built in self test.
2
2. LÝ THUYẾT
2.1 Design for test là gì (DFT)

DFT là một kỹ thuật giúp cho một thiết kế có thể được kiểm tra (test) dễ dàng
và đầy đủ hơn sau khi sản xuất thành chip mà không cần quan tâm đến chức năng của
mạch (thiết kế). Một quy trình sản xuất không thể đảm bảo toàn bộ chip được sản xuất
ra đều đạt chất lượng và không có lỗi. Lỗi ở đây là lỗi vật lý (physical fault) sinh ra so
quá trình sản xuất, không phải lỗi chức năng hay lỗi logic (logical fault) do thiết kế
sai. Lỗi chức năng Reduce test cost do thiết kế sai phải được phát hiện khi mô phỏng
và kiểm tra trước khi sản xuất.
Tại sao phải sử dụng design for test (DFT)?
• Reduce ATPG effort :Rút ngắn thời gian chạy ATPG
• Improve test quality :Khả năng bao phủ lỗi cao, Rút ngắn độ lớn kiểm
tra và thời gian kiểm tra
• Reduce time to market : Chuẩn đoán và gỡ lỗi đơn giản
2.2 Fault Mode (physical fault)

2.2.1 Stuck-at Fault (SAF)
• Single Stuck-at Fault (SSF)
Lỗi kẹt đơn có nghĩa là một đường tín hiệu trong mạng tổ hợp của cổng logic
được cố định thành logic 0 hoặc logic 1, độc lập với các tín hiệu logic và các dòng tín
hiệu khác
Kí hiệu : node x stuck-at fault
o x/0, x/1
o x s@0, x s@1
o x SA0, x SA1
Số lượng lỗi đơn là tuyến tính đối với kích thước của mạch. Bởi vì chúng ta có
2 lỗi đó là stuck-at one và stuck-at zero nên trên mỗi mạch chúng ta có 2n SSF trên
mỗi nút.
3
Examples: kiểm tra lỗi kẹt đơn tại hai ngõ vào của cổng AND
Hình 2.2.1.1: Các lỗi kẹt đơn tại các ngõ vào ra của cổng AND
Như hình trên thì chúng ta hoàn toàn có thể suy ra 6 lỗi: lỗi kẹt 0 hoặc 1 tại nút
a, kẹt 0 hoặc 1 tại nút b, kẹt 0 hoặc 1 tại nút c. Bây giờ chúng ta sẽ lập bảng các
trường ngõ vào của a và b để kiểm tra quan sát các giá trị lỗi ở đầu ra.
Input Fault-free Fault Output Value with SSF

ab Output a/0 a/1 b/0 b/1 c/0 c/1
00 0 0 0 0 0 0 1
01 0 0 1 0 0 0 1
11 1 0 1 0 1 0 1
10 0 0 0 0 1 0 1
Bảng 2.2.1.1: Bảng giá trị các lỗi đơn tại ngõ vào ra của cổng AND
Trong bảng này chúng ta kí hiệu tất cả các tín hiệu SSF màu đỏ để dễ dàng
nhận biết, ta có thể thấy rằng tất cả 6 cột tín hiệu lỗi ngõ ra có thể được phát hiện bởi
ít nhất 1 mẫu thử nghiệm. Bây giờ nếu chúng ta thiết lập một bộ ba thử nghiệm cho
ngõ vào a và b (01 11 10) khi đó chúng ta có thể thấy rằng 3 mẫu này có thể phát hiện
hoàn toàn tất cả 6 lỗi này nên chúng ta kết luận rằng độ dài tối thiểu của thử nghiệm
này là = 3 để đạt 100% độ bao phủ lỗi.
• Fanout Stems and Branches
Lỗi kẹt đơn trên Fanout stem không tương đương với lỗi kệt đơn trên Branches.
Bởi vì lỗi trên hai phần này được tính và xác định riêng, vậy để làm rõ vấn đề này
chúng ta đi xét ví dụ dưới đây:
4
Hình 2.2.1.2: Lỗi kẹt đơn Fanout và Branches trên mạch

Kí hiệu :
E là fanout stem
L,F là fanout branches
Input Output
A B C Good E/0 F/0 L/0 E/1 F/1 L/1
0 0 0 0 0 0 0 1 1 0
0 0 1 1 0 0 1 1 1 1
0 1 0 1 0 0 1 1 1 1
0 1 1 1 0 0 1 1 1 1
1 0 0 0 0 0 0 0 1 0
1 0 1 0 0 0 1 0 0 0
1 1 0 0 0 0 1 0 0 0
1 1 1 0 0 0 1 0 0 0
Bảng 2.2.1.2: Bảng giá trị biểu hiện Lỗi kẹt đơn Fanout và Branches trên mạch
Ở bảng này chúng ta có 8 bộ mẫu thử kết hợp đầu vào của ABC, cột tín hiệu tốt
và 6 cột giá trị đầu ra lỗi lần lượt là E/0, F/0, L/0,E/1, F/1, L/1. Vậy như quan sát tại
các giá trị ngõ ra, đầu tiên là kẹt tại 0 tại E F L tín hiệu lỗi của E và L hoàn toàn khác
nhau và sau đó là kẹt tại 1 thì chúng ta có thể thấy tín hiệu lỗi của E và F cũng khác
nhau. Từ đó chứng minh rằng lỗi kẹt đơn trên Fanout stem không tương đương với lỗi
kẹt đơn trên Branches.
• Multiple Stuck-at Fault

Mô hình multiple stuck-at fault có nghĩa là có nhiều hơn 1 tín hiệu kẹt ở giá trị
logic trong mạch.
Vậy có bao nhiêu multiple stuck-at fault trong một mạch có n nút( không bao
gồm lỗi kẹt đơn). Như các ví trước chúng ta có thể thấy rằng tại mỗi nút có thể có 3
trạng thái đó là SA1, SA0, good, vậy trong một mạch chúng ta có 3𝑛 các kết hợp khác
5
nhau tại các nút và vì chúng ta không tính đến tín hiệu các tín hiệu kẹt đơn cũng như 1
tín hiệu output good nên lúc này sẽ là 3𝑛 -2n-1. Vậy số multiple stuck-at fault trong
một mạch có n nút( không bao gồm lỗi kẹt đơn) là 3𝑛 -2n-1.
2.2.2 Bridging Fault (BF)

Lỗi Bridging Fault (BF) có nghĩa là 2 hoặc nhiều hơn các tín hiệu logic khác
nhau bị ngắn lại với nhau ngoài ý muốn và tạo ra wired logic
Hình 2.2.2.1: Các lỗi Bridging thực tế

Trong Bridging Fault chúng ta có các mô hình như sau:
• Wired-OR (1-dominant)
• Wired-AND (0-dominant)
• A-dominant
Hình 2.2.2.2: Mô hình lỗi Wired-OR và Wired-AND

Original Wired-OR Wired-AND a-dominant
a b a+ b+ a+ b+ a+ b+
0 0 0 0 0 0 0 0
0 1 1 1 0 0 0 0
1 0 1 1 0 0 1 1
1 1 1 1 1 1 1 1
6
Bảng 2.2.2.1: Bảng biểu thị giá trị của mô hình lỗi Wired-OR và Wired-AND
Trong hình này, giả sử chúng ta có lỗi BF giữa 2 tín hiệu a và b nếu chúng ta
mô hình hóa nó như wired -OR thì lúc này đoạn dây nối bắc cầu đó sẽ được xem như
một cổng OR khi đó tín hiệu qua nó sẽ được tuân theo cổng logic này cùng với giá trị
trội là 1 (quan sát ở bảng mẫu thử trên), hoặc chúng ta mô hình hóa lỗi này như wired-
AND thì lúc này đoạn dây nối bắc cầu đó sẽ được xem như một cổng AND và tín hiệu
qua nó sẽ được tuân theo cổng logic này cùng với giá trị trội là 0 (quan sát ở bảng mẫu
thử trên).
Cuối cùng là A-dominant với mô hình này thì có nghĩa rằng là giá trị của b
luôn được kiểm soát bởi a, như trên bảng mẫu thử chúng ta có thể thấy rằng nếu ban
đầu a=1 và b=0 sau khi bị lỗi bridging thì tín hiệu a vẫn được giữ nguyên còn tín
hiệu b=1, điều này chứng tỏ tín hiệu b đang bị kiểm soát chi phối hoàn toàn theo tín
hiệu a.
2.2.3 Delay Fault (DF)
Trong delay fault một sô hành vi lỗi không giống stuck-at fault bởi vì lỗi có thể
thay đổi thời gian mạch nhưng không thể thay đổi chức năng
Ta có thể lấy một số ví dụ :
• Lỗi ngẫu nhiên: resistive opens, resistive bridging
• Lỗi hệ thống : crosstalk
Hình 2.2.3: Hình mô phỏng lỗi hở điện trở

Trong hình 2.2.3 giả sử chúng ta có hở điện trở hoặc tiếp xúc kém giữa hai biến
tần, nếu chúng ta áp dụng mức chuyển đổi falling kí hiệu là A thì tín hiệu ra tốt sẽ là
tín hiệu kí hiệu là b như trong hình. Nhưng tín hiệu lỗi sẽ bị chậm hơn kí hiệu là C so
với tín hiệu b, vậy chúng ta có thể thấy rằng tuy dạng tín hiệu truyền ra đi qua lỗi có
thể sẽ bị chậm hơn so với thời gian tín hiệu tốt nhưng nó vẫn được đảm bảo và không
bị thay đổi dạng sóng tín hiệu.
7
Vậy chúng ta sẽ áp dụng các loại mẫu thử nào cho delay fault?
Không giống như lỗi stuck-at chỉ cần một bộ mẫu thử, transion fault cần sử
dụng đến 2 mẫu thử để kiểm tra đó là V1,V2
V1: khởi tạo trạng thái của mạch
V2: khởi động quá trình chuyển đổi, truyền ảnh hưởng của lỗi tới đầu ra
Trong hình này ta có thể thấy đầu tiên ta sử dụng mẫu thử V1=00 để khởi tạo
trạng thái cổng OR sau đó sử dụng đến mẫu thử V2 để truyền chuỗi tín hiệu ra quan
sát. Chúng ta có thể điều khiển thời gian T giữa V1 và V2 để ta có thể xác định xem
mạch này có PASS/FAIL, nếu tín hiệu output tăng trong khoảng thời gian T thì PASS
còn nếu tăng sau thời gian T thì FAIL.
Bây giờ chúng ta sẽ đi tìm hiểu về hai mô hình delay fault phổ biến nhất hiện
nay.
2.3 Các thuật toán sử dụng trong DFT

2.3.1 Thuật toán Ad-hoc
Ad-hoc DFT có nghĩa là một kĩ thuật DFT thiết kế cụ thể hoặc dành cho một
mục đích cụ thể khái quát. Phương pháp Ad-hoc là phương pháp chỉ nhắm đến các
phần không thể kiểm tra được các phần rất khó để kiểm tra trong một thiết kế.
Kĩ thuật DFT này dựa trên thực hành thiết kế tốt được lấy từ kinh nghiệm.
• Quy tắc Ad-hoc DFT
Rule 1: thiết kế mạch dễ dàng được khởi tạo.
Rule 2: vô hiệu hóa internal clock trong suốt thời gian kiểm tra.
8
Rule 3: phân chia mạch lớn thành các khối nhỏ.

Rule 4: chèn các điểm kiểm tra vào mạch có khả năng kiểm tra thấp.
• Chèn điểm kiểm tra
Mục đích: việc chèn kiểm tra nhằm mục đích để tăng khả năng điều khiển và
khả năng quan sát.
Có hai hai loại cho test point
1. Control point
Tín hiệu điều khiển thường từ ngõ vào chính PI hoặc scan FF
Original Control x to 0 Control x to 1
9
Hình 2.3.1: Chèn điểm kiểm tra
Chú thích: DI data input; DO data output TM test mode ; SI scan input ; SO
scan output
Khi TM=0, mạch hoạt động ở chế độ bình thường ta tiến hành cắt kết nối ban
đầu và kết nối nguồn với đầu vào DI của control point FF và gửi dữ liệu ngõ ra kết nối
với điểm đến ban đầu.
Khi TM=1, các node ABC được điều khiển bởi các FF tương ứng các dữ liệu
đến Q sẽ được kết nối với mux và dữ liệu ngõ vào D được cấp từ SI.
2. Observation point
Hình 2.3.2: Chèn điểm quan sát

Chú thích: DI data input
DO data output
SE scan enable
SI scan input
SO scan output
Khi SE=0, ABC sẽ được lưu vào FF bởi một chu kỳ.
Khi SE=1 , sau ba chu kỳ thì giá trị quan sát sẽ được hiện tại SO.
Các vấn đề của Test point

• Suy giảm hiệu suất: Thiết kế bị chậm với test point
• Tốn nhiều diện tích hơn: Mỗi một test point cần khoảng 1k cổng
10
• Tốn nhiều chân hơn

• Cần phải hiểu rõ và biết vị trí chèn điểm: Cần một thước đo cho việc
kiểm thử
2.3.2 Thuật toán Scan
2.3.2.1 Scan flip flop (SFF)
Scan Flip flop có 4 chân chính:
Scan chain: scan input ( SI ), scan output (SO)
Logic: data input (DI), data output (DO)
Scan FF có hai chức năng chính: Shift và Capture
Mạch có hai chế độ hoạt động: Normal mode và test mode
Hình 2.3.2.1: Chế độ hoạt động của Scan flip flop
Normal mode: được cấu hình để capture để có thể nhận phản hồi từ logic và
sau đó áp dụng phản hồi của nó cho logic một cách chính xác nhất.
Test mode: đầu tiên được cấu hình để thực hiện thao tác vận chuyển (shift) để
chúng ta có thể vận chuyển mẫu thử nghiệm của mình vào các FF. Sau đó SFF được
cấu hình capture phản hồi tín hiệu logic trong 1 hoặc 1 vài chu kỳ. Và cuối cùng
chúng ta cấu hình SFF thành shift out để ta có thể quan sát phản hồi của logic trong
SFF.
11
Examples: Normal mode
 Scan FF giống như non-scan FF
Examples: Test mode
Ở ví dụ này để phát hiện lỗi SA0, thì về cơ bản lỗi SA0 là kẹt trên đường tín
hiệu mong muốn là 1 nên để có giá trị mong muốn ta tiến hành cấp tín hiệu vào bằng 1
và SFF1=1 tại cổng OR để xác định giá trị mong muốn là 1 và lỗi = 0 thì chúng ta cấp
tín hiệu SFF2=0, sau khoảng thời gian 2 chu kỳ, ta tiến hành Capture tín hiệu vào
SFF, sau khi capture tín hiệu thì tiến hành shift out trong 2 chu kỳ ta có thể quan sát
được giá trị mong muốn và giá trị lỗi của mạch này.
 Việc xác định lỗi này hoàn toàn không thể xác định bằng phương pháp
Normal mode
12
Scan có thể chuyển từ mạch tuần tự sang mạch tổ hợp
Hình 2.3.2.2: Sơ đồ chuyển đổi mạch tuần tự sang mạch tổ hợp
Thật sự chúng ta có thể chuyển mạch tuần tự thành mạch tổ hợp trong chế độ
Testing vì các FF có thể hoàn toàn scan được nên chúng ta có thể kiểm soát hoàn toàn
đầu vào đầu ra của chúng. Vì vậy trên thực tế chúng ta có thể bỏ các flip flop này
trong chế độ kiểm thử, khi đó mạch ATPG sẽ chỉ còn là mạch tổ hợp.
SFF D0 trở thành pseudo primary input (PPI), điều khiển toàn bộ ngõ vào.
SFF DI trở thành pseudo primary output (PP0), quan sát toàn bộ ngõ ra.
Examples:
2.3.2.2 Muxed D Scan (FF)
Muxed D scan Thường được sử dụng trong flip flop based, tiêu chuẩn thiết kế
cell
13
Cấu tạo gồm:
3 ngõ vào: scan enable (SE), Data in (DI): dữ liệu vào từ logic, Scan in (SI): từ
scanff trước
1 ngõ ra: Data output (Q) or scan output (SO)
1 chân clock (CK)
Chế độ hoạt động
Hình 2.3.2.3: Mô tả chế độ hoạt động của Muxed DFF
Muxed_D scan FF kích hoạt cạnh tích cực lên
Khi SE = 0, SI -> Q tại cạnh tích cực lên
Khi SE = 1, DI -> Q tại cạnh tích cực lên
Test Mode Operation ( hoạt động của chế độ kiểm tra)
• Kiểm tra lỗi stuck-at
Sử dụng một mẫu thử cho mỗi scan out/in
14
Trong sơ đồ hiển thị trên đây chúng ta có hàng đầu tiên PI và SI biểu thị cách
chúng ta áp dụng mẫu thử, hàng thứ ba observe hiển thị cách chúng ta quan sát đầu ra,
hàng thứ 4 hiển thị dạng sóng clock và hàng cuối cùng SE hiển thị tín hiệu sóng cho
phép scan. Tiếp theo đến cột, thì cột đầu tiên chúng ta sẽ tải chuỗi quét theo chuỗi
xung clock CK. Sau khi các mẫu thử này được tải đầy đủ vào chuỗi quét thì chúng ta
bắt đầu capture giá trị này, chúng ta sẽ quan sát đầu ra chính P0 và tạo xung clock để
lưu lại phản hồi vào SFF, và cuối cùng chúng ta sẽ tạo chuỗi CK để có thể quan sát
giá trị phản hồi (SO) của SFF.
Examples:
15
Trong ví dụ này chúng ta sẽ tiến hành kiểm tra lỗi kẹt tại các vị trí đánh dấu
trong mạch mạch. Đầu tiên chúng ta tiến hành tải chuỗi dữ liệu SI = X011 và PI = 1
bằng cách cấp chuỗi xung CK PPPP và giữ SE=1 trong suốt thời gian tải này. Bây giờ
chúng ta tiến hành quan sát PO ngõ ra ta thấy lỗi kẹt ở đây kẹt 1 nên giá trị mong
muốn trên đường kẹt này sẽ là 0 khi đó ngõ ra mong muốn PO sẽ là L. Sau khi đã tải
xong giá trị thử SI chúng ta tiến hành capture tín hiệu phản hồi từ logic vào các FF
bằng một xung clock và giữ SE=0, ta thấy lỗi kẹt SA0 màu hồng đầu tiên, vì đây là lỗi
kẹt 0 nên giá trị mong muốn phản hồi từ logic lúc này sẽ là 1 và lỗi sẽ là 0, cũng tại lỗi
kẹt SA0 màu xanh thứ 2 chúng ta có giá trị mong muốn từ logic là 1 và lỗi là 0. Sau
khi quan sát và tiến hành capture tín hiệu vào các FF ta tiến hành chuyển các phản hồi
từ các FF này ra để quan sát bằng chuỗi các xung clock và giữa SE=1.
• Kiểm tra lỗi Delay

Sử dụng 2 mẫu thử cho mỗi scan in/out, và có 2 phương pháp chính đó là:
Launch-on-shift và Launch-on-capture.
Phương pháp 1: Launch-on-shift (LOS)
16
Trong mô hình này đầu tiên chúng ta tải V1 bằng cách đặt chuỗi các clock CK
và SE được giữ bằng 1, tiếp sau đó chúng ta thực hiện tải V2 bằng một xung clock
khác và vẫn giữ SE=1 khi đó ta áp dụng mẫu thử thứ 2 PI2, SI2. Bây giờ chúng ta sẽ
tiến hành quan sát giá trị đầu ra chính PO và sử dụng một xung clock để lưu phản hồi
logic tại FF lúc này thì SE=0. Sau khi đã lưu giá trị phản hồi logic vào FF chúng ta
thực hiện bước cuối cùng đó là shift out vận chuyển ra ngoài giá trị được lưu trong
SFF để có thể quan sát đầu ra scan của mẫu này.
Ưu và nhược điểm của LOS

• Ưu điểm: dễ dàng cho việc tạo mẫu thử của mạch tổ hợp ATPG.
• Nhược điểm:
- Giới hạn thời gian, giảm tín hiệu Scan-enable.
- Một số lỗi trì hoãn quá trình TDF có thì không được kiểm tra rỗ ràng, vì
đây là vấn đề về cấu trúc.
Examples:
Trong ví dụ này ta sẽ tiến hành kiểm tra lỗi STF được đánh dấu màu đỏ và lỗi
STR được đánh dấu màu hồng bằng phương pháp LOS. Đầu tiên chúng ta sẽ tiến hành
17
tải mẫu thử V1, SI= X101 bằng chuỗi Clock và giữ SE bằng 1 ngõ vào PI lúc này
không cần, tiếp theo đó ta tiến hành tải V2 với mẫu thử SI=1, PI=1 và tạo một xung
clock khác cũng như giữ cho SE=1. Lúc này giá trị trong FF đã được thay đổi khi V2
vào sẽ đẩy giá trị X ra và giá trị SFF này sẽ dịch lên SFF tiếp theo, khi này chúng ta
cũng có thể quan sát đầu ra PO nếu giá trị tốt mong muốn sẽ là L nhưng do lỗi TRF
nên giá trị lỗi lúc này sẽ là H. Bây giờ chúng ta sẽ tiến hành capture phản hồi từ logic
vô FF và tạo một xung clock cũng như chuyển SE=0, sau khi đã capture các phản hồi
logic này ta tiến hành tạo chuỗi xung clock và giữ SE=1 để chuyển các giá trị này ra
ngoài để quan sát.
Phương pháp 2: Launch-on-capture (LOC)
Trong mô hình này đầu tiên thì chúng ta cũng tải chuỗi mẫu thử V1 bằng cách
tạo chuỗi xung clock và tín hiệu quét SE được giữ bằng 1. Khi chúng ta áp dụng mẫu
thử V2 thì lúc này SE sẽ được giữ bằng 0 và chúng ta áp dụng mẫu thử PI2 vào thời
điểm này khi đó chúng ta sử dụng một xung clock để tạo vecto V2, sau đó chúng ta có
thể quan sát ngõ ra chính PO và lưu giá trị phản hồi logic vào SFF. Cuối cùng chúng
ta tiến hành gỡ quá trình test bằng các tạo một chuỗi xung clock và giữ SE=1 để vận
chuyển các giá trị phản hồi logic được lưu trong FF ra ngoài tiến hành quan sát.
18
Examples:
Trong ví dụ này chúng ta sẽ kiểm tra lỗi STR và lỗi STF bằng phương pháp
LOC, thì đầu tiên chúng ta cũng tiến hành tải V1 SI=1X0001 bằng cách tạo một chuỗi
xung clock tương đương và giữ SE=1 lúc này ngõ vào PI chung ta chưa xét đến. Sau
khi tải xong V1 ta tiến hành chuyển SE từ 1 xuống 0 và lúc này ta cấp cho nguồn vào
PI=1, trong thời gian SE=0 này ta thì tạo một xung clock để tạo V2 cho quá trình
chuyển đổi FF nhận giá trị từ mạch logic, lúc này ta có thể quan sát đầu ra chính PO
có già trị mong muốn sẽ là L và giá trị lỗi sẽ là H. Sau khi đã tiến hành tải các giá trị
thì ta sẽ capture phản hồi từ logic vào FF, và cuối cùng là tạo chuỗi xung clock và
chuyển SE lên chuỗi 1 để tiến hành chuyển giá trị trong FF ra ngoài quan sát.
2.3.3 JTAG
JTAG là một phương pháp test PCB được một nhóm kỹ sư Harry Wardrop đề
xuất đầu tiên vào năm 1985. Sự ra đời của công cụ này xuất phát từ tính phức tạp của
phần cứng của hệ thống ngày càng cao. Hệ thống không chỉ là 1 chíp và là nhiều chíp,
19
PCB không chỉ 1 lớp, 2 lớp mà là nhiều lớp. Chính vì thế người ta không thể dùng
đầu dò để kiểm tra hệ thống
Tại sao phải sử dụng quét ranh giới ?
1. Kiểm tra và chuẩn đoán Board-level

Nếu chúng ta muốn kiểm tra board mạch và tất cả các chip trên board chúng ta
cần ghép tất cả các chip vào một chuỗi quét JTAG, bằng cách này JTAG cho phép
kiểm tra và chuẩn đoán các board level. Và đặc biệt việc kiểm tra này có thể được
thực hiện hoàn toàn off line hoặc online có nghĩa là chúng ta có thể kiểm tra và gỡ lỗi
ngay cả khi mạch đang hoạt động.
Hình 2.3.3.1: Kiểm tra board mạch bằng JTAG
2. Kiểm tra kết nối giữa các chip trên board
20
Giả sử hai chip này đang trên cùng một board mạch, nếu chúng ta muốn xác
định lỗi bắc cầu giữa hai chip hoặc lỗi stuck at 0 trên dây nối chúng ta có thể sử dụng
chức năng quét ranh giới.
Đầu tiên chúng ta tiến hành quét với chuỗi 1 0 1 ở đầu ra trong chip 1 và theo
chuỗi quét giá trị của đầu vào của chip 2 cũng sẽ là 1 0 1, khi đó ta tiến hành capture
tại giá trị đầu vào này nếu quan sát thấy giá trị thay đổi thì chúng ta có thể xác định
các lỗi này.
3. Kiểm tra hệ thống logic trên chip
Giả sử chúng ta muốn kiểm tra chip này nhưng nó đã được lắp trên board nên
chúng ta không thể sử dụng bộ kiểm tra ATE để kiểm tra, nên chúng ta tiến hành kiểm
tra bằng quét ranh giới. Ở đây ta kiểm tra với các mẫu thử input 11 01 10 và các tín
21
hiệu output good lần lượt là 1 0 0, ta có thể thấy được bằng cách này ta có thể kiểm tra
được tính logic của chip khi chip đã được gắn trên board.
2.3.3.1 Kiến trúc thành phần của JTAG

JTAG bao gồm các thành phần kiến trúc là: TAP, TAP controller, Register,
Instruction Decoder.
Hình 2.3.3.2: Kiến trúc của JTAG
Test access point (TAP)
Trong test access point có 4 test bắt buộc:
• TDI : test data in

• TDO: test data out
• TCK: test clock
• TMS: test mode select
22
TAP controller
TAP controller là 16 máy trạng thái hữu hạn điều khiển hoạt động của JTAG,
bao gồm TMS là giá trị đầu vào, TCK là clock của máy trạng thái này.
Hình 2.3.3.3: Sơ đồ máy trạng thái của tap controller
Chúng ta có thể tạm chia trạng thái thiết lập này thành 2 khối màu vàng và màu
hồng như trên hình, màu vàng đó là đại diện cho khối liên quan đến thanh ghi dữ liệu
DR còn màu hồng đại diện cho khối liên quan đến thanh ghi lệnh IR
Test-logic-reset là trạng thái thiết lập lại kiểm tra, đây là trạng thái mà chúng ta
nên bắt đầu từ đó mỗi khi chúng ta tiến hành sử dụng logic JTAG. Có hai phương
pháp mà chúng ta có thể đưa máy trạng thái đã hoàn thiện về trạng thái đặt lại logic
thử nghiệm:
- Phương pháp 1: chúng ta cho TMS = 111…., điều này sẽ đưa chúng ta đến
trạng thái đặt lại logic.
- Phương pháp 2: ta có thể sử dụng chân tùy chọn TRST = 0 để khởi tạo lại
• REGISTER
Có hai loại thanh ghi JTAG bắt buộc:
Data register (DR):

Bypass register ,BR
23
Boundary scan register, BSR

Instruction register (IR)
Hình 2.3.3.4: Kiến trúc register trong JTAG

1. Bypass register BR
Mục đích: cung cấp đường đi ngắn nhất từ TDI đến TD0 giúp rút ngắn chuỗi
quét ranh giới từ chip đang thử nghiệm.
Cấu trúc đơn giản chỉ sử dụng 1 bit FF khi shiftDR = 1 thì dữ liệu được dịch
chuyển từ TDI đến TDO
Examples:
24
Trong ví dụ này chúng ta giả sử rằng chip 2 và 3 đang kiểm tra JTAG còn chip
1 thì không được kiểm tra JTAG. Vì vậy chúng ta muốn quét ranh giới đi qua cả 24
cell do đó cần tới 24 clock. Nhưng nếu chúng ta tiến hành bypass tại chip 1 thì chúng
ta chỉ tốn 17 clock, giảm tới 29% thời gian kiểm tra.
2. Boundary scan register BSR
Mục đích : điều khiển và quan sát hệ thống các chân I/O
BSR bao gồm: Boundary scan cells (BSC)
Input Boundary Scan Cells
Mỗi input BSC có:
• 2 FF: capture/scan FF, output FF

• 2 control signal: shift DR, mode
• 2 clock : clock DR, update DR
Hình 2.3.3.5: Kiến trúc ngõ vào Boundary scan cells
25
Input Boundary Scan Cells hỗ trợ 4 chế độ hoạt động:
❖ Chế độ 1: Normal
Ở chế độ này tín hiệu điều khiển Mode gắn với logic 0 để tín hiệu đầu vào từ hệ
thống các chân đến hệ thống logic và BSC trong trạng thái transparent.
Hình 2.3.3.6: Kiến trúc ngõ vào Boundary scan cells chế độ Normal
26
❖ Chế độ 2: Scan
Ở chế độ này tín hiệu điều khiển ShiftDR được gán giá trị 1 để dữ liệu thử
nghiệm từ cell trước thông qua FF đầu tiên tới cell tiếp theo và sử dụng clockDR để
vận chuyển các cell. Và hoàn toàn không can thiệp vào logic hệ thống
Hình 2.3.3.7: Kiến trúc ngõ vào Boundary scan cells chế độ Scan
❖ Chế độ 3: Update
Ở chế độ này dữ liệu kiểm tra được chuyển từ scan ff sang update ff sử dụng
clock update DR, bằng cách này ta có thể áp dụng các mẫu thử cho hệ thống
logic.
Hình 2.3.3.8: Kiến trúc ngõ vào Boundary scan cells chế độ Update
27
❖ Chế độ 4: Capture
Ở chế độ cuối cùng này chúng ta sử dụng shiftDR gán với giá trị 0 và clock
DR, bằng cách này chúng ta có thể capture giá trị từ hệ thống các chân ghim vào scan
ff đầu tiên.
Hình 2.3.3.9: Kiến trúc ngõ vào Boundary scan cells chế độ Capture
Bảng 2.3.3.1: Tóm tắt tín hiệu điều khiển các chế độ hoạt động ngõ vào
28
Output Boundary Scan Cells hỗ trợ 4 chế độ hoạt động:
Tại đầu ra BSC có cấu tạo và các chế độ tương tự với Input BSC chỉ khác là
giữ liệu vào lúc này là từ hệ thống logic còn dữ liệu đầu ra là từ hệ thống các chân.
Chế độ Tín hiệu điều khiển Clock

Mode Shift
Normal 0 X System
Scan X 1 ClockDR
Capture X 0 ClockDR
Update 1 X UpdataDR
Bảng 2.3.3.2: Bảng tóm tắt tín hiệu của các chế độ hoạt động ngõ ra JTAG
Phương pháp tải lệnh:

• ShiftIR = 1, ClockIR, ClockIR,........, sau khi tải xong tập lệnh ta tạm dừng
clockIR.
• Sau khi tạm dừng tại sff thì tiến hành UpdateIR để có thể cập nhập lệnh
vào output FF.
29
• Tập lệnh này sau đó được chuyển đến bộ giải mã để tạo tín hiệu điều khiển.
Phương pháp tải tập lệnh với mô hình máy trạng thái hữu hạn:
• Khởi tạo kiểm tra JTAG: TMS = 1-1-1-1-1 => Sau khi thiết lập TMS
thì bất kể bạn đang ở đâu trong máy trạng thái sẽ đều trở về trạng thái thiết lập lại
kiểm tra logic.
• Lựa chọn thanh ghi lệnh IR: Sau khi trở về trạng thái thiết lập lại kiểm
tra logic thì ta có thể áp dụng chuỗi TMS : 0-1-1-0-0 điều này sẽ đưa chúng ta đến
trạng thái thay đổi của chúng ta aowr trạng thái này.
• Tải lệnh : Bây giờ chúng ta có thể tải lệnh với TMS=0...0 để có thể duy
trì trạng thái của mình và lệnh của chúng sẽ được shift in bằng đầu vào TDI
• Kết thúc :Sau khi hoàn thành chúng ta có thể thoát khỏi trạng thái
shiftIR bằng cách thực hiện chuỗi TMS=1-1-0 quay trở về trạng thái run-test-idle.
30
2.3.4 JTAG instruction

Trong các tập lệnh của JTAG chúng ta có 3 tập lệnh bắt buộc thực hiện:
• EXTEST
• PYPASS
• SAMPLE/PRELOAD
Trước khi chúng ta thực hiện một lệnh nào đó thì ta cần phải tải mã lệnh vào
thanh ghi. Vậy đầu tiên trước khi tìm hiểu về các lệnh trên ta sẽ tiến hành tải lệnh vào
thanh ghi như sau:
Đầu tiên chúng ta áp dụng chuỗi TMS : 1-1-1-1-1 để chúng ta có thể khởi tạo
tại trạng thái thiết lập lại kiểm tra logic. Sau đó chúng ta tải lệnh bằng cách áp dụng
một chuỗi 0-1-1, lúc này chúng ta đang ở ô select IR scan cột 2 và cột này tương ứng
với các trạng thái liên quan đến thanh ghi lệnh. Sau đó ta tiếp tục với chuỗi 0-0 thì
chúng ta sẽ tới với shift IR và thực hiện tải thanh ghi và mã lệnh tại đây với chuỗi 0-
……-0 ( số lượng số 0 bằng tổng độ dài thanh ghi lệnh của tất cả các chip trên board).
Cuối cùng sau khi thực hiện tải xong mã lệnh thì chúng ta có thể thoát ra với chuỗi 1-
1-0 quay lại trạng thái run-test/idle.
Vậy mã lệnh chúng ta có thể vận chuyển thông qua chân đầu vào TDI
Mã tập lệnh JTAG được chỉ định là:

o EXTEST = 000….(tất cả số không)
o BYPASS = 111…(tất cả số một)
o Các mã lệnh khác được nhà thiết kế chỉ định
2.3.4.1 EXTEST
Mục đích của EXTEST đó là để kiểm tra bên ngoài của các kết nối dây giữa
các chip.
31
Giả sử trong ví dụ này chúng ta muốn xác định lỗi bắc cầu giữa hai chip hoặc
lỗi stuck at 0 trên dây nối chúng ta có thể sử dụng chức năng quét ranh giới. Chúng ta
có thể áp dụng chuỗi 101 tại thanh gi quét ranh giới ở đầu ra của chip 1 sau đó chúng
ta có thể capture phản hồi ở thanh ghi quét ranh giới ở đầu vào của chip 2, bằng cách
này chúng ta có thể phát hiện được các lỗi trên.
Các bước tiến hành kiểm tra:
Bước 1: scan in chip 1: shiftDR = 1, clockDR,…….
Bước 2: Update chip 1: updateDR
Bước 3: Capture chip 2: shiftDR=0, clockDR
Bước 4: Scan out chip 2: shiftDR=1, clockDR…..
Mode luôn luôn bằng 1
Hình 2.3.4.1: Sơ đồ kiến trúc quá trình kiểm tra EXTEST
32
Ở bước 1 trước tiên chúng ta quét dữ liệu thử nghiệm vào chip 1 để làm như
vậy chúng ta nhập tín hiệu điều khiển shifDR=1 và đặt một chuỗi xung nhịp clockDR.
Ở bước 2 chúng ta thêm 1 tín hiệu clock UpdateDR theo cách này thì dữ liệu quét từ
SFF 1 được chuyển sang SFF2, tiếp theo đó ở bước 3 chúng ta có thể capture phản hồi
ở chip số 2, chúng ta nhập tín hiệu điều khiển shiftDR=0 và sử dụng 1 clock DR. Ở
bước 4, bây giờ chúng ta có thể quét nội dung bên trong chip 2 lúc này ta nhập tín
hiệu shiftDR=1 và đặt 1 chuỗi xung clockDR bằng cách này chúng ta có thể quan sát
nội dung trong ô quét ranh giới của chip 2. Và trong chế độ này thì tín hiệu điều khiển
Mode luôn bằng 1.
BSC chip1 và TAP controller
Hình 2.3.4.2: Cấu trúc output BSC và máy trạng thái hoạt động của chip1
Bây giờ chúng ta sẽ đi tìm hiểu về quá trình chuyển đổi trạng thái trong tap
controller tại output BSC chip1, chúng ta giả sử tập lệnh đã được tải thành công nên
hiện tại chúng ta đang ở trạng thái run-test/idle. Bắt đầu từ trạng thái này ta áp dụng
33
trình tự TMS = 1 để đi đến ô slectDR scan ở cột thứ nhất tương ứng với thanh ghi dữ
liệu, ta tiếp tục thêm chuỗi TMS = 0 0 khi đó ta sẽ tới được vị trí shift-DR ở trạng thái
này chúng ta có thể quét dữ liệu thử nghiệm của mình với chuỗi TMS=0…..0 (số
lượng số 0 bằng tổng độ dài thanh ghi dữ liệu của tất cả các chip trên board bao gồm
cả thanh ghi quét ranh giới và thanh ghi BYPASS). Khi chúng ta đã tải xong tất cả dữ
liệu thì thực hiện chuỗi TMS = 1-1 đến trạng thái update DR, ở trạng thái này chúng ta
có thể cập nhập dữ liệu kiểm tra từ SFF1 sang SFF2 sau cùng áp dụng TMS=1 để
quay về trạng thái quét đã chọn.
BSC chip2 và TAP controller
Hình 2.3.4.3: Cấu trúc input BSC và máy trạng thái hoạt động của chip2
Ở đây bây giờ chúng ta sẽ đi tìm hiểu về quá trình chuyển đổi trạng thái trong
tap controller tại input BSC chip2, tiếp tục quá trình của chip1 bắt đầu từ trạng thái
34
quét đã trọn áp dụng trình tự TMS = 0 để lưu lại phản hồi của SFF2 của chip1 sau đó
tiếp tục trình tự TMS = 0 để thực hiện shiftDR một lần nữa ta áp dụng chuỗi trình tự
TMS= 0-…-0 để quét ra nội dung trong SFF tại chip 2 (số lượng số 0 bằng tổng độ dài
thanh ghi dữ liệu của tất cả các chip trên board bao gồm cả thanh ghi quét ranh giới và
thanh ghi BYPASS). Cuối cùng ta áp dụng trình tự chuỗi TMS = 1-1-0 để quay trở về
trạng thái run-test/idle.
Examples: Tải tập lệnh

Initialize TAP Load instruction
TMS 11111 01100* 000 0000** 110
TDI 000 0000
TDO
Final state Test logic-reset Shift-IR Run-test/ildle
Trong ví dụ này giả sử chúng ta muốn kiểm tra kết nối giữa chip 1 và chip 2.
Đầu tiên ta sẽ bắt đầu từ bảng hiển thị trình tự TMS TDI TDO, ở cột đầu tiên TMS
hiển thị chuỗi 1-1-1-1-1 để chúng ta có thể bắt đầu tại trạng thái đặt lại kiểm tra logic,
sau đó ta áp dụng chuỗi 01100 để đến với trạng thái shiftIR và bây giờ ta có thể tải mã
lệnh vào hai chip, giả sử rằng tại chip 1 có 4 bit thanh ghi lệnh và chip số 2 có 3 bit
thanh ghi lệnh vì vậy chúng ta áp dụng chuỗi 7 số 0 trong TDI sau khi chúng ta đã tải
35
mã truy xuất cho hai chip, giờ đây chúng ta có thể thoát khỏi trạng thái bằng cách áp
dụng chuỗi TMS = 110 và quay trở về trạng thái run-test/idle .
Example: Scan – in – update

Scan in Update
TMS 100 1 1 1
TDI xxxx xxxx x101 xxxx
TDO
Final state Shift-DR Update-DR Select-DR-scan
Sau khi tiến hành tải lệnh xong và trở về trạng thái chạy thử ( run-test/idle)
chúng ta sẽ áp dụng chuỗi trình tự TMS = 100 để đến ô shift DR và bây giờ chúng ta
có thể gửi dữ liệu kiểm tra, giả sử rằng cổng ngõ vào TDI như trên hình và chúng ta
có 8 bits thanh ghi dữ liệu tại chip 1 và 8 bits thanh ghi giữ liệu tại chip 2 vậy tổng
chiều dài của thanh ghi dữ liệu là 16 vậy chuỗi 16 số 0 trong quá trình TMS này, và áp
dụng mẫu thử xxxx xxxx x101 xxxx vào từ đầu TDI. Sau khi đã quét tất cả các mẫu
kiểm tra thì ta áp dụng chuỗi trình tự TMS=11 khi đó chúng ta sẽ quay trở lại trạng
thái slect-DR-scan.
36
Examples: Capture – scan – out

Capture Scan out
TMS 0 1 0000 0000 0000 0000 110
TDI
TDO Xxxx HLHx xxxx xxxx*
Final state Capture-DR Shift-DR Run-test/idle
Sau khi hoàn thành việc quét giá trị thử nghiệm vào chip 1 ta tiến hành lưu giá
trị phản hồi ở phía đầu vào của chip2, đầu tiên chúng ta áp dụng TMS = 0 bây giờ
chúng ta ở trạng thái capture DR, sau khi chúng ta đã capture phản hồi mà chúng ta
mong muốn thì áp dụng thêm 1 số 0 để thực hiện scan out và hiện tại ta ở trạng thái
shift DR trong trạng thái này ta áp dụng liên tục 16 clockDR để chuyển nội dung trong
thanh ghi dữ liệu và chuỗi giá trị chúng ta mong muốn là xxxx HLHx xxxx xxxx. Sau
khi đã gửi chuỗi quét muốn kết thúc thì ta thực hiện chuỗi trình tự TMS= 110 khi đó
chúng ta sẽ quay về trạng thái run-test/idle điều này sẽ kết thúc quá trình kiểm tra giữa
2 chip.
2.3.4.2 BYPASS
Mục đích: cung cấp đường đi ngắn nhất từ TDI đến TD0 giúp rút ngắn chuỗi
quét ranh giới từ chip đang thử nghiệm.
37
Cấu trúc đơn giản chỉ sử dụng 1 bit FF khi shiftDR = 1 thì dữ liệu được dịch
chuyển từ TDI đến TDO.
Examples:
Trong ví dụ này chúng ta giả sử rằng chip 2 và 3 đang kiểm tra JTAG còn chip
1 thì không được kiểm tra JTAG. Vì vậy chúng ta muốn quét ranh giới đi qua cả 24
cell do đó cần tới 24 clock. Nhưng nếu chúng ta tiến hành bypass tại chip 1 thì chúng
ta chỉ tốn 17 clock, giảm tới 29% thời gian kiểm tra.
QUIZ: Chúng ta sẽ lấy lại hoàn toàn ví dụ như trên EXTEST và giả sử chúng
ta thêm vào 1 chip nữa trong bảng mạch, khi chúng ta áp dụng EXTEST cho
chip 2 và chip 3 vui lòng hãy thay đổi trình tự TMS/TDI/TD0 để chip 1 có thể
Bypass
Lưu ý: Mã lệnh Bypass cho chip 1 là 11
38
2.4 BIST
BIST là viết tắt của Built-in self-test, đây là một kĩ thuật cho phép một chip tự
tạo ra các test pattern và tự kiểm tra các mạch bên trong nó rồi báo cáo kết quả
PASS/FAIL. Với kĩ thuật này để test một thành phần bên trong chip, các test pattern
không phải cung cấp từ từ bên ngoài việc phân tích các kết quả cũng không cần phải
thực hiện bên ngoài chip như kĩ thuật ad-hoc hay scan nên BIST có một ưu điểm lớn
là giảm thời gian test và giảm chi phí test chip.
Kỹ thuật BIST có thể được áp dụng để test logic của thiết kế (Logic BIST -
LBIST) và bộ nhớ (Memory BIST - MBIST).
Cấu trúc BIST gồm các phần cơ bản sau đây:
• Bộ tạo test pattern (Test pattern generator – TPG)
• Bộ phân tích đáp ứng ngõ ra ( output response analyzer – ORA)
• Bộ điều khiển BIST ( test controller)
39
Hình 2.4: Kiến trúc built in self test
2.4.1 MBIST
Mbit tạo ra một cấu trúc BIT trên chip áp dụng mẫu thử so sánh các phản hồi
của chip. Kiểm tra bộ nhớ thông qua một thuật toán hiệu quả dù đó là lỗi stuck at
(SAF), transion(TF), coupling ( CF), hay lỗi nhạy cảm lân cận (NPSF). Nó sử dụng
một bộ điều khiển, bộ tạo địa chỉ, bộ tạo mẫu thử nền, bộ so sánh, tín hiệu ghi/đọc và
bộ nhớ với trình đọc của nó.
Hình 2.4.1: kiến trúc MBIST
Bộ nhớ được kiểm tra bằng các thuật toán đặc biệt giúp phát hiện các lỗi xảy ra
trong bộ nhớ. Một số thuật toán khác nhau có thể được sử dụng để kiểm tra RAM và
ROM, dưới đây chúng ta sẽ đi tìm hiểu hai trong số các thuật toán quan trọng nhất
40
được sử dụng để kiểm tra bộ nhớ. Các thuật toán này có thể phát hiện nhiều lỗi trong
bộ nhớ với số bước kiểm tra và thời gian kiểm tra tối thiểu.
Trước khi tìm hiểu về các bước thực hiện của thuật toán thì chúng ta sẽ đi tìm
hiểu hệ thống các lỗi trong phần này:
Stuck-at fault (SA0_SA1): lỗi kẹt tại giá trị 0 hoặc 1
Bộ nhớ bị lỗi nếu một trong các tín hiệu điều khiển hoặc ô nhớ của nó vẫn bị
kẹt ở một giá trị cụ thể. Các lỗi bị kẹt mô hình hóa hành vi này, trong đó tín hiệu hoặc
cell dường như được gắn với nguồn điện (bị kẹt ở mức 1) hoặc mặt đất (bị kẹt ở mức
0).
Để phát hiện lỗi bị kẹt, bạn đặt giá trị ngược lại với giá trị của lỗi bị kẹt tại vị trí
lỗi. Để phát hiện tất cả các lỗi bị kẹt tại 1, bạn phải đặt 0 tại tất cả các vị trí lỗi. Để
phát hiện tất cả các lỗi bị kẹt ở 0, bạn phải đặt 1 tại tất cả các vị trí lỗi.
Kí hiệu:
Một ô luôn bị kẹt ở 0 – SA0
Một ô luôn bị kẹt ở 1 – SA1
Examples:
Trong ví dụ này đầu tiên ta tiến hành nhập hai nhóm mẫu thử 0 1 và tất cả các ô
miễn sao mỗi ô là hai nhóm khác nhau, sau đó ta tiến hành đọc giá trị tất cả các ô và
viết lại giá trị đảo ngược vào. Ta thấy ở ô đầu tiên bị kẹt tại giá trị 1, nếu đúng thì giá
trị mong muốn của nó sẽ là 0.
41
Transion fault ( TF): lỗi truyền
Một bảng memories không thành công nếu một trong các tín hiệu điều khiển
hoặc ô nhớ của nó không thể thực hiện chuyển đổi từ 0 sang 1 hoặc 1 đến 0. Hình cho
thấy một ô có thể hoạt động bình thường khi một bài kiểm tra ghi và sau đó đọc 1. Nó
thậm chí có thể chuyển đổi đúng cách từ 1 sang 0. Tuy nhiên, khi trải qua chuyển
tiếp 0->1, ô có thể vẫn ở mức 0 thể hiện hành vi bị mắc kẹt ở mức 0 kể từ thời điểm
đó. Tuy nhiên, một thử nghiệm bị mắc kẹt ở mức 0 có thể không phát hiện ra lỗi này
nếu cell ở mức 1 ban đầu.
Kí hiệu:
cell không thể tăng từ 0 lên 1 - <↑/0>
cell không thể giảm từ 1 xuống 0 - <↓/1>
Coupling fault (CF)
Bộ nhớ cũng thất bại khi thao tác ghi trong một ô ảnh hưởng đến giá trị trong
một ô khác. Lỗi khớp nối mô hình hóa hành vi này. Lỗi khớp nối thuộc một số loại:
đảo ngược, idempotent, bắc cầu và trạng thái.
State coupling fault (CFst)
Ở lỗi này nếu ô aggressor ở trạng thái nhất định thì, ô victim kế tiếp sẽ phải
buộc ở trạng thái 0 hoặc 1.
A: aggressor
V: victim
42
Kí hiệu: có 4 loại kí hiệu cho các trường hợp lỗi này
<0;0/1>, <0;1/0>, <1;1/0>, <1;0/1>
Examples:
Trong ví dụ này ta có thể thấy nếu xảy ra lỗi giữa ô A và V thì khi A có giá trị
bằng 0 ngay lập tức lỗi được kích hoạt và khiến cho V có giá trị bằng 1.
Inversion coupling fault (Cfins)
Xảy ra khi quá trình chuyển đổi của một ô gây ra sự đảo ngược giá trị của một
ô khác.
Ví dụ : quá trình chuyển đổi 0->1 trong cell_n khiến giá trị trong cell_m đảo
ngược trạng thái của nó.
43
Idempotent coupling fault (Cfid)
Xảy ra khi quá trình chuyển tiếp của một ô buộc một giá trị cụ thể lên một ô
khác. Ví dụ: quá trình chuyển đổi 0->1 trong cell_n khiến giá trị của cell_m thay đổi
thành 1 nếu giá trị trước đó là 0. Tuy nhiên, nếu giá trị trước là 1, ô vẫn là 1.
Lỗi khớp nối cầu (BFs) xảy ra khi một đoạn ngắn, hoặc cầu, tồn tại giữa hai
hoặc nhiều ô hoặc tín hiệu. Trong trường hợp này, một giá trị logic cụ thể kích hoạt
hành vi bị lỗi, thay vì chuyển tiếp.
Address-Decoder Fault (AF)
Lỗi giải mã địa chỉ, ở đây ta đi tìm hiểu 4 hành vi thường xảy ra ở lỗi này:
• Đưa ra một địa chỉ nhất định, không một ô nào được truy cập
44
• Một ô nhất định sẽ không được truy cập bất kỳ địa chỉ nào
• Một ô nhất định có thể được truy cập bởi nhiều địa chỉ
• Đưa ra một địa chỉ và nhiều ô có thể truy cập
Lỗi địa chỉ được chia thành 2 loại: OR-type AF, AND-type AF
Examples:
Trong ví dụ này ta có thể ở loại đầu tiên OR-AF giả sử A1 có giá trị 0 à A2 có
giá trị 1, khi chúng ta đọc A2 thì được giá trị đúng còn khi đọc giá trị 1 thì có giá trị
lỗi là 1 và giá trị mong muốn là 0. Tại lỗi này thật ra một cổng or tại đầu cuối và nhóm
2 giá trị A1 A2 là giá trị vào và kết quả sau khi qua cổng or sẽ là giá trị được được.
Ở loại thứ 2 AND-AF giả sử A1 có giá trị 0 à A2 có giá trị 1, khi chúng ta đọc
A1 thì được giá trị đúng còn khi đọc giá trị A2 thì có giá trị lỗi là 0 và giá trị mong
muốn là 1. Tại lỗi này thật ra một cổng and tại đầu cuối và nhóm 2 giá trị A1 A2 là giá
trị vào và kết quả sau khi qua cổng and sẽ là giá trị được được.
Mô hình vùng lân cận Lỗi nhạy cảm
Một cách khác mà các ô nhớ có thể bị lỗi liên quan đến thao tác ghi trên
45
một nhóm các ô xung quanh ảnh hưởng đến giá trị của một hoặc nhiều ô lân
cận.
2.4.1.1 Thuật toán Checkerboard

Trong thuật toán này các số 0 và 1 được ghi vào các vị trí bộ nhớ của mảng ô
theo mẫu bàn cờ. Thuật toán chia các ô thành hai nhóm thay thế sao cho các ô lân cận
thuộc các nhóm khác nhau. Thuật toán được sử dụng chủ yếu để kích hoạt các lỗi do
stuck-at(Sax), lỗi leakage, shorts between cells.
Các bước thực hiện:
• Bước 1: Viết mẫu bàn cờ cho tất cả các ô.
• Bước 2: Đọc mẫu bàn cờ từ cả các ô.
• Bước 3: Viết mẫu bàn cờ ngược với thứ tự ban đầu cho tất cả các ô.
• Bước 4: Đọc mẫu bàn cờ với thứ tự ngược mới được viết vào.
Bằng thuật toán checkboard này thì chúng ta có thể phát hiện hoàn toàn lỗi
stuck-at và lỗi transion nhưng chỉ phát hiện một nửa lỗi coupling. Vì như chúng ta
46
thấy trong hình thì trong quá trình chuyển đổi thì chỉ có giảm từ 1 xuống 0 hoặc tăng
từ 0 lên 1 mà không thể có ô nào có trình từ kiểm tra cả hai. Nên để làm rõ các lỗi còn
lại ta sẽ tiến tới thuật toán tiếp theo.
2.4.1.2 Thuật toán March
Trong số các thuật toán kiểm tra bộ nhớ thì thuật toán March được chứng minh
là đơn giản và hiệu quả nhất. Có nhiều loại kiểm thử mạch với các phạm vi lỗi khác
nhau, thử nghiệm March áp dụng các mẫu lên xuống địa chỉ bộ nhớ trong khi ghi các
giá trị vào và đọc các giá trị từ các vị trí đã biết.
Mục đích: xác định các lỗi mục tiêu đó là stuck-at ( Sax ), Transion fault (TF),
address fault (AF), Coupling fault( CF).
Trong thuật toán kiểm tra March chúng ta có một chuỗi các phương pháp để
xác định các lỗi, và mỗi phương pháp đó được cấu tạo bởi 2 yếu tố quan trọng:
• Hoạt động và dữ liệu

Đọc giá trị 0 được mong đợi (r0), đọc giá trị 1 được mong đợi ( r1)
Viết giá trị 0 tới 1 ô (w0), viết giá trị 1 tới 1 ô (w1)
• Chuỗi địa chỉ
: thay đổi địa chỉ theo thứ tự tăng dần
: thay đổi địa chỉ theo thứ tự giảm dần

: chuỗi địa chỉ có thể theo thứ tự lên dần hoặc giảm dần
Phương pháp MATS ( Modified algorithmic test sequence)
Trong phương pháp này sử dụng phần tử: { (w0); (r0,w1); (r1)}.
Chi tiết các bước thực hiện:
• Bước 1: ta viết 0 cho tất cả các ô, nó có thể theo thứ tự tắng dần hoặc
giảm dần { (w0)}

• Bước 2: ta tiến hành đọc giá trị 0 và sau đó viết giá trị 1 vào tất cả các ô
theo thứ tự địa chỉ tăng dần { (r1,w1)}
• Bước 3: cuối cùng chúng ta đọc 1 theo thứ tự địa chỉ giảm dần { (r1)}
47
Examples1:
Trong ví dụ này ta thức hiện đúng các bước để kiểm tra như trên. Đầu tiên viết
0 vào tất cả các ô có thể theo thứ tự tăng giảm tùy thích, tiếp theo là đọc giá trị 0 và
viết giá trị 1 vào các ô theo thứ tự địa chỉ tăng dần, cuối cùng là đọc 1 theo thứ tự
giảm dần.
Bằng cách này chúng ta có thể phát hiện hoàn toàn lỗi stuck-at (SAF) vì chúng
ta đọc cả từ 0 và đọc cả từ 1, nhưng chỉ phát hiện một nửa lỗi chuyển đổi vì chúng ta
chỉ thực hiện chuyển đổi từ 0 sang 1 chứ chưa chuyển đổi từ 1 lại 0.
 Phương pháp MATS phát hiện toàn bộ lỗi SAF và ½ TF
Examples2: OR-type AF giữa A1 và A3
Trong ví dụ này, giả sử chúng ta đã viết 0 vào tất cả các ô và đang thực hiện
đọc 0 viết 1 theo thứ tự tăng dần. Giả sử lỗi địa chỉ giữa A3 và A1, bây giờ chúng ta
sẽ xác định nó sẽ thuộc loại lỗi địa chỉ nào, chúng ta đọc 0 từ A3 và có một bộ giải mã
A1 để đánh giá giá trị sau khi đọc. Như vậy chúng ta chỉ có thể phát hiện được lỗi
OR-type và không thể phát hiện lỗi AND-type vì khi lỗi AND thì gía trị đọc được vẫn
là 0 mà 0 là giá trị đọc đúng.
Vậy làm cách nào chúng ta có thể phát hiện lỗi AND-type AF với phương pháp
MATS ? Một cách đơn giản đó là chúng ta sẽ đảo ngược lại các giá trị trong các bước
cảu phương pháp này: { (w1); (r1,w0); (r0)}.
48
Kết luận: từ các ví dụ trên ta có thể kết luận về chức năng của phương pháp
MATS là có thể phát hiện toàn bộ lỗi stuck-at và ½ lỗi Transion, Address.
Phương pháp MATS+
Phương pháp MATS+ là sự kết hợp của OR-type và AND-type của phương
pháp MAST. Bằng cách thêm 1 w0 vào thuật toán MAST: { (w0); (r0,w1);
(r1,w0)}.
Như trên ví dụ 2 của phương pháp MAST thì ta đã xác định được lỗi OR-type,
giả sử bây giờ chúng ta đã thực hiện tới bước đọc 1 viết 0 vào bộ giải mã địa chỉ A2.
Bây giờ chúng ta sẽ đọc 1 từ A1 và cùng đánh giá với giá trị tại bộ giải mã A1, tại thời
điểm này chúng ta có thể phát hiện lỗi AND-type với giá trị đánh giá 1/0, giá trị mong
đợi là 1 còn giá trị lỗi là 0.
Kết luận: vậy chúng ta kết luận phương pháp MAST+ có thể phát hiện toàn bộ
lỗi stuck-at và lỗi Address nhưng vẫn chỉ phát hiện ½ lỗi Transion.
Phương pháp MAST++
Trong phương pháp này chúng ta sử dụng lại tất cả các bước của phương pháp
MAST+ và thêm một bước r0 vào cuối cùng: { (w0); (r0,w1); (r1,w0,r0)}.
Vậy với phương pháp này chúng ta đã thực hiện chuyển trạng thái từ 0 lên 1 và
từ 1 xuông 0, nên chúng ta hoàn toàn có thể phát hiện lỗi Transion, stuck-at, Address.
Nhưng còn lỗi coupling (CF) thì sao, liệu phương pháp này có phát hiện được lỗi này
không?
49
Examples: Phương pháp MATS++ { (w0); (r0,w1); (r1,w0,r0)} liệu có

thể phát hiện lỗi 𝑪𝑭𝒊𝒏 <↓; ∀/↑↓>
Để làm rõ vấn đề trên ta cùng đi làm ví dụ này,chúng ta quy định A3 là victim
còn A1 là aggress, trong bảng 1 chúng ta đã thực hiện xong các bước { (w0);
(r0,w1)} qua tới bảng 2 tiếp tục thực hiện { (r1,w0,r0)} tại A2 và A3 ta đã tiến hành
đọc 1 viết 0, bây giờ ta thực hiện cho A1. Mà chúng ta đang đi xác định lỗi Cfin
với ô A chuyển trạng thái từ 1 xuống 0 ô victim sẽ bị tác động và đổi giá
trị thành 1, nhưng vì trong phương pháp MAST++ bước cuối cùng thực hiện theo
trình tự giảm dần, tức là A3 ô victim sẽ được đọc trước và được lưu giá trị 0 nên tới
khi thực hiện A1 ô aggress thì trương trình đã kết thúc cho nên ta không thể nào phát
hiện lỗi Cfin trong phương pháp này.
Phương pháp MarchX
Phương pháp marchX này cũng gần như sử dụng thuật toán của phương pháp
MAST++ nhưng được cải tiến lại trình tự lên xuống để có thể dễ dàng phát hiện lỗi
Cfin mà phương pháp MAST++ chưa thực hiện được: { (w0); (r0,w1); (r1,w0);
(r0)}.
50
Bây giờ chúng ta thực hiện lại các bước như ví dụ ở phần phương pháp
MAST++, đến bảng 2 khi A1 aggress thực hiện chuyển trạng thái từ 1 xuống 0 và vì
bây giờ bước đọc r0 tại bảng 3 có thể đọc theo trình tự lên xuống bất kỳ nên giá trị
chuyển trạng thái của A1 sẽ được đọc trước nên khi đó giá trị tại A3 ban đầu đang
bằng 0 phải chuyển đổi thành 1 và giá trị mong muốn của chúng ta là 0. Nên chúng ta
hoàn toàn có thể xác định được lỗi Cfin trong phương pháp này.
Kết luận: phương pháp MARCHX có thể xác định được các lỗi stuck-at (SAF),
Transion (TF), Address (AF), Inversion Coupling (Cfin).
Phương pháp March C
Phương pháp này là sự kết hợp của hai phương pháp March X nhưng có trình
tự địa chỉ khác nhau: { (w0); (r0,w1); (r1,w0); (r0); (r0,w1); (r1,w0);
(r0)}. Mục đích là để xác định hoàn toàn các lỗi Coupling.
Examples:
51
Bây giờ chúng ta xét ví dụ này với các trường hợp lỗi của Cfid theo phương
pháp March C, trong bảng đầu tiên ta thực hiện { (w0); (r0,w1)} để xác định lỗi
<↑; 0/1 >, trong bảng này sau khi chúng ta đã viết 0 cho tất cả các ô và tiến hành đọc
1 theo thứ tự tăng dần, nếu ô A mà bị lỗi <↑; 0/1 > là tại ô A đang chuyển đổi từ 0 lên
1 nên kéo theo ô V cũng phải tăng lên 1 mà giá trị mong muốn của ô V là 0 (0/1).
Tại bảng 2 để phát hiện lỗi <↑; 1/0 >, đầu tiên điều kiện kích hoạt lỗi là tại ô A
phải ở trạng thái tăng từ 0 lên 1 nên ta thực hiện (r0,w1), sau khi đã viết 1 vào tất cả
các ô ta tiến hành (r1,w0) đọc một viết 0 với thứ tự tăng dần, lúc này khi A bắt đầu
được viết 0 thì ô V cũng sẽ ngay lập tức bị chuyển từ 1 thành 0.
Tại bảng 3 và bảng 4 sử dụng hai thuật toán tiếp theo cách kiểm tra như trường
hợp 1 và trường hợp 2.
Kết luận: vậy từ ví dụ trên chúng ta có thể thấy rằng phương pháp March C có
thể xác định hoàn toàn lỗi Cfid cũng như các lỗi AF, SAF, TF.
3. THIẾT KẾ PHẦN CỨNG
3.1 Thiết kế mạch kiểm tra Scan

Mục đích: kiểm tra được các lỗi stuck-at, delay transition
3.1.1 Kiểm tra lỗi stuck-at
Trong phương pháp này chúng ta sẽ tiến hành thiết kế một mạch đơn giản gồm
hai cổng chính là AND và OR sau đó sẽ chèn thêm 4 bộ scan flip flop để test.
• Khối scan flip flop
Hình 3.1: Sơ đồ khối scan flip flop
52
Scan flip flop được cấu tạo bởi một cổng mux có chức năng điều khiển tín hiệu
đầu vào và một bộ DFF có chức năng nhận và lưu trữ giữ liệu theo tín hiệu xung clock
• Mạch logic tích hợp scan kiểm tra
Trong mạch test này chúng ta giả sử mạch bị lỗi stuck-at 0 tại đầu ra của cổng
OR và cổng AND, để kiểm tra chúng ta tiến hành scan flip flop với một mẫu thử cho
mỗi scan in/out
Hình 3.1.1: Sơ đồ mạch test stuck at trên candence
Trong mạch thử này chúng ta tiến hành shift in chuỗi giá trị dữ liệu SI = X011
bằng cách cấp chuỗi xung CK tích cực lên và giữ SE=1 trong suốt thời gian tải này.
Mục đích: Sau khi đã tải xong giá trị thử SI chúng ta tiến hành capture tín hiệu
phản hồi từ logic vào các FF bằng một xung clock và giữ SE=0, ta sẽ phát hiện thấy
lỗi kẹt SA0 đầu tiên, vì đây là lỗi kẹt 0 nên giá trị mong muốn phản hồi từ logic lúc
này sẽ là 1 và lỗi sẽ là 0, Sau khi quan sát và tiến hành capture tín hiệu vào các FF ta
tiến hành chuyển các phản hồi từ các FF này ra để quan sát bằng chuỗi các xung clock
và giữa SE=1.
KẾT QUẢ:
53
Hình 3.1.2: Kết quả dạng sóng biểu thị mẫu thử scanff
Trong kết quả dạng sóng trên hình 3.1.2 ta có thể thấy rằng chuỗi tín hiệu mẫu
thử 1101 được tải khi SE=1 và hoàn thành tại chu kỳ thứ 4 (được kí hiệu là vùng màu
đỏ). Tiếp theo đó khi tín hiệu cho phép SE=0 mạch bắt đầu nhận tín hiệu từ mạch
logic và chụp tín hiệu bằng một xung clock tiếp theo (được đánh dấu là vùng màu
vàng), khi này mạch đang bị lỗi stuck-at 0 tại 2 ngõ ra của cổng AND và OR và giá trị
lỗi sẽ được hiển thị trong F3 và OUT. Lúc này tín hiệu thu được là 1100 vậy rõ ràng
tại chu kỳ thứ 5 này chúng ta có thể thấy được hai giá trị ngõ ra đều bị kẹt tại 0.
Kết luận: Mạch test lỗi stuck-at với scan flip flop cho kết quả đúng với lý
thuyết cũng như phát hiện và dự đoán đúng hoàn toàn các lỗi stuck at trong mạch.
Phương pháp khắc phục: trong trường hợp chúng ta không thể tác động đến
thay đổi thiết kế cổng logic trong mạch thì chúng ta sẽ tiến hành thêm một nguồn vdc
có giá trị ngược với giá trị lỗi stuck at, khi đó tín hiệu sẽ truyền đúng trong một trường
hợp ngõ vào tạm thời.
3.1.2 Kiểm tra lỗi transition delay

Trong mạch kiểm tra này chúng ta cũng sử dụng các cổng logic cơ bản là NOT,
AND, OR và giả sử mạch bị lỗi truyền tại cổng vào của cổng OR. Để kiểm tra chúng
ta sử dụng 2 mẫu thử cho mỗi scan in/out.
54
Hình 3.1.3: Sơ đồ mạch kiểm tra lỗi delay transition trên candence
Ta tiến hành kiểm tra lỗi STF bằng phương pháp LOS. Đầu tiên chúng ta sẽ
tiến hành tải mẫu thử V1, SI= X101 bằng chuỗi Clock và giữ SE bằng 1 ngõ vào PI
lúc này không cần, tiếp theo đó ta tiến hành tải V2 với mẫu thử SI=1, PI=1 và tạo một
xung clock khác cũng như giữ cho SE=1. Lúc này giá trị trong FF đã được thay đổi
khi V2 vào sẽ đẩy giá trị X ra và giá trị SFF này sẽ dịch lên SFF tiếp theo.
Mục đích: capture phản hồi từ logic vô FF và tạo một xung clock cũng như
chuyển SE=0, sau khi đã capture các phản hồi logic này ta tiến hành tạo chuỗi xung
clock và giữ SE=1 để chuyển các giá trị này ra ngoài để quan sát.
KẾT QUẢ
Hình 3.1.4: Kết quả tín hiệu dạng sóng mạch kiểm tra lỗi transition
55
Trong tín hiệu dạng sóng ở hình 3.1.4 tại vùng màu lam đầu tiên là chuỗi tín
hiệu đầu vào V1 = 1110, tiếp theo đó ta sử dụng mẫu thử thứ 2 V2=1 lúc này giá trị là
1111 được biểu thị tại vùng màu đỏ. Sau đó ta tiến hành cho tín hiệu SE=0 để lưu giá
trị chuyển đổi, lúc này mạch đang bị lỗi truyền tăng chậm nên giá trị nhận được sẽ là
1110 được lưu tại vùng màu vàng. Như vậy giá trị mong muốn nhận được sẽ là 1111
nhưng sau khi truyền giá trị vẫn là 1110 và phải sau một chu kỳ nữa thì giá trị mới là
1111. Nên ta kết luận mạch này bị lỗi delay transition.
Kết luận: kết quả đã hoàn toàn cho ta thấy thiết kế hoàn toàn có thể phát hiện
được lỗi truyền đúng như lý thuyết đã chứng minh và hoàn động rất ổn định.
4. THIẾT KẾ GIẢI THUẬT MBIST CHO SRAM
Mục tiêu cho phần này là làm sao thiết kế được sơ đồ giải thuật (FSM) phát
hiện được hết các mô hình lỗi thông thường xuất hiện trên bộ nhớ SRAM, dựa trên
kiến trúc MBIST được biểu thị như hình 4.1.
Hình 4.1: Kiến trúc MBIST cho bộ nhớ
Sơ đồ máy trạng thái FSM thực hiện quy trình kiểm tra và phát hiện lỗi sai trên
RAM dựa vào từng bước của thuật toán MarchC- , việc thực hiện kiểm tra được thực
hiện thông qua sơ đồ trạng thái máy của giải thuật MarchC- theo mô tả như hình sau:
56
Hình 4.2: Mô hình trạng thái máy của giải thuật MarchC-
Bảng 4.1: Các giá trị trạng thái MarchC-

Trạng thái Ý nghĩa
INITIAL Trạng thái ban đầu
START Trạng thái ban đầu thực hiện giải thuật MarchC-
Ghi giá trị 0 vào địa chỉ ô nhớ, từ địa chỉ thấp đến địa chỉ cao nhất
MARCHC_1 Đọc giá trị, so sánh, ghi giá trị 1
Thực hiện từ giá trị thấp nhất đến địa chỉ cao nhất
MARCHC_5 Đọc giá trị, so sánh
FINISH Giải thuật MarchC- đã thực hiện hoàn tất
Bảng 4.2: Sự chuyển trạng thái trong MarchC-

Trạng thái hiện Trạng thái kế tiếp Lý do chuyển trạng thái
tại
INITIAL START Marchc_en=1 bắt đầu thực hiện giải thuật
57
START MARCH_1 Trạng thái Star thực hiện xong ( dựa trên
dựa trên giá trị địa chỉ cao nhất vì giá trị 0
được ghi từ thấp đến cao)
MARCH_1 MARCH_2 Trạng thái MARCH_1 thực hiện xong (

dựa trên địa chỉ cao nhất)
MARCH_5 FINISH Trạng thái MARCH_1 thực hiện xong (
FINISH INITIAL MarchC_complete =1 giải thuật đã thực
hiện xong
Như vậy với sơ đồ giải thuật MarchC- chúng ta có thể dễ dàng kiểm tra các mô
hình lỗi thông thường trên bộ nhớ SRAM theo quy trình các bước như trên.
5. KẾT LUẬN VÀ HƯỚNG PHÁT TRIỂN
5.1 Kết luận
Đây thật sự là một đề tài rất thú vị, nó vừa là tạo thách thức vừa tạo tính logic
và chuẩn đoán, thách thức ở đây là chúng ta sẽ đi tìm hiểu kiến thức hoàn toàn mới về
việc kiểm tra mạch cũng như các thuật toán phương pháp cho cả mạch logic và mạch
memory. Nhưng qua đó giúp ta có nhiều thêm các kiến thức về testing cũng như tập
cho ta tính logic chuẩn đoán mạch từ đó suy ra các biện pháp khắc phục.
Qua các nội dung đã nghiên cứu trong đề tài này chúng ta có thể biết được quy
trình Design for test cho mạch logic và cả memory, cũng như hiểu được bản chất của
các mô hình lỗi trong trong quá trình thiết kế mạch và chip. Đồng thời biết được cách
xác định các lỗi đó bằng các phương pháp thuật toán hữu hiệu như scanff, built in selt
test, qua đó tiến hành thiết kế và chứng minh các cơ sở lý thuyết bằng các ví dụ kiểm
tra mạch cụ thể.
58
5.2 Hướng phát triển
Quy mô đề tài này chỉ dừng lại ở mức nghiên cứu bản chất của các mô hình lỗi
cũng như các thuật toán phương pháp xác định lỗi, và thiết kế một vài mạch logic đơn
giản. Nhưng định hướng phát triển sẽ có thể mở rộng lên các mạch kiểm tra logic cho
FIFO và bộ test MBIST cho SRAM với các thuật toán đã tìm hiểu.
6. TÀI LIỆU THAM KHẢO
[1] Nguyễn Quân, “Mô tả cơ bản về DFT – Design for testablity”

[2] Laung-Terng Wang cheng-wen Xiaoping Wen, “VLSI Test Principles
and architectures design for testability”, 2006 by Elsevier Inc. All rights reserved.
[3] Nurqamarina Binti Mohd Noor, "Deep Encoding With Clustering
Technique for Programmable MBIST," Journal of Theoretical and Applied
Information Technology, vol. 65, no. 1, pp. 55-66, 2014.
[4] Dr.Adam Teman “design for test – DFT”
[5] G.PRAKASH, "Efficient Memory Built-In Self Test for Embedded
SRAM Using PA Algorithm," International Journal of Engineering and Technology,
vol. 5, no. 2, pp. 944-948,2013.
[6] H. Lang; J. Pfeiffer; J. Maguire, " Using on-chip test pattern
compression for full scan SoC designs", Proceedings International Test Conference
2000
[7] Y. Oyama; T. Kanai; H. Niijima, " Scan design oriented test technique
for VLSI's using ATE", Proceedings International Test Conference 1996. Test and
Design Validity
59

Báo Cáo Đ Án 1 (Design For Test)

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Báo Cáo Đ Án 1 (Design For Test)

Uploaded by

Copyright:

Available Formats

ĐẠI HỌC QUỐC GIA TP.

BÁO CÁO ĐỒ ÁN MÔN HỌC

ĐỀ TÀI: DESIGN FOR TEST

GVHD: Nguyễn Phan Hải Phú

SVTH: Hoàng Đức Thắng

TP. HỒ CHÍ MINH, THÁNG 03 NĂM 2023

Tp. Hồ Chí Minh, ngày 9 tháng 3 năm 2023.

Hoàng Đức Thắng

1. GIỚI THIỆU .............................................................................................................1

1.1 Tổng quan .........................................................................................................1

1.2 Nhiệm vụ đề tài .................................................................................................2

2.1 Design for test là gì (DFT)................................................................................3

2.2 Fault Mode (physical fault) ..............................................................................3

2.2.1 Stuck-at Fault (SAF) ...................................................................................3

2.2.2 Bridging Fault (BF) .....................................................................................6

2.2.3 Delay Fault (DF) .........................................................................................7

2.3 Các thuật toán sử dụng trong DFT ...................................................................8

2.3.1 Thuật toán Ad-hoc.......................................................................................8

2.3.2 Thuật toán Scan .........................................................................................11

2.3.3 JTAG .........................................................................................................19

2.3.4 JTAG instruction .......................................................................................31

2.4 BIST ................................................................................................................39

2.4.1 MBIST .......................................................................................................40

3. THIẾT KẾ PHẦN CỨNG ......................................................................................52

3.1 Thiết kế mạch kiểm tra Scan ..........................................................................52

3.1.1 Kiểm tra lỗi stuck-at ..................................................................................52

3.1.2 Kiểm tra lỗi transition delay ......................................................................54

4. THIẾT KẾ GIẢI THUẬT MBIST CHO SRAM ...................................................56

5. KẾT LUẬN VÀ HƯỚNG PHÁT TRIỂN.............................................................. 58

5.1 Kết luận ...........................................................................................................58

5.2 Hướng phát triển ............................................................................................. 59

6. TÀI LIỆU THAM KHẢO ......................................................................................59

DANH SÁCH HÌNH MINH HỌA

Hình 2.2.2.1: Các lỗi Bridging thực tế ............................................................................6

Hình 2.2.2.2: Mô hình lỗi Wired-OR và Wired-AND ......................................................6

Hình 2.2.3: Hình mô phỏng lỗi hở điện trở .....................................................................7

Hình 2.3.1: Chèn điểm kiểm tra ....................................................................................10

Hình 2.3.2: Chèn điểm quan sát ....................................................................................10

Hình 2.3.2.3: Mô tả chế độ hoạt động của Muxed DFF ...............................................14

Hình 2.3.3.1: Kiểm tra board mạch bằng JTAG ........................................................... 20

Hình 2.3.3.2: Kiến trúc của JTAG .................................................................................22

Hình 2.3.3.3: Sơ đồ máy trạng thái của tap controller .................................................23

Hình 2.3.3.4: Kiến trúc register trong JTAG ................................................................ 24

Hình 2.4: Kiến trúc built in selt test ..............................................................................40

Hình 2.4.1: kiến trúc MBIST .........................................................................................40

Hình 3.1: Sơ đồ khối scan flip flop ................................................................................52

Hình 3.1.1: Sơ đồ mạch test stuck at trên candence .....................................................53

Hình 4.1: Kiến trúc MBIST cho bộ nhớ ........................................................................56

DANH SÁCH BẢNG SỐ LIỆU

Bảng 4.1: Các giá trị trạng thái MarchC- ....................................................................57

Bảng 4.2: Sự chuyển trạng thái trong MarchC-............................................................ 57

1.1 Tổng quan

1.2 Nhiệm vụ đề tài

Nội dung 1: Tìm hiểu nguyên lý, lý thuyết về DFT

2.1 Design for test là gì (DFT)

2.2 Fault Mode (physical fault)

Kí hiệu : node x stuck-at fault

Input Fault-free Fault Output Value with SSF

• Fanout Stems and Branches

Hình 2.2.1.2: Lỗi kẹt đơn Fanout và Branches trên mạch

• Multiple Stuck-at Fault

2.2.2 Bridging Fault (BF)

Hình 2.2.2.1: Các lỗi Bridging thực tế