Kiến Trúc Vi Điều Khiển (MCU) & Giao Tiếp GPIO

Từ Bài 1 đến Bài 14, mọi mạch trong series đều là mạch cứng: hành vi của nó cố định vĩnh viễn theo cách bạn hàn dây và chọn linh kiện. Muốn đổi hành vi — phải hàn lại mạch. Vi điều khiển (MCU) phá vỡ giới hạn đó: cùng một con chip vật lý, chỉ cần nạp một đoạn mã lệnh khác là toàn bộ hành vi mạch thay đổi hoàn toàn — không cần chạm vào dây dẫn hay linh kiện nào.

Bài học này mở ra nửa sau của series: thay vì thiết kế mạch tương tự (analog) hay số (digital) cố định, bạn sẽ học cách một chương trình phần mềm điều khiển trực tiếp phần cứng thông qua các thanh ghi đặc biệt, và tự tay lập trình một MCU ảo để nhấp nháy đèn LED — cellphone, máy giặt, hay chính bàn phím bạn đang gõ đều chạy trên nguyên lý giống hệt.

1. Kiến trúc tổng quan bên trong vi điều khiển

Một MCU gói gọn cả một "máy tính mini" vào một con chip duy nhất: bộ xử lý trung tâm (CPU) để thực thi lệnh, bộ nhớ Flash để lưu chương trình vĩnh viễn (giữ dữ liệu kể cả khi mất điện), và SRAM để lưu biến tạm thời trong lúc chạy (mất hết khi ngắt điện — bạn đã gặp SRAM 6-transistor ở Bài 13). Ba khối này nói chuyện với nhau qua một bus hệ thống — một "xa lộ" dây dẫn chung mang địa chỉ, dữ liệu và tín hiệu điều khiển qua lại.

Điểm khác biệt cốt lõi so với "vi xử lý" (như CPU trong máy tính bàn) là MCU tích hợp luôn Flash + SRAM + các khối ngoại vi (I/O, Timer, ADC...) vào một chip duy nhất — không cần RAM rời, ổ cứng rời. Cái giá phải trả là tài nguyên rất hạn chế: một MCU 8-bit phổ biến trong lớp học chỉ có vài KB SRAM (so với hàng GB của máy tính) — đủ cho các tác vụ điều khiển thiết bị nhưng không đủ chạy hệ điều hành đầy đủ.

1.1 Kiến trúc Harvard vs Von Neumann: vì sao Flash và SRAM là hai "thế giới" khác nhau

Sơ đồ khối ở trên vẽ Flash và SRAM là hai ô riêng biệt — đó không chỉ là cách vẽ cho dễ nhìn, mà phản ánh đúng một lựa chọn thiết kế phần cứng thật gọi là kiến trúc Harvard: chương trình (Flash) và dữ liệu (SRAM) nằm trên hai không gian địa chỉ hoàn toàn tách biệt, mỗi loại đi trên một bus riêng. Địa chỉ 0x25 trong Flash (một lệnh máy) và địa chỉ 0x25 trong SRAM (thanh ghi PORTB ở mục 3) là hai ô nhớ vật lý hoàn toàn khác nhau, dù trùng số. Đây là lý do CPU không thể vô tình "thực thi nhầm" dữ liệu thành lệnh — một lớp bảo vệ tự nhiên mà kiến trúc Von Neumann (máy tính bàn, và cả nhiều MCU ARM hiện đại) không có, vì ở đó chương trình và dữ liệu chia sẻ chung một không gian địa chỉ.

1.2 So sánh vài họ MCU phổ biến trong thực tế

"MCU" không phải một sản phẩm duy nhất — đây là cả một phổ rộng từ chip 8-bit giá vài nghìn đồng đến chip 32-bit đa lõi mạnh ngang điện thoại đời đầu. Độ rộng thanh ghi ($8$-bit, $16$-bit hay $32$-bit) quyết định trực tiếp độ rộng của các thanh ghi DDRx/PORTx/PINx mà bạn sẽ thao tác ở mục 3 — MCU 8-bit thì mỗi thanh ghi GPIO rộng đúng 8 bit (khớp 8 chân một cổng) như trong toàn bộ bài học này; MCU 32-bit thường gộp nhiều chân hơn vào một thanh ghi rộng hơn.

Series này chọn mô hình 8-bit kiểu AVR (giống Arduino Uno) làm chuẩn xuyên suốt Bài 15 & 16 vì tập lệnh đơn giản, thanh ghi 8-bit trực quan để vẽ tay từng bit — nhưng mọi nguyên lý (memory-mapped I/O, DDR/PORT/PIN, đọc-sửa-ghi bitwise) áp dụng y hệt trên MCU 32-bit, chỉ khác độ rộng thanh ghi và tên gọi thanh ghi cụ thể.

2. Memory-Mapped I/O — địa chỉ hoá phần cứng

Đây là ý tưởng quan trọng nhất của bài học: các thanh ghi điều khiển chân vật lý được đặt trong CÙNG một không gian địa chỉ với SRAM. Với CPU, ghi một byte vào ô nhớ 0x25 và ghi một byte vào "thanh ghi điều khiển chân GPIO" là cùng một thao tác — chỉ khác địa chỉ đích. Cách tiếp cận này gọi là Memory-Mapped I/O.

Nhắc lại Series C — con trỏ: một con trỏ chỉ là một địa chỉ bộ nhớ. Khi thư viện MCU viết PORTB = 0x20;, trình biên dịch thực chất dịch nó thành:

// "PORTB" chỉ là một macro cho con trỏ trỏ tới địa chỉ cố định 0x25
#define PORTB (*(volatile uint8_t *)0x25)

// Viết PORTB = 0x20 thực chất là:
*(volatile uint8_t *)0x25 = 0x20;
// Ghi thẳng byte 0x20 vào ô nhớ 0x25 — CPU không hề biết (và không cần biết)
// ô nhớ đó là RAM hay một thanh ghi điều khiển chân vật lý.

3. Bộ ba thanh ghi GPIO: DDRx, PORTx, PINx

Mỗi cổng GPIO 8-chân (ví dụ cổng B) được điều khiển bởi đúng 3 thanh ghi 8-bit, mỗi bit ứng với một chân vật lý:

Nói cách khác: DDRx quyết định "vai trò" của chân (nói hay nghe), còn PORTx và PINx là hai chiều dữ liệu khác nhau của cùng một chân — PORTx là "miệng" (ghi/xuất), PINx là "tai" (đọc/nhập). Chúng không thể dùng thay nhau.

3.1 Bảng địa chỉ thật: memory-mapped I/O không phải lý thuyết suông

Để thấy rõ "3 thanh ghi mỗi cổng" không phải là ẩn dụ mà là các ô nhớ thật với địa chỉ cụ thể, đây là trích đoạn bản đồ bộ nhớ dữ liệu (data memory map) thật của chip ATmega328P (chip trên Arduino Uno) — địa chỉ lấy từ chính datasheet của Microchip:

Quan sát một quy luật rất đẹp: cứ mỗi cổng chiếm đúng 3 địa chỉ liên tiếp, luôn theo thứ tự PIN → DDR → PORT, rồi lặp lại cho cổng kế tiếp. Đây chính xác là lý do vì sao macro PORTB ở mục 2 trỏ đúng vào 0x25 — không phải con số ngẫu nhiên, mà nhà sản xuất chip đã "đổ khuôn" các cổng GPIO liên tiếp nhau trong không gian địa chỉ để trình biên dịch dễ tạo mã tối ưu.

#define PB0 0

void setup(void) {
  DDRB  &= ~(1 << PB0);  // PB0 là INPUT (mặc định, nhưng ghi rõ cho dễ đọc)
  PORTB |=  (1 << PB0);  // Chân INPUT: bit PORT này bật điện trở pull-up nội bộ
                         // → chân "nghỉ" ở mức HIGH khi nút nhấn chưa được bấm
}

int docNutNhan(void) {
  // Nút nhấn thường đấu một đầu xuống GND, đầu kia vào chân PB0.
  // Khi CHƯA bấm: pull-up kéo chân lên HIGH → PINB bit 0 = 1.
  // Khi ĐANG bấm: nút nối thẳng chân xuống GND → PINB bit 0 = 0 (logic đảo ngược!).
  return (PINB & (1 << PB0)) == 0;  // trả về 1 (true) khi nút ĐANG được bấm
}

Chú ý logic bị đảo ngược so với trực giác: nút nhấn đang bấm lại đọc được mức LOW, còn chưa bấm đọc được mức HIGH — vì điện trở pull-up mặc định kéo chân lên cao, nút nhấn chỉ có tác dụng "kéo tuột" chân xuống đất khi đóng mạch. Đây là mẫu đọc nút nhấn phổ biến nhất trong thực tế vì không cần thêm điện trở rời bên ngoài.

4. Kỹ thuật đọc–sửa–ghi bằng phép toán bitwise

Vì một thanh ghi 8-bit điều khiển 8 chân cùng lúc, bạn gần như không bao giờ được phép ghi đè nguyên byte (trừ khi chủ đích muốn đổi cả 8 chân). Thay vào đó, dùng phép toán bitwise để chỉ sửa đúng bit mình cần, giữ nguyên 7 bit còn lại:

// Giả sử LED nối chân PB5 (giống hệt LED tích hợp sẵn trên board Arduino Uno)
#define PB5 5

// 1. SET một bit (đưa lên 1, giữ nguyên các bit khác) — dùng OR
PORTB |= (1 << PB5);   // (1 << 5) = 0b00100000 → chỉ bật riêng bit 5

// 2. CLEAR một bit (đưa về 0, giữ nguyên các bit khác) — dùng AND với số đã đảo bit
PORTB &= ~(1 << PB5);  // ~(0b00100000) = 0b11011111 → chỉ tắt riêng bit 5

// 3. TOGGLE một bit (đảo trạng thái) — dùng XOR
PORTB ^= (1 << PB5);   // bit 5: 0→1 hoặc 1→0, các bit khác giữ nguyên

// 4. ĐỌC một bit (kiểm tra chân đang HIGH hay LOW) — dùng AND rồi so 0
if (PINB & (1 << PB0)) {
  // Chân PB0 đang ở mức HIGH (ví dụ: nút nhấn đang được thả ra nhờ pull-up)
}

// ❌ SAI #1: Quên set DDR trước — LED không bao giờ sáng
PORTB |= (1 << PB5);   // Chân PB5 vẫn đang là INPUT (DDR mặc định = 0)!

// ✅ ĐÚNG #1: Luôn cấu hình chiều DDR trước khi điều khiển PORT
DDRB  |= (1 << PB5);   // Bước 1: khai báo PB5 là OUTPUT
PORTB |= (1 << PB5);   // Bước 2: bây giờ mới bật mức HIGH cho LED

// ❌ SAI #2: Gán đè cả byte — xoá mất cấu hình PB3 (Relay) đã set trước đó
DDRB = (1 << PB5);      // Ghi đè toàn bộ 8 bit! PB3 vô tình bị đưa về 0 (input)

// ✅ ĐÚNG #2: Dùng OR để chỉ bật thêm bit mới, giữ nguyên các bit đã cấu hình
DDRB |= (1 << PB5);     // Chỉ bật thêm bit 5, bit 3 (Relay) vẫn nguyên vẹn

5. Ứng dụng thực tế: điều khiển nhiều chân GPIO cùng lúc

Sức mạnh thật sự của thao tác thanh ghi lộ rõ khi điều khiển nhiều chân cùng lúc bằng một lệnh duy nhất — thay vì gọi hàm bật/tắt từng LED riêng lẻ (như các thư viện cấp cao thường làm), bạn có thể ghi thẳng cả một mẫu bit vào PORTx để đổi trạng thái toàn bộ 8 chân trong đúng một chu kỳ máy.

5.1 Bộ đếm nhị phân hiển thị trên 4 LED

Nối 4 LED vào 4 chân thấp nhất của cổng D (PD0–PD3). Đếm nhị phân từ $0$ đến $15$ chỉ đơn giản là gán liên tiếp giá trị đếm vào PORTD:

void setup(void) {
  DDRD |= 0b00001111;  // 4 bit thấp (PD0-PD3) là OUTPUT, 4 bit cao giữ nguyên INPUT
}

void demNhiPhan(void) {
  for (uint8_t dem = 0; dem <= 15; dem++) {
    // Chỉ ghi đè đúng 4 bit thấp, GIỮ NGUYÊN 4 bit cao (tránh lặp lại sai lầm ở mục 4!)
    PORTD = (PORTD & 0b11110000) | (dem & 0b00001111);
    delay(300);  // Mỗi bước đếm cách nhau 300ms để mắt kịp nhìn
  }
  // dem = 13 = 0b1101 → LED PD3,PD2 tắt, PD1,PD0 sáng — thử tính nhẩm các giá trị còn lại!
}

Chú ý dòng PORTD = (PORTD & 0b11110000) | (dem & 0b00001111); — đây là kỹ thuật kết hợp AND và OR để chỉ thay 4 bit thấp, khoá cứng 4 bit cao, tổng quát hoá chính xác cạm bẫy "ghi đè cả byte" ở mục 4 cho trường hợp nhiều bit cùng lúc thay vì chỉ 1 bit.

5.2 Hiệu ứng đèn chạy (Knight Rider / Larson Scanner)

Hiệu ứng đèn chạy qua lại kinh điển — một chấm sáng "chạy" từ trái sang phải rồi ngược lại trên dãy LED — chỉ cần đúng một toán tử dịch bit (<</>>, khác với &/|/^ đã học ở mục 4):

void hieuUngDenChay(void) {
  uint8_t mau = 0b00000001;  // Bắt đầu từ chân PD0
  int8_t chieu = 1;          // 1 = dịch phải→trái, -1 = dịch trái→phải

  while (1) {
    PORTD = mau;
    delay(100);

    if (chieu == 1) {
      mau <<= 1;               // Dịch chấm sáng sang trái 1 bit
      if (mau == 0b10000000) chieu = -1;  // Chạm biên phải → đổi chiều
    } else {
      mau >>= 1;               // Dịch chấm sáng sang phải 1 bit
      if (mau == 0b00000001) chieu = 1;   // Chạm biên trái → đổi chiều
    }
  }
}

Vòng lặp while (1) chạy vĩnh viễn bằng cách "đợi bận" (busy-wait) qua delay() — trong lúc đó CPU không làm được việc gì khác, kể cả đọc một nút nhấn. Đây chính là giới hạn bạn sẽ vượt qua ở Bài 16: dùng ngắt Timer phần cứng để CPU vẫn rảnh xử lý việc khác trong lúc đèn vẫn chạy đều đặn — không cần vòng lặp chờ tốn tài nguyên như ở đây.

6. Trình giả lập: Lập trình GPIO cho MCU ảo

Bảng dưới đây mô phỏng một MCU ảo với LED nối ở chân PB5 (giống hệt LED tích hợp sẵn trên board Arduino Uno). Bấm ▶ Chạy từng lệnh để thực thi tuần tự đoạn mã chớp tắt LED, quan sát giá trị 3 thanh ghi DDRB/PORTB/PINB đổi theo từng dòng lệnh và đèn LED thật sự sáng/tắt tương ứng. Nút ❌ Bỏ qua bước set DDR tái hiện chính xác cạm bẫy ở mục 4.

7. Câu hỏi trắc nghiệm ôn tập