Giới thiệu dự án

Sự bùng nổ của phương tiện giao thông chạy điện (Electric Vehicles - EV) và các dòng xe máy điện thông minh đặt ra yêu cầu cấp thiết về việc hiện đại hóa mạng lưới điện tử trên xe. Trên các phương tiện truyền thống, hệ thống dây dẫn analog kết nối điểm - điểm (point-to-point) khiến khối lượng bó dây tăng vọt (chiếm tới 30-50 kg trên ô tô và 3-5 kg trên xe máy), làm tăng chi phí sản xuất, phức tạp hóa việc bảo trì và dễ bị ảnh hưởng bởi nhiễu điện từ trường (Electromagnetic Interference - EMI). Để giải quyết triệt để vấn đề này, mạng truyền thông CAN (Controller Area Network) theo tiêu chuẩn quốc tế ISO 11898 trở thành chuẩn kết nối xương sống nhờ cấu trúc bus 2 dây vi sai kháng nhiễu vượt trội và khả năng truyền dữ liệu thời gian thực tin cậy cao.

Đồ án tốt nghiệp "Nghiên cứu, thiết kế giao diện hiển thị thông số xe máy điện ứng dụng giao tiếp CAN" (thực hiện bởi sinh viên An Lê Tuấn Anh và Nguyễn Huy Nghiêm, Trường Đại học Sư phạm Kỹ thuật TP.HCM, dưới sự hướng dẫn của TS. Lê Thanh Phúc) tập trung giải quyết bài toán thu thập, phân xử và hiển thị trực quan các thông số vận hành của xe máy điện thông qua mạng CAN.

+-------------------------------------------------------------------------------+
|                       HỆ THỐNG HIỂN THỊ XE MÁY ĐIỆN                           |
|                                                                               |
|  [Cảm biến / Biến trở]                                                        |
|  [Công tắc đèn / Còi ] ---> [Arduino Uno 1] ---> [MCP2515]                    |
|                                                     |                         |
|                                               CAN Bus (2 dây)                 |
|                                              (CAN_H / CAN_L)                  |
|                                                     |                         |
|  [Màn hình Tablo PC]  <--- [Arduino Uno 2] <--- [MCP2515]                    |
|  (Python Dashboard)        (Gateway/Serial)                                   |
+-------------------------------------------------------------------------------+

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

  1. Nghiên cứu toàn diện cơ sở lý thuyết về giao thức CAN (tiêu chuẩn ISO 11898, phiên bản CAN 2.0A và CAN 2.0B) và phương thức truyền thông ngoại vi SPI (Serial Peripheral Interface).
  2. Thiết kế và chế tạo phần cứng 2 node mạng CAN sử dụng vi điều khiển ATmega328P (Arduino Uno R3) kết hợp chip điều khiển CAN MCP2515 và bộ thu phát TJA1050.
  3. Xây dựng giao diện hiển thị bảng đồng hồ kỹ thuật số (Digital Instrument Cluster/Tablo) bằng ngôn ngữ lập trình Python, bao gồm màn hình chính và màn hình phụ.
  4. Lập trình giả lập, thu thập và truyền nhận dữ liệu vi sai thời gian thực cho các thông số: tốc độ xe (speedometer), điện áp/dung lượng pin (SOC - State of Charge), trạng thái đèn pha/cos, đèn báo rẽ (xi-nhan) và đèn cảnh báo nguy hiểm.

Phạm vi và giới hạn đề tài:

  • Phạm vi: Xây dựng mô hình thực nghiệm giả lập Hardware-in-the-Loop (HIL) hoàn chỉnh trên băng ghế thử nghiệm, kết nối hiển thị lên máy tính qua cổng nối tiếp USB-UART.
  • Giới hạn: Tín hiệu cảm biến vận tốc và nguồn pin được mô phỏng thông qua các biến trở xoay (potentiometers); giao tiếp hiển thị sử dụng màn hình Desktop máy tính cá nhân thay vì màn hình nhúng chuyên dụng trên xe.

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

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

Trước khi chuẩn hóa giao thức mạng nội bộ xe, các nhà sản xuất phải lựa chọn giữa các phương thức giao tiếp truyền thống với nhiều hạn chế cố hữu:

Tiêu chí CAN Bus (ISO 11898) UART / RS-232 LIN Bus (Local Interconnect) Dây Analog truyền thống
Kiến trúc mạng Đa chủ (Multi-master Bus) Điểm - Điểm (Point-to-Point) Đơn chủ / Đa tớ (Master-Slave) Độc lập song song
Số lượng dây dẫn 2 dây xoắn (CAN_H, CAN_L) 3 dây (Tx, Rx, GND) 1 dây đơn Hàng chục đến hàng trăm dây
Tốc độ truyền dữ liệu 125 kbps – 1 Mbps 9.6 kbps – 115.2 kbps Tối đa 20 kbps Không áp dụng (tín hiệu điện áp)
Khả năng kháng nhiễu Cực cao (Điện áp vi sai) Thấp (Điện áp đơn cực) Trung bình Kém (Dễ suy hao, sai lệch áp)
Cơ chế phát hiện lỗi CRC 15-bit, Bit stuffing, ACK Parity bit đơn giản Checksum 8-bit Không có
Chi phí triển khai Trung bình Thấp Rất thấp Rất cao (chi phí dây & nhân công)

Phân tích yêu cầu hệ thống theo mô hình MoSCoW:

  • Must-have (Bắt buộc): Truyền nhận dữ liệu không mất gói giữa 2 node qua CAN bus ở tốc độ 500 kbps; hiển thị kim đồng hồ tốc độ (0–120 km/h), mức pin (0–100%), đèn xi-nhan trái/phải, đèn pha.
  • Should-have (Cần có): Giao diện đồ họa đa màn hình (Tablo chính và Tablo phụ thông số chi tiết); độ trễ hiển thị dưới 50 ms.
  • Could-have (Có thể có): Ghi log dữ liệu ra file CSV và hiển thị đồ thị điện áp vi sai CAN.
  • Won't-have (Chưa triển khai): Cập nhật phần mềm qua mạng CAN (Firmware Update over CAN/UDS).

Thiết kế hệ thống

Kiến trúc hệ thống bao gồm hai khối phần cứng độc lập và một khối hiển thị phần mềm:

[Khối Thu Thập Dữ Liệu: Node 1]
    [Bus CAN 2 dây vi sai - Trở đầu cuối 120 Ohm]
[Khối Thu Nhận & Gateway: Node 2]
[Khối Xử Lý & Hiển Thị: PC/Host]

Ngăn xếp công nghệ (Technology Stack):

  • Phần cứng vi điều khiển: 02 bo mạch Arduino Uno R3 (Vi điều khiển ATmega328P, điện áp hoạt động 5V, thạch anh 16 MHz).
  • Bộ điều khiển CAN độc lập: Microchip MCP2515 (Hỗ trợ chuẩn CAN 2.0B, tốc độ truyền lên đến 1 Mbps, giao tiếp SPI tốc độ 10 MHz, 3 bộ đệm truyền TXB0-TXB2, 2 bộ đệm nhận RXB0-RXB1 với 6 bộ lọc filter RXF0-RXF5).
  • Bộ thu phát CAN (Transceiver): NXP/Philips TJA1050 (Chuyển đổi mức logic số sang điện áp vi sai đường truyền).
  • Môi trường lập trình nhúng: Arduino IDE v2.1.x, thư viện mcp_can.
  • Môi trường phát triển giao diện: Python v3.9.x, thư viện pyserial, tkinter, pygame, math, time.
  • Thiết kế cơ khí khung vỏ: Autodesk AutoCAD 2021 (thiết kế khung gá tablo kích thước chuẩn bàn thử nghiệm).

Cấu trúc bức điện (CAN 2.0A Standard Data Frame Format):

Hệ thống sử dụng khung truyền chuẩn (Standard Frame) với mã định danh 11-bit Identifier 0x0F6:

+-----+---------------+-----+-----+------------------------+----------+-----+-----+
| SOF | CAN-ID (11b)  | RTR | IDE | Control (DLC = 8 Bytes)| Data(8B) | CRC | ACK |
+-----+---------------+-----+-----+------------------------+----------+-----+-----+
  • Byte 0: Tốc độ tức thời của xe (Giá trị: 0 – 120 km/h, độ phân giải 1 km/h).
  • Byte 1: Mức dung lượng pin SOC (Giá trị: 0 – 100%, độ phân giải 1%).
  • Byte 2: Nhiệt độ động cơ / Bộ điều khiển (Giá trị: 0 – 150 °C).
  • Byte 3: Trạng thái tín hiệu nhị phân (Bitmask):
    • Bit 0: Đèn báo rẽ trái (0: Tắt, 1: Bật)
    • Bit 1: Đèn báo rẽ phải (0: Tắt, 1: Bật)
    • Bit 2: Đèn chiếu xa/gần (0: Cos, 1: Pha)
    • Bit 3: Đèn cảnh báo nguy hiểm Hazard (0: Tắt, 1: Bật)
  • Byte 4 – Byte 7: Dữ liệu dự phòng (Odometer/Quãng đường tích lũy, mã lỗi chẩn đoán DTC).

Phương pháp nghiên cứu và phát triển (Methodology)

Dự án áp dụng mô hình phát triển hệ thống V-Model thu nhỏ:

  1. Giai đoạn 1 (Tuần 1 - 3): Khảo sát tài liệu giao thức ISO 11898-2 (CAN High-Speed), tính toán điện trở bus (120 $\Omega$ tại hai điểm mút), phân tích thời gian bit (Bit timing: Sync_Seg, Prop_Seg, Phase_Seg1, Phase_Seg2).
  2. Giai đoạn 2 (Tuần 4 - 7): Lắp ráp mạch phần cứng, đấu nối bus SPI giữa ATmega328P và MCP2515 (chân SCK -> Pin 13, MISO -> Pin 12, MOSI -> Pin 11, CS -> Pin 10, INT -> Pin 2).
  3. Giai đoạn 3 (Tuần 8 - 11): Lập trình firmware truyền/nhận dữ liệu CAN trên Arduino; tối ưu hóa thuật toán lọc mặt nạ (Masks/Filters); phát triển giao diện GUI Python vẽ kim đồng hồ bằng hàm lượng giác ($\sin/\cos$) theo thời gian thực.
  4. Giai đoạn 4 (Tuần 12 - 14): Tích hợp toàn hệ thống, kiểm thử độ trễ, đánh giá hiện tượng trôi khung truyền và đóng gói hoàn thiện mô hình.

Implementation và kết quả

Quá trình phát triển phần mềm

1. Lập trình Firmware Node 1 (Truyền dữ liệu CAN - Transmitter):

Node 1 thực hiện quét tín hiệu ADC từ các biến trở (0-1023 tương ứng 0-5V), chuyển đổi sang đơn vị vật lý, đọc trạng thái các chân digital input nút nhấn và đóng gói vào bức điện CAN.

#include <SPI.h>
#include <mcp_can.h>

const int SPI_CS_PIN = 10;
MCP_CAN CAN(SPI_CS_PIN);

unsigned char canData[8] = {0, 0, 0, 0, 0, 0, 0, 0};

void setup() {
    Serial.begin(115200);
    // Khởi tạo MCP2515 với thạch anh 8MHz, tốc độ bus 500kbps
    while (CAN_OK != CAN.begin(MCP_ANY, CAN_500KBPS, MCP_8MHZ)) {
        delay(100);
    }
    CAN.setMode(MCP_NORMAL); // Chuyển sang chế độ hoạt động bình thường
}

void loop() {
    int rawSpeed = analogRead(A0);
    int rawBattery = analogRead(A1);
    
    // Scale dữ liệu sang dải hiển thị vật lý
    canData[0] = map(rawSpeed, 0, 1023, 0, 120);     // Tốc độ: 0 - 120 km/h
    canData[1] = map(rawBattery, 0, 1023, 0, 100);   // Mức Pin: 0 - 100%
    canData[2] = 45;                                 // Nhiệt độ mô phỏng 45°C
    
    byte statusFlags = 0;
    if (digitalRead(3) == LOW) statusFlags |= (1 << 0); // Xi-nhan trái
    if (digitalRead(4) == LOW) statusFlags |= (1 << 1); // Xi-nhan phải
    if (digitalRead(5) == LOW) statusFlags |= (1 << 2); // Đèn pha
    canData[3] = statusFlags;

    // Gửi bản tin CAN ID 0x0F6, Standard Frame (0), độ dài 8 byte
    byte sndStat = CAN.sendMsgBuf(0x0F6, 0, 8, canData);
    delay(20); // Chu kỳ truyền 50Hz (20ms/frame)
}

2. Lập trình Firmware Node 2 (Thu nhận CAN & Chuyển tiếp Serial):

Node 2 nhận bản tin CAN bằng cơ chế ngắt (Interrupt Pin D2), kiểm tra ID, giải mã và gửi chuỗi ký tự định dạng chuẩn qua cổng USB Serial lên máy tính:

#include <SPI.h>
#include <mcp_can.h>

const int SPI_CS_PIN = 10;
MCP_CAN CAN(SPI_CS_PIN);

void setup() {
    Serial.begin(115200);
    CAN.begin(MCP_ANY, CAN_500KBPS, MCP_8MHZ);
    CAN.setMode(MCP_NORMAL);
}

void loop() {
    long unsigned int rxId;
    unsigned char len = 0;
    unsigned char rxBuf[8];

    if (CAN_MSGAVAIL == CAN.checkReceive()) {
        CAN.readMsgBuf(&rxId, &len, rxBuf);
        if (rxId == 0x0F6) {
            // Định dạng chuỗi gửi lên Python: "SPEED,BATTERY,TEMP,STATUS\n"
            Serial.print(rxBuf[0]); Serial.print(",");
            Serial.print(rxBuf[1]); Serial.print(",");
            Serial.print(rxBuf[2]); Serial.print(",");
            Serial.println(rxBuf[3]);
        }
    }
}

3. Thuật toán vẽ giao diện Tablo trên Python:

Giao diện đồ họa sử dụng công thức lượng giác để tính toán tọa độ đầu kim đồng hồ: $$x = x_{center} + R \cdot \cos(\theta)$$ $$y = y_{center} + R \cdot \sin(\theta)$$ Trong đó góc $\theta$ được nội suy tuyến tính từ giá trị vận tốc đo được ($0 - 120\text{ km/h}$ tương ứng với góc quét $135^\circ$ đến $405^\circ$).

import serial
import math
import tkinter as tk

ser = serial.Serial('COM3', 115200, timeout=0.1)

def update_dashboard():
    if ser.in_waiting:
        line = ser.readline().decode('utf-8').strip()
        data = line.split(',')
        if len(data) == 4:
            speed = float(data[0])
            battery = float(data[1])
            flags = int(data[3])
            
            # Tính toán góc quét kim đồng hồ (từ 135 độ đến 405 độ)
            angle = 135 + (speed / 120.0) * 270
            rad = math.radians(angle)
            center_x, center_y, radius = 250, 250, 150
            x_end = center_x + radius * math.cos(rad)
            y_end = center_y + radius * math.sin(rad)
            
            canvas.coords(needle_line, center_x, center_y, x_end, y_end)
            speed_text.config(text=f"{int(speed)} km/h")
            battery_label.config(text=f"BATTERY: {int(battery)}%")
            
    root.after(20, update_dashboard) # Tần số quét 50 FPS

Kết quả đo kiểm và thực nghiệm

  1. Kiểm tra mức điện áp vật lý trên đường truyền vi sai (High-Speed CAN):

    • Trạng thái lặn (Recessive state - Logic 1): $V_{CAN_H} \approx 2.50\text{ V}$, $V_{CAN_L} \approx 2.50\text{ V} \rightarrow V_{diff} = 0.00\text{ V}$.
    • Trạng thái trội (Dominant state - Logic 0): $V_{CAN_H} \approx 3.52\text{ V}$, $V_{CAN_L} \approx 1.48\text{ V} \rightarrow V_{diff} = 2.04\text{ V}$.
    • Trở kháng đo đạc giữa 2 dây bus (khi ngắt nguồn): $R_{bus} = 60.3\text{ }\Omega$ (2 điện trở $120\text{ }\Omega$ mắc song song tại 2 đầu bus), đạt tiêu chuẩn ISO 11898-2.

  2. Chỉ số hiệu năng truyền nhận:

    • Tần số gửi tin: 50 Hz (chu kỳ 20 ms/bản tin).
    • Tỷ lệ mất gói (Packet Loss Rate): Dưới $0.05%$ khi đo kiểm liên tục 100.000 frame trên đường truyền có nối đất chống nhiễu.
    • Độ trễ toàn trình (End-to-End Latency): Từ lúc thay đổi biến trở đến khi kim đồng hồ Python phản hồi $\approx 28.5\text{ ms}$ (đạt chuẩn thời gian thực cho hệ thống hiển thị lái xe).

Đổi mới và đóng góp

  1. Thay thế kiến trúc tập trung cồng kềnh bằng cấu trúc mạng phân tán chi phí thấp: Thay vì phải sử dụng các máy tính nhúng đắt tiền như Raspberry Pi 4 (vốn tiêu thụ điện năng lớn và khởi động chậm) để đọc trực tiếp mọi cảm biến, đề tài áp dụng cấu trúc 2 Node vi điều khiển nhúng chuyên dụng kết hợp CAN Controller rời MCP2515. Chi phí phần cứng giảm hơn $70%$ so với việc sử dụng máy tính công nghiệp.

  2. Cơ chế phân xử không phá hủy (Non-destructive Bitwise Arbitration): Hệ thống ứng dụng cơ chế phân xử theo mức ưu tiên ID của chuẩn CAN. Khi nhiều tín hiệu cùng phát (ví dụ: cảnh báo phanh khẩn cấp và thông số tốc độ), bản tin có ID nhỏ hơn sẽ chiếm quyền điều khiển đường truyền mà không làm hỏng dữ liệu hay gây tắc nghẽn bus, đảm bảo tính an toàn nghiêm ngặt cho xe máy điện.

  3. Cắt giảm dây dẫn và tối ưu hóa không gian cơ khí: Toàn bộ hệ thống tín hiệu từ cảm biến động cơ, pin và hệ thống đèn chỉ cần truyền tải qua 01 cặp dây xoắn duy nhất từ thân xe lên cụm đồng hồ táp-lô trên ghi-đông, giúp giảm $65%$ khối lượng dây điện trên đầu xe máy điện.

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

Kịch bản ứng dụng thực tế

  • Cụm đồng hồ hiển thị thông minh (Digital Cluster) cho xe máy điện thương mại: Ứng dụng trực tiếp trên các dòng xe máy điện đô thị (E-scooter), kết nối với khối quản lý pin (BMS - Battery Management System) và bộ điều khiển động cơ (MCU - Motor Controller Unit) qua mạng CAN để hiển thị dòng xả, nhiệt độ cell pin, quãng đường còn lại và mã lỗi động cơ.
  • Bàn thí nghiệm đào tạo sinh viên ngành Kỹ thuật Ô tô: Làm mô hình học cụ trực quan giúp người học đo kiểm dạng sóng điện áp vi sai CAN_H, CAN_L bằng máy hiện sóng (Oscilloscope), phân tích các dạng khung truyền (Data Frame, Remote Frame, Error Frame).
+-------------------------------------------------------------------------------+
|                       LỘ TRÌNH THƯƠNG MẠI HÓA HỆ THỐNG                        |
|                                                                               |
|  [Giai đoạn 1]  Nghiên cứu & Thực nghiệm trên Arduino + Python PC (Đã đạt)   |
|  [Giai đoạn 2]  Chuyển đổi sang STM32F4 / ESP32-S3 + Màn hình màu LCD/TFT    |
|  [Giai đoạn 3]  Tích hợp GUI nhúng (LVGL Library) & Đóng gói chuẩn IP67       |
|  [Giai đoạn 4]  Thử nghiệm trên xe thương mại & Đạt chuẩn chống nhiễu EMC     |
+-------------------------------------------------------------------------------+

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

Hạn chế kỹ thuật

  • Độ trễ do lớp chuyển đổi USB-UART: Việc trung chuyển dữ liệu từ Arduino Node 2 qua cổng Serial USB lên máy tính PC làm phát sinh độ trễ phụ (khoảng 8-15 ms) và phụ thuộc vào hệ điều hành của máy tính.
  • Nhiễu điện từ ở môi trường công suất lớn: Mô hình mới được thử nghiệm trong phòng lab với tải giả biến trở. Khi đưa lên xe máy điện thực tế, xung nhiễu tần số cao từ bộ nghịch lưu IGBT (Inverter) của động cơ BLDC có thể gây sai số nếu đường truyền không có lớp bọc kim chống nhiễu (Shielded Twisted Pair - STP).

Hướng phát triển

  1. Nâng cấp vi điều khiển lên chip 32-bit (STM32 hoặc ESP32 tích hợp sẵn bộ điều khiển CAN nội) kết hợp màn hình LCD màu tròn chuyên dụng cho xe máy điện, loại bỏ hoàn toàn máy tính PC.
  2. Tích hợp giao thức chẩn đoán lỗi tiêu chuẩn OBD-II / UDS (ISO 14229) để đọc và xóa mã lỗi DTC của xe trực tiếp trên màn hình.
  3. Nâng cấp lên chuẩn CAN FD (Flexible Data-rate) để tăng tốc độ truyền lên tới 2–5 Mbps, đáp ứng các tính năng dẫn đường GPS và định vị thời gian thực.

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

  • Sinh viên và Nghiên cứu sinh ngành Ô tô / Cơ điện tử: Cung cấp tài liệu tham khảo chi tiết, mã nguồn mẫu và phương pháp luận rõ ràng về việc tích hợp mạng CAN và giao tiếp SPI trên vi điều khiển.
  • Kỹ sư phát triển hệ thống nhúng ô tô (Automotive Embedded Engineers): Nắm bắt kỹ thuật xây dựng hệ thống phần cứng phân tán, định dạng gói tin và xử lý giao diện hiển thị dữ liệu telematics thời gian thực.
  • Nhà sản xuất xe điện cỡ nhỏ (LEV Manufacturers): Mô hình kiến trúc chi phí thấp giúp tối ưu hóa giá thành sản xuất cụm đồng hồ táp-lô cho các dòng xe điện thông minh phân khúc phổ thông.

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

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

Cần tối thiểu 02 bo mạch vi điều khiển (như Arduino Uno/Nano hoặc STM32), 02 module CAN MCP2515 kèm bộ thu phát TJA1050, 01 dây xoắn đôi trở kháng $120\text{ }\Omega$, 02 điện trở đầu cuối $120\text{ }\Omega$, biến trở và máy tính có cài đặt Python 3.8+ cùng các thư viện pyserial, tkinter.

2. Mạng CAN trong đồ án có thể kết nối tối đa bao nhiêu node trên cùng một đường truyền?

Theo lý thuyết của tiêu chuẩn ISO 11898-2 và giới hạn tải của chip thu phát TJA1050, bus CAN có thể hỗ trợ tối đa 112 node trên một mạng duy nhất mà vẫn đảm bảo tính toàn vẹn tín hiệu.

3. Tại sao phải lắp 2 điện trở đầu cuối 120 $\Omega$ ở hai đầu của bus CAN?

Hai điện trở đầu cuối $120\text{ }\Omega$ (tổng trở song song là $60\text{ }\Omega$) có nhiệm vụ phối hợp trở kháng với đường dây xoắn đôi, giúp triệt tiêu hiện tượng phản xạ sóng điện từ tại các điểm cuối của bus, ngăn ngừa biến dạng tín hiệu và suy hao gói tin ở tốc độ cao.

4. Hệ thống xử lý lỗi trên đường truyền CAN như thế nào nếu một node bị hỏng?

CAN tích hợp cơ chế tự giám sát lỗi (Fault Confinement). Khi một node gặp sự cố liên tục, bộ đếm lỗi TEC/REC của MCP2515 sẽ tăng lên, tự động chuyển node từ trạng thái Error Active sang Error Passive, và cuối cùng là Bus-Off (tự cô lập khỏi mạng) để không làm tê liệt đường truyền của các node còn lại.

5. Chi phí gia công và thời gian lắp ráp mô hình thực nghiệm là bao nhiêu?

Tổng chi phí linh kiện phần cứng (2 Arduino, 2 MCP2515, dây nối, biến trở, nút nhấn và khung mica cắt CNC theo bản vẽ AutoCAD) chưa tới 600.000 VNĐ. Thời gian lắp ráp và nạp code hoàn thiện mất khoảng 2-4 giờ làm việc.

Kết luận

Đề tài "Nghiên cứu, thiết kế giao diện hiển thị thông số xe máy điện ứng dụng giao tiếp CAN" đã giải quyết trọn vẹn và thành công bài toán thu thập, truyền dẫn và biểu diễn dữ liệu đo từ xa (telemetry) trên xe máy điện. Bằng việc làm chủ công nghệ CAN bus theo tiêu chuẩn quốc tế ISO 11898 kết hợp chip điều khiển MCP2515 và ngôn ngữ lập trình Python, đồ án không chỉ chứng minh tính ưu việt của mạng truyền thông vi sai trong việc cắt giảm dây dẫn và chống nhiễu mà còn tạo ra một nền tảng thực nghiệm có tính ứng dụng sư phạm và khả năng thương mại hóa cao cho ngành công nghiệp xe điện hiện đại.