• Output ổn định, chỉ phụ thuộc trạng thái

• Dễ mô phỏng, dễ debug

• Dễ đạt timing khi synthesize

Bài viết này hướng dẫn bạn cách mô tả FSM Moore đúng chuẩn, kèm ví dụ VHDL hoàn chỉnh và các lưu ý quan trọng.

1. Ôn nhanh: FSM Moore là gì?

FSM Moore là máy trạng thái mà:

• Output = f(State)

• Không phụ thuộc trực tiếp vào input

👉 Output chỉ thay đổi khi state thay đổi (tức là theo clock).

Minh họa FSM Moore

2. Cấu trúc chuẩn của FSM Moore trong VHDL

FSM Moore chuẩn FPGA luôn gồm 3 khối tách biệt:

1. State register (mạch tuần tự)

2. Next-state logic (mạch tổ hợp)

3. Output logic (mạch tổ hợp, phụ thuộc state)

👉 Đây là best practice, rất nên tuân theo.

3. Ví dụ FSM Moore đơn giản (bật/tắt LED)

Yêu cầu

• Nhấn nút btn:

  • Từ IDLE → ON

  • Từ ON → IDLE

• LED sáng khi ở trạng thái ON

4. Khai báo trạng thái (ENUM – rất khuyến nghị)

process(clk)
begin
  if rising_edge(clk) then
    if rst = '1' then
      state <= IDLE;        -- reset về trạng thái ban đầu
    else
      state <= next_state; -- cập nhật trạng thái
    end if;
  end if;
end process;

✅ Code rõ ràng
✅ Tool tự tối ưu encoding
✅ Tránh lỗi nhầm bit

5. Khối 1 – State Register (FSM + reset)

process(clk)
begin
  if rising_edge(clk) then
    if rst = '1' then
      state <= IDLE;        -- reset về trạng thái ban đầu
    else
      state <= next_state; -- cập nhật trạng thái
    end if;
  end if;
end process;

📌 Lưu ý:

• Reset đồng bộ (khuyến nghị)

• Chỉ cập nhật state, không xử lý logic khác

6. Khối 2 – Next State Logic (tổ hợp)

process(state, btn)
begin
  -- mặc định giữ nguyên trạng thái
  next_state <= state;

  case state is
    when IDLE =>
      if btn = '1' then
        next_state <= ON;
      end if;

    when ON =>
      if btn = '1' then
        next_state <= IDLE;
      end if;

  end case;
end process;

📌 Rất quan trọng:

• Luôn gán giá trị mặc định

• Tránh latch ngoài ý muốn

7. Khối 3 – Output Logic (Moore FSM)

process(state)
begin
  case state is
    when IDLE =>
      led <= '0';

    when ON =>
      led <= '1';
  end case;
end process;

👉 Output chỉ phụ thuộc state → đúng bản chất Moore FSM.

8. Ghép lại: FSM Moore hoàn chỉnh bằng VHDL

library ieee;
use ieee.std_logic_1164.all;

entity fsm_moore is
  port (
    clk : in  std_logic;
    rst : in  std_logic;
    btn : in  std_logic;
    led : out std_logic
  );
end entity;

architecture rtl of fsm_moore is
  type state_t is (IDLE, ON);
  signal state, next_state : state_t;
begin

  -- 1. State register
  process(clk)
  begin
    if rising_edge(clk) then
      if rst = '1' then
        state <= IDLE;
      else
        state <= next_state;
      end if;
    end if;
  end process;

  -- 2. Next-state logic
  process(state, btn)
  begin
    next_state <= state;

    case state is
      when IDLE =>
        if btn = '1' then
          next_state <= ON;
        end if;

      when ON =>
        if btn = '1' then
          next_state <= IDLE;
        end if;
    end case;
  end process;

  -- 3. Output logic (Moore)
  process(state)
  begin
    case state is
      when IDLE =>
        led <= '0';
      when ON =>
        led <= '1';
    end case;
  end process;

end architecture;

9. Những lỗi thường gặp khi mô tả FSM Moore

❌ Output phụ thuộc input → thành Mealy FSM
❌ Không gán next_state mặc định → tạo latch
❌ Gộp cả FSM + output + logic vào 1 process → khó debug
❌ Reset không đưa FSM về state xác định

10. Checklist FSM Moore chuẩn VHDL

• State dùng enum

• Có state reset rõ ràng

• 3 process tách biệt

• Output chỉ phụ thuộc state

• Không latch

• Mô phỏng trước khi synthesize

11. Khi nào nên dùng FSM Moore?

• Điều khiển LED, relay, LCD

• FSM tổng quát trong FPGA

• Người mới học VHDL

• Hệ thống cần output ổn định

👉 90% FSM trong FPGA có thể dùng Moore FSM.

1) Reset là gì và nó làm gì?

Reset đưa các phần tử nhớ (flip-flop, register, FSM…) về trạng thái ban đầu xác định:

• Counter = 0

• FSM về state IDLE

• Thanh ghi về giá trị an toàn

👉 Nói cách khác, reset giúp hệ thống biết mình đang ở đâu ngay từ đầu.

2) Điều gì xảy ra nếu không có reset?

• Flip-flop không đảm bảo khởi tạo cùng giá trị khi cấp nguồn

• FSM có thể bắt đầu ở state ngẫu nhiên

• Mạch:

  • Chạy sai ngẫu nhiên

  • Lỗi chỉ xuất hiện trên board thật

  • Rất khó debug

👉 Mô phỏng có thể đúng, phần cứng lại sai — nguyên nhân thường là reset.

3) Reset giúp hệ thống khởi động đúng & lặp lại được

• Mỗi lần cấp nguồn → hành vi giống nhau

• FSM luôn bắt đầu từ trạng thái xác định

• Dễ kiểm tra, dễ tái hiện lỗi

👉 Đây là yêu cầu bắt buộc trong hệ thống công nghiệp.

4) Reset giúp đảm bảo an toàn hệ thống

Trong nhiều ứng dụng, trạng thái khởi động không được phép nguy hiểm:

• Motor không được quay khi bật nguồn

• Van/relay không được kích nhầm

• Bus giao tiếp không được phát dữ liệu rác

Reset giúp:

• Đưa output về giá trị an toàn

• Tránh hành vi ngoài ý muốn lúc power-up

5) Reset giúp debug & bảo trì dễ hơn

 

• Khi mạch “treo” → reset để quay lại trạng thái ban đầu

• Test từng khối độc lập

• So sánh waveform dễ dàng hơn

👉 Thiết kế không reset rõ ràng = debug rất tốn thời gian.

6) Reset và mối liên hệ với FSM, counter, datapath

👉 Mọi khối có nhớ → đều cần reset (hoặc init an toàn).

7) Reset và timing / độ ổn định

• Reset sai cách có thể gây:

  • Metastability

  • Timing violation

• Reset đúng cách giúp:

  • Đồng bộ hệ thống

  • Tránh glitch lúc khởi động

👉 Vì vậy, reset không chỉ là logic, mà còn là vấn đề timing.

8) Những lỗi reset rất thường gặp

❌ Không reset FSM
❌ Dùng reset không đồng bộ cho toàn hệ thống mà không đồng bộ nhả reset
❌ Dựa vào giá trị khởi tạo (:= / initial) thay vì reset thật
❌ Reset không rõ active-high / active-low

9) Thực hành tốt (Best Practices)

• ✔️ FSM luôn có state reset

• ✔️ Ưu tiên reset đồng bộ cho logic nội bộ

• ✔️ Reset từ bên ngoài → assert async, deassert sync

• ✔️ Mô phỏng reset kỹ như clock

10) Kết luận ngắn gọn

Reset quyết định hệ thống có “đáng tin” hay không.

Một thiết kế mạch số tốt là thiết kế:

• Khởi động đúng

• Lặp lại giống nhau

• Debug dễ

• An toàn cao

Và tất cả đều bắt đầu từ reset được xử lý đúng cách.

• Tốc độ học

• Cách tư duy thiết kế

• Hiệu quả làm dự án FPGA thực tế

Bài viết này sẽ giúp bạn hiểu rõ sự khác nhau, ưu – nhược điểm và nên chọn Verilog hay VHDL trong từng trường hợp.

Tổng quan Verilog và VHDL

1. Verilog là gì?

Đặc điểm chính

• Cú pháp ngắn gọn, dễ đọc

• Gần với ngôn ngữ lập trình C

• Rất phổ biến trong FPGA thương mại & startup

Ví dụ Verilog (counter)

always @(posedge clk) begin
  if (rst)
    cnt <= 0;
  else
    cnt <= cnt + 1;
end

Ưu điểm của Verilog

✅ Dễ học, dễ viết
✅ Code ngắn, ít dòng
✅ Phù hợp sinh viên & người mới học FPGA
✅ Cộng đồng lớn, nhiều ví dụ

Nhược điểm của Verilog

❌ Kiểu dữ liệu đơn giản → dễ viết sai
❌ Ít ràng buộc → bug khó phát hiện sớm
❌ Dự án lớn dễ khó bảo trì nếu code không chặt

2. VHDL là gì?

Đặc điểm chính

• Cú pháp chặt chẽ, tường minh

• Kiểu dữ liệu mạnh, kiểm tra lỗi sớm

• Phổ biến trong hệ thống công nghiệp, hàng không, quốc phòng

Ví dụ VHDL (counter)

process(clk)
begin
  if rising_edge(clk) then
    if rst = '1' then
      cnt <= (others => '0');
    else
      cnt <= cnt + 1;
    end if;
  end if;
end process;

Ưu điểm của VHDL

✅ Kiểm soát lỗi tốt
✅ Rõ ràng, dễ đọc logic với dự án lớn
✅ Phù hợp tiêu chuẩn công nghiệp
✅ An toàn hơn cho hệ thống quan trọng

Nhược điểm của VHDL

❌ Cú pháp dài, nhiều dòng
❌ Học chậm hơn Verilog
❌ Ít “linh hoạt” khi thử nghiệm nhanh

3. So sánh chi tiết Verilog vs VHDL

3.1 Cú pháp & độ dễ học

👉 Verilog phù hợp học nhanh
👉 VHDL phù hợp học kỹ, bài bản

3.2 Kiểu dữ liệu & độ an toàn

👉 VHDL giúp bắt lỗi ngay khi compile

3.3 Quy mô dự án

4. Hiệu năng & tài nguyên FPGA – có khác nhau không?

👉 Câu trả lời: KHÔNG ĐÁNG KỂ

• Verilog và VHDL đều là RTL HDL

• Synthesis tool sẽ tạo phần cứng giống nhau nếu:

  • Thuật toán giống

  • Kiến trúc giống

⚠️ Hiệu năng phụ thuộc cách viết, không phải ngôn ngữ.

5. Tool FPGA hỗ trợ ra sao?

• Vivado, Quartus, Libero: hỗ trợ cả Verilog & VHDL

• Verilog thường được:

  • Ví dụ nhiều hơn

  • IP core mẫu dùng nhiều hơn

6. Nên chọn Verilog hay VHDL?

👉 Chọn Verilog nếu bạn:

• Mới học FPGA

• Làm nhanh đồ án, prototype

• Đọc tài liệu/opensource nhiều

• Muốn code gọn

👉 Chọn VHDL nếu bạn:

• Làm dự án lớn, dài hạn

• Yêu cầu độ ổn định cao

• Làm trong môi trường công nghiệp

• Muốn kiểm soát lỗi chặt chẽ

👉 Thực tế: rất nhiều kỹ sư giỏi biết cả hai.

7. Lời khuyên thực tế cho người mới học FPGA

🔹 Bắt đầu bằng Verilog → hiểu bản chất mạch số → học thêm VHDL sau

Vì:

• Tư duy RTL là quan trọng nhất

• Đổi ngôn ngữ chỉ là đổi cú pháp

Tổng quan quy trình triển khai FPGA

Luồng chuẩn gồm 8 bước chính:

1. Xác định yêu cầu thiết kế

2. Mô tả mạch bằng HDL (Verilog/VHDL)

3. Mô phỏng (Simulation)

4. Tạo project FPGA

5. Tổng hợp (Synthesis)

6. Gán chân & constraint

7. Implement & tạo bitstream

8. Nạp FPGA và kiểm tra thực tế

1. Xác định yêu cầu thiết kế (Specification)

Trước khi viết HDL, cần trả lời rõ:

• Mạch làm chức năng gì?

• Tần số clock bao nhiêu?

• Input/Output gồm những tín hiệu nào?

• Có dùng FSM, counter, bộ nhớ không?

• Chạy độc lập hay giao tiếp với CPU/ngoại vi?

👉 Sai từ bước này → sửa rất tốn thời gian về sau.

2. Mô tả mạch bằng HDL (Verilog/VHDL)

Viết code RTL rõ ràng

• Phân biệt logic tổ hợp và logic tuần tự

• FSM viết rõ state register / next state / output

• Reset rõ ràng (ưu tiên reset đồng bộ)

Ví dụ cấu trúc chuẩn:

• Module top

• Các module con (counter, FSM, datapath…)

👉 Mục tiêu: code đúng chức năng + dễ synthesize

3. Mô phỏng (Simulation) – BẮT BUỘC

Tại sao phải mô phỏng?

• Kiểm tra logic trước khi lên FPGA

• Bắt lỗi FSM, reset, counter

• Tiết kiệm rất nhiều thời gian debug

Cần có:

• RTL code

• Testbench (tạo clock, reset, stimulus)

• Xem waveform

👉 Không mô phỏng = debug mù trên phần cứng

4. Tạo project FPGA trong tool

Dùng tool tương ứng với hãng FPGA:

• Chọn đúng chip/board

• Add file HDL

• Add file simulation

📌 Lưu ý:

• Sai chip → synthesize vẫn chạy nhưng không nạp được

• Chọn đúng tốc độ (speed grade) nếu có

5. Tổng hợp (Synthesis)

Synthesis làm gì?

• Biến HDL → LUT, FF, BRAM, DSP

• Tạo netlist logic

Cần kiểm tra:

• Số LUT / FF / BRAM / DSP

• Có warning latch không?

• FSM có được nhận diện đúng không?

👉 Đây là bước đầu phát hiện thiết kế có quá nặng không.

6. Gán chân & constraint (XDC / SDC)

Gán chân (Pin assignment)

• LED, button, switch

• UART, SPI, I2C

• Clock đầu vào

Constraint clock (RẤT QUAN TRỌNG)

• Khai báo tần số clock thực tế

• Thiếu constraint → timing report không tin được

📌 Đây là bước liên kết HDL với phần cứng thật.

7. Implement & tạo bitstream

Implementation gồm:

• Place (đặt logic)

• Route (định tuyến)

Kiểm tra:

• Timing summary

  • Setup slack ≥ 0

  • Hold slack ≥ 0

• Critical path ở đâu?

👉 Nếu timing fail → phải quay lại tối ưu code.

8. Nạp FPGA & kiểm tra thực tế

Nạp bitstream

• Qua JTAG / USB

• FPGA chạy mạch thật

Kiểm tra:

• LED có đúng không?

• FSM có chạy đúng trạng thái?

• Clock có đúng tần số?

• Có lỗi ngẫu nhiên không?

👉 Nếu mô phỏng đúng mà chạy sai → thường do:

• Reset

• Constraint clock

• Input không đồng bộ

9. Vòng lặp debug (thực tế luôn có)

Thiết kế FPGA không bao giờ xong ngay lần đầu:

Code → Sim → Synthesis → Implement → Test
           ↑__________________________|

👉 Debug tốt = tiết kiệm 70% thời gian dự án.

10. Checklist nhanh cho người mới học FPGA

• Yêu cầu thiết kế rõ ràng

• Code HDL đúng chuẩn RTL

• Có testbench & waveform

• Không có latch

• Clock & reset rõ ràng

• Constraint đúng

• Timing pass

• Test trên board thật

Kết luận

Triển khai mạch số lên FPGA không chỉ là viết HDL, mà là một quy trình kỹ thuật hoàn chỉnh.

Người làm FPGA giỏi là người:

• Hiểu từng bước

• Biết lỗi thường nằm ở đâu

• Luôn mô phỏng & đọc report

• Chạy không ổn định

• Sai dữ liệu ngẫu nhiên

• Chỉ lỗi khi lên board thật (mô phỏng vẫn đúng)

Bài viết này giúp bạn hiểu bản chất, phân loại lỗi timing và cách khắc phục hiệu quả, thực tế.

1. Timing violation là gì?

Timing violation xảy ra khi dữ liệu không đáp ứng yêu cầu thời gian của flip-flop hoặc logic, gồm:

• Setup violation: dữ liệu đến quá trễ

• Hold violation: dữ liệu đến quá sớm

Nói ngắn gọn: logic chạy chậm hơn (hoặc nhanh hơn) so với yêu cầu clock.

2. Hai loại timing violation cơ bản

2.1 Setup Time Violation (phổ biến nhất)

Xảy ra khi:

• Đường dữ liệu quá dài

• Clock quá nhanh

• Logic giữa 2 FF quá phức tạp

👉 Dữ liệu chưa kịp ổn định trước cạnh clock.

2.2 Hold Time Violation (nguy hiểm nhưng khó thấy)

Xảy ra khi:

• Đường dữ liệu quá ngắn

• Clock skew

• Reset/enable không đồng bộ

👉 Dữ liệu thay đổi quá sớm ngay sau cạnh clock.

3. Dấu hiệu nhận biết timing violation

• Vivado/Quartus báo:

  • ❌ Setup Slack < 0

  • ❌ Hold Slack < 0

• Mạch:

  • Chạy lúc được lúc không

  • Sai ngẫu nhiên

  • Chỉ lỗi ở tần số cao

4. Quy trình xử lý timing violation (CHUẨN)

Bước 1: Đọc báo cáo timing (rất quan trọng)

Xem các mục:

• Worst Negative Slack (WNS)

• Total Negative Slack (TNS)

• Critical Path

👉 Đừng sửa code trước khi biết đường nào chậm nhất.

Bước 2: Xác định loại violation

• Slack âm ở setup → xử lý logic/chia pipeline

• Slack âm ở hold → thêm delay/buffer (tool thường tự xử)

5. Cách xử lý Setup Violation (80% trường hợp)

5.1 Giảm độ phức tạp logic (tách pipeline)

 

Sai (logic dài trong 1 chu kỳ):

Đúng (pipeline):

stage1 <= a + b;
stage2 <= c + d;
y      <= stage1 * stage2;

✅ Giảm delay mỗi chu kỳ
✅ Dễ đạt Fmax cao hơn

5.2 Giảm tần số clock (khi không cần quá nhanh)

• Từ 200 MHz → 100 MHz

• Hoặc dùng clock enable thay vì tăng clock

5.3 Dùng tài nguyên chuyên dụng (DSP/BRAM)

• Phép nhân/cộng lớn → dùng DSP

• Bộ nhớ → BRAM

👉 Tránh để tool suy ra LUT cho các phép nặng.

5.4 Tối ưu FSM

• Giảm số trạng thái

• Tránh logic IF–ELSE lồng quá sâu trong 1 state

6. Cách xử lý Hold Violation

6.1 Đừng “sửa tay” vội

👉 Với FPGA hiện đại:

• Hold violation thường do routing

• Tool tự fix bằng delay buffer

6.2 Kiểm tra reset & enable

• Reset async nhả không đồng bộ

• Enable không đồng bộ clock

👉 Dùng:

• Reset đồng bộ

• Enable đồng bộ theo clock

7. Những lỗi coding gây timing violation (rất hay gặp)

❌ Tạo clock bằng logic

✅ Dùng clock enable

❌ Bit-width quá lớn

✅ Vừa đủ

8. Timing constraint – đừng bỏ qua!

Nếu constraint sai hoặc thiếu, tool không thể tối ưu đúng.

Tối thiểu cần có:

• Clock constraint (create_clock)

• Input/Output delay (nâng cao)

👉 Thiếu constraint = timing report không đáng tin.

9. Checklist nhanh xử lý timing violation

• Đọc Critical Path

• Xác định setup hay hold

• Thêm pipeline nếu logic dài

• Giảm clock nếu có thể

• Dùng DSP / BRAM

• Không tạo clock mới bằng logic

• Reset & enable đồng bộ

• Constraint đúng và đủ

10. Kết luận (rất quan trọng)

Timing violation không phải “tool yếu”, mà thường do cách thiết kế.

Thiết kế số tốt là:

• Chia nhỏ logic

• Đồng bộ rõ ràng

• Cho tool cơ hội tối ưu

• Trạng thái khởi động của hệ thống

• Độ ổn định khi chạy thực tế

• Khả năng synthesize và đạt timing

Bài viết này sẽ giúp bạn:

• Hiểu rõ reset đồng bộ và reset không đồng bộ

• Biết cách viết VHDL đúng chuẩn

• Biết khi nào nên dùng loại nào trong FPGA

1. Reset là gì trong mạch số?

Reset là tín hiệu đưa mạch về trạng thái ban đầu xác định:

• Thanh ghi = 0

• FSM về state IDLE

• Counter về giá trị ban đầu

👉 Trong FPGA, reset thường dùng cho:

• Flip-Flop

• Register

• FSM

• Datapath

2. Reset không đồng bộ (Asynchronous Reset)

Khái niệm

Reset không đồng bộ là reset không phụ thuộc clock:

• Reset có hiệu lực ngay lập tức

• Không cần đợi cạnh clock

Đặc điểm

• Reset tác động tức thì

• Hay dùng cho power-up reset

• Dễ gây lỗi timing nếu nhả reset không đúng

Sơ đồ nguyên lý

 

Cách viết reset không đồng bộ trong VHDL

process(clk, rst_n)
begin
  if rst_n = '0' then
    q <= (others => '0');
  elsif rising_edge(clk) then
    q <= d;
  end if;
end process;

📌 Lưu ý:

• rst_n thường là active-low

• Reset được kiểm tra trước clock

• Phải khai báo reset trong sensitivity list

Ưu & nhược điểm

✅ Ưu điểm:

• Reset nhanh, tức thì

• Phù hợp reset khi bật nguồn

❌ Nhược điểm:

• Dễ gây metastability khi nhả reset

• Khó timing closure hơn

• Không phù hợp hệ thống clock phức tạp

3. Reset đồng bộ (Synchronous Reset)

Khái niệm

Reset đồng bộ chỉ có hiệu lực tại cạnh clock:

• Reset chỉ được lấy mẫu khi có clock

• Giống một tín hiệu điều khiển bình thường

Đặc điểm

• Reset ổn định, an toàn timing

• Dễ kiểm soát trong hệ thống lớn

Sơ đồ nguyên lý

Cách viết reset đồng bộ trong VHDL

process(clk)
begin
  if rising_edge(clk) then
    if rst = '1' then
      q <= (others => '0');
    else
      q <= d;
    end if;
  end if;
end process;

📌 Lưu ý:

• Reset không nằm trong sensitivity list

• Reset được kiểm tra bên trong clock

Ưu & nhược điểm

✅ Ưu điểm:

• Dễ đạt timing

• Không lo glitch/reset sai pha

• Khuyến nghị cho FSM & datapath

❌ Nhược điểm:

• Reset chậm hơn (đợi clock)

• Không dùng được khi clock chưa chạy

4. So sánh reset đồng bộ và không đồng bộ

5. Khi nào nên dùng loại reset nào?

👉 Nên dùng reset đồng bộ khi:

• Thiết kế FSM

• Datapath phức tạp

• Hệ thống có nhiều clock

• Thiết kế chuẩn cho FPGA hiện đại

👉 Chỉ nên dùng reset không đồng bộ khi:

• Reset nguồn (power-on reset)

• Reset từ nút nhấn bên ngoài

• Kết hợp với mạch đồng bộ reset release

6. Kỹ thuật chuẩn: Async assert – Sync deassert (RẤT QUAN TRỌNG)

Trong FPGA thực tế:

• Assert reset: không đồng bộ (nhanh)

• Deassert reset: đồng bộ theo clock

Ví dụ VHDL reset chuẩn FPGA

signal rst_sync : std_logic;

process(clk, rst_n)
begin
  if rst_n = '0' then
    rst_sync <= '1';
  elsif rising_edge(clk) then
    rst_sync <= '0';
  end if;
end process;

👉 Sau đó dùng rst_sync làm reset đồng bộ cho toàn hệ thống.

7. Reset trong FSM (ví dụ chuẩn)

process(clk)
begin
  if rising_edge(clk) then
    if rst = '1' then
      state <= IDLE;
    else
      state <= next_state;
    end if;
  end if;
end process;

✅ Dễ debug
✅ Dễ synthesize
✅ Dễ timing closure

8. Lỗi thường gặp khi xử lý reset trong VHDL

❌ Đặt reset sai sensitivity list
❌ Dùng reset không đồng bộ cho FSM lớn
❌ Nhả reset cùng lúc cho nhiều clock khác nhau
❌ Dựa vào giá trị khởi tạo (:=) thay vì reset thật

• Thiết kế fit chip

• Tăng tốc độ (Fmax)

• Giảm công suất

• Dễ mở rộng về sau

Bài viết này tổng hợp nguyên tắc + mẹo thực tế đã được dùng nhiều trong dự án FPGA.

1. Hiểu rõ tài nguyên FPGA gồm những gì?

Các tài nguyên chính

• LUT (Look-Up Table): logic tổ hợp

• Flip-Flop (FF): lưu trạng thái

• BRAM: bộ nhớ trong chip

• DSP slice: nhân, MAC tốc độ cao

• Routing: kết nối (ảnh hưởng timing)

👉 Tối ưu FPGA = dùng đúng loại tài nguyên cho đúng việc.

2. Nguyên tắc vàng #1: Giảm LUT bằng cách dùng FF và BRAM đúng chỗ

❌ Sai lầm phổ biến

• Dùng mảng reg mem cho bộ nhớ lớn → ăn LUT

• Dùng logic để cộng/nhân số lớn → tốn LUT

✅ Cách đúng

• Dùng BRAM cho bộ nhớ

• Dùng DSP cho nhân/cộng lớn

Ví dụ (suy ra BRAM):

reg  mem ;
always @(posedge clk)
  mem <= din;

👉 Thêm attribute:

(* ram_style = "block" *) reg  mem ;

3. Nguyên tắc #2: FSM gọn – giảm số trạng thái

FSM là “kẻ ngốn tài nguyên thầm lặng” nếu viết không gọn.

Mẹo tối ưu FSM

• Tránh FSM quá chi tiết không cần thiết

• Gộp trạng thái có hành vi giống nhau

• Dùng Moore FSM khi không cần phản hồi tức thì

• Mã hóa trạng thái hợp lý

Ví dụ:

typedef enum logic  {
  IDLE,
  RUN,
  DONE
} state_t;

👉 FSM ít trạng thái → ít FF + LUT hơn.

4. Nguyên tắc #3: Dùng clock enable thay vì tạo clock mới

❌ Không nên

always @(posedge clk_div) begin
  ...
end

✅ Nên

always @(posedge clk) begin
  if (ce) begin
    ...
  end
end

Lợi ích:

• Giảm routing clock

• Dễ timing closure

• Ít tài nguyên clock buffer

5. Nguyên tắc #4: Chọn độ rộng bit (bit-width) vừa đủ

❌ Lãng phí

✅ Tối ưu

👉 Mỗi bit dư = thêm FF + LUT.

6. Nguyên tắc #5: Tận dụng DSP slice cho phép nhân/cộng

Ví dụ

• Nếu bit-width phù hợp → tool tự suy ra DSP

• Nếu không → nhân bằng LUT (rất tốn)

👉 Kiểm tra Synthesis Report → DSP usage.

7. Nguyên tắc #6: Pipeline để tăng Fmax (và đôi khi giảm LUT)

Pipeline giúp:

• Giảm logic mỗi chu kỳ

• Dễ đạt timing

• Có thể giảm LUT do tool tối ưu tốt hơn

Ví dụ:

always @(posedge clk) begin
  stage1 <= a + b;
  stage2 <= stage1 * c;
end

8. Nguyên tắc #7: Tránh logic “không dùng nhưng vẫn tồn tại”

• Tín hiệu không dùng → vẫn có thể tốn LUT

• Debug signal quên xóa

👉 Dùng:

• (* keep = "false" *)

• Kiểm tra Unused logic trong report

9. Quy trình tối ưu thực tế (rất quan trọng)

1. Viết code rõ ràng, đúng chức năng

2. Run Synthesis

3. Xem:

   • LUT / FF / BRAM / DSP

   • Critical path

4. Tối ưu chỗ ăn tài nguyên nhất

5. Lặp lại

❗ Đừng tối ưu “mù” trước khi xem report.

Mô phỏng = chạy module bằng testbench trên PC để kiểm tra đúng/sai trước khi nạp FPGA.
Bạn sẽ xem waveform (dạng sóng), kiểm tra reset, timing, trạng thái…

Cần gì để mô phỏng?

• File RTL: dut.v (design under test)

• File testbench: tb.v (tạo clock/reset/input và quan sát output)

Ví dụ testbench tối giản

`timescale 1ns/1ps

module tb;
  reg  clk = 0;
  reg  rst_n = 0;
  wire out;

  // tạo clock 100MHz => chu kỳ 10ns
  always #5 clk = ~clk;

  // gọi module cần test
  my_module dut (
    .clk   (clk),
    .rst_n (rst_n),
    .out   (out)
  );

  initial begin
    // reset
    #20 rst_n = 1;

    // chạy một lúc
    #500;
    $finish;
  end
endmodule

✅ Tips nhanh:

• Luôn có timescale

• Clock tạo bằng always #...

• Reset rõ ràng (đặc biệt cho sequential logic)

2) Synthesise (tổng hợp) là gì?

Synthesis = chuyển Verilog RTL thành netlist cổng logic + FF + LUT + BRAM… phù hợp FPGA.

Synthesis không “chạy thời gian” như simulation. Nó biến code thành phần cứng thật.

Code nào synthesize được?

✅ always @(posedge clk) (FF/Registers)
✅ always @(*) + gán đầy đủ (combinational)
✅ assign (logic tổ hợp)

❌ #delay, initial (thường chỉ dùng cho simulation, trừ vài FPGA hỗ trợ init FF nhưng không nên dựa vào)
❌ $display, $finish (system task chỉ cho mô phỏng)

3) Quy trình mô phỏng và synthesize trong Vivado (chuẩn)

A. Mô phỏng (Vivado Simulator)

1. Create Project

2. Add Sources → thêm *.v (Design Sources)

3. Add Simulation Sources → thêm tb_*.v

4. Flow Navigator → Run Simulation → Run Behavioral Simulation

5. Xem waveform:

   • Add signals (hoặc “Add to Wave”)

   • Run / Restart / Zoom

✅ Behavioral simulation: kiểm tra logic cơ bản (chưa có delay routing).

B. Tổng hợp + Implement

1. Flow Navigator → Run Synthesis

2. Xem:

   • Utilization (LUT/FF/BRAM)

   • Schematic (netlist)

3. Run Implementation

4. Generate Bitstream

Nếu bạn dùng board (PYNQ-Z2) thì còn bước thêm:

• Constraints file .xdc (gán chân LED, clock, button…)

4) “Checklist” lỗi hay gặp khi synthesize

(1) Latch ngoài ý muốn

Nguyên nhân: always @(*) nhưng không gán đủ nhánh.
Ví dụ sai:

always @(*) begin
  if (en) y = a;  // thiếu else => latch
end

Cách đúng:

always @(*) begin
  y = b;          // default
  if (en) y = a;
end

(2) Reset không đúng kiểu

• Nếu bạn dùng reset đồng bộ: đặt trong posedge clk

• Nếu reset bất đồng bộ: dùng or negedge rst_n

Ví dụ reset bất đồng bộ:

always @(posedge clk or negedge rst_n) begin
  if (!rst_n) q <= 0;
  else        q <= d;
end

(3) Dùng “clock chia” làm clock thật

Trên FPGA, tốt nhất dùng clock enable hoặc MMCM/PLL, tránh tự tạo clock bằng logic (trừ khi bạn hiểu rõ clocking/routing).

5) Mẹo nhanh để mô phỏng đúng “như phần cứng”

• Đảm bảo reset/khởi tạo rõ ràng (FF trong FPGA không phải lúc nào cũng giống “initial”).

• Với input từ nút nhấn: mô phỏng cả debounce nếu cần.

• Khi cần sát thực tế timing: chạy Post-Implementation Timing Simulation (nâng cao).

Cách đơn giản nhất: dùng bit của counter.

module freq_div_pow2 #(
    parameter integer K = 1   // chia cho 2^K
)(
    input  wire clk,
    input  wire rst_n,
    output wire clk_div
);

    reg  cnt;

    always @(posedge clk) begin
        if (!rst_n)
            cnt <= 32'd0;
        else
            cnt <= cnt + 32'd1;
    end

    assign clk_div = cnt; // K=1 => /2, K=2 => /4, K=3 => /8 ...

endmodule

2) Divider chia N chẵn (clk_out 50% duty, chính xác)

Ý tưởng: đếm đến N/2 - 1 rồi toggle output → chu kỳ output = N chu kỳ input.

module freq_div_even #(
    parameter integer N = 10   // N phải là số chẵn: 2,4,6,...
)(
    input  wire clk,
    input  wire rst_n,
    output reg  clk_out
);
    localparam integer HALF = N/2;

    // đủ rộng để đếm tới HALF-1
    reg  cnt;

    initial clk_out = 1'b0;

    always @(posedge clk) begin
        if (!rst_n) begin
            cnt     <= 0;
            clk_out <= 1'b0;
        end else begin
            if (cnt == HALF-1) begin
                cnt     <= 0;
                clk_out <= ~clk_out;
            end else begin
                cnt <= cnt + 1'b1;
            end
        end
    end

endmodule

Ví dụ: N=10 → clk_out = clk_in / 10 (duty 50%).

3) Divider chia N bất kỳ (dễ dùng, N lẻ duty không 50%)

Cách này tạo 1 xung “tick” khi đếm đủ N, hoặc tạo clock bằng toggle mỗi N chu kỳ (khi đó output sẽ là / (2N)). Mình đưa bản toggle mỗi N chu kỳ (đơn giản, ổn định):

module freq_div_any #(
    parameter integer N = 5   // N >= 1
)(
    input  wire clk,
    input  wire rst_n,
    output reg  clk_out
);

    reg  cnt;

    initial clk_out = 1'b0;

    always @(posedge clk) begin
        if (!rst_n) begin
            cnt     <= 0;
            clk_out <= 1'b0;
        end else begin
            if (cnt == N-1) begin
                cnt     <= 0;
                clk_out <= ~clk_out;  // toggle mỗi N chu kỳ
            end else begin
                cnt <= cnt + 1'b1;
            end
        end
    end

endmodule

✅ Tần số đầu ra: f_out = f_in / (2*N)
Ví dụ N=5 → ra /10.

Bài viết này sẽ giúp bạn:

• Hiểu rõ mạch tổ hợp là gì

• Hiểu rõ mạch tuần tự là gì

• So sánh chi tiết mạch tổ hợp vs mạch tuần tự

• Biết cách áp dụng đúng khi thiết kế FPGA / Verilog / VHDL

Mạch tổ hợp là gì? (Combinational Circuit)

Khái niệm

Mạch tổ hợp là mạch mà đầu ra chỉ phụ thuộc vào đầu vào hiện tại, không phụ thuộc vào quá khứ.

👉 Không có khả năng nhớ dữ liệu.

Công thức tổng quát

Ví dụ mạch tổ hợp

• Cổng logic AND, OR, NOT, XOR

• Bộ cộng (Adder)

• Bộ trừ (Subtractor)

• Multiplexer (MUX)

• Decoder / Encoder

• So sánh số (Comparator)

Minh họa mạch tổ hợp

Đặc điểm

• ❌ Không có bộ nhớ

• ❌ Không cần clock

• ✅ Output thay đổi ngay lập tức khi input thay đổi

• ✅ Thiết kế đơn giản

Mạch tuần tự là gì? (Sequential Circuit)

Khái niệm

Mạch tuần tự là mạch mà đầu ra phụ thuộc vào:

• Đầu vào hiện tại

• Trạng thái trước đó (dữ liệu đã lưu trong bộ nhớ)

👉 Mạch tuần tự có khả năng ghi nhớ.

Công thức tổng quát

Ví dụ mạch tuần tự

• Flip-Flop (D, JK, T)

• Thanh ghi (Register)

• Bộ đếm (Counter)

• FSM (Finite State Machine)

• Bộ nhớ RAM / FIFO

Minh họa mạch tuần tự

Đặc điểm

• ✅ Có bộ nhớ (state)

• ✅ Hoạt động theo clock

• ❌ Thiết kế phức tạp hơn

• ❌ Có độ trễ theo chu kỳ clock

So sánh mạch tổ hợp và mạch tuần tự

Ví dụ minh họa dễ hiểu

Ví dụ mạch tổ hợp

👉 Cộng 2 số A và B

• A = 3, B = 2 → Output = 5

• Chỉ cần A hoặc B đổi → Output đổi ngay

• Không nhớ giá trị cũ

Ví dụ mạch tuần tự

👉 Bộ đếm

• Mỗi xung clock → tăng 1

• Giá trị hiện tại phụ thuộc giá trị trước đó

• Có khả năng nhớ

Trong FPGA, hai loại mạch này được dùng như thế nào?

Mạch tổ hợp trong FPGA

• Logic xử lý

• Điều kiện IF–ELSE

• So sánh, mã hóa, giải mã

• Datapath

Mạch tuần tự trong FPGA

• FSM điều khiển

• Thanh ghi dữ liệu

• Bộ đếm thời gian

• Giao thức UART, SPI, I2C

👉 Thiết kế FPGA thực tế = kết hợp mạch tổ hợp + mạch tuần tự

Liên hệ với FSM (Finite State Machine)

👉 FSM là ví dụ điển hình cho sự kết hợp tổ hợp + tuần tự.

Lỗi thường gặp của người mới học FPGA

❌ Viết mạch tuần tự nhưng quên clock
❌ Dùng always @(*) nhưng lại tạo latch
❌ Không phân biệt rõ logic tổ hợp vs logic tuần tự
❌ Nhầm lẫn giữa FSM và mạch tổ hợp