ROSTHAI สร้างหุ่นยนต์ด้วย ROS

16 ตุลาคม 2561

ประกอบหุ่นยนต์ Raspberry Pi สำหรับใช้กับ ROS

อุปกรณ์ที่ใช้

1. Raspberry Pi 3 Model B

2. Micro SD Card Class 10 16GB + Card Adapter

3. 4WD Smart Robot Car Chassis Kits (สีน้ำเงิน)

4. Motor Driver Module L298N

5. Jumper (M2M) cable 20cm Male to Male

6. Jumper (F2M) cable 20cm Female to Male

7. Jumper (F2F) cable 10cm Female to Female

8. เพาเวอร์สวิตซ์สำหรับเปิดปิด

9. รางถ่าน 18650 3 ก้อน

10 . ถ่านชาร์จ 18650 Panasonic NCR18650B 3.7v 3400mAh จำนวน 3 ก้อน

11. สกรูหัวกลม+น็อตตัวเมีย ขนาด 2.6 มม. ยาว 10 มม

12. Power Bank 20000 mAh USB Output DC 5V/2.1A

เริ่มต้น ด้วย ใช้ Jumper 20cm Male to Male ผู้-ผู้ บัดกรี เข้ากับ มอเตอร์ ทั้ง 4 ตัว โดยเลือกสีของ Jumper ให้เหมือนกัน เป็นคู่ๆ เพื่อกำหนดขั้วของมอเตอร์ และ การจับคู่มอเตอร์

*** ในตัวอย่าง ****

มอเตอร์ 2 ตัวบน ใช้ Jumper สีขาว อยู่ด้านล่าง และ สีดำ อยู่ด้านบน
มอเตอร์ 2 ตัวล่าง ใช้ Jumper สีม่วง อยู่ด้านล่าง และ สีเทา อยู่ด้านบน

ประกอบมอเตอร์ 2 ตัว ด้านบน เข้ากับโครงของหุ่นยนต์ชั้นที่ 1

โดย... เชื่อมต่อสาย สีดำ จาก มอเตอร์ตัวที่ 1 ไปยัง มอเตอร์ตัวที่ 2 ที่เป็นสายสีดำเหมือนกัน และ เชื่อมต่อสาย สีขาว จาก มอเตอร์ตัวที่ 1 ไปยัง มอเตอร์ตัวที่ 2 ที่เป็นสายสีขาวเหมือนกัน

ประกอบมอเตอร์ 2 ตัว ด้านล่าง เข้ากับโครงของหุ่นยนต์ ชั้นที่1

โดย... เชื่อมต่อสาย สีเทา จาก มอเตอร์ตัวที่ 3 ไปยัง มอเตอร์ตัวที่ 4 ที่เป็นสายสีเทาเหมือนกัน และ เชื่อมต่อสาย สีม่วง จาก มอเตอร์ตัวที่ 3 ไปยัง มอเตอร์ตัวที่ 4 ที่เป็นสายสีม่วงเหมือนกัน

เมื่อประกอบเสร็จ จะเหลือสาย 2 คู่ สำหรับ ต่อเข้ากับ Motor Driver ดังรูป

ยึดเสา 6 เสา สำหรับ วาง โครงหุ่นยนต์ชั้นที่ 2

ใส่ล้อ ทั้ง 4 ล้อ

การประกอบ รางถ่าน + เพาเวอร์สวิตซ์ + Motor Driver

ใช้ สกรูหัวกลม+น็อตตัวเมีย ขนาด 2.6 มม. ยาว 10 มม. ยึด รางถ่าน 18650 แบบ 3 ก้อน

บัดกรี สายสีแดงจาก รางถ่าน ไปยัง ขาด้านหนึ่งของ เพาเวอร์สวิตซ์สำหรับเปิด-ปิดไฟเข้า Motor Driver

ใช้ จั้มเปอร์ ผู้-ผู้ ความยาว 20 เซ็นติเมตร ในตัวอย่างเป็นสายสีแดง บัดกรี เข้ากับ ขาด้านหนึ่งของ เพาเวอร์สวิตซ์สำหรับเปิด-ปิด ที่เหลือ และ บัตกรี จั้มเปอร์ ผู้-ผู้ ความยาว 20 เซ็นติเมตร ในตัวอย่างเป็นสายสีน้ำเงิน เข้ากับสายสีดำของรางถ่าน

ใช้กาวยึด เพาเวอร์สวิตซ์สำหรับเปิด-ปิด เข้ากับตัวหุ่นยนต์

ใส่ถ่านขนาด 18650 จำนวน 3 ก้อน เข้าไปที่ รางถ่าน

ใช้ สกรูหัวกลม+น็อตตัวเมีย ขนาด 2.6 มม. ยาว 10 มม. ยึด Motor Driver เข้า กับ โครงหุ่นยนต์ชั้นที่ 2

ใช้ สกรูหัวกลม+น็อตตัวเมีย ขนาด 2.6 มม. ยาว 10 มม. ยึด Raspberry Pi เข้า กับ โครงหุ่นยนต์ชั้นที่ 2

ยึด โครงหุ่นยนต์ชั้นที่ 2 เข้า กับ โครงหุ่นยนต์ชั้นที่ 1 ที่เตรียมไว้แล้ว โดยนำสายมอเตอร์ทั้ง 2 ด้าน และ สายไฟสำหรับจ่ายไฟ ให้กับ Motor Driver ออกมาไว้ด้านบนด้วย

เชื่อมต่อไฟเข้า Motor Driver ในตัวอย่างสายสีส้มเข้าไฟ +12V และ สายสีน้ำเงินเข้า GND (เมื่อต่อเสร็จ ทดสอบเปิด เพาเวอร์สวิตซ์ จะมีไฟสีแดงติดที่ Motor Driver) แล้วจึงยึดน๊อต 6 ตัว ด้านบน

การประกอบ Motor Driver กับ GPIO ของ Raspberry Pi

ใช้ จั้มเปอร์ ผู้-เมีย ความยาว 20 เซ็นติเมตร เชื่อมต่อจาก GND ของ Motor Driver (จะเสียบ 2 สายในช่องเดียวกัน) ในตัวอย่างเป็นสายสีน้ำเงิน ไปยัง GND ของ Raspberry Pi

ต่อสายมอเตอร์ทั้ง 2 ด้าน เข้ากับ Motor Driver ในตัวอย่างเป็นสาย สีขาวกับสายสีดำ และ สายสีม่วงกับสายสีเทา

เชื่อมต่อสายควบคุมมอเตอร์ จำนวน 4 เส้น ระหว่าง Raspberry Pi กับ Motor Driver ในตัวอย่าง เป็นสาย สีน้ำตาล-สีม่วง-สีเขียว-สีเหลือง

ภาพรวมการต่อถึงขั้นตอนนี้

ใช้ปืนยิงกาวยึด Power Bank เข้ากับตัวหุ่นยนต์ด้านล่าง

เสียบสาย USB เข้ากับ Power Bank

เสียบสาย Micro USB ของ Power Bank เข้ากับ Micro USB ของบอร์ด Raspberry Pi

ถึงขั้นตอนนี้หุ่นยนต์ของเราก็พร้อมที่จะใช้งานในขั้นตอนต่อไป

...

สร้าง Packages ภาษา Python ให้กับ Raspberry Pi

การสร้าง Package ด้วยภาษา Python

อ้างอิง : http://wiki.ros.org/rospy_tutorials/Tutorials/WritingPublisherSubscriber

เริ่มแรก เรามาออกแบบกันก่อน เรากำลังจะทำ Node 2 อัน ที่ทำหน้าที่พูดคนนึง และ รับฟังคนนึง

Package ชื่อ : test_python

โดยใช้ Dependencies ดังนี้:

1. catkin (build system)
2. rospy (ROS ภาษา Python)
3. std_msgs (Package ข้อความพื้นฐานใน ROS)

อยากจะสร้าง Node ที่ทำหน้าที่เป็น
Publisher 1 Node ทำหน้าที่ สุ่มตัวเลข แล้วส่งตัวเลขนั้นออกไป
Subscriber 1 Node ทำหน้าที่รับตัวเลขที่ส่งออกมา — แล้วแสดง

สร้าง Package ของ ROS ขึ้นมา ซึ่ง Package จะต้องอยู่ใน src ของ Workspace

เปิด Terminal ของ Ubuntu

catkin_create_pkg ชื่อ วรรค ตามด้วย dependency หลายๆตัว ที่เว้นวรรค 1 ที

cd catkin_ws/src

catkin_create_pkg test_python std_msgs rospy

เราจะได้ โฟลเดอร์ ที่มีชื่อว่า test_python ขึ้นมา พอเป็นเข้าไปด้านใน จะพบว่ามี โฟลเดอร์ และไฟล์มารอดังนี้

แล้วสร้างโฟลเดอร์ ที่มีชื่อว่า scripts ให้อยู่ภายใต้ โฟลเดอร์ test_python

เปิด Terminal ใหม่

mkdir catkin_ws/src/test_python/scripts

เขียนโค้ดภาษา Python

เปิดโปรแกรม IDLE (using Python-2.7)

คลิก New File เพื่อสร้างไฟล์ใหม่ เขียนโค้ดเสร็จแล้ว Save As.. เก็บไฟล์ไว้ที่ โฟลเดอร์ test_python/scripts

1. สร้าง Node ตัวส่งข้อความ “Publisher”

ไฟล์ : random_number.py

#!/usr/bin/env python
import rospy

from std_msgs.msg import Int32
from random import randint

def random_number_publisher():
    rospy.init_node('random_number')
    pub=rospy.Publisher('rand_no', Int32, queue_size=10)
    rate= rospy.Rate(2)

    while not rospy.is_shutdown():
        random_msg=randint(0,5000)
        rospy.loginfo(random_msg)
        pub.publish(random_msg)
        rate.sleep()

if __name__=='__main__':
    try:
        random_number_publisher()
    except rospy.ROSInterruptException:
        pass

ต้องการให้เป็นไฟล์ที่ ROS เรียกใช้งานได้ เปิด Terminal ใหม่ โดยคำสั่ง:

cd catkin_ws/src/test_python/scripts

chmod u+x random_number.py

2. สร้าง Node ตัวรับข้อความ “Subscriber”

ไฟล์ : random_subscriber.py

#!/usr/bin/env python

import rospy

from std_msgs.msg import Int32

def callback(data):
    rospy.loginfo("I receive %s", data.data)

def random_subscriber():
    rospy.init_node('random_subscriber')
    rospy.Subscriber('rand_no',Int32, callback)
    rospy.spin()

if __name__=='__main__':
    random_subscriber()

ต้องการให้เป็นไฟล์ที่ ROS เรียกใช้งานได้ เปิด Terminal ใหม่ โดยคำสั่ง:

cd catkin_ws/src/test_python/scripts

chmod u+x random_subscriber.py

หลังจากเขียนโค้ดเสร็จแล้ว ให้ทำการ Build โดย เปิด Terminal ใหม่ แล้วใช้คำสั่ง

cd catkin_ws

catkin_make

ทดสอบการทำงาน

หน้าต่างที่1 เราจะ RUN ระบบ ROS จะต้องมี Core ที่ทำหน้าที่เป็นหัวใจของระบบ

roscore

หลังจากนั้นจึง Run Node ของเราได้

หน้าต่างที่ 2 เปิด Publisher (ตัวส่งข้อมูล)

rosrun test_python random_number.py

หน้าต่างที่ 3 เปิด Subscriber (ตัวฟัง/รับข้อมูล)

rosrun test_python random_subscriber.py

กด Ctrl + C ถ้าต้องการหยุดการทำงาน

หมายเหตุ : เรียบเรียงและแก้ไขดัดแปลงจากบทความต้นฉบับด้านล่าง

ติดตั้ง ROS สร้าง Workspace ให้กับ Raspberry Pi

สภาพแวดล้อมในการพัฒนาโปรแกรม (Developing Environment) ที่ใช้อยู่ตอนนี้เป็น Ubuntu Xenial (16.04) ซึ่งบังคับให้ ROS ต้องใช้เวอร์ชั่น ROS Kinetic Kame มาเริ่มติดตั้งกันเลยนะครับ

การติดตั้ง ROS Kinetic Kame

โดยจะอ้างอิง การติดตั้ง จาก Official Website ของ ROS

http://wiki.ros.org/kinetic/Installation/Ubuntu

หน้าจอเริ่มต้นของ Ubuntu MATE

เริ่มต้นจากการเปิด Terminal โดย คลิกขวา ที่ Home แล้ว เลือก Open in Terminal

Terminal ของ Ubuntu MATE

โดยสามารถ Copy และ Paste ใน Terminal ได้

1. เริ่ม Add Repository ใส่ใน Ubuntu ก่อน

sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'

2. Setup Key ของการเข้าถึง Package

sudo apt-key adv --keyserver hkp://pgp.mit.edu:80 --recv-key 421C365BD9FF1F717815A3895523BAEEB01FA116

3. หลังจาก Add Key Add repository แล้ว ก็ Update (ดึงจากแหล่งข้อมูล)

sudo apt-get update

4. เริ่มติดตั้ง ROS Kinetic

sudo apt-get install ros-kinetic-desktop-full

5. ติดตั้ง Environment ของ ROS เพื่อให้ ROS จัดการเรื่อง การอ้างอิงต่างๆ ที่จำเป็นกับ Framework

sudo rosdep init

rosdep update

6. ทำให้ Terminal รู้จักคำสั่งของ ROS ด้วย Code ชุดนี้

echo "source /opt/ros/kinetic/setup.bash" >> ~/.bashrc

source ~/.bashrc

เป็นการเอาคำสั่งต่างๆที่ ROS มี ไปแจ้งให้กับ terminal (ในที่นี้ใช้ bash — config file จะอยู่ที่ home folder ชื่อไฟล์ “.bashrc” ) ซึ่ง source ก็คือ การสั่งใช้ config นั้น นั่นเอง

7 . ติดตั้งตัวช่วยในการสร้างแพ็คเกจ

sudo apt-get install python-rosinstall python-rosinstall-generator python-wstool build-essential

8. ทดลองการทำงานของ Core ROS ด้วยการ พิมพ์ roscore (หน้าต่างที่ 1)

roscore

ถ้าไม่มี Error และแสดงภาพประมาณภาพด้านล่าง แสดงว่า ROS ของเรานั้นพร้อมทำงานแล้วครับ

การสร้าง Catkin Workspace

เปิด Terminal โดย คลิกขวา ที่ Home แล้ว เลือก Open in Terminal

1. สร้างโฟลเดอร์ที่จะเป็น Workspace ในที่นี้จะตั้งชื่อว่า catkin_ws ไว้ที่ home ของ Ubuntu

mkdir catkin_ws

2. สร้างโฟลเดอร์ ที่เก็บ Code ของเรา ชื่อ src (อยู่ใน catkin_ws อีกที)

mkdir catkin_ws/src

3. Initial Workspace (เตรียม Site ก่อสร้าง) เข้าไปที่โฟลเดอร์ src แล้วใช้คำสั่ง catkin_init_workspace

cd catkin_ws/src

catkin_init_workspace

4. ระบุว่านี่คือ Site ก่อสร้าง Code ของเรา ด้วยการ Build Workspace ที่เปล่าๆ 1 ครั้ง ให้เกิด Reference โดยไปที่ โฟลเดอร์ catkin_ws แล้วใช้คำสั่ง catkin_make

เปิด Terminal ใหม่

cd catkin_ws

catkin_make

จะพบว่ามี โฟลเดอร์ เพิ่มเข้ามา ซึ่งเป็นของที่ประกอบขึ้นมาเป็น Workspace ของเรา

5. บอกกับ Ubuntu ว่า ROS Workspace ได้ปักหลักตรงนี้แล้ว

จะได้รวบรวมของที่เราเคย Install ไว้แล้ว (ROS ทั้งหมด รวมถึง Catkin) ให้สามารถมาใช้งานร่วมกับตรงนี้ได้

สั่งให้ Ubuntu รู้จัก ROS Workspace ของเรา ผ่านไฟล์ setup.bash โดยเปิดไฟล์ชื่อ .bashrc ภายใต้โฟลเดอร์ home ขึ้นมาแก้ไข แล้วเพิ่มโค้ด "source ~/catkin_ws/devel/setup.bash" ที่บอกไฟล์กรรมสิทธิ์การก่อสร้างของเรา เปิด Terminal ใหม่ ต่อท้ายไฟล์เข้าไป ด้วยคำสั่ง

echo "source ~/catkin_ws/devel/setup.bash" >> ~/.bashrc

หลังจากนี้ “ต้องปิด Terminal และเปิดมันขึ้นมาใหม่” เพื่อให้ระบบโหลดไฟล์ที่เพิ่งแก้ใหม่ ซึ่งตอนเปิด Terminal มันจะทำให้ หรือใช้คำสั่ง source ~/.bashrc ก็ได้เช่นกัน

source ~/.bashrc

หลังจากนี้ ระบบ ทั้ง Ubuntu และ Catkin ก็คือ ROS ก็จะรู้จักว่า Workspace เรา Code เราอยู่ตรงนี้แล้ว

...

หมายเหตุ : เรียบเรียงและแก้ไขดัดแปลงจากบทความต้นฉบับด้านล่าง

15 ตุลาคม 2561

ติดตั้ง Ubuntu MATE ลงใน Raspberry Pi

อุปกรณ์ที่ใช้

1. Raspberry Pi 3 Model B

2. Micro SD Card Class 10 16GB + Card Adapter

3. 5V 2.1A Power Adapter + MircoUSB

4. จอ Monitor

5. HDMI to VGA Adapter สำหรับต่อ Raspberry Pi กับ Monitor

6. USB Keyboard

7. USB Mouse

8. คอมพิวเตอร์ PC / Laptop

บอร์ด Raspberry Pi (ออกเสียงว่า ราส-เบอร์-รี่-พาย) Model B (Model B+ ไม่สามารถลง Ubuntu MATE เวอร์ชั่นนี้ได้ ) Raspberry Pi คือ บอร์ดคอมพิวเตอร์ขนาดเล็ก ที่ถูกพัฒนาขึ้นโดย Raspberry Pi Foundation มีคุณสมบัติเด่น คือ ติดต่อ และ ความคุมอุปกรณ์อิเล็กทรอนิกส์ได้

Raspberry Pi ไม่มีหน่วยความจำแบบแฟลชเมมโมรี ดังนั้นจำเป็นที่จะใช้ SD Card ภายนอก ซึ่งหากเปรียบเทียบกับคอมพิวเตอร์ SD Card นี้ก็จะเปรียบเสมือนฮาร์ดดิสก์นั่นเอง การลงระบบปฏิบัติการ OS รวมถึงการโปรแกรมหรือข้อมูลต่างๆ จะถูกจัดเก็บไว้ใน SD Card นี้ทั้งหมด ดังนั้นความเร็วในการสื่อสารรวมถึงคุณภาพของ SD Card ก็เป็นสิ่งที่ต้องคำนึงถึง ซึ่งโปรเจคนี้เลือกการ์ดที่เป็น Class 10 ที่ความจุ 16GB เพื่อให้การใช้งาน Raspberry Pi มีประสิทธิภาพมากที่สุด

การจะใช้งาน บอร์ด Raspberry Pi นั้น ขั้นแรกจะต้องลงปฏิบัติการ Linux ให้กับบอร์ด Raspberry Pi เสียก่อน ซึ่งในการใช้ ROS นี้จะใช้ระบบปฏิบัติการ Ubuntu (อูบุนตู) ชื่อของดิสทริบิวชันนั้นมาจากคำในภาษาซูลู และภาษาโคซา (ภาษาในแอฟริกาใต้) ว่า Ubuntu ซึ่งมีความหมายในภาษาอังกฤษคือ "humanity towards others" เป็นระบบปฏิบัติการที่มีรากฐานมาจากระบบปฏิบัติการ Debian (เดเบียน) ซึ่งแตกตัวออกมาจากระบบปฏิบัติการ Linux คำสั่งต่างๆ ของ Ubuntu จึงจะเหมือนกับคำสั่งที่มีใช้งานบนระบบปฏิบัติการ Linux เกือบทั้งหมด จะมีแตกต่างกันบ้างเล็กน้อยเท่านั้น

ซึ่งตัวอย่างในการทำงานนี้จะเป็น คอมพิวเตอร์ ระบบปฏิบัติการ Windows 7

ติดตั้ง Ubuntu MATE

1. ดาวน์โหลดไฟล์ระบบปฏิบัติการ Ubuntu MATE

สามารถดาวน์โหลดได้จากลิงค์

https://ubuntu-mate.org/raspberry-pi/ubuntu-mate-16.04.2-desktop-armhf-raspberry-pi.img.xz

หรือ

https://drive.google.com/open?id=1UevdfM8jd2MrwXfSQP7gQ0zU9aDtYR-z

2. ทำให้เป็นไฟล์ Image (*.img) โดยโปรแกรม 7 Zip

7 Zip ดาวน์โหลดที่

https://www.7-zip.org/download.html

เปิดไฟล์ ubuntu-mate-16.04.2-desktop-armhf-raspberry-pi.img ที่เราดาวน์โหลดมา

คลิก .... เพื่อเลือกโฟลเดอร์ ที่ต้องการเก็บไฟล์

เลือกโฟลเดอร์ ที่ต้องการเก็บไฟล์ไว้ (ในตัวอย่างเป็น D:\2018-Ubuntu-Mate\) -> ตกลง

เมื่อเข้าไปดูที่ โฟลเดอร์ จะพบ Ubuntu MATE ที่เป็นไฟล์ Image (*.img)

3. ฟอร์แมต SD Card

ติดตั้งโปรแกรม SD Card Formatter 5.0 ใช้สำหรับ Format Disk สามารถดาวน์โหลดได้จากลิงก์

https://www.sdcard.org/downloads/formatter_4/eula_windows/

จากนั้นให้คลิกปุ่ม Accept โปรแกรม SD Formatter โปรแกรมจึงจะดาวน์โหลดสู่ คอมพิวเตอร์ของเรา

Micro SD Card , Class 10 ความจุ 16GB + Card Adapter

ให้เสียบ Micro SD Card เข้าไปใน Card Adapter

Card Adapter ที่มี Micro SD Card อยู่ด้านใน

แล้วจึงเสียบ Card Adapter ที่บรรจุ Micro SD Card ใส่ในช่องซ็อกเก็ตของคอมพิวเตอร์ PC (ดันจนกระทั่งมีเสียงคลิก)

แล้วทำการ Format , Micro SD Card โดยใช้โปรแกรม SD Card Formatter

ถ้าเสียบ Card Adapter ที่บรรจุ Micro SD Card ได้ถูกต้อง ที่ Select card จะมี ไดรฟ์ ให้เลือก ในตัวอย่างจะเป็น ไดรฟ์ F:/

เลือก Quick format และที่ Volume label ในตัวอย่างตั้งชื่อเป็น Robot

คลิก Format

คลิก Yes

คลิก OK ถึงขั้นตอนนี้การ Format SD Card ของเรานั้นเสร็จสมบูรณ์แล้ว ให้ปิดโปรแกรมลงไป

4. เขียนไฟล์ Image ลงใน SD Card

ติดตั้งโปรแกรม Win32 Disk Imager ใช้สำหรับเขียนไฟล์ระบบปฏิบัติการที่เป็นไฟล์ Image (*.img) ลงบน Micro SD Card สามารถดาวน์โหลดได้จากลิงก์

http://sourceforge.net/projects/win32diskimager/

เมื่อติดตั้งโปรแกรมเสร็จแล้ว

ให้เขียนไฟล์ image ระบบปฏิบัติการ Ubuntu MATE ทีเราทำการคลายซิบ เป็นไฟล์ Image (*.img) แล้ว ลง ไปใน Micro SD Card

โดย Browse เลือกไปยัง โฟลเดอร์ที่เราเก็บไฟล์ Image (*.img) ระบบปฏิบัติการ Ubuntu MATE ไว้ (จากการทำงานในข้อที่ 2)

เลือก Device ที่จะเขียน ไฟล์ image ลงไป ก็คือ Device ที่เสียบ Micro SD Card อยู่ ในตัวอย่างเป็นไดรฟ์ F:\

คลิกปุ่ม Write

จะปรากฏหน้าต่างยืนยัน ให้คลิกปุ่ม Yes

โปรแกรมจะเริ่มเขียนไฟล์ image ระบบปฏิบัติการ Ubuntu MATE ลง ไปใน Micro SD Card

หน้าต่างแสดงเมื่อเขียนไฟล์ image ระบบปฏิบัติการ Ubuntu MATE สำเร็จ คลิก OK แล้วปิดโปรแกรมลงไป

ดัน Card Adapter จนกระทั่งมีเสียงคลิก เพื่อนำ Card Adapter ที่มี Micro SD Card อยู่ด้านใน ออกมาจากคอมพิวเตอร์ PC ของเรา

5. ประกอบ Raspberry Pi เข้ากับอุปกรณ์คอมพิวเตอร์

นำ Micro SD Card ออกจาก Card Adapter แล้วเสียบลงในช่องซ็อกเก็ต Micro SD Card Slot ของบอร์ด Raspberry Pi โดยมีขั้นตอนดังนี้

Card Adapter ที่มี Micro SD Card อยู่ด้านใน

ถอด Micro SD Card ออกจาก Card Adapter

เสียบ Micro SD Card ลงในช่องซ็อกเก็ต Micro SD Card Slot ที่อยู่ด้านล่างของบอร์ด Raspberry Pi

ดัน Micro SD Card เข้าในช่องซ็อกเก็ต Micro SD Card ของบอร์ด Raspberry Pi

กลับสู่ด้านบนของบอร์ด Raspberry Pi

เสียบ Keyboard เข้ากับ 4 x USB 2 Ports ของบอร์ด Raspberry Pi

เสียบ Mouse เข้ากับ 4 x USB 2 Ports ของบอร์ด Raspberry Pi

เสียบ Monitor เข้ากับ Full Size HDMI Video Output ของบอร์ด Raspberry Pi

สายแปลงสัญญาณ HDMI to VGA

ถ้า Monitor เป็นแบบไม่มีที่เสียบสาย แบบ HDMI สามารถใช้ สายแปลงสัญญาณ HDMI to VGA เพื่อให้ ใช้งานได้ตามปกติ

ป้อนแหล่งจ่าย 5V 2.1A Power Adapter + MircoUSB เข้ากับ 5V Micro USB ของบอร์ด Raspberry Pi

5V 2.1A Power Adapter + MircoUSB

เลือกตามค่า Default เป็น English

เลือก Connect to this network และเลือก WiFi และป้อน Password ในการเชื่อมต่อ

เลือกตามค่า Default เป็น English (US)

พิมพ์ชื่อ, ชื่อคอมพิวเตอร์,ชื่อเข้าระบบและรหัสผ่าน

ที่จอภาพ จะแสดง ระบบปฏิบัติการ Ubuntu MATE ถึงขั้นตอนนี้ แสดงว่า บอร์ด Raspberry Pi ของเรานั้น ได้ติดตั้ง ระบบปฏิบัติการ Ubuntu MATE สําเร็จแล้ว