Giới thiệu dự án

Thị trường thiết bị giải trí tương tác và trò chơi điện tử mô phỏng chuyển động thực tế (Motion-Controlled Gaming) đã có bước tăng trưởng vượt bậc với giá trị toàn cầu vượt mốc 180 tỷ USD. Tuy nhiên, các dòng game arcade cổ điển sử dụng súng quang học (Light Gun như NES Zapper) đã hoàn toàn mất khả năng tương thích khi màn hình hiển thị chuyển dịch từ công nghệ quét tia cathode (CRT) sang màn hình tinh thể lỏng (LCD/OLED). Điều này đặt ra yêu cầu cấp thiết về việc phát triển hệ thống điều khiển tương tác vật lý thế hệ mới dựa trên công nghệ cảm biến quán tính (Inertial Measurement Unit - IMU) kết hợp hệ vi điều khiển nhúng giá thành thấp.

Đồ án tốt nghiệp "Thiết kế và thi công hệ thống trò chơi bắn vịt trời" do sinh viên Lâm Trọng Nhân thực hiện dưới sự hướng dẫn của GV. Huỳnh Hoàng Hà tại Trường Đại học Sư phạm Kỹ thuật TP.HCM (Ngành Công nghệ Kỹ thuật Máy tính) đã giải quyết triệt để bài toán này bằng cách tích hợp vi điều khiển nhúng, cảm biến đo góc xoay không gian và kiến trúc phần mềm hướng đối tượng (OOP).

+-------------------------------------------------------------------------+
|                          HỆ THỐNG PHẦN CỨNG                             |
|  [Cảm biến MPU6050] (Gia tốc/Góc quay) ---I2C---> [Arduino Uno R3]      |
|  [Cò súng - Push Button] --------------ISR------> (ATmega328P 16MHz)   |
+----------------------------------------------------+--------------------+
                                                     | UART (Virtual COM)
                                                     v
+-------------------------------------------------------------------------+
|                          HỆ THỐNG PHẦN MỀM                              |
|  [Python 3.6 Engine] <---> [Tkinter Canvas GUI] <---> [VBA / XML Parser]|
|  - CFactoryBird (Creational Pattern)                                    |
|  - CBaseObject -> CBaseBird / CGun / CPlayer (Polymorphic Entities)     |
+-------------------------------------------------------------------------+

Mục tiêu cụ thể của dự án

  1. Thiết kế phần cứng bộ điều khiển súng: Tích hợp module cảm biến 6 trục MPU6050 cùng nút nhấn cò súng kết nối với bo mạch vi điều khiển Arduino Uno R3 (ATmega328P), giao tiếp qua giao thức I2C và ngắt phần cứng (Hardware Interrupt).
  2. Xây dựng giao thức truyền thông dữ liệu: Thiết lập luồng truyền UART bất đồng bộ qua cổng COM ảo (Virtual COM Port) với tốc độ lấy mẫu ổn định và độ trễ thấp (<15ms).
  3. Phát triển Game Engine trên nền tảng Python 3.6: Ứng dụng thư viện đồ họa GUI Tkinter, áp dụng triệt để 4 đặc tính của lập trình hướng đối tượng (Tính đóng gói, Kế thừa, Đa hình, Trừu tượng) thông qua mô hình Factory Pattern để quản lý các thực thể game (Main Bird, Gun Bird, Bullet Bird, CGun, CPlayer).
  4. Tích hợp cơ chế cấu hình động bằng XML & VBA: Cho phép tùy chỉnh tham số trò chơi linh hoạt mà không cần biên dịch lại mã nguồn chương trình.

Phân tích và thiết kế giải pháp

Phân tích hiện trạng

Tiêu chí kỹ thuật Súng quang học cổ điển (NES Zapper) Chuột / Bàn phím máy tính Hệ thống điều khiển MPU6050 + Arduino (Đồ án)
Cơ chế nhận diện Cảm biến diode quang bắt điểm quét CRT Tọa độ 2D mặt phẳng di chuột Đo 6 trục gia tốc và con quay hồi chuyển (6-DOF IMU)
Môi trường hiển thị Chỉ tương thích màn CRT (Bóng đèn hình) Mọi loại màn hình Tương thích đa nền tảng (LCD, OLED, Projector)
Trải nghiệm xúc giác Mô phỏng súng thật, độ chính xác quang học Tương tác gián tiếp, thiếu trực quan Trực quan không gian 3 chiều, phản hồi theo thời gian thực
Độ phức tạp tích hợp Phần cứng lỗi thời, không còn hỗ trợ Đơn giản, thư viện chuẩn có sẵn Yêu cầu lập trình nhúng, xử lý tín hiệu cảm biến & GUI

Yêu cầu hệ thống theo mô hình MoSCoW:

  • Must have: Đọc chính xác góc quay 3 trục (Yaw, Pitch, Roll) từ MPU6050 qua bus I2C; chuyển đổi thành tọa độ Pixel di chuyển hồng tâm (CGun); bắt sự kiện bắn tức thời qua ngắt ngoại vi; cập nhật trạng thái các đối tượng chim bay với tốc độ 60 FPS.
  • Should have: Phân tách rõ ràng giữa hai màn hình chức năng (CFrmMenu và CFrmGame); quản lý vòng đời đối tượng bằng danh sách liên kết (List).
  • Could have: Cấu hình tham số xác suất xuất hiện của vật thể thông qua bảng tính Excel xuất định dạng XML.
  • Won't have (giai đoạn này): Truyền nhận dữ liệu không dây Bluetooth/RF (kết nối trực tiếp qua USB Serial).

Thiết kế hệ thống và ngăn xếp công nghệ

+-------------------------------------------------------------+
|               KIẾN TRÚC PHẦN MỀM HƯỚNG ĐỐI TƯỢNG            |
+-------------------------------------------------------------+
|                        CBaseObject                          |
|        (m_nIDObject, m_nPosX, m_nPosY, DrawObject())        |
+------------------------------+------------------------------+
                               |
        +----------------------+----------------------+
        |                                             |
+-------v-------+                             +-------v-------+
|   CBaseBird   |                             |     CGun      |
| (m_arrPic...) |                             | (m_nDiameter) |
+-------+-------+                             +-------+-------+
        |                                             ^
        +---> CMainBird (Mục tiêu chính tính điểm)   |
        +---> CGunBird  (Nâng cấp kích thước tâm)     | (Chứa trong)
        +---> CBulletBird (Tăng trữ lượng đạn)        |
                                              +-------+-------+
                                              |    CPlayer    |
                                              |  (m_nBullet)  |
                                              +---------------+
  • Công nghệ phần cứng:
    • Bo mạch nhúng: Arduino Uno R3 tích hợp vi điều khiển Microchip ATmega328P (Tần số dao động thạch anh: 16 MHz, 32 KB Flash, 2 KB SRAM, 14 chân Digital I/O, 6 chân Analog 10-bit).
    • Cảm biến IMU: MPU6050 (Tích hợp con quay hồi chuyển 3 trục Gyroscope dải đo $\pm 250^\circ/\text{s} \text{ đến } \pm 2000^\circ/\text{s}$, gia tốc kế 3 trục Accelerometer $\pm 2\text{g} \text{ đến } \pm 16\text{g}$, chuẩn giao tiếp I2C tốc độ 400 kHz).
  • Công nghệ phần mềm:
    • Ngôn ngữ phát triển: Python 3.6 kết hợp framework đồ họa Tkinter 8.6.
    • Cấu hình & Dữ liệu: Microsoft Visual Basic for Applications (VBA), Microsoft XML 6.0, Cổng truyền thông PySerial 3.4.

Phương pháp luận phát triển (Methodology)

Dự án áp dụng mô hình phát triển phần cứng - phần mềm song hành (Hardware-Software Co-Design):

  1. Tầng nhúng vi điều khiển: Thiết lập chu kỳ đọc thanh ghi cảm biến địa chỉ 0x3B (Accelerometer X-out) và 0x43 (Gyroscope X-out) định kỳ trong vòng lặp chính. Khi có sự kiện kích hoạt nút bấm trên thân súng, vi điều khiển kích hoạt ngắt ngoài (External Interrupt) gửi ngay ký tự cờ (Trigger Flag) lên máy tính thông qua UART TX pin, loại bỏ hiện tượng bỏ lỡ thao tác bắn (Input Lag).
  2. Tầng xử lý trung tâm (PC): Một luồng tiến trình chuyên biệt (Worker Thread) liên tục lắng nghe cổng nối tiếp, giải mã chuỗi byte, ánh xạ góc quay sang độ dời pixel $(dx, dy)$ trên đối tượng Tkinter Canvas và cập nhật hình học hồng tâm.

Triển khai và kết quả thực nghiệm

Quá trình phát triển và thuật toán cốt lõi

Kiến trúc phần mềm phân tầng rành mạch giữa giao diện và logic điều khiển. Dưới đây là hiện thực thuật toán quản lý thực thể chim bay và vẽ đối tượng đồ họa kế thừa từ lớp cơ sở:

# Trích đoạn mã nguồn hướng đối tượng trên Python 3.6 / Tkinter
class CBaseObject:
    """Lớp cơ sở trừu tượng đại diện cho mọi thực thể hiển thị trên Canvas"""
    def __init__(self, canvas, pos_x=0, pos_y=0):
        self.m_Canvas = canvas
        self.m_nPosX = pos_x
        self.m_nPosY = pos_y
        self.m_nIDObject = None

    def SetPos(self, x, y):
        self.m_nPosX = x
        self.m_nPosY = y

    def GetPos(self):
        return (self.m_nPosX, self.m_nPosY)

    def DrawObject(self, image_data):
        if self.m_nIDObject is None:
            self.m_nIDObject = self.m_Canvas.create_image(
                self.m_nPosX, self.m_nPosY, image=image_data
            )
        else:
            self.m_Canvas.coords(self.m_nIDObject, self.m_nPosX, self.m_nPosY)
            self.m_Canvas.itemconfig(self.m_nIDObject, image=image_data)

class CBaseBird(CBaseObject):
    """Lớp thực thể chim cơ sở quản lý hành vi chuyển động và hoạt ảnh"""
    def __init__(self, canvas, list_images, speed_fly, speed_move, direction_x, direction_y):
        super().__init__(canvas)
        self.m_arrPicBirdFlying = list_images  # Danh sách 3 trạng thái Bitmap
        self.m_nSpeedFlying = speed_fly
        self.m_nSpeedMove = speed_move
        self.m_nDirectionX = direction_x        # -1 (Trái) hoặc 1 (Phải)
        self.m_nDirectionY = direction_y        # -1 (Lên) hoặc 1 (Xuống)
        self.m_nCurrentFrame = 0

    def Fly(self):
        """Cập nhật frame ảnh động mô phỏng vỗ cánh"""
        self.m_nCurrentFrame = (self.m_nCurrentFrame + 1) % len(self.m_arrPicBirdFlying)
        return self.m_arrPicBirdFlying[self.m_nCurrentFrame]

    def Move(self):
        """Tính toán tọa độ vector mới trên màn hình 2D"""
        new_x = self.m_nPosX + (self.m_nDirectionX * self.m_nSpeedMove)
        new_y = self.m_nPosY + (self.m_nDirectionY * self.m_nSpeedMove)
        self.SetPos(new_x, new_y)

Ở tầng điều khiển nhúng, chương trình đọc dữ liệu cảm biến qua giao thức I2C và xử lý ngắt phím bắn được tối ưu hóa nhằm giảm thiểu thời gian thực thi của trình phục vụ ngắt (Interrupt Service Routine - ISR):

// Thuật toán vi điều khiển ATmega328P (Arduino Uno R3)
#include <Wire.h>

const int MPU_ADDR = 0x68; // Địa chỉ I2C mặc định khi chân AD0 = GND
const byte BUTTON_PIN = 2; // Chân ngắt ngoài INT0
volatile bool fireEventTriggered = false;

void isrButtonPress() {
    // Đánh dấu cờ ngắt trong thời gian ngắn nhất (<1 microsecond)
    fireEventTriggered = true;
}

void setup() {
    Wire.begin();
    Wire.beginTransmission(MPU_ADDR);
    Wire.write(0x6B); // Thanh ghi Power Management 1
    Wire.write(0);    // Đánh thức MPU6050 (Wake-up)
    Wire.endTransmission(true);

    pinMode(BUTTON_PIN, INPUT_PULLUP);
    attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), isrButtonPress, FALLING);
    Serial.begin(115200);
}

void loop() {
    // Đọc liên tục 6 thanh ghi tọa độ gia tốc và con quay
    Wire.beginTransmission(MPU_ADDR);
    Wire.write(0x3B); // Bắt đầu từ thanh ghi ACCEL_XOUT_H
    Wire.endTransmission(false);
    Wire.requestFrom(MPU_ADDR, 6, true);

    int16_t AcX = Wire.read() << 8 | Wire.read();
    int16_t AcY = Wire.read() << 8 | Wire.read();
    int16_t AcZ = Wire.read() << 8 | Wire.read();

    // Gửi chuỗi telemetry lên PC định dạng: "AcX,AcY,AcZ,FireFlag\n"
    Serial.print(AcX); Serial.print(",");
    Serial.print(AcY); Serial.print(",");
    Serial.print(AcZ); Serial.print(",");
    Serial.println(fireEventTriggered ? 1 : 0);

    if (fireEventTriggered) {
        fireEventTriggered = false; // Reset cờ ngắt
    }
    delay(10); // Tần số lấy mẫu 100Hz
}

Kết quả kiểm nghiệm và hiệu năng

+-----------------------------------------------------------------------+
|                KẾT QUẢ ĐO LƯỜNG VÀ ĐÁNH GIÁ HIỆU NĂNG                 |
+-----------------------------------------------------------------------+
|  Thông số kiểm nghiệm            |  Kết quả thực tế đạt được          |
+----------------------------------+------------------------------------+
|  Độ trễ phản hồi cảm biến (Lag)  |  < 12.5 ms (Tần số quét 100Hz)     |
|  Tốc độ khung hình (Frame Rate)  |  58 - 60 FPS (Tkinter Canvas)      |
|  Tỷ lệ nhận ngắt nút bấm (Hit)   |  100% (Không trễ nhịp / No loss)   |
|  Thời gian nạp cấu hình XML      |  < 80 ms khi khởi tạo hệ thống     |
|  Nguồn cấp toàn hệ thống         |  5V DC trực tiếp qua cổng USB Bus  |
+-----------------------------------------------------------------------+
  1. Độ ổn định giao tiếp UART/I2C: Hệ thống duy trì kết nối ổn định ở baudrate 115200 bps. Tín hiệu I2C trên 2 đường SDA/SCL giữ biên độ chuẩn 5V nhờ điện trở kéo lên nguồn (Pull-up Resistors), không phát sinh lỗi tràn bộ đệm (Buffer Overflow).
  2. Xử lý va chạm (Hit-box Collision Detection): Phép toán kiểm tra khoảng cách Euclide giữa tâm đường tròn súng $(\text{Gun}_x, \text{Gun}_y)$ bán kính $R = \text{m_nDiameter}/2$ và tọa độ bounding box của đối tượng chim bay trả kết quả tức thời với độ chính xác đạt tuyệt đối ($100%$).

Đổi mới và đóng góp khoa học

  • Cải tiến tương tác không gian thực: Thay vì điều khiển chuột 2D thông thường, hệ thống tích hợp cảm biến 6-DOF IMU MPU6050, mang lại trải nghiệm cầm nắm và ngắm bắn trực quan với chi phí phần cứng thấp hơn 85% so với các thiết bị VR Controller thương mại.
  • Cơ chế tách rời dữ liệu và mã nguồn (Data-Driven Decoupling): Đột phá trong việc xây dựng hệ thống mẫu cấu hình (Template) trên Microsoft Excel kết hợp macro VBA để sinh tệp setting.xml. Người vận hành không cần có kỹ năng lập trình hay công cụ biên dịch vẫn có thể thay đổi:
    • Tốc độ bay (m_arrSpeedMove)
    • Thời gian tái tạo đối tượng (m_arrTimeCreateBird)
    • Xác suất xuất hiện chim đặc biệt (GunBird, BulletBird)
  • Khả năng mở rộng phần cứng đa người chơi (Scalable Hardware Design): Đưa ra giải pháp phân bổ địa chỉ động I2C thông qua việc điều khiển chân logic AD0 của MPU6050 bằng các chân Digital I/O của Arduino Uno R3:
    • Khi AD0 = 0 (GND) $\rightarrow$ Địa chỉ thiết bị là 0x68.
    • Khi AD0 = 1 (VCC) $\rightarrow$ Địa chỉ thiết bị là 0x69.
    • Bằng kỹ thuật quét mức logic chân AD0, một bo vi điều khiển duy nhất có thể giao tiếp tuần tự với 3 đến 4 cảm biến trên cùng một bus I2C mà không bị xung đột địa chỉ.
+-----------------------------------------------------------------------+
|            SƠ ĐỒ MỞ RỘNG ĐA NGƯỜI CHƠI BẰNG CHÂN AD0 TRÊN BUS I2C     |
+-----------------------------------------------------------------------+
|  Arduino Digital Pin 8  ---(Logic Low=0x68 / High=0x69)---> MPU6050 #1|
|  Arduino Digital Pin 9  ---(Logic Low=0x68 / High=0x69)---> MPU6050 #2|
|  Arduino Digital Pin 10 ---(Logic Low=0x68 / High=0x69)---> MPU6050 #3|
|  Arduino I2C (SDA/SCL)  ==================================> Bus chung |
+-----------------------------------------------------------------------+

Ứng dụng thực tế và triển khai

Kịch bản ứng dụng

  1. Thiết bị giáo dục STEM / Đào tạo Robotics & IoT: Làm đồ án mẫu trực quan cho sinh viên chuyên ngành Kỹ thuật Máy tính, Cơ điện tử và Điện tử Viễn thông trong việc nghiên cứu lập trình vi điều khiển, xử lý ngắt, giao tiếp nối tiếp và lập trình hướng đối tượng.
  2. Khu trò chơi giải trí Retro Arcade: Tái hiện các trò chơi kinh điển trên các màn hình LCD thế hệ mới với chi phí gia công cực thấp.
  3. Thiết bị phục hồi chức năng vận động: Ứng dụng bộ điều khiển con quay hồi chuyển trong việc hỗ trợ bệnh nhân luyện tập phản xạ cổ tay và cánh tay thông qua các bài tập ngắm bắn tương tác.

Hướng dẫn cài đặt và vận hành (Deployment Guide)

# 1. Cài đặt môi trường thực thi
git clone https://github.com/project/duck-hunting-system.git
cd duck-hunting-system

# 2. Cài đặt các thư viện phụ thuộc
pip install pyserial==3.4 pillow==8.2.0

# 3. Nạp code cho vi điều khiển Arduino Uno R3
# Mở file /firmware/mpu6050_gun.ino trên Arduino IDE 1.8.x và ấn Upload (Baud: 115200)

# 4. Khởi chạy ứng dụng game trên máy tính tính
python main_game.py

Bảng dự toán chi phí phần cứng (BOM)

Linh kiện phần cứng Model / Quy cách Đơn giá ước tính (VND)
Bo mạch vi điều khiển Arduino Uno R3 (Chip nạp ATmega328P / CH340) 95.000
Cảm biến 6-DOF IMU Module GY-521 (MPU6050) 38.000
Cò bấm & Nút chức năng Push button công nghiệp + Trở kéo 10k 7.000
Dây kết nối & Vỏ súng Vỏ in 3D / Khung nhựa + Cáp USB A-B 1.5m 60.000
Tổng chi phí phần cứng (Tối ưu hóa sản xuất đơn chiếc) ~200.000 VND (~8.5 USD)

Hạn chế và hướng phát triển

Hạn chế kỹ thuật hiện tại

  • Tích luỹ sai số con quay (Gyro Drift): Cảm biến MPU6050 xuất hiện độ lệch góc theo thời gian khi không có thuật toán lọc bù (Complementary Filter) hoặc lọc Kalman (Kalman Filter) hoàn chỉnh ở tầng vi điều khiển.
  • Kết nối vật lý có dây: Việc sử dụng cáp USB Serial hạn chế không gian vận động của người chơi trong phạm vi 1.5 - 2m.

Kế hoạch nâng cấp và hướng nghiên cứu mở rộng

  • Nâng cấp giao tiếp không dây: Thay thế module Arduino Uno bằng SoC ESP32-WROOM-32 tích hợp Bluetooth Low Energy (BLE 5.0) hoặc module RF NRF24L01+ 2.4 GHz để loại bỏ dây cáp tín hiệu.
  • Tích hợp giải thuật lọc Kalman đa biến: Bù sai số trôi cảm biến trong không gian 3D nhằm đạt độ phân giải góc ngắm ổn định dưới $0.1^\circ$.
  • Chuyển đổi đồ họa sang Pygame / OpenGL: Nâng cấp từ Tkinter Canvas lên nền tảng đồ họa phần cứng (Hardware Accelerated Rendering) để hỗ trợ hiệu ứng hạt (Particle Effects) và âm thanh đa kênh.

Đối tượng hưởng lợi

+-------------------------------------------------------------------------+
|                         GIÁ TRỊ MANG LẠI                                |
+-------------------------------------------------------------------------+
|  [Sinh viên Kỹ thuật]  ---> Nắm vững mô hình Hardware-in-the-loop, I2C,  |
|                             ngắt phần cứng và mẫu thiết kế Factory OOP. |
|  [Kỹ sư Lập trình]     ---> Nắm kỹ thuật đọc Serial Port bất đồng bộ     |
|                             và cơ chế tách dữ liệu cấu hình XML qua VBA.|
|  [Nhà phát triển Game] ---> Khai thác kiến trúc game 2D tương tác IMU   |
|                             với chi phí linh kiện dưới 10 USD.          |
+-------------------------------------------------------------------------+
  • Sinh viên ngành Kỹ thuật Máy tính / Điện tử: Cung cấp tài liệu tham khảo toàn diện kết hợp thực tế giữa thiết kế mạch điện tử, giao thức I2C/UART và lập trình phần mềm máy tính bậc cao.
  • Lập trình viên phần mềm nhúng: Tiếp cận giải pháp xử lý ngắt tối ưu, chuyển giao dữ liệu từ cảm biến lên giao diện máy tính với độ trễ tối thiểu.
  • Doanh nghiệp sản xuất thiết bị giải trí: Có được thiết kế mẫu hoàn chỉnh về phần cứng lẫn phần mềm để phát triển các dòng sản phẩm máy chơi game Arcade chi phí thấp.

Câu hỏi thường gặp

1. Yêu cầu cấu hình phần cứng tối thiểu để triển khai hệ thống là gì?

Hệ thống yêu cầu máy tính chạy hệ điều hành Windows 7/10/11 hoặc Linux, trang bị CPU tối thiểu Dual Core 2.0 GHz, 2 GB RAM, 1 cổng USB 2.0 Type-A khả dụng và đã cài đặt môi trường Python 3.6 trở lên.

2. Làm thế nào để mở rộng hệ thống cho 2 người chơi cùng lúc?

Cần bổ sung thêm một cảm biến MPU6050 thứ hai. Chân AD0 của cảm biến thứ nhất nối xuống đất (GND - Địa chỉ 0x68), chân AD0 của cảm biến thứ hai nối lên nguồn VCC 3.3V/5V (Địa chỉ 0x69). Vi điều khiển sẽ tuần tự đọc dữ liệu từ cả hai địa chỉ qua bus I2C chung.

3. Tại sao hệ thống sử dụng ngắt phần cứng (Hardware Interrupt) cho nút bắn thay vì kiểm tra vòng lặp (Polling)?

Kiểm tra vòng lặp dễ bị bỏ lỡ thao tác bấm cò súng nếu thời điểm bấm rơi vào lúc vi điều khiển đang bận giao tiếp I2C với MPU6050. Ngắt phần cứng ngắt ngang luồng thực thi để ghi nhận cờ bắn ngay lập tức với thời gian phản hồi dưới $1\mu\text{s}$.

4. Nếu cảm biến MPU6050 bị trôi tọa độ hồng tâm (Drift) thì xử lý như thế nào?

Có thể bổ sung nút hiệu chuẩn (Calibration Button) trên thân súng. Khi bấm giữ, chương trình sẽ lấy giá trị đo hiện tại làm điểm gốc tọa độ $(0, 0)$ trên màn hình và thiết lập lại điểm bù (Offset) cho con quay hồi chuyển.

5. Chi phí sản xuất hàng loạt một bộ tay cầm điều khiển là bao nhiêu?

Nếu sản xuất trên quy mô từ 100 bộ trở lên với việc tích hợp vi điều khiển ATmega328P bề mặt (SMD) và cảm biến MPU6050 trên một bo mạch in (PCB) duy nhất, giá thành gia công ước tính chỉ khoảng 120.000 - 150.000 VND / bộ.

Kết luận

Đồ án tốt nghiệp "Thiết kế và thi công hệ thống trò chơi bắn vịt trời" là một công trình nghiên cứu ứng dụng tiêu biểu trong lĩnh vực Công nghệ Kỹ thuật Máy tính, thể hiện sự kết hợp chặt chẽ giữa thiết kế mạch vi điều khiển phần cứng và kỹ nghệ phần mềm hiện đại. Bằng việc làm chủ giao thức truyền thông I2C/UART, khai thác sức mạnh của kiến trúc lập trình hướng đối tượng trên Python và xây dựng thành công cơ chế cấu hình dữ liệu động qua XML, đồ án không chỉ hoàn thành xuất sắc mục tiêu ban đầu mà còn mở ra tiềm năng ứng dụng to lớn trong giáo dục STEM và giải trí tương tác.