ในยุคปัจจุบันที่เทคโนโลยีก้าวล้ำไปอย่างรวดเร็ว การสร้างหุ่นยนต์เป็นหนึ่งในแนวทางที่น่าสนใจอย่างยิ่งสำหรับนักพัฒนาและผู้เริ่มต้นในด้านดังกล่าว ในบทความนี้ เราจะพาคุณไปสู่การสร้างหุ่นยนต์ที่สามารถเดินตามเส้นได้โดยใช้เซ็นเซอร์ 3 ตัว และบอร์ด ESP32 ร่วมกับ Arduino IDE ซึ่งเป็นเครื่องมือที่ทันสมัยและมีประสิทธิภาพในการพัฒนาหุ่นยนต์ที่ท่านต้องการสร้างขึ้นมา
เทคโนโลยีและอุปกรณ์ที่ใช้
- เซ็นเซอร์เลเซอร์ (Line Sensor): เป็นเซ็นเซอร์ที่ใช้สำหรับตรวจจับเส้นทาง โดยสามารถตรวจจับเส้นทางที่มีสีคงที่เช่นดำหรือเทาได้ มักใช้ในการนำหุ่นยนต์เดินตามเส้น
- บอร์ด ESP32: เป็นบอร์ดไมโครคอนโทรเลอร์ที่มีความสามารถมากมาย เช่น การเชื่อมต่อ WiFi, Bluetooth, และการประมวลผลที่เร็วและมีประสิทธิภาพ
- Arduino IDE: เป็นโปรแกรมที่ใช้ในการเขียนและอัปโหลดโค้ดลงในบอร์ด Arduino หรือ ESP32 ซึ่งมีความสะดวกและใช้งานง่ายสำหรับผู้เริ่มต้น
อุปกรณ์ที่ใช้
1. RB-0024 4WD Smart Robot Car Chassis Kits
2. RB-0173 DevKitC V4 ESP32 Development Board
3. RB-0272 ESP32 Expansion Board 38Pins
4. RB-0003 Motor Driver Module L298N
5. RB-0019 รางถ่าน 18650 – 2 ก้อน
6. RB-0025 เสารองแผ่นพีซีบีโลหะแบบเหลี่ยม 8 mm
7. RB-0049 แจ๊กขั้วถ่าน 9 โวลต์ สำหรับ Ardiuno
8. RB-0042 เพาเวอร์สวิตซ์สำหรับเปิดปิด (ON / OFF Rocker Switch)
9. RB-0015 Jumper (F2M) cable wire 20cm Female to Male
10. RB-0021 ถ่านชาร์จ 18650 NCR18650B 3.7v 3400mAh 2 ก้อน
11. RB-0017 Jumper (F2F) cable wire 20cm Female to Female
12. RB-0106 Micro USB Cable Wire 1m for NodeMCU
13. RB-0137 3 Road Tracing Sensor Robot
14. RB-0121 Jumper (F2F) cable wire 30cm Female to Female
15. RB-0026 สกรูหัวกลม+น็อตตัวเมีย ขนาด 3มม ยาว 12มม
หลักการทำงานที่พื้นฐาน
การสร้างหุ่นยนต์เดินตามเส้นโดยใช้เซ็นเซอร์ 3 ตัวนั้นสามารถทำได้โดยใช้ ESP32 ร่วมกับ Arduino ในการควบคุมการเคลื่อนไหวของหุ่นยนต์โดยอ้างอิงจากข้อมูลที่ได้รับจากเซ็นเซอร์เพื่อติดตามเส้นทางที่กำหนดไว้ ดังนี้คือหลักการทำงานที่อาจจะนำมาใช้ในการสร้างหุ่นยนต์ดังกล่าว:
- ติดตั้งเซ็นเซอร์: ให้ติดตั้งเซ็นเซอร์สายไปยัง ESP32 เพื่อรับข้อมูลจากพื้นผิวเส้นทางที่หุ่นยนต์จะต้องเดินตาม ในกรณีนี้ 3 เซ็นเซอร์อาจจะต้องติดตั้งแบบสามเซ็นเซอร์ในเส้นทางที่แตกต่างกัน ที่เป็นไปได้คือเซ็นเซอร์แบบอินฟราเรด (infrared sensors)
- อ่านข้อมูล: ESP32 จะต้องอ่านข้อมูลจากเซ็นเซอร์เพื่อตรวจจับตำแหน่งและทิศทางของเส้นทาง
- ประมวลผลข้อมูล: หลังจากได้รับข้อมูลจากเซ็นเซอร์ ตัว ESP32 จะทำการประมวลผลเพื่อตรวจสอบตำแหน่งปัจจุบันของหุ่นยนต์ในเส้นทาง และหาทิศทางที่ถูกต้องในการเดินต่อไป
- ควบคุมการเคลื่อนไหว: หลังจากที่ตรวจสอบและประมวลผลข้อมูลแล้ว ต่อไปคือการควบคุมการเคลื่อนไหวของหุ่นยนต์เพื่อให้เดินตามเส้นทางที่ต้องการ นี่อาจเป็นการควบคุมมอเตอร์เพื่อเปลี่ยนทิศทางหรือความเร็วของหุ่นยนต์
- วนวางโค้ด: สร้างลูปวนเพื่อให้โปรแกรมทำงานอยู่ซ้ำๆ โดยอ่านข้อมูลจากเซ็นเซอร์อย่างต่อเนื่องและปรับปรุงการเคลื่อนไหวของหุ่นยนต์ตามความจำเป็น
- การแก้ปัญหา: หากเซ็นเซอร์ตรวจจับว่าหุ่นยนต์ออกนอกเส้นทางหรือพบกับอุปสรรค ระบบจะต้องมีการจัดการปัญหานี้ อาจเป็นการหยุดหุ่นยนต์และรอให้มีการแก้ไขด้วยมือ หรืออาจเป็นการปรับแต่งการเคลื่อนไหวเพื่อเลี่ยงอุปสรรค
แนวคิดของ หุ่นยนต์เดินตามเส้น 3 เซ็นเซอร์
- เมื่อ “เซ็นเซอร์กลาง” ของหุ่นยนต์ อยู่บริเวณเทปสีดำ (L=0 C=1 R=0) ให้หุ่นยนต์เดินไปข้างหน้า
2. เมื่อ “เซ็นเซอร์ซ้าย” ของหุ่นยนต์ อยู่บริเวณเทปสีดำ (L=1 C=0 R=0) ให้หุ่นยนต์เดินเลี้ยวไปทางด้านซ้าย เพื่อไม่ให้หุ่นยนต์หลุดไปนอกเส้น
3. เมื่อหุ่นยนต์เลี้ยวซ้าย ทำให้ “เซ็นเซอร์กลาง” ของหุ่นยนต์ กลับมาอยู่บริเวณเทปสีดำอีกครั้ง (L=0 C=1 R=0) ทำให้หุ่นยนต์เดินไปข้างหน้า เหมือนขั้นตอนที่ 1
4. และเมื่อ “เซ็นเซอร์ซ้าย” ของหุ่นยนต์ อยู่บริเวณเทปสีดำ อีกครั้ง (L=1 C=0 R=0) หุ่นยนต์จะเลี้ยวซ้าย เพื่อให้ “เซ็นเซอร์กลาง” ของหุ่นยนต์ กลับมาอยู่บริเวณเทปสีดำ อีกครั้ง เช่นกัน เป็นลักษณะนี้เรื่อยๆ จึงทำให้หุ่นยนต์สามารถเคลื่อนที่ ไปตามเส้นที่เรากำหนดไว้ได้
และ เมื่อหุ่นยนต์ เจอเส้นทางที่ต้องเลี้ยวขวา ก็ใช้หลักการเดียวกัน เพียงแต่เปลี่ยนไปเป็น “เซ็นเซอร์ขวา”
นี่เป็นหลักการทำงานที่พื้นฐานของหุ่นยนต์เดินตามเส้นด้วยการใช้ ESP32 ร่วมกับ Arduino และเซ็นเซอร์ อย่างไรก็ตาม การสร้างหุ่นยนต์เดินตามเส้นนั้นอาจมีความซับซ้อนขึ้นขึ้นอยู่กับการออกแบบและการใช้เทคโนโลยีที่ต่างกัน และการปรับปรุงการทำงานของระบบนี้สามารถทำได้ตามความต้องการของโครงการและความชำนาญของผู้พัฒนา.
การสร้าง หุ่นยนต์เดินตามเส้น 3 เซ็นเซอร์ ด้วย ESP32
1.ประกอบหุ่นยนต์และเชื่อมต่อวงจร
บัดกรีสายมอเตอร์ โดย สายสีแดงอยู่ด้านบน และ สายสีดำอยู่ด้านล่าง ทั้ง 4 ตัว
ยึดมอเตอร์เข้ากับโครงหุ่นยนต์ (ด้านล่าง)
ยึดเสา 6 ต้น สำหรับใส่โครงหุ่นยนต์ด้านบน
การต่อวงจร
ยึด Expansion Board (บอร์ดขยายขา ESP32) , โมดูลขับมอเตอร์ และ รางถ่าน เข้ากับโครงหุ่นยนต์ด้านบน
ใส่บอร์ด ESP32 เข้ากับ บอร์ดขยายขา ESP32
ต่อสายไฟ จากรางถ่าน กับ แจ๊กขั้วถ่าน โดย สายสีแดง ต่อ ผ่านสวิตช์ปิดเปิด แล้ว เสียบแจ๊กขั้วถ่าน เข้ากับ DC 6.5 – 16V ของ บอร์ดขยายขา ESP32
ใส่ถ่าน 18650 จำนวน 2 ก้อน และ เมื่อเปิดไฟเข้า ต้องมีไฟติดทั้ง 3 บอร์ด คือ บอร์ดขยายขา ESP32 , บอร์ด ESP32 และ โมดูลขับมอเตอร์
เชื่อมต่อวงจร ระหว่าง บอร์ดขยายขา ESP32 กับ โมดูลขับมอเตอร์
(ใช้ Jumper (F2F) ความยาว 20 cm ในการเชื่อมต่อ)
เชื่อมต่อ มอเตอร์ ทั้ง 4 ตัวเข้ากับ โมดูลขับมอเตอร์ (ตรวจสอบการต่อสายและสีของสาย)
ใส่ล้อและยึดน็อตโครงหุ่นยนต์ชั้นบนกับชั้นล่างเข้าด้วยกัน
ภาพรวมการต่อหุ่นยนต์
2.ติดตั้ง Arduino IDE
สิ่งแรกคือการติดตั้ง Arduino IDE เพื่อให้คุณสามารถค้นหา Arduino IDE ใน Google
จากนั้นคุณมีสองทางเลือก
หนึ่งคือการติดตั้งเวอร์ชัน1 หรือเพื่อติดตั้งเวอร์ชัน 2
เราจะติดตั้งเวอร์ชัน 2 เพราะมีคุณสมบัติเพิ่มเติมบางอย่าง แต่ไม่ว่าคุณจะเลือกอะไรมันจะทำงานเช่นกัน ดังนั้นคุณสามารถเลือกอย่างใดอย่างหนึ่ง
ดาวน์โหลด Arduino IDE จากที่นี่
https://www.arduino.cc/en/software
2. กำหนดค่าให้ รองรับบอร์ด ESP32
ไปที่ File > Preferences
คัดลอกและวางบรรทัดต่อไปนี้ลงในฟิลด์ Boards Manager URLs
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
คลิกไอคอนตัวจัดการบอร์ดที่มุมด้านซ้าย ค้นหา ESP32 และกดปุ่มติดตั้งสำหรับ esp32 โดย Espressif Systems
3. ทดสอบ การเคลื่อนที่ของหุ่นยนต์
การทดสอบนี้ เป็นการตรวจสอบการต่อสายต่างๆ เช่น การเชื่อมต่อสายของมอเตอร์ ทั้ง 4 ตัว รวมทั้งสายอื่นๆ ของหุ่นยนต์ที่เราสร้าง ว่าถูกต้องหรือไม่ ถ้าถูกต้องหุ่นยนต์จะดำเนินการดังนี้
คือ เดินหน้า -> ถอยหลัง -> เลี้ยวซ้าย -> เลี้ยวขวา
และนี่คือโค้ดที่ใช้ทดสอบ
int MA1 = 27; // Motor A1
int MA2 = 26; // Motor A2
int PWM_A = 14; // Speed Motor A
int MB1 = 17; // Motor B1
int MB2 = 16; // Motor B2
int PWM_B = 4; // Speed Motor B
int SPEED = 255; // Speed PWM สามารถปรับความเร็วได้ถึง 0 - 255
void setup() {
//Setup Channel A
pinMode(MA1, OUTPUT); //Motor A1
pinMode(MA2, OUTPUT); //Motor A2
pinMode(PWM_A, OUTPUT); //Speed PWM Motor A
//Setup Channel B
pinMode(MB1, OUTPUT); //Motor B1
pinMode(MB2, OUTPUT); //Motor B2
pinMode(PWM_B, OUTPUT); //Speed PWM Motor B
}
void loop() {
Stop(5000);
Forward(600);
Stop(200);
Backward(600);
Stop(200);
turnLeft(600);
Stop(200);
turnRight(600);
}
void Backward(int time)
{
digitalWrite(MA1, LOW);
digitalWrite(MA2, HIGH);
analogWrite(PWM_A, SPEED);
digitalWrite(MB1, HIGH);
digitalWrite(MB2, LOW);
analogWrite(PWM_B, SPEED);
delay(time);
}
void Forward (int time)
{
digitalWrite(MA1, HIGH);
digitalWrite(MA2, LOW);
analogWrite(PWM_A, SPEED);
digitalWrite(MB1, LOW);
digitalWrite(MB2, HIGH);
analogWrite(PWM_B, SPEED);
delay(time);
}
void turnLeft(int time)
{
digitalWrite(MA1, HIGH);
digitalWrite(MA2, LOW);
analogWrite(PWM_A, SPEED);
digitalWrite(MB1, LOW);
digitalWrite(MB2, LOW);
analogWrite(PWM_B, 0);
delay(time);
}
void turnRight(int time)
{
digitalWrite(MA1, LOW);
digitalWrite(MA2, LOW);
analogWrite(PWM_A, 0);
digitalWrite(MB1, LOW);
digitalWrite(MB2, HIGH);
analogWrite(PWM_B, SPEED);
delay(time);
}
void Stop(int time)
{
digitalWrite(MA1, LOW);
digitalWrite(MA2, LOW);
analogWrite(PWM_A, 0);
digitalWrite(MB1, LOW);
digitalWrite(MB2, LOW);
analogWrite(PWM_B, 0);
delay(time);
}
ลิงค์โค้ด https://lungmaker.com/code/test-motor-esp32.ino
เชื่อมต่อสาย Micro USB ระหว่าง คอมพิวเตอร์ กับ ESP32 และ ต้องเปิดสวิตช์เพื่อจ่ายไฟจากรางถ่านให้กับหุ่นยนต์ด้วย
เลือกบอร์ด ESP32 ตามรุ่นที่ใช้ เป็น ESP32 Dev Module
เลือก Port โดยไปที่ Tools -> Port -> COM5
(โดย COM5 แต่ละเครื่องจะไม่เหมือนกัน ให้เลือกตามที่ปรากฎ)
คลิกที่ Upload
แสดงการ Upload สำเร็จ
วิดีโอผลลัพธ์การทำงาน การเคลื่อนที่ของหุ่นยนต์ ESP32
ถ้ายังทำงานไม่ถูกต้อง คือ เดินหน้า -> ถอยหลัง -> เลี้ยวซ้าย -> เลี้ยวขวา ให้กลับไปแก้ไขการต่อวงจร การต่อสายต่างๆ เช่น การต่อสายมอเตอร์ จนกว่าจะทำงานถูกต้อง ถึงจะสามารถไปทำงานในขั้นตอนต่อไป
4. เชื่อมต่อวงจร ระหว่าง บอร์ดขยายขา ESP32 กับ เซ็นเซอร์
(ใช้ Jumper (F2F) ความยาว 30 cm ในการเชื่อมต่อ)
และนี่คือโค้ดที่ใช้ทดสอบ
/*
read analog data from A1-A3 and send to PC via Serial port
*/
int sensor_L, sensor_C, sensor_R; //optical sensor values
String tmp;
int ADC_stabilize = 5;
void setup() {
// initialize the serial communication:
Serial.begin(9600);
}
void loop() {
//take a snapshot
sensor_L = digitalRead(23);
delay(ADC_stabilize); //stabilize
sensor_L = digitalRead(23);
delay(ADC_stabilize);
sensor_C = digitalRead(22);
delay(ADC_stabilize);
sensor_C = digitalRead(22);
delay(ADC_stabilize);
sensor_R = digitalRead(21);
delay(ADC_stabilize);
sensor_R = digitalRead(21);
delay(ADC_stabilize);
tmp = "L=" + String(sensor_L) + " C=" + String(sensor_C) + " R=" + String(sensor_R);
// send the value of analog inputs:
Serial.println(tmp);
// wait a bit for next reading
delay(1000); //1000=1 sec
}
ลิงค์โค้ด https://lungmaker.com/code/tesi-line-sensor-esp32.ino
Upload โค้ด
เซ็นเซอร์ ทั้ง 3 ตัว ของหุ่นยนต์ เมื่ออยู่บริเวณ พื้นสีขาว ไฟ LED สีแดงทั้ง 3 ตัว จะติด
และเมื่อ “เซ็นเซอร์ขวา” ของหุ่นยนต์ อยู่บริเวณเทปสีดำ
และ เซ็นเซอร์ซ้าย และ เซ็นเซอร์กลาง อยู่บริเวณพื้นสีขาว ไฟ LED สีแดง ด้านขวาจะดับ
แล้วไปที่ Tools -> Serial Monitor
เลือก Both NL & CR และ เลือก 9600 baud
Serial Monitor จะแสดง L=0 C=0 R=1
และเมื่อ “เซ็นเซอร์กลาง” ของหุ่นยนต์ อยู่บริเวณเทปสีดำ
และ เซ็นเซอร์ซ้าย และ เซ็นเซอร์ขวา อยู่บริเวณพื้นสีขาว
ไฟ LED สีแดง ของ เซ็นเซอร์ตัวกลาง จะดับ
Serial Monitor จะแสดง L=0 C=1 R=0
และเมื่อ “เซ็นเซอร์ซ้าย” ของหุ่นยนต์ อยู่บริเวณเทปสีดำ
และ เซ็นเซอร์ขวา และ เซ็นเซอร์กลาง อยู่บริเวณพื้นสีขาว
ไฟ LED สีแดง ของ เซ็นเซอร์ซ้าย จะดับ
Serial Monitor จะแสดง L=1 C=0 R=0
ถ้ายังทำงานไม่ถูกต้อง ให้กลับไปแก้ไขการต่อวงจร การต่อสายเซ็นเซอร์ และ ปรับค่าการรับแสง โดย ใช้ไขควงหมุน ตัว R ปรับค่าได้ แบบ trimpot สี่เหลี่ยมสีฟ้า จนกว่าจะทำงานถูกต้อง ถึงจะสามารถไปทำงานในขั้นตอนต่อไป
5. ทดสอบ หุ่นยนต์เดินตามเส้น
โค้ดหุ่นยนต์เดินตามเส้น ESP32
int MA1 = 27; // Motor A1
int MA2 = 26; // Motor A2
int PWM_A = 14; // Speed Motor A
int MB1 = 17; // Motor B1
int MB2 = 16; // Motor B2
int PWM_B = 4; // Speed Motor B
int SPEED = 255; // Speed PWM สามารถปรับความเร็วได้ถึง 0 - 255
/*-------definning Sensor------*/
int sensor[3] = { 0, 0, 0 };
void setup() {
//Setup Channel A
pinMode(MA1, OUTPUT); //Motor A1
pinMode(MA2, OUTPUT); //Motor A2
pinMode(PWM_A, OUTPUT); //Speed PWM Motor A
//Setup Channel B
pinMode(MB1, OUTPUT); //Motor B1
pinMode(MB2, OUTPUT); //Motor B2
pinMode(PWM_B, OUTPUT); //Speed PWM Motor B
pinMode(23, INPUT); //sensor_L
pinMode(22, INPUT); //sensor_C
pinMode(21, INPUT); //sensor_R
}
void loop() {
sensor[0] = digitalRead(23);
sensor[1] = digitalRead(22);
sensor[2] = digitalRead(21);
if ((sensor[0] == 0) && (sensor[1] == 0) && (sensor[2] == 0)) {
SPEED = 220;
Backward(2);
} else if ((sensor[0] == 0) && (sensor[1] == 1) && (sensor[2] == 0)) {
SPEED = 220;
Forward(10);
} else if ((sensor[0] == 1) && (sensor[1] == 0) && (sensor[2] == 0)) {
SPEED = 220;
turnLeft(10);
SPEED = 220;
Forward(1);
} else if ((sensor[0] == 1) && (sensor[1] == 1) && (sensor[2] == 0)) {
SPEED = 220;
turnLeft(1);
SPEED = 220;
Forward(1);
} else if ((sensor[0] == 0) && (sensor[1] == 0) && (sensor[2] == 1)) {
SPEED = 220;
turnRight(10);
SPEED = 220;
Forward(1);
} else if ((sensor[0] == 0) && (sensor[1] == 1) && (sensor[2] == 1)) {
SPEED = 220;
turnRight(1);
SPEED = 220;
Forward(1);
}
}
void Backward(int time) {
digitalWrite(MA1, LOW);
digitalWrite(MA2, HIGH);
analogWrite(PWM_A, SPEED);
digitalWrite(MB1, HIGH);
digitalWrite(MB2, LOW);
analogWrite(PWM_B, SPEED);
delay(time);
}
void Forward(int time) {
digitalWrite(MA1, HIGH);
digitalWrite(MA2, LOW);
analogWrite(PWM_A, SPEED);
digitalWrite(MB1, LOW);
digitalWrite(MB2, HIGH);
analogWrite(PWM_B, SPEED);
delay(time);
}
void turnLeft(int time) {
digitalWrite(MA1, HIGH);
digitalWrite(MA2, LOW);
analogWrite(PWM_A, SPEED);
digitalWrite(MB1, LOW);
digitalWrite(MB2, LOW);
analogWrite(PWM_B, 0);
delay(time);
}
void turnRight(int time) {
digitalWrite(MA1, LOW);
digitalWrite(MA2, LOW);
analogWrite(PWM_A, 0);
digitalWrite(MB1, LOW);
digitalWrite(MB2, HIGH);
analogWrite(PWM_B, SPEED);
delay(time);
}
void Stop(int time) {
digitalWrite(MA1, LOW);
digitalWrite(MA2, LOW);
analogWrite(PWM_A, 0);
digitalWrite(MB1, LOW);
digitalWrite(MB2, LOW);
analogWrite(PWM_B, 0);
delay(time);
}
ลิงค์โค้ด https://lungmaker.com/code/robot-esp32-line.ino
การทดสอบ หาพื้นที่เป็นสีขาว หรือ สีอ่อนๆ และใช้ เทปพันสายไฟ สีดำ โดยขนาด ความกว้างของเส้นประมาณ 3 เซนติเมตร โดยใช้ใช้ 2 เทปพันสายไฟ เรียงต่อกันเพื่อเพิ่มขนาดของเส้น
วิดีโอผลลัพธ์การทำงาน หุ่นยนต์เดินตามเส้น ESP32
สรุป
การสร้างหุ่นยนต์เดินตามเส้นด้วยเซ็นเซอร์ 3 เซ็นเซอร์ และบอร์ด ESP32 เป็นโครงการที่น่าสนใจและมีประโยชน์ ทำให้ผู้ที่สนใจสามารถเรียนรู้เรื่องการเขียนโปรแกรมและการทำงานของหุ่นยนต์ได้อย่างเพลิดเพลิน โดยใช้เทคโนโลยีที่ทันสมัยและเครื่องมือที่มีความสะดวกสบายอย่าง Arduino IDE และ ESP32 ที่มีประสิทธิภาพสูง ลองท้าทายตัวเองและสร้างหุ่นยนต์ที่น่าตื่นเต้นขึ้นมาดูกันเถอะ!
