หุ่นยนต์กู้ระเบิด (ROBOT BOOM)

โครงงานวิชาเรียน
พฤศจิกายน 5, 2024
0

ผู้เขียนบทความ
นายกิตตินันท์ ช่วยนิมิตร COE#16
นายกฤษณะ บัวทุม COE#16
นายพลภัทร พุทธชาติ COE#16
นายธนวัฒน์ คูณพูล COE#16
คณะวิศวกรรมศาสตร์ สาขาวิศวกรรมคอมพิวเตอร์
วิชา : 04-513-201 การโปรแกรมคอมพิวเตอร์ขั้นสูง 1/2567

1. ความเป็นมา

ในประเทศไทย การทำหน้าที่กู้ระเบิดถือเป็นหนึ่งในงานที่เสี่ยงอันตรายอย่างยิ่ง เจ้าหน้าที่ที่ทำงานในพื้นที่เสี่ยงภัยเหล่านี้ ต้องเผชิญหน้ากับภัยคุกคามที่อาจเกิดขึ้นได้ทุกเมื่อ โดยเฉพาะในพื้นที่ที่มีความขัดแย้งหรือการก่อความไม่สงบ หลายครั้งที่การกู้ระเบิดนำไปสู่ความสูญเสีย ไม่ว่าจะเป็นการบาดเจ็บหรือเสียชีวิตจากการระเบิดที่เกิดขึ้นโดยไม่ได้คาดการณ์ ซึ่งเป็นเรื่องที่สะท้อนให้เห็นถึงความท้าทายและความเสี่ยงที่ต้องเผชิญในงานนี้ ทางผู้จัดเห็นถึงปัญหานี้ซึางมีความเสี่ยงสูง จึงได้จัดทำการพัฒนาหุ่นยนต์กู้ระเบิดขึ้นมา
ทั้งนี้การใช้หุ่นยนต์กู้ระเบิดจึงเข้ามามีบทบาทสำคัญอย่างยิ่งในสถานการณ์เหล่านี้ หุ่นยนต์กู้ระเบิดช่วยลดความเสี่ยงที่มนุษย์ต้องเผชิญ โดยการเข้าไปทำงานในพื้นที่เสี่ยงแทน ซึ่งช่วยลดอันตรายที่อาจเกิดขึ้นกับเจ้าหน้าที่ นอกจากนี้ หุ่นยนต์ยังสามารถทำงานในพื้นที่ที่มนุษย์ไม่สามารถเข้าถึงได้ ทำให้การใช้หุ่นยนต์กู้ระเบิดเป็นทางเลือกที่มีประโยชน์อย่างมากในการรักษาความปลอดภัยของเจ้าหน้าที่และประชาชน
ในการทดสอบหุ่นยนต์กู้ระเบิด มักจะมีการจำลองสถานการณ์ต่าง ๆ เพื่อทดสอบความสามารถในการตรวจจับและกู้ระเบิด รวมถึงการทดสอบความแม่นยำและความปลอดภัยในสภาพแวดล้อมที่หลากหลาย นอกจากนี้ การศึกษาและพัฒนาหุ่นยนต์กู้ระเบิดยังเป็นส่วนหนึ่งของวิชาการโปรแกรมคอมพิวเตอร์ขั้นสูง โดยอ.สันติ สถิตวรรธนะเป็นผู้สอนและที่ปรึกษาโครงงานย่อยชิ้นนี้ เพื่อนำรายวิชานี้มาประยุกต์เข้ากับหุ่นยนต์กู้ระเบิดด้วยภาษา python

2. วัตถุประสงค์

2.1 เพื่อออกแบบและสร้างหุ่นยนต์กู้ระเบิดที่สามารถใช้งานได้จริง
2.2 เพื่อพัฒนาทักษะการเขียนโปรแกรมและควบคุมหุ่นยนต์ในสถานการณ์เสี่ยง
2.3 พื่อเสริมสร้างความรู้ด้านวิศวกรรมและเทคโนโลยีคอมพิวเตอร์ในการพัฒนาหุ่นยนต์

3. ขอบเขตของการทำงาน

3.1 ออกแบบและสร้างหุ่นยนต์ต้นแบบที่สามารถตรวจจับและกู้ระเบิดในสภาพแวดล้อมจำลอง
3.2 ทดสอบหุ่นยนต์ในสถานการณ์จำลองหลากหลายรูปแบบ เช่น พื้นที่เปิดโล่งและพื้นที่จำกัด
3.3 ปรับปรุงและแก้ไขข้อบกพร่องของหุ่นยนต์ตามผลการทดสอบเพื่อเพิ่มประสิทธิภาพ
3.4 พัฒนาโปรแกรมควบคุมหุ่นยนต์สำหรับการตรวจจับและกู้ระเบิด
3.5 หุ่นยนต์กู้ระเบิดต้นแบบสามารถเคลื่อนที่ได้และกู้ระเบิดได้จริง

4. ประโยชน์ที่คิดว่าจะได้รับ

4.1 ช่วยลดความเสี่ยงและเพิ่มความปลอดภัยให้กับเจ้าหน้าที่กู้ระเบิด
4.2 พัฒนาทักษะด้านการเขียนโปรแกรมและการควบคุมหุ่นยนต์
4.3 สามารถช่วยชีวิตผู้คนได้
4.4 ส่งเสริมการเรียนรู้ผ่านการทำงานจริงและการแก้ปัญหาในสถานการณ์จำลอง0

5.ความรู้ที่เกี่ยวข้อง

5.1 Arduino Uno R3

Arduino Uno R3 คำว่า Uno เป็นภาษาอิตาลี ซึ่งแปลว่าหนึ่ง เป็นบอร์ด Arduino รุ่นแรกที่ผลิตออกมา มีขนาดประมาณ 68.6×53.4 mm. เป็นบอร์ดมาตรฐานที่นิยมใช้งานมากที่สุด เนื่องจากเป็นขนาดที่เหมาะสาหรับการเริ่มต้นเรียนรู้ Arduino และมี Shields ให้เลือกใช้งานได้มากกว่าบอร์ด Arduino รุ่นอื่นๆ ที่ออกแบบมาเฉพาะมากกว่า โดยบอร์ด Arduino Uno ได้มีการพัฒนาเรื่อยมา ตั้งแต่ R2 R3 และรุ่นย่อยที่เปลี่ยนชิปไอซีเป็นแบบ SMD เป็นบอร์ด Arduino ที่ได้รับความนิยมมากที่สุด เนื่องจากราคาไม่แพง และส่วนใหญ่โปรเจคและ Library ต่างๆ ที่พัฒนาขึ้นมา Support จะอ้างอิงกับบอร์ดนี้เป็นหลัก และข้อดีอีกอย่างคือกรณีที่ MCU เสียผู้ใช้งานสามารถซื้อมาเปลี่ยนเองได้ง่าย Arduino Uno R3 มี MCU ที่เป็น Package DIP

5.2 Servo

Servo Motor เป็นอุปกรณ์ที่สามารถควบคุมเครื่องจักรกล หรือระบบการทํางานนั้นๆ ให้เป็นไปตามความต้องการ เช่น ควบคุมความเร็ว (Speed) , ควบคุมแรงบิด (Torque) , ควบคุมแรงตําแหน่ง (Position) โดยให้ผลลัพธ์ตามความต้องการที่มีความแม่นยําสูง

5.3 บลูทูธ bluetooth

บลูทูท บ้างเขียน บลูทูธ (Bluetooth) เป็นมาตรฐานเทคโนโลยีแบบไร้สายในพื้นที่ใกล้ ซึ่งใช้แลกเปลี่ยนข้อมูลระหว่างเครื่องมือไร้สายที่อยู่ในบริเวณใกล้เคียงกันรวมถึงในเครือข่ายพื้นที่ส่วนบุคคล ในประเภทการใช้งานที่แพร่หลายที่สุด ขีดอำนาจในการส่งผ่านข้อมูลนั้นจำกัดอยู่ที่ 2.5 มิลลิวัตต์ ซึ่งทำให้เทคโนโลยีนี้ดำเนินไปได้ในพื้นที่ที่น้อยมาก คือ ไม่เกิน 10 เมตร เทคโนโลยีนี้อาศัยคลื่นวิทยุแบบยูเอชเอฟตั้งแต่ 2.402 กิกะเฮิรตซ์ไปจนถึง 2.48 กิกะเฮิรตซ์

6. การดำเนินงาน

6.1 Diagram การทำงานของระบบ

6.2 โค๊ด Code

#include "IR_remote.h"
#include "keymap.h"
#include <Servo.h>

// Infrared receiving control pin
#define RECV_PIN            3
// PWM control pin
#define PWM1_PIN            5
#define PWM2_PIN            6
// 74HCT595N chip pin
#define SHCP_PIN            2                               // The displacement of the clock
#define EN_PIN              7                               // Can make control
#define DATA_PIN            8                               // Serial data
#define STCP_PIN            4                               // Memory register clock         
// Servo control pin
#define CLAW_PIN            9
#define ARM_PIN             10
#define BASE_PIN            11
// Ultrasonic control pin
const int Trig       =      12;
const int Echo       =      13;
// Trace the control pin
#define LEFT_LINE_TRACJING      A0
#define CENTER_LINE_TRACJING    A1
#define right_LINE_TRACJING     A2

const int Forward       = 92;                               // Forward
const int Backward      = 163;                              // Backward
const int Turn_Left     = 149;                              // Left translation
const int Turn_Right    = 106;                              // Right translation
const int Top_Left      = 20;                               // Upper left mobile
const int Bottom_Left   = 129;                              // Lower left mobile
const int Top_Right     = 72;                               // Upper right mobile
const int Bottom_Right  = 34;                               // The lower right move
const int Stop          = 0;                                // Stop
const int Contrarotate  = 172;                              // Counterclockwise rotation
const int Clockwise     = 83;                               // Rotate clockwise

int base_degress = 90;
int arm_degress = 90;
int claw_degress = 90;
boolean Line_tracking_Function_flag = false;
boolean Avoidance_Function_flag = false;
boolean Following_Function_flag = false;
int Left_Tra_Value;
int Center_Tra_Value;
int Right_Tra_Value;
int Black_Line = 500;

IRremote IR(RECV_PIN);
Servo   clawservo;
Servo   armservo;
Servo   baseservo;

void setup()
{
    pinMode(SHCP_PIN, OUTPUT);
    pinMode(EN_PIN, OUTPUT);
    pinMode(DATA_PIN, OUTPUT);
    pinMode(STCP_PIN, OUTPUT);
    pinMode(PWM1_PIN, OUTPUT);
    pinMode(PWM2_PIN, OUTPUT);

    pinMode(Trig, OUTPUT);
    pinMode(Echo, INPUT);

    pinMode(LEFT_LINE_TRACJING, INPUT);
    pinMode(CENTER_LINE_TRACJING, INPUT);
    pinMode(right_LINE_TRACJING, INPUT);

    clawservo.attach(CLAW_PIN);
    armservo.attach(ARM_PIN);
    baseservo.attach(BASE_PIN);
    clawservo.write(135);
    armservo.write(45);
    baseservo.write(90);
    delay(500);

    Motor(Stop, 0);

    Serial.begin(9600);

}

void loop()
{
    switch (IR.getIrKey(IR.getCode(), IR_TYPE_EM))
    {
        case EM_IR_KEYCODE_UP:      // Forward
            Motor(Forward, 200);
            delay(200);
            break;
        case EM_IR_KEYCODE_DOWN:    // Backward
            Motor(Backward, 200);
            delay(200);
            break;
        case EM_IR_KEYCODE_LEFT:    // Turn_Left
            Motor(Turn_Left, 200);
            delay(200);
            break;
        case EM_IR_KEYCODE_RIGHT:    // Turn_Right
            Motor(Turn_Right, 200);
            delay(200);
            break;
        case EM_IR_KEYCODE_D:       // Top_Left
            Motor(Top_Left, 200);
            delay(200);
            break;
        case EM_IR_KEYCODE_PLUS:    // Top_Right
            Motor(Top_Right, 200);
            delay(200);
            break;
        case EM_IR_KEYCODE_0:       // Bottom_Left
            Motor(Bottom_Left, 200);
            delay(200);
            break;
        case EM_IR_KEYCODE_REDUCE:       // Bottom_Right
            Motor(Bottom_Right, 200);
            delay(200);
            break;
        case EM_IR_KEYCODE_OK:       // Clockwise
            Motor(Clockwise, 200);
            delay(200);
            break;
        case EM_IR_KEYCODE_4:       // Claws open
            claw_degress = claw_degress - 3;
            if (claw_degress <= 50) 
            {
                claw_degress = 50;
            }
            clawservo.write(claw_degress);
            delay(2);
            break;
        case EM_IR_KEYCODE_7:       // Paw closed
            claw_degress = claw_degress + 3;
            if (claw_degress >= 180) 
            {
                claw_degress = 180;
            }
            clawservo.write(claw_degress);
            delay(2);
            break;
        case EM_IR_KEYCODE_5:       // Arm forward
            arm_degress = arm_degress + 3;
            if (arm_degress >= 150) 
            {
                arm_degress = 150;
            }
            armservo.write(arm_degress);
            delay(2);
            break;
        case EM_IR_KEYCODE_8:       // Arm backwards
            arm_degress = arm_degress - 3;
            if (arm_degress <= 0) 
            {
                arm_degress = 0;
            }
            armservo.write(arm_degress);
            delay(2);
            break;
        case EM_IR_KEYCODE_6:       // Chassis left pendulum
            base_degress = base_degress + 3;
            if (base_degress >= 180) 
            {
                base_degress = 180;
            }
            baseservo.write(base_degress);
            delay(2);
            break;
        case EM_IR_KEYCODE_9:       // Chassis side
            base_degress = base_degress - 5;
            if (base_degress <= 0) 
            {
                base_degress = 0;
            }
            baseservo.write(base_degress);
            delay(2);
            break;
        case EM_IR_KEYCODE_1:       // Tracking mode
            Motor(Stop, 0);
            Line_tracking_Function();
            delay(500);
            break;
        case EM_IR_KEYCODE_2:       // Obstacle avoidance mode
            Motor(Stop, 0);
            Avoidance_Function();
            delay(500);
            break;
        case EM_IR_KEYCODE_3:       // Tracking mode
            Motor(Stop, 0);
            Following_Function();
            delay(500);
            break;
        default:
            Motor(Stop, 0);
            break;
    }
}

void Motor(int Dir, int Speed)
{
    digitalWrite(EN_PIN, LOW);
    analogWrite(PWM1_PIN, Speed);
    analogWrite(PWM2_PIN, Speed);

    digitalWrite(STCP_PIN, LOW);
    shiftOut(DATA_PIN, SHCP_PIN, MSBFIRST, Dir);
    digitalWrite(STCP_PIN, HIGH);
}

float SR04(int Trig, int Echo)
{
    digitalWrite(Trig, LOW);
    delayMicroseconds(2);
    digitalWrite(Trig, HIGH);
    delayMicroseconds(10);
    digitalWrite(Trig, LOW);
    float distance = pulseIn(Echo, HIGH) / 58.00;
    delay(10);
    return distance;
}

void Line_tracking_Function()           // Tracking mode
{
    Line_tracking_Function_flag = true;
    delay(500);
    while (Line_tracking_Function_flag)
    {
        Left_Tra_Value = analogRead(LEFT_LINE_TRACJING);
        Center_Tra_Value = analogRead(CENTER_LINE_TRACJING);
        Right_Tra_Value = analogRead(right_LINE_TRACJING);
        if (Left_Tra_Value < Black_Line && Center_Tra_Value >= Black_Line && Right_Tra_Value < Black_Line)
        {
            Motor(Forward, 175);
        }
        else if (Left_Tra_Value >= Black_Line && Center_Tra_Value >= Black_Line && Right_Tra_Value < Black_Line)
        {
            Motor(Contrarotate, 165);
        }
        else if (Left_Tra_Value >= Black_Line && Center_Tra_Value < Black_Line && Right_Tra_Value < Black_Line)
        {
            Motor(Contrarotate, 190);
        }
        else if (Left_Tra_Value < Black_Line && Center_Tra_Value < Black_Line && Right_Tra_Value >= Black_Line)
        {
            Motor(Clockwise, 190);
        }
        else if (Left_Tra_Value < Black_Line && Center_Tra_Value >= Black_Line && Right_Tra_Value >= Black_Line)
        {
            Motor(Clockwise, 165);
        }
        else if (Left_Tra_Value >= Black_Line && Center_Tra_Value >= Black_Line && Right_Tra_Value >= Black_Line)
        {
            Motor(Stop, 0);
        }
        if (IR.getIrKey(IR.getCode(), IR_TYPE_EM) == EM_IR_KEYCODE_1) 
        {
            Line_tracking_Function_flag = false;
            Motor(Stop, 0);
            delay(1000);
        }
    }
}

void Following_Function()
{
    int Following_distance = 0;
    Following_Function_flag = true;
    delay(500);
    while (Following_Function_flag)
    {
        Following_distance = SR04(Trig, Echo);
        if (Following_distance < 15)
        {
            Motor(Backward, 200);
        }
        else if (15 <= Following_distance && Following_distance <= 20)
        {
            Motor(Stop, 0);
        }
        else if (20 <= Following_distance && Following_distance <= 25)
        {
            Motor(Forward, 180);
        }
        else if (25 <= Following_distance && Following_distance <= 50)
        {
            Motor(Forward, 220);
        }
        else
        {
            Motor(Stop, 0);
        }
        if (IR.getIrKey(IR.getCode(), IR_TYPE_EM) == EM_IR_KEYCODE_3)
        {
            Following_Function_flag = false;
            Motor(Stop, 0);
            delay(1000);
        }
    }
}

void Avoidance_Function()
{
    int Avoidance_distance = 0;
    Avoidance_Function_flag = true;
    delay(500);
    while (Avoidance_Function_flag)
    {
        Avoidance_distance = SR04(Trig, Echo);
        if (Avoidance_distance <= 25) 
        {
            if (Avoidance_distance <= 15) 
            {
                Motor(Stop, 0);
                delay(100);
                Motor(Backward, 180);
                delay(600);
                Motor(Clockwise, 180);
                delay(200);
            } 
            else
            {
                Motor(Stop, 0);
                delay(100);
                Motor(Backward, 180);
                delay(300);
                Motor(Contrarotate, 180);
                delay(600);
            }
        } 
        else 
        {
            Motor(Forward, 180);
        }
        if (IR.getIrKey(IR.getCode(), IR_TYPE_EM) == EM_IR_KEYCODE_2)
        {
            Avoidance_Function_flag = false;
            Motor(Stop, 0);
            delay(1000);
        }
    }
}

6.3 หลักการใช้งานรีโมท IR

7. สรุปผล

ตัวต้นแบบหุ่นยนต์กู้ระเบิดนี้ประสบความสำเร็จในการพัฒนาฟังก์ชันพื้นฐานเพื่อการเก็บกู้และตรวจสอบวัตถุที่อาจเป็นระเบิดในพื้นที่เสี่ยง โดยมีรายละเอียดสรุปดังนี้:

ความสามารถในการเคลื่อนที่: หุ่นยนต์มีความคล่องตัวสูงด้วยฐานล้อ 4 ล้อที่ออกแบบมาให้เคลื่อนไหวได้ทั้งบนพื้นเรียบและพื้นขรุขระ ช่วยให้เข้าถึงพื้นที่แคบหรือซับซ้อนได้อย่างปลอดภัย
ระบบควบคุมระยะไกล: ใช้ระบบควบคุมไร้สาย (Wi-Fi หรือ RF) ทำให้สามารถควบคุมหุ่นยนต์ได้จากระยะปลอดภัย ช่วยลดความเสี่ยงต่อผู้ปฏิบัติงาน
แขนกลสำหรับกู้วัตถุต้องสงสัย: แขนกลสามารถจับและเคลื่อนย้ายวัตถุต้องสงสัยได้อย่างแม่นยำและระมัดระวัง ช่วยให้สามารถจัดการวัตถุได้โดยไม่เกิดความเสียหายหรืออันตรายเพิ่มเติม
เซนเซอร์ตรวจจับ: ติดตั้งเซนเซอร์ เช่น กล้องและเซนเซอร์โลหะ เพื่อช่วยในการระบุลักษณะของวัตถุและประเมินสถานการณ์เบื้องต้นได้ทันที

ผลลัพธ์โดยรวม: ตัวต้นแบบนี้สามารถทำงานได้ดีในสถานการณ์จำลองการเก็บกู้ระเบิด โดยมีความปลอดภัยและประสิทธิภาพสูง ทำให้ผู้ปฏิบัติงานสามารถตรวจสอบและจัดการวัตถุต้องสงสัยได้อย่างปลอดภัย