Làm sao để mô tả FSM dạng Moore bằng VHDL?

Để mô tả FSM (Finite State Machine) dạng Moore bằng VHDL, bạn cần xác định các thành phần sau và triển khai chúng trong code:

**1. State Definition (Định nghĩa trạng thái):**

* Liệt kê tất cả các trạng thái mà FSM của bạn có thể ở.
* Sử dụng `type` và `enumeration` để định nghĩa kiểu dữ liệu cho trạng thái.

**2. State Register (Thanh ghi trạng thái):**

* Lưu trữ trạng thái hiện tại của FSM.
* Khai báo một tín hiệu có kiểu dữ liệu là kiểu trạng thái đã định nghĩa.

**3. Next State Logic (Logic trạng thái kế tiếp):**

* Quyết định trạng thái kế tiếp dựa trên trạng thái hiện tại và các đầu vào.
* Sử dụng một `process` nhạy với tín hiệu đồng hồ (`clock`) và (có thể) các tín hiệu đầu vào.
* Sử dụng câu lệnh `case` hoặc `if-then-else` để xác định trạng thái kế tiếp cho mỗi trạng thái hiện tại và tổ hợp đầu vào.

**4. Output Logic (Logic đầu ra):**

* Tạo ra các tín hiệu đầu ra dựa trên trạng thái hiện tại. **Đây là đặc điểm chính của FSM Moore: đầu ra chỉ phụ thuộc vào trạng thái hiện tại.**
* Sử dụng một `process` nhạy với tín hiệu `state` (trạng thái hiện tại).
* Sử dụng câu lệnh `case` để gán giá trị đầu ra cho mỗi trạng thái.

**Ví dụ VHDL cho FSM Moore đơn giản (phát hiện chuỗi "101"):**

```vhdl
library ieee;
use ieee.std_logic_1164.all;

entity moore_fsm is
port (
clk : in std_logic;
reset : in std_logic;
input : in std_logic;
output: out std_logic -- Đầu ra chỉ phụ thuộc vào trạng thái
);
end entity;

architecture behavioral of moore_fsm is

-- 1. Định nghĩa trạng thái
type state_type is (S_IDLE, S_ONE, S_ONE_ZERO, S_ONE_ZERO_ONE);
signal current_state, next_state : state_type;

begin

-- 2. State Register (process đồng bộ)
process (clk, reset)
begin
if reset = '1' then
current_state <= S_IDLE;
elsif rising_edge(clk) then
current_state <= next_state;
end if;
end process;

-- 3. Next State Logic (process kết hợp)
process (current_state, input)
begin
case current_state is
when S_IDLE =>
if input = '1' then
next_state <= S_ONE;
else
next_state <= S_IDLE;
end if;
when S_ONE =>
if input = '0' then
next_state <= S_ONE_ZERO;
else
next_state <= S_ONE;
end if;
when S_ONE_ZERO =>
if input = '1' then
next_state <= S_ONE_ZERO_ONE;
else
next_state <= S_IDLE;
end if;
when S_ONE_ZERO_ONE =>
if input = '1' then
next_state <= S_ONE;
else
next_state <= S_IDLE;
end if;
end case;
end process;

-- 4. Output Logic (process kết hợp - Moore Output)
process (current_state)
begin
case current_state is
when S_ONE_ZERO_ONE =>
output <= '1'; -- Phát hiện chuỗi "101"
when others => -- S_IDLE, S_ONE, S_ONE_ZERO
output <= '0'; -- Không phát hiện chuỗi
end case;
end process;

end architecture;
```

**Giải thích chi tiết:**

* **`entity moore_fsm is ... end entity;`**: Định nghĩa interface của FSM. `clk`, `reset` và `input` là các đầu vào, còn `output` là đầu ra.
* **`type state_type is ...;`**: Định nghĩa kiểu dữ liệu `state_type` cho các trạng thái. Trong ví dụ này, FSM có 4 trạng thái: `S_IDLE` (trạng thái ban đầu), `S_ONE` (đã nhận '1'), `S_ONE_ZERO` (đã nhận '10'), `S_ONE_ZERO_ONE` (đã nhận '101').
* **`signal current_state, next_state : state_type;`**: Khai báo các tín hiệu `current_state` và `next_state` để lưu trữ trạng thái hiện tại và trạng thái kế tiếp.
* **`process (clk, reset) ... end process;`**: Đây là process đồng bộ (synchronous process), nhạy với tín hiệu `clk` và `reset`. Nó cập nhật `current_state` với `next_state` mỗi khi có cạnh lên của xung clock, trừ khi tín hiệu `reset` được kích hoạt.
* **`process (current_state, input) ... end process;`**: Đây là process kết hợp (combinatorial process), nhạy với tín hiệu `current_state` và `input`. Nó xác định `next_state` dựa trên `current_state` và `input`. Câu lệnh `case` được sử dụng để xác định các chuyển tiếp trạng thái khác nhau.
* **`process (current_state) ... end process;`**: Đây là process kết hợp, nhạy với tín hiệu `current_state`. **Quan trọng: Đầu ra chỉ phụ thuộc vào `current_state`.** Câu lệnh `case` được sử dụng để gán giá trị cho tín hiệu `output` dựa trên trạng thái hiện tại. Khi `current_state` là `S_ONE_ZERO_ONE`, `output` được gán giá trị '1' (chuỗi "101" đã được phát hiện). Trong tất cả các trạng thái khác, `output` được gán giá trị '0'.

**Lưu ý:**

* **Reset:** Việc reset FSM về trạng thái ban đầu (`S_IDLE` trong ví dụ này) là rất quan trọng.
* **Process nhạy với `current_state`:** Process output logic phải nhạy cảm với `current_state` để đảm bảo đầu ra thay đổi khi trạng thái thay đổi.
* **Code rõ ràng và dễ đọc:** Sử dụng tên biến và trạng thái có ý nghĩa để làm cho code dễ hiểu hơn.
* **Đảm bảo tính đầy đủ của `case` statement:** Luôn sử dụng `when others =>` trong câu lệnh `case` để xử lý tất cả các trường hợp không được liệt kê rõ ràng. Điều này giúp tránh tình trạng latching và đảm bảo code hoạt động đúng trong mọi tình huống.
* **Sử dụng các công cụ mô phỏng (simulation):** Kiểm tra FSM của bạn bằng các công cụ mô phỏng VHDL để đảm bảo nó hoạt động đúng như mong đợi.

**Ưu điểm của FSM Moore:**

* **Đầu ra ổn định:** Vì đầu ra chỉ phụ thuộc vào trạng thái hiện tại, nó không thay đổi ngay lập tức khi đầu vào thay đổi. Điều này làm cho FSM Moore đáng tin cậy hơn trong các ứng dụng thời gian thực.
* **Dễ thiết kế:** Vì đầu ra được xác định rõ ràng cho mỗi trạng thái, việc thiết kế FSM Moore thường đơn giản hơn so với FSM Mealy.

**Khi nào nên sử dụng FSM Moore?**

FSM Moore phù hợp khi bạn cần đầu ra ổn định và dự đoán được, và khi độ trễ giữa đầu vào và đầu ra không phải là vấn đề quan trọng. Ví dụ: bộ điều khiển động cơ, giao diện người dùng.

Hi vọng điều này giúp bạn hiểu cách mô tả FSM dạng Moore bằng VHDL!