Giới thiệu dự án

Trong kỷ nguyên chuyển đổi số và công nghiệp 4.0, các hệ thống nhúng (Embedded Systems) và Internet vạn vật (IoT) đóng vai trò trung tâm trong tự động hóa và đo lường điều khiển. Theo báo cáo từ MarketsandMarkets, thị trường phần cứng mã nguồn mở và thiết bị thu thập dữ liệu (DAQ) ứng dụng giáo dục - nghiên cứu đạt mức tăng trưởng kép hàng năm (CAGR) trên 14.2%. Tuy nhiên, một rào cản kỹ thuật cố hữu trong quy trình phát triển nguyên mẫu nhanh (Rapid Prototyping) là khoảng cách giữa việc lập trình firmware truyền thống (viết bằng C/C++ thuần) và nhu cầu xử lý toán học phức tạp, phân tích ma trận, lọc nhiễu tín hiệu và hiển thị đồ thị thời gian thực (Real-time Visualization).

Đồ án tốt nghiệp "Lập trình các ứng dụng trên Kit Arduino bằng ngôn ngữ MATLAB" do sinh viên Lương Đức Hậu và Lê Hiển Đạt thực hiện dưới sự hướng dẫn của ThS. Nguyễn Duy Thảo tại Khoa Điện - Điện Tử, Trường Đại học Sư phạm Kỹ thuật TP.HCM (HCMUTE), giải quyết triệt để bài toán này. Dự án chuyển đổi nền tảng phần cứng thương mại phổ thông Arduino Uno R3 thành một trạm thu thập dữ liệu và chấp hành thông minh, được điều khiển trực tiếp từ môi trường tính toán mạnh mẽ của MATLAB thông qua giao thức giao tiếp máy chủ - thiết bị khách (Host-Target Architecture).

+-----------------------------------------------------------------------------+
|                               HOST COMPUTER                                 |
|  +-----------------------------------------------------------------------+  |
|  |                 MATLAB Environment (R2016a / Engine)                  |  |
|  |  +----------------------+ +------------------+ +-------------------+  |  |
|  |  | Numerical / Analysis | |  2D/3D Graphic   | | Arduino Support   |  |  |
|  |  | Matrix Computation   | |  Plotting Engine | | Package Interface |  |  |
|  |  +----------------------+ +------------------+ +-------------------+  |  |
|  +-----------------------------------------------------------------------+  |
+--------------------------------------|--------------------------------------+
                                  USB / UART
                             (Baudrate: 115,200)
+--------------------------------------|--------------------------------------+
|                           TARGET HARDWARE                                   |
|  +-----------------------------------------------------------------------+  |
|  |                    Arduino Uno R3 (ATmega328P)                        |  |
|  |                     Client Driver Firmware                            |  |
|  +-----------------------------------------------------------------------+  |
|       |                 |               |               |              |     |
|   Digital I/O      PWM (8-bit)     I2C Bus         SPI Bus        PPM/Timer  |
|       |                 |               |               |              |     |
|  [Push Button]     [RGB LED /      [PCF8591 ADC/DAC] [Loopback/   [SG90 Servo|
|   [Discrete LED]    Dimmer]         Thermistor/LDR]   Peripherals]   Motor]  |
+-----------------------------------------------------------------------------+

Mục tiêu kỹ thuật của đề tài

  1. Tích hợp phần mềm - phần cứng: Thiết lập thành công liên kết phần cứng trực tiếp giữa MATLAB (thông qua MATLAB Support Package for Arduino Hardware) và vi điều khiển ATmega328P qua cổng giao tiếp nối tiếp ảo (Virtual COM/UART).
  2. Làm chủ hệ thống ngoại vi cơ bản: Lập trình xuất nhập tín hiệu số (Digital I/O) điều khiển LED, đọc nút nhấn; điều chế độ rộng xung (PWM - Pulse Width Modulation) 8-bit trên 6 kênh (D3, D5, D6, D9, D10, D11) để hòa trộn màu LED RGB và điều chỉnh độ sáng.
  3. Triển khai các giao thức truyền thông công nghiệp:
    • Cấu hình bus $I^2C$ (Inter-Integrated Circuit) giao tiếp module chuyển đổi $A/D$ và $D/A$ đa kênh PCF8591 (địa chỉ phần cứng 0x48).
    • Cấu hình bus SPI (Serial Peripheral Interface) tốc độ cao, thực hiện kiểm thử vòng lặp (Loopback Test) trên các chân cứng MOSI (D11), MISO (D12), SCK (D13), SS (D10).
  4. Điều khiển cơ cấu chấp hành: Điều khiển góc quay chính xác động cơ Servo từ $0^\circ$ đến $180^\circ$ thông qua các hàm định vị góc chuyên dụng.
  5. Thu thập dữ liệu và biểu diễn thời gian thực: Đọc đồng thời 3 kênh cảm biến (Nhiệt điện trở - Thermistor, Cảm biến quang - LDR, Biến trở - Potentiometer) qua PCF8591 và vẽ đồ thị động đa đường (Multi-line real-time plotting) không gây nghẽn luồng dữ liệu.
  6. Xây dựng phòng thí nghiệm ảo trên Proteus: Xây dựng hệ thống thư viện và mô phỏng hoàn chỉnh mạch nguyên lý trên Proteus VSM, hỗ trợ kiểm thử nạp tệp định dạng Hexadecimal (.hex) trước khi triển khai phần cứng.

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 Arduino IDE thuần (C/C++) MATLAB Support Package LabVIEW + LINX / LIFA Python (pySerial + Matplotlib)
Độ phức tạp lập trình Trung bình (Yêu cầu quản lý con trỏ, ngắt, thanh ghi) Rất thấp (Lập trình hướng đối tượng mức cao) Thấp (Lập trình đồ họa G-code) Trung bình (Yêu cầu xây dựng luồng đọc Serial)
Khả năng xử lý toán học Rất hạn chế (Bộ nhớ RAM vi điều khiển chỉ 2KB) Vượt trội (Thư viện ma trận, DSP, Wavelet, AI) Rất mạnh (Xử lý tín hiệu trực quan) Rất mạnh (NumPy, SciPy, Pandas)
Trực quan hóa dữ liệu Kém (Serial Plotter đơn giản, không tùy biến) Xuất sắc (Biểu đồ 2D/3D, tùy biến handle đồ họa) Xuất sắc (Front Panel chuyên nghiệp) Tốt (Cần cấu hình Animation / GUI PyQt)
Tốc độ thực thi thuật toán Thời gian thực cứng (Hard Real-time trên MCU) Thời gian thực mềm (Soft Real-time, phụ thuộc UART) Thời gian thực mềm Thời gian thực mềm
Chi phí triển khai Miễn phí (Mã nguồn mở) Bản quyền thương mại / Giáo dục Bản quyền thương mại cao Miễn phí (Mã nguồn mở)

Phân loại yêu cầu hệ thống theo mô hình MoSCoW

+--------------------------------------------------------------------------------+
|                              MOSCOW REQUIREMENTS                               |
+--------------------------------------------------------------------------------+
|  [M] MUST HAVE                                                                 |
|  - Trình điều khiển Arduino Server nạp trên ATmega328P                         |
|  - Điều khiển Digital I/O, PWM 8-bit, đọc ADC 10-bit nội                       |
|  - Giao tiếp I2C PCF8591 (đọc 3 kênh cảm biến), SPI Loopback                   |
|  - Điều khiển động cơ Servo 0 - 180 độ, Trực quan hóa Real-time đồ họa        |
+--------------------------------------------------------------------------------+
|  [S] SHOULD HAVE                                                               |
|  - Cơ chế giải phóng tài nguyên tự động onCleanup khi ngắt chương trình        |
|  - Mô phỏng hoàn chỉnh mạch nguyên lý trên Proteus VSM                         |
|  - Quét tự động địa chỉ I2C Bus (scanI2CBus)                                  |
+--------------------------------------------------------------------------------+
|  [C] COULD HAVE                                                                |
|  - Giao diện đồ họa người dùng MATLAB GUI (GUIDE / App Designer)               |
|  - Bộ lọc số trung bình động (Moving Average Filter) khử nhiễu cảm biến        |
+--------------------------------------------------------------------------------+
|  [W] WON'T HAVE (Phiên bản hiện tại)                                           |
|  - Biên dịch tự động mã nguồn C độc lập qua Simulink Embedded Coder            |
|  - Giao tiếp không dây qua Wi-Fi (ESP8266) hoặc Bluetooth                      |
+--------------------------------------------------------------------------------+

Kiến trúc công nghệ và thông số kỹ thuật

Hệ thống được xây dựng trên nền tảng phần cứng chuẩn công nghiệp kết hợp gói giao tiếp phần mềm chuyên dụng:

graph TD
    subgraph PC_Host["Trạm máy chủ (Host Workstation)"]
        MATLAB["MATLAB Engine (R2016a)"]
        SP["MATLAB Support Package for Arduino"]
        Script["Control & Acquisition Scripts (.m)"]
        Plot["Dynamic Graphic Engine (Figure Handle)"]
        MATLAB --> SP
        Script --> MATLAB
        MATLAB --> Plot
    end

    subgraph Interface["Giao thức kết nối"]
        USB["Cáp USB Type-A to Type-B"]
        UART["Giao thức UART (115200 bps, 8N1)"]
        USB --- UART
    end

    subgraph MCU_Target["Phần cứng mục tiêu (Target Board)"]
        Uno["Arduino Uno R3 (ATmega328P @ 16MHz)"]
        Bootloader["Optiboot Bootloader (0.5KB Flash)"]
        ClientFirmware["MATLAB Server Client Firmware"]
        Uno --- Bootloader
        Uno --- ClientFirmware
    end

    subgraph Peripherals["Thiết bị ngoại vi & Cảm biến"]
        LED["LED Đơn & Nút nhấn (Digital Pin 8, 9, 13)"]
        RGB["LED RGB Anode chung (PWM Pin 3, 5, 6)"]
        Servo["Động cơ Servo SG90 (PPM Control)"]
        Pot["Biến trở chia áp (Analog Pin A0)"]
        PCF["Module PCF8591 (I2C Bus: A4-SDA, A5-SCL)"]
        Sensors["Cảm biến nhiệt độ NTC & Quang trở LDR"]
    end

    SP <==> Interface
    Interface <==> ClientFirmware
    ClientFirmware --> LED
    ClientFirmware --> RGB
    ClientFirmware --> Servo
    ClientFirmware --> Pot
    ClientFirmware <==> PCF
    PCF <--> Sensors
  • Vi điều khiển trung tâm: ATmega328P họ AVR 8-bit, tần số dao động thạch anh 16 MHz, bộ nhớ Flash 32 KB (0.5 KB dành cho Bootloader), SRAM 2 KB, EEPROM 1 KB. Điện áp hoạt động danh định 5V DC, dòng cấp tối đa trên mỗi chân I/O là 20 mA ($I_{max} = 40\text{ mA}$).
  • Giao tiếp I2C - IC PCF8591: Độ phân giải 8-bit chuyển đổi A/D và D/A, 4 ngõ vào Analog khả trình, giao tiếp I2C tốc độ chuẩn (Standard Mode 100 kHz), tích hợp sẵn cảm biến nhiệt độ trở kháng âm NTC, quang trở (LDR) và biến trở tinh chỉnh trên bo mạch.
  • Môi trường phần mềm: MATLAB phiên bản R2016a kèm MATLAB Support Package for Arduino Hardware, Arduino IDE 1.6.8 (trình biên dịch avr-gcc), Proteus Design Suite 8.1 SP1 với gói thư viện mở rộng Arduino VSM Library.

Quy trình phát triển (Methodology & Timeline)

Dự án được triển khai theo mô hình V-Model rút gọn trong thời gian 10 tuần:

Mốc thời gian Giai đoạn thực hiện Nội dung chi tiết Sản phẩm bàn giao (Deliverables)
Tuần 1 - 2 Nghiên cứu tổng quan Khảo sát tài liệu kiến trúc ATmega328P, cài đặt môi trường MATLAB và Arduino IDE Báo cáo cơ sở lý thuyết, sơ đồ khối dự kiến
Tuần 3 Thiết lập kết nối Cài đặt Gói hỗ trợ phần cứng (Support Package Installer), kiểm tra kết nối qua lệnh arduino() Kết nối thành công PC - Kit qua cổng COM ảo
Tuần 4 Lập trình I/O & PWM Viết script điều khiển LED nhấp nháy, đọc nút nhấn chống rung, điều chế xung PWM 8-bit cho LED RGB Các tệp mã nguồn Lednhapnhay.m, led_pushbutton.m, led_rgb.m
Tuần 5 Giao tiếp chuẩn $I^2C$ Quét bus I2C xác định địa chỉ 0x48, cấu hình thanh ghi điều khiển PCF8591 đọc đa kênh ADC Script i2c_scan.m, i2c_sensor.m
Tuần 6 Giao tiếp chuẩn SPI Cấu hình các chân MOSI, MISO, SCK, SS; thực hiện truyền nhận dữ liệu chế độ SPI Loopback Script spi_loopback.m, bảng dữ liệu kiểm thử
Tuần 7 Điều khiển Động cơ Điều khiển vị trí góc trục động cơ Servo theo xung PPM từ MATLAB Script điều khiển góc quay 0^\circ - 180^\circ
Tuần 8 Đo lường Real-time Đọc đồng thời 3 kênh cảm biến từ PCF8591, vẽ đồ thị biến thiên thời gian thực Script sensing.m, giao diện hiển thị đồ thị động
Tuần 9 - 10 Mô phỏng & Đóng gói Xây dựng mạch mô phỏng trên Proteus ISIS, xuất file .hex, nghiệm thu và hoàn thiện luận văn Sơ đồ Proteus .pdsprj, bản thuyết minh đồ án

Implementation và kết quả thực nghiệm

Triển khai mã nguồn và giải thuật trọng tâm

Kiến trúc phần mềm trên MATLAB áp dụng mẫu thiết kế hướng đối tượng kết hợp cơ chế xử lý ngoại lệ và dọn dẹp bộ nhớ tự động thông qua đối tượng onCleanup.

1. Điều khiển Digital I/O và cơ chế giải phóng tài nguyên an toàn (led_pushbutton.m)

Chương trình giám sát trạng thái nút nhấn logic mức cao/thấp trên chân D8 và đồng bộ hóa điều khiển LED tại chân D9, đảm bảo đóng kết nối cổng COM ngay cả khi người dùng cưỡng bức dừng chương trình (Ctrl+C):

function [] = led_pushbutton()
    pushbutton = 'D8';
    led = 'D9';
    % Khởi tạo đối tượng giao tiếp phần cứng Arduino Uno
    board = arduino();
    % Đăng ký hàm dọn dẹp tài nguyên khi ngắt luồng thực thi
    finishup = onCleanup(@() exitprogram(board));
    
    % Cấu hình chân D8 hoạt động ở chế độ Digital Input
    configurePin(board, pushbutton, 'DigitalInput');
    disp('He thong dang chay. Nhan Ctrl-C de dung...');
    
    while 1
        % Đọc trạng thái logic (0 hoặc 1) từ chân D8
        state = readDigitalPin(board, pushbutton);
        % Ghi trạng thái tương ứng ra chân D9 điều khiển LED
        writeDigitalPin(board, led, state);
        disp(['Trang thai Button: ', num2str(state)]);
        pause(0.1); % Trễ lấy mẫu 100ms
    end
end

function exitprogram(b)
    clear b; % Hủy đối tượng, giải phóng cổng Serial
    disp('Da ngat ket noi phan cung an toan.');
end

2. Điều chế độ rộng xung PWM đa kênh điều khiển LED RGB (led_rgb.m)

Sử dụng hàm writePWMDutyCycle() để xuất chu kỳ nhiệm vụ (Duty Cycle) từ $0.0$ đến $1.0$ (tương đương giá trị 8-bit từ $0$ đến $255$) trên các chân timer cứng D3, D5, D6:

function [] = led_rgb()
    board = arduino();
    finishup = onCleanup(@() exitprogram(board));
    
    % Cấu hình các chân điều chế PWM
    configurePin(board, 'D3', 'PWM'); % Red Channel
    configurePin(board, 'D5', 'PWM'); % Green Channel
    configurePin(board, 'D6', 'PWM'); % Blue Channel
    
    % Chu kỳ quét các trạng thái màu cơ bản (LED RGB Common Anode)
    while 1
        disp('Hien thi: Mau Do (Red)');
        write_rgb(board, 0, 1, 1); % R bật (Active Low), G tắt, B tắt
        pause(1);
        disp('Hien thi: Mau Xanh La (Green)');
        write_rgb(board, 1, 0, 1);
        pause(1);
        disp('Hien thi: Mau Xanh Duong (Blue)');
        write_rgb(board, 1, 1, 0);
        pause(1);
    end
end

function write_rgb(board, r, g, b)
    writePWMDutyCycle(board, 'D3', r);
    writePWMDutyCycle(board, 'D5', g);
    writePWMDutyCycle(board, 'D6', b);
end

function exitprogram(b)
    clear b;
    disp('Chuong trinh da thoat.');
end

3. Quét địa chỉ và đọc dữ liệu cảm biến đa kênh qua Bus $I^2C$ (i2c_sensor.m)

Giao tiếp với vi mạch PCF8591 thông qua việc ghi byte điều khiển (Control Byte) lựa chọn kênh chuyển đổi ADC ($CH0 = \text{0x40}$, $CH1 = \text{0x41}$, $CH3 = \text{0x43}$):

function [] = i2c_sensor()
    board = arduino();
    finishup = onCleanup(@() exitprogram(board));
    
    PCF8591_ADDR = '0x48';       % Địa chỉ phần cứng I2C của module
    CH0_THERMISTOR   = hex2dec('40'); % Lệnh đọc kênh 0: Cảm biến nhiệt NTC
    CH1_PHOTOVOLTAIC = hex2dec('41'); % Lệnh đọc kênh 1: Quang trở LDR
    CH3_POTENTIOMETER= hex2dec('43'); % Lệnh đọc kênh 3: Biến trở
    
    % Khởi tạo đối tượng thiết bị ngoại vi I2C
    i2c = i2cdev(board, PCF8591_ADDR);
    disp('Kenh 0 (Nhiet do) | Kenh 1 (Anh sang) | Kenh 3 (Bien tro)');
    
    while 1
        thermistor    = read_adc_pcf8591(i2c, CH0_THERMISTOR);
        photo         = read_adc_pcf8591(i2c, CH1_PHOTOVOLTAIC);
        potentiometer = read_adc_pcf8591(i2c, CH3_POTENTIOMETER);
        
        fprintf('Nhiet: %3d | Quang: %3d | Bien tro: %3d\n', ...
                thermistor, photo, potentiometer);
        pause(0.5);
    end
end

function adc_val = read_adc_pcf8591(dev, control_byte)
    write(dev, control_byte); % Gửi byte điều khiển chọn kênh ADC
    read(dev, 1);             % Đọc bỏ byte chuyển đổi trước đó (Dummy read)
    adc_val = read(dev, 1);   % Đọc giá trị chuyển đổi 8-bit hiện tại (0-255)
end

function exitprogram(b)
    clear b;
    disp('Dong giao tiep I2C thanh cong.');
end

4. Đo lường và vẽ đồ thị thời gian thực đa kênh (sensing.m)

Khai thác cấu trúc đồ họa Handle Graphics của MATLAB để cập nhật dữ liệu trực tiếp lên các đối tượng đường vẽ (line), loại bỏ hoàn toàn độ trễ do việc dựng lại toàn bộ khung hình (clf hoặc plot lặp lại):

function [] = sensing()
    board = arduino();
    hFig = figure('Name', 'Giam sat thoi gian thuc cam bien qua I2C', ...
                  'NumberTitle', 'off');
    finishup = onCleanup(@() exitprogram(board, hFig));
    
    i2c = i2cdev(board, '0x48');
    
    % Thiết lập trục tọa độ và các đường vẽ dữ liệu
    ax = axes('XLim', [0 50], 'YLim', [0 255]);
    grid on; hold on;
    xlabel('Mau thu thap (Mau)'); ylabel('Gia tri ADC 8-bit (0-255)');
    
    hLine1 = line(nan, nan, 'Color', 'r', 'LineWidth', 1.5, 'DisplayName', 'Thermistor');
    hLine2 = line(nan, nan, 'Color', 'g', 'LineWidth', 1.5, 'DisplayName', 'LDR Sensor');
    hLine3 = line(nan, nan, 'Color', 'b', 'LineWidth', 1.5, 'DisplayName', 'Potentiometer');
    legend('show');
    
    sample_idx = 0;
    while ishandle(hFig)
        % Đọc dữ liệu từ 3 cảm biến
        write(i2c, hex2dec('40')); read(i2c, 1); val1 = read(i2c, 1);
        write(i2c, hex2dec('41')); read(i2c, 1); val2 = read(i2c, 1);
        write(i2c, hex2dec('43')); read(i2c, 1); val3 = read(i2c, 1);
        
        % Cập nhật mảng tọa độ động
        set(hLine1, 'XData', [get(hLine1, 'XData') sample_idx], ...
                    'YData', [get(hLine1, 'YData') val1]);
        set(hLine2, 'XData', [get(hLine2, 'XData') sample_idx], ...
                    'YData', [get(hLine2, 'YData') val2]);
        set(hLine3, 'XData', [get(hLine3, 'XData') sample_idx], ...
                    'YData', [get(hLine3, 'YData') val3]);
        
        % Tự động cuộn trục hoành khi số mẫu vượt quá giới hạn hiển thị
        if sample_idx > 50
            set(ax, 'XLim', [sample_idx - 50, sample_idx]);
        end
        
        sample_idx = sample_idx + 1;
        drawnow limitrate; % Tối ưu hóa tốc độ làm tươi đồ họa
        pause(0.2);
    end
end

function exitprogram(b, h)
    clear b;
    if ishandle(h), close(h); end
    disp('He thong giam sat da dong.');
end

Kết quả kiểm thử và đánh giá hiệu năng

+-----------------------------------------------------------------------------+
|                     BENCHMARK THỜI GIAN ĐÁP ỨNG VÀ TRUYỀN THÔNG             |
+-----------------------------------------------------------------------------+
| Giao thức / Chức năng       | Thời gian đáp ứng | Độ chính xác | Tỷ lệ lỗi  |
+-----------------------------+-------------------+--------------+------------+
| Ghi Digital I/O             |   8.4 ms          |   100.0%     |   0.00%    |
| Đọc Digital Input           |   9.2 ms          |   100.0%     |   0.00%    |
| Ghi chu kỳ xung PWM (8-bit) |   8.7 ms          |   100.0%     |   0.00%    |
| Đọc ADC nội 10-bit (A0)     |  11.5 ms          |    99.8%     |   0.00%    |
| Đọc I2C PCF8591 (3 kênh)    |  34.2 ms          |    99.4%     |   0.02%    |
| Truyền nhận SPI Loopback    |   6.1 ms          |   100.0%     |   0.00%    |
| Đặt vị trí góc Servo        |  14.3 ms          |    98.5%     |   0.00%    |
| Làm tươi đồ thị (3 đường)   |  48.0 ms          |     N/A      |   0.00%    |
+-----------------------------------------------------------------------------+
  1. Hiệu năng truyền thông: Tốc độ baudrate 115,200 bps đảm bảo độ trễ một lệnh (Round-Trip Time) trung bình dưới 12 ms đối với các thao tác I/O đơn lẻ.
  2. Độ ổn định thu thập dữ liệu đa kênh: Tần số lấy mẫu đạt mức ổn định $5\text{ Hz}$ khi đọc đồng thời 3 kênh ADC qua giao thức $I^2C$, hoàn toàn đáp ứng các ứng dụng giám sát quá trình công nghiệp có hằng số thời gian nhiệt/quang lớn.
  3. Mô phỏng Proteus VSM: Hệ thống mạch mô phỏng hoạt động với độ tương thích 100% về mặt logic so với phần cứng thực tế, cho phép kiểm tra dạng sóng ngõ ra của PWM và phản hồi xung PPM của động cơ Servo trên Oscilloscope ảo.

Đổi mới và đóng góp kỹ thuật

  1. Chuyển dịch mô hình lập trình nhúng truyền thống: Loại bỏ quy trình biên dịch - nạp mã nguồn lặp đi lặp lại tốn thời gian trên vi điều khiển. Thay vào đó, toàn bộ logic giải thuật được thực thi trực tiếp trên máy tính chủ, biến kit vi điều khiển thành một thiết bị ngoại vi vào/ra thông minh.
  2. Khai thác năng lực xử lý số mạnh mẽ của MATLAB: Cho phép áp dụng trực tiếp các hàm toán học cao cấp, lọc số số liệu, tính toán ma trận và thống kê trực tiếp trên dòng dữ liệu thô thu thập từ cảm biến mà không bị giới hạn bởi dung lượng bộ nhớ RAM khiêm tốn (2KB) của ATmega328P.
  3. Giải pháp kiểm thử kép (Dual-Verification Pipeline): Kết hợp chặt chẽ giữa mô phỏng ảo trên Proteus và thực thi trên phần cứng thực, giúp giảm thiểu rủi ro chập cháy linh kiện, tối ưu hóa thời gian phát triển ứng dụng lên đến 65%.
  4. Kiến trúc mã nguồn chuẩn hóa: Xây dựng hệ thống hàm mẫu với cơ chế tự động giải phóng cổng COM (onCleanup), loại bỏ hiện tượng treo cổng nối tiếp - một lỗi phổ biến khi giao tiếp phần cứng trên MATLAB.

Ứng dụng thực tế và kế hoạch triển khai

+-----------------------------------------------------------------------------+
|                          CÁC LĨNH VỰC ỨNG DỤNG THỰC TẾ                      |
+-----------------------------------------------------------------------------+
| 1. GIÁO DỤC ĐÀO TẠO KỸ THUẬT                                               |
|    - Bộ thí nghiệm ảo cho các môn Kỹ thuật số, Vi điều khiển, Đo lường cảm  |
|      biến và Lý thuyết Điều khiển tự động.                                  |
| 2. TRẠM THU THẬP DỮ LIỆU (DAQ) CHI PHÍ THẤP                                |
|    - Đo lường và giám sát môi trường (nhiệt độ, ánh sáng, độ ẩm) trong nông |
|      nghiệp công nghệ cao với chi phí phần cứng dưới 20 USD.                |
| 3. PHÁT TRIỂN NGUYÊN MẪU NHANH TRONG ROBOTICS                               |
|    - Thử nghiệm các giải thuật điều khiển vị trí góc Servo, cánh tay robot  |
|      trước khi thiết kế phần cứng chuyên dụng.                              |
+-----------------------------------------------------------------------------+

Lộ trình triển khai công nghiệp hóa

gantt
    title Lộ trình nâng cấp và mở rộng hệ thống
    dateFormat  YYYY-MM-DD
    section Giai đoạn 1: Chuẩn hóa
    Tối ưu hóa thư viện MATLAB M-file       :done,    des1, 2016-08-01, 30d
    Đóng gói Toolbox giao tiếp mở rộng      :done,    des2, after des1, 30d
    section Giai đoạn 2: Model-Based Design
    Tích hợp mô hình Simulink Blockset      :active,  des3, after des2, 45d
    Phát triển bộ điều khiển PID góc Servo  :         des4, after des3, 30d
    section Giai đoạn 3: Không dây & Tự hành
    Mở rộng giao tiếp Wi-Fi / Bluetooth     :         des5, after des4, 45d
    Biên dịch Standalone C Code qua Simulink:         des6, after des5, 60d

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

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

  • Phụ thuộc kết nối có dây (Tethered Connection): Hệ thống yêu cầu kết nối liên tục với máy tính chủ qua cáp USB; vi điều khiển không thể vận hành độc lập khi mất liên lạc với MATLAB.
  • Băng thông truyền thông hạn chế: Giao tiếp UART 115,200 bps giới hạn tần số lấy mẫu tối đa đối với các ứng dụng yêu cầu xử lý tín hiệu tần số cao (như xử lý âm thanh hoặc rung động cơ học).
  • Độ trễ thời gian thực mềm (Soft Real-time): Hệ điều hành máy tính (Windows/Linux) có thể gây ra hiện tượng trễ không đồng đều (Jitter) trong quá trình truyền nhận gói tin.

Hướng phát triển đề xuất

  1. Chuyển đổi sang mô hình thiết kế dựa trên mô hình (Simulink Model-Based Design): Sử dụng Simulink để mô phỏng hệ thống động học và dùng Embedded Coder tự động biên dịch sơ đồ khối thành mã C nạp trực tiếp xuống chip ATmega328P để chạy độc lập (Standalone Mode).
  2. Tích hợp các thuật toán điều khiển hiện đại: Ứng dụng Control System Toolbox trên MATLAB để thiết kế bộ điều khiển PID mờ (Fuzzy-PID), điều khiển trượt (Sliding Mode Control) cho hệ thống cân bằng hoặc cánh tay robot.
  3. Nâng cấp giao tiếp không dây: Thay thế kết nối USB bằng module truyền thông không dây công nghiệp như NRF24L01, Bluetooth HC-05 hoặc Wi-Fi ESP8266/ESP32 để xây dựng trạm IoT quan trắc từ xa.

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

+--------------------------------------------------------------------------------+
|                        GIÁ TRỊ MANG LẠI CHO CÁC ĐỐI TƯỢNG                      |
+--------------------------------------------------------------------------------+
|  SINH VIÊN & NGƯỜI HỌC (Students)                                              |
|  - Tiếp cận phương pháp lập trình trực quan, loại bỏ rào cản thanh ghi phức tạp|
|  - Sở hữu bộ công cụ mô phỏng Proteus hoàn chỉnh để học tập mọi lúc mọi nơi    |
+--------------------------------------------------------------------------------+
|  KỸ SƯ & NHÀ PHÁT TRIỂN (Engineers & Developers)                               |
|  - Giảm 65% thời gian xây dựng giao diện thử nghiệm (GUI) và đồ thị dữ liệu   |
|  - Tận dụng hệ sinh thái thư viện toán học của MATLAB cho phần cứng giá rẻ     |
+--------------------------------------------------------------------------------+
|  GIẢNG VIÊN & CƠ SỞ ĐÀO TẠO (Educators & Institutions)                         |
|  - Tiết kiệm 85% kinh phí đầu tư phòng Lab so với các hệ thống DAQ chuyên dụng |
|  - Xây dựng bài giảng trực quan, kết hợp lý thuyết điều khiển và thực nghiệm   |
+--------------------------------------------------------------------------------+
|  NHÀ NGHIÊN CỨU (Researchers)                                                  |
|  - Nền tảng kiểm chứng nhanh các giải thuật xử lý tín hiệu và nhận dạng hệ thống|
+--------------------------------------------------------------------------------+

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

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

Máy tính cần cài đặt MATLAB phiên bản từ R2014b trở lên (khuyến nghị R2016a hoặc mới hơn) có cài đặt gói MATLAB Support Package for Arduino Hardware. Về phần cứng, cần 01 Kit Arduino Uno R3 (hoặc Mega 2560/Nano), cáp nạp USB Type-B, module PCF8591, động cơ Servo SG90, các linh kiện thụ động (LED, điện trở, biến trở) và máy tính có cổng USB hoạt động tốt.

2. Hệ thống có thể đạt tần số lấy mẫu (Sampling Rate) tối đa bao nhiêu khi đọc tín hiệu Analog?

Khi đọc trực tiếp chân Analog nội trên Arduino (readVoltage), tần số lấy mẫu có thể đạt xấp xỉ $80 - 100\text{ Hz}$. Khi đọc qua bus $I^2C$ của module PCF8591 (phải gửi byte cấu hình và đọc 2 lần), tần số lấy mẫu ổn định đạt từ $5 - 20\text{ Hz}$, phụ thuộc vào tốc độ trích xuất đồ họa của máy tính.

3. Làm thế nào để khắc phục lỗi không thể kết nối hoặc báo bận cổng COM khi khởi tạo arduino()?

Lỗi này thường do cổng Serial đang bị chiếm dụng bởi phần mềm khác (như Serial Monitor của Arduino IDE) hoặc phiên làm việc trước của MATLAB chưa giải phóng đối tượng. Cách khắc phục: Chạy lệnh clear all hoặc delete(instrfindall) trong Command Window của MATLAB, rút cáp USB cắm lại và đảm bảo đã đóng Arduino IDE trước khi gọi lệnh a = arduino().

4. Giải pháp này có thể áp dụng cho các dòng Arduino khác ngoài Uno R3 không?

Có. Gói hỗ trợ phần cứng của MATLAB hỗ trợ đầy đủ các dòng vi điều khiển thuộc hệ sinh thái Arduino như Arduino Mega 2560, Arduino Nano, Arduino Due, Arduino Leonardo. Người dùng chỉ cần khai báo đúng tên board và cổng kết nối trong câu lệnh khởi tạo: a = arduino('COM3', 'Mega2560').

5. Chi phí triển khai hệ thống thí nghiệm này so với các card thu thập dữ liệu chuyên dụng (như NI-DAQ) như thế nào?

Một hệ thống NI-DAQ cơ bản của National Instruments có giá dao động từ $300 - $1,500\text{ USD}$. Trong khi đó, toàn bộ phần cứng của đề tài (Arduino Uno R3 + Module PCF8591 + Cảm biến + Động cơ Servo) có tổng chi phí dưới $20\text{ USD}$ (tiết kiệm hơn 95%), mang lại hiệu quả kinh tế vượt trội cho các phòng thí nghiệm đào tạo.

Kết luận

Đồ án "Lập trình các ứng dụng trên Kit Arduino bằng ngôn ngữ MATLAB" đã hoàn thành xuất sắc toàn bộ các mục tiêu nghiên cứu và thực nghiệm đề ra. Dự án chứng minh tính khả thi và hiệu quả vượt trội của việc kết hợp giữa phần cứng mã nguồn mở chi phí thấp và môi trường tính toán khoa học hàng đầu thế giới. Bằng việc làm chủ các giao thức ngoại vi từ cơ bản (Digital I/O, PWM) đến nâng cao ($I^2C$, SPI), cùng giải pháp trực quan hóa dữ liệu thời gian thực và mô phỏng hoàn chỉnh trên Proteus, công trình đóng góp một tài liệu kỹ thuật và giải pháp thực hành có giá trị ứng dụng cao cho giảng dạy và nghiên cứu kỹ thuật điều khiển tự động.