Bài 4: Lập trình ESP32 + Điều khiển Motor

→ Điều khiển được 4 Motor Drone Mini ESP32

Sau khi đã tìm hiểu tay cầm ESP32 ở Bài 2 và phần cứng Drone ESP32 ở Bài 3, chúng ta bắt đầu bước vào phần quan trọng nhất của lập trình Drone:

Điều khiển 4 động cơ bằng ESP32.

Trong bài này, mục tiêu chưa phải làm cho Drone bay. Chúng ta sẽ xây dựng nền tảng điều khiển motor trước:

ESP32 → PWM → Mạch công suất → Motor 1–4

Khi 4 motor có thể hoạt động độc lập và được điều chỉnh tốc độ, chúng ta mới có cơ sở để thực hiện Motor Mixing, MPU6050 và điều khiển Roll/Pitch/Yaw ở các bài sau.

1. Mục tiêu của Bài 4

Sau khi hoàn thành bài học, học viên có thể:

• Hiểu cách ESP32 điều khiển motor.
• Hiểu khái niệm PWM.
• Phân biệt tín hiệu điều khiển và công suất motor.
• Điều khiển từng motor riêng biệt.
• Điều chỉnh tốc độ motor.
• Điều khiển đồng thời 4 motor.
• Kiểm tra chiều quay và phản hồi của từng motor.
• Chuẩn bị dữ liệu cho thuật toán Motor Mixing.

Mục tiêu cuối bài:

ESP32
  │
  ├── PWM → Motor 1
  ├── PWM → Motor 2
  ├── PWM → Motor 3
  └── PWM → Motor 4

2. ESP32 có trực tiếp cấp điện cho Motor không?

Đây là kiến thức rất quan trọng.

Không nên kết nối trực tiếp motor Drone vào GPIO của ESP32.

GPIO của ESP32 chủ yếu tạo ra tín hiệu điều khiển.

Motor lại cần dòng điện lớn hơn nhiều so với khả năng cung cấp trực tiếp của GPIO.

Do đó, hệ thống cần tầng công suất.

             ESP32
               │
          Tín hiệu PWM
               ↓
        MOSFET / Driver
               ↓
             Motor
               ↓
            Cánh quạt

Với loại Drone Mini sử dụng motor DC chổi than như mẫu trong khóa học, mạch công suất trên PCB đảm nhiệm việc đóng/cắt dòng cấp cho motor.

3. PWM là gì?

PWM là viết tắt của:

Pulse Width Modulation – điều chế độ rộng xung.

Thay vì cấp một điện áp liên tục để thay đổi tốc độ motor, ESP32 tạo ra các xung điện đóng/ngắt rất nhanh.

Ví dụ:

PWM thấp:

__|‾|____|‾|____|‾|____


PWM trung bình:

__|‾‾‾|__|‾‾‾|__|‾‾‾|__


PWM cao:

_|‾‾‾‾‾|_|‾‾‾‾‾|_|‾‾‾‾‾|

Tỷ lệ thời gian tín hiệu ở mức HIGH được gọi là Duty Cycle.

Duty càng lớn → công suất trung bình cấp cho motor càng lớn → motor có xu hướng quay nhanh hơn.

4. Duty Cycle

Ví dụ đơn giản:

Đây chỉ là cách minh họa nguyên lý.

Tốc độ thực tế của motor không tỷ lệ tuyến tính tuyệt đối với Duty Cycle, vì còn phụ thuộc vào:

• Điện áp pin.
• Tải cánh quạt.
• Ma sát.
• Motor.
• MOSFET/driver.
• Sụt áp.
• Trạng thái pin.

5. Vì sao Drone cần điều khiển 4 motor?

Drone quadcopter sử dụng 4 motor để tạo lực nâng và điều khiển tư thế.

Có thể hình dung:

             M1
              ●
             / \
            /   \
        M2 ●     ● M3
            \   /
             \ /
              ●
             M4

Bốn motor không hoạt động độc lập hoàn toàn.

Chúng sẽ phối hợp với nhau để thực hiện:

• Throttle.
• Roll.
• Pitch.
• Yaw.

Ví dụ khi cất cánh:

M1 ↑
M2 ↑
M3 ↑
M4 ↑

Cả bốn motor cùng tăng tốc → lực nâng tổng tăng.

Nhưng khi Drone cần nghiêng, tốc độ từng motor sẽ được thay đổi theo những mức khác nhau.

Phần này sẽ được nghiên cứu sâu ở Bài 7.

6. Xác định 4 motor trên PCB

Trước khi lập trình, cần xác định chính xác 4 motor trên PCB thực tế.

Có thể đặt tên:

M1 – Motor 1
M2 – Motor 2
M3 – Motor 3
M4 – Motor 4

Tuy nhiên, M1/M2/M3/M4 chỉ là tên quy ước.

Không nên tự mặc định rằng:

M1 = GPIO X
M2 = GPIO Y

nếu chưa kiểm tra schematic hoặc firmware của chính PCB đang sử dụng.

Đối với khóa học LINHKIEN1993, nên xác định:

Motor
  ↓
MOSFET/Driver
  ↓
GPIO ESP32

trên đúng phiên bản PCB Drone Mini ESP32.

7. Từ GPIO ESP32 đến Motor

Một kênh motor có thể được hiểu theo sơ đồ:

ESP32 GPIO
    │
    │ PWM
    ↓
MOSFET
    │
    │ Dòng motor
    ↓
Motor
    │
    ↓
Cánh quạt

Khi GPIO thay đổi PWM:

PWM thấp
   ↓
Motor quay chậm

PWM cao
   ↓
Motor quay nhanh

Như vậy ESP32 không trực tiếp "kéo" motor mà chỉ ra lệnh cho tầng công suất.

8. Lập trình PWM trên ESP32

Với Arduino-ESP32 hiện nay, có thể sử dụng phần cứng PWM của ESP32 thông qua LEDC.

Ví dụ cơ bản:

#define MOTOR1_PIN 25

#define PWM_FREQ 20000
#define PWM_RES  8

void setup()
{
    ledcAttach(MOTOR1_PIN, PWM_FREQ, PWM_RES);
}

void loop()
{
    ledcWrite(MOTOR1_PIN, 128);
}

Trong ví dụ trên:

PWM frequency = 20 kHz
Resolution    = 8 bit
Duty          = 128

Với độ phân giải 8 bit:

0   → 0%
255 → 100%

Do đó:

ledcWrite(MOTOR1_PIN, 0);

là mức PWM bằng 0.

Trong khi:

ledcWrite(MOTOR1_PIN, 255);

là mức PWM tối đa theo cấu hình trên.

Lưu ý: GPIO 25 trong ví dụ chỉ là GPIO minh họa. Khi lập trình PCB Drone LINHKIEN1993, phải thay bằng GPIO thực tế của motor trên schematic/firmware của board.

9. Điều khiển một Motor

Trước tiên, không nên điều khiển cả 4 motor cùng lúc.

Hãy kiểm tra từng motor.

Ví dụ:

#define MOTOR1_PIN 25

void setup()
{
    ledcAttach(MOTOR1_PIN, 20000, 8);
}

void loop()
{
    ledcWrite(MOTOR1_PIN, 100);

    delay(2000);

    ledcWrite(MOTOR1_PIN, 0);

    delay(2000);
}

Nguyên lý:

2 giây
↓
Motor chạy

2 giây
↓
Motor dừng

Lặp lại

Mục tiêu đầu tiên là xác nhận:

ESP32 → Driver → Motor hoạt động đúng.

10. Điều khiển tốc độ Motor

Chúng ta có thể tăng PWM theo từng bước.

for (int pwm = 0; pwm <= 255; pwm++)
{
    ledcWrite(MOTOR1_PIN, pwm);
    delay(20);
}

Sau đó giảm xuống:

for (int pwm = 255; pwm >= 0; pwm--)
{
    ledcWrite(MOTOR1_PIN, pwm);
    delay(20);
}

Motor sẽ thay đổi tốc độ theo giá trị PWM.

Có thể hình dung:

0
│
├── 50
│
├── 100
│
├── 150
│
├── 200
│
└── 255

Đây là bước đầu tiên để học viên hiểu điều khiển tốc độ motor bằng phần mềm.

11. Điều khiển cả 4 Motor

Sau khi kiểm tra từng motor, chúng ta có thể tạo 4 kênh PWM.

Ví dụ cấu trúc chương trình:

#define MOTOR1_PIN 25
#define MOTOR2_PIN 26
#define MOTOR3_PIN 27
#define MOTOR4_PIN 14

#define PWM_FREQ 20000
#define PWM_RES  8

void setup()
{
    ledcAttach(MOTOR1_PIN, PWM_FREQ, PWM_RES);
    ledcAttach(MOTOR2_PIN, PWM_FREQ, PWM_RES);
    ledcAttach(MOTOR3_PIN, PWM_FREQ, PWM_RES);
    ledcAttach(MOTOR4_PIN, PWM_FREQ, PWM_RES);
}

void loop()
{
    ledcWrite(MOTOR1_PIN, 100);
    ledcWrite(MOTOR2_PIN, 100);
    ledcWrite(MOTOR3_PIN, 100);
    ledcWrite(MOTOR4_PIN, 100);

    delay(3000);

    ledcWrite(MOTOR1_PIN, 0);
    ledcWrite(MOTOR2_PIN, 0);
    ledcWrite(MOTOR3_PIN, 0);
    ledcWrite(MOTOR4_PIN, 0);

    delay(3000);
}

Các GPIO trên chỉ là ví dụ minh họa. Không nạp nguyên đoạn code này vào PCB Drone nếu chưa thay bằng GPIO đúng của board.

12. Tạo hàm điều khiển 4 Motor

Thay vì viết lại nhiều dòng code, chúng ta có thể tạo một hàm:

void setMotors(int m1, int m2, int m3, int m4)
{
    ledcWrite(MOTOR1_PIN, m1);
    ledcWrite(MOTOR2_PIN, m2);
    ledcWrite(MOTOR3_PIN, m3);
    ledcWrite(MOTOR4_PIN, m4);
}

Sau đó:

setMotors(100, 100, 100, 100);

có nghĩa:

M1 = 100
M2 = 100
M3 = 100
M4 = 100

Hoặc:

setMotors(100, 120, 100, 120);

thì mỗi motor có giá trị PWM riêng.

Đây chính là nền tảng để sau này xây dựng Motor Mixing.

13. Tại sao phải điều khiển từng Motor riêng?

Nếu chỉ có:

setMotors(100,100,100,100);

chúng ta mới chỉ điều khiển được tốc độ tổng thể.

Drone thực tế cần nhiều hơn thế.

Ví dụ hệ thống cần tạo một chuyển động Roll:

M1 = 110
M2 = 130
M3 = 110
M4 = 130

Đây chỉ là ví dụ minh họa về nguyên lý, không phải công thức điều khiển chính thức cho PCB này.

Thuật toán thực tế phải phụ thuộc vào:

• Vị trí từng motor.
• Chiều quay.
• Khung Drone.
• Thứ tự motor.
• Hệ tọa độ.
• Thuật toán điều khiển.

14. Motor Mixing

Motor Mixing là cầu nối giữa:

Lệnh điều khiển → tốc độ từng motor.

Ví dụ:

              THROTTLE
                  │
                  ↓
ROLL ───────→ MOTOR MIXING ←────── YAW
                  ↑
                  │
                PITCH
                  │
        ┌─────────┼─────────┐
        ↓         ↓         ↓
       M1        M2        M3        M4

Đầu vào:

Throttle
Roll
Pitch
Yaw

Đầu ra:

Motor 1
Motor 2
Motor 3
Motor 4

Ở Bài 4 chúng ta chưa cần triển khai đầy đủ Motor Mixing.

Mục tiêu hiện tại là đảm bảo 4 kênh motor có thể nhận lệnh độc lập.

15. Giới hạn PWM

Không nên để chương trình cho motor chạy bất kỳ giá trị nào mà không giới hạn.

Có thể tạo hàm:

int limitPWM(int value)
{
    if (value < 0)
        value = 0;

    if (value > 255)
        value = 255;

    return value;
}

Sau đó:

value = limitPWM(value);

Điều này giúp tránh tình trạng giá trị điều khiển vượt khỏi phạm vi PWM đã cấu hình.

Trong firmware Drone hoàn chỉnh, chúng ta sẽ cần thêm các giới hạn an toàn khác.

16. Thử nghiệm tăng tốc 4 Motor

Một bài thực hành đơn giản:

for (int pwm = 0; pwm <= 150; pwm++)
{
    setMotors(pwm, pwm, pwm, pwm);
    delay(20);
}

delay(1000);

setMotors(0, 0, 0, 0);

Mục đích:

Kiểm tra 4 motor có phản ứng đồng đều hay không.

Quan sát:

• Motor nào không chạy?
• Motor nào chạy yếu?
• Motor nào khởi động chậm?
• Motor nào rung?
• Chiều quay có đúng không?
• Tầng công suất có nóng bất thường không?

Đây là cách tiếp cận rất quan trọng trong quá trình debug phần cứng.

17. Không nên kiểm tra motor bằng cánh quạt đang lắp

Trong quá trình lập trình và kiểm tra motor trên bàn:

Nên tháo cánh quạt trước khi test motor.

Đặc biệt không nên vừa debug firmware vừa cầm Drone trên tay.

Quy trình an toàn:

Tắt nguồn
   ↓
Tháo cánh quạt
   ↓
Kiểm tra PCB
   ↓
Cấp nguồn
   ↓
Nạp firmware
   ↓
Test PWM
   ↓
Test từng motor
   ↓
Tắt nguồn
   ↓
Kiểm tra lại

Chỉ tiến hành kiểm tra bay khi đã hoàn thành các bước kiểm tra cần thiết và có khu vực thử nghiệm phù hợp.

18. Kiểm tra chiều quay Motor

Đối với quadcopter, chiều quay của từng motor rất quan trọng.

Không chỉ cần:

Motor chạy.

Mà cần:

Motor chạy đúng chiều theo thiết kế của Drone.

Ví dụ quy ước:

        M1 ↻

   M2 ↺       M3 ↺

        M4 ↻

Đây chỉ là sơ đồ minh họa. Không được lấy chiều quay này làm quy định cho PCB LINHKIEN1993 nếu chưa đối chiếu thiết kế thực tế.

Nếu motor quay sai chiều, có thể xảy ra:

• Cánh không tạo lực nâng đúng.
• Drone rung.
• Drone không thể cất cánh ổn định.
• Điều khiển Yaw không đúng.
• Thuật toán điều khiển bị sai.

19. Kiểm tra 4 Motor bằng Serial Monitor

Trong quá trình debug, Serial Monitor là công cụ rất hữu ích.

Ví dụ:

Serial.begin(115200);

Serial.println("Motor Test Start");

Sau đó:

Motor 1 = 100
Motor 2 = 100
Motor 3 = 100
Motor 4 = 100

Nếu muốn chuyên nghiệp hơn, có thể xây dựng giao diện lệnh:

M1 100
M2 150
M3 200
M4 50

ESP32 nhận lệnh từ máy tính và điều khiển motor tương ứng.

Đây là một bài thực hành rất tốt cho sinh viên lập trình nhúng.

20. Từ chương trình test đến Firmware Drone

Firmware thực tế sẽ không chỉ có:

setMotors();

Mà sẽ phát triển thành kiến trúc:

                    MAIN LOOP
                        │
          ┌─────────────┼─────────────┐
          ↓             ↓             ↓
      ESP-NOW        MPU6050       Safety
          │             │             │
          └─────────────┼─────────────┘
                        ↓
                  CONTROL INPUT
                        ↓
                   MOTOR MIXING
                        ↓
                MOTOR LIMIT / MAP
                        ↓
                  MOTOR OUTPUT
                 ┌──────┼──────┐
                 ↓      ↓      ↓
                M1     M2     M3     M4

Đây mới là kiến trúc hướng đến của khóa học.

21. Những lỗi thường gặp khi điều khiển Motor

Lỗi 1: ESP32 chạy nhưng Motor không quay

Có thể kiểm tra:

• GPIO.
• MOSFET/driver.
• Nguồn motor.
• GND.
• Đường PCB.
• Motor.
• PWM.

Lỗi 2: Một motor chạy, ba motor không chạy

Kiểm tra:

GPIO M1
GPIO M2
GPIO M3
GPIO M4

và kiểm tra riêng từng tầng công suất.

Lỗi 3: Motor chỉ rung

Có thể liên quan đến:

• Điện áp nguồn.
• Dòng cấp.
• Motor.
• Driver.
• PWM.
• Tiếp xúc.
• Cánh quạt/tải.

Lỗi 4: Motor quay không đúng chiều

Kiểm tra:

• Dây motor.
• Thiết kế PCB.
• Cấu hình firmware.
• Mapping motor.

Lỗi 5: ESP32 reset khi motor tăng tốc

Đây là lỗi rất đáng chú ý.

Có thể liên quan đến:

• Sụt áp nguồn.
• Nguồn không đủ dòng.
• Nhiễu từ motor.
• Thiết kế nguồn.
• GND.
• Tụ lọc.
• Tải motor quá lớn.

Khi gặp lỗi này, không nên chỉ sửa code.

Cần kiểm tra cả phần cứng nguồn.

22. Bài thực hành cuối Bài 4

Học viên cần hoàn thành 5 bước:

Bước 1

Xác định GPIO điều khiển:

M1 → GPIO ?
M2 → GPIO ?
M3 → GPIO ?
M4 → GPIO ?

Bước 2

Nạp chương trình PWM.

Bước 3

Test từng motor:

M1 → ON/OFF
M2 → ON/OFF
M3 → ON/OFF
M4 → ON/OFF

Bước 4

Điều chỉnh PWM:

50
100
150
200

và quan sát phản hồi.

Bước 5

Test đồng thời:

M1 = 100
M2 = 100
M3 = 100
M4 = 100

Sau khi hoàn thành, học viên phải trả lời được:

ESP32 đã điều khiển được cả 4 motor độc lập hay chưa?

23. Kết quả cần đạt sau Bài 4

Sau bài học này, học viên cần hiểu được chuỗi:

ESP32
   ↓
GPIO / PWM
   ↓
MOSFET / Motor Driver
   ↓
Motor
   ↓
Cánh quạt

Và quan trọng hơn:

M1 ──┐
M2 ──┤
M3 ──┼──→ Có thể điều khiển độc lập
M4 ──┘

Đây là nền tảng để chuyển từ điều khiển một motor sang điều khiển toàn bộ hệ thống quadcopter.

24. Kết luận

Ở Bài 4, chúng ta chưa cố làm Drone bay ngay.

Chúng ta đi theo đúng tư duy của một kỹ sư:

Hiểu phần cứng → kiểm tra từng khối → điều khiển từng motor → điều khiển 4 motor → sau đó mới ghép thuật toán bay.

Chuỗi kiến thức hiện tại:

BÀI 1
Tổng quan Drone
        ↓
BÀI 2
Tay cầm ESP32
        ↓
BÀI 3
Phần cứng Drone
        ↓
BÀI 4
ESP32 + PWM + 4 Motor
        ↓
BÀI 5
ESP-NOW
        ↓
BÀI 6
Joystick → ESP-NOW → Drone
        ↓
BÀI 7
MPU6050 + Motor Mixing + hiệu chỉnh
        ↓
BÀI 8
Hoàn thiện & cất cánh

🚁 BÀI TIẾP THEO

Bài 5: ESP-NOW – Giao tiếp 2 ESP32

Trong bài tiếp theo, chúng ta sẽ tách hệ thống thành hai thiết bị:

ESP32 TAY CẦM
      ↕
    ESP-NOW
      ↕
ESP32 DRONE

Mục tiêu là giúp hai ESP32 truyền dữ liệu trực tiếp với nhau, tạo nền tảng để sau đó truyền dữ liệu joystick từ tay cầm đến Drone.

LINHKIEN1993 – KHÓA HỌC STEM DRONE ESP32

Học điện tử → Học lập trình → Hiểu nguyên lý → Tự nghiên cứu

🌐 linhkien1993.com
📞 Zalo: 0367 547 577
📍 124/8 Võ Văn Hát, P. Long Trường, TP.HCM