ระบบปฏิบัติการหุ่นยนต์ (ROS) ไม่ใช่ระบบปฏิบัติการจริง แต่เป็นเฟรมเวิร์กและชุดเครื่องมือที่ให้ฟังก์ชันการทำงานของระบบปฏิบัติการบนคลัสเตอร์คอมพิวเตอร์ที่แตกต่างกัน ประโยชน์ของมันไม่ได้ จำกัด อยู่แค่หุ่นยนต์ แต่เครื่องมือส่วนใหญ่ที่มีให้นั้นเน้นไปที่การทำงานกับฮาร์ดแวร์อุปกรณ์ต่อพ่วง

ROS แบ่งออกเป็นมากกว่า 2,000 แพ็คเกจแต่ละแพ็คเกจมีฟังก์ชันพิเศษ จำนวนเครื่องมือที่เชื่อมต่อกับเฟรมเวิร์กอาจเป็นพลังที่ยิ่งใหญ่ที่สุด

เหตุใดฉันจึงควรใช้ Robot OS

ROS มีฟังก์ชันการทำงานสำหรับฮาร์ดแวร์ที่เป็นนามธรรมไดรเวอร์อุปกรณ์การสื่อสารระหว่างกระบวนการผ่านเครื่องหลายเครื่องเครื่องมือสำหรับการทดสอบและการแสดงภาพและอื่น ๆ อีกมากมาย

คุณลักษณะที่สำคัญของ ROS คือวิธีการทำงานของซอฟต์แวร์และวิธีการสื่อสารทำให้คุณสามารถออกแบบซอฟต์แวร์ที่ซับซ้อนโดยไม่รู้ว่าฮาร์ดแวร์บางตัวทำงานอย่างไร ROS ให้วิธีการเชื่อมต่อเครือข่ายของกระบวนการ (โหนด) กับฮับกลาง โหนดสามารถทำงานได้บนอุปกรณ์หลายเครื่องและเชื่อมต่อกับฮับนั้นด้วยวิธีต่างๆ

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

นักพัฒนาสามารถประกอบระบบที่ซับซ้อนโดยเชื่อมต่อโซลูชันที่มีอยู่สำหรับปัญหาเล็ก ๆ วิธีการใช้งานระบบช่วยให้เราสามารถ:

• เปลี่ยนส่วนประกอบด้วยอินเทอร์เฟซที่คล้ายกันได้ทันทีโดยไม่จำเป็นต้องหยุดระบบสำหรับการเปลี่ยนแปลงต่างๆ

• มัลติเพล็กซ์เอาท์พุทของส่วนประกอบหลายอย่างเป็นอินพุตเดียวสำหรับส่วนประกอบอื่นช่วยให้สามารถแก้ปัญหาต่างๆได้แบบขนาน

  
  
  

• เชื่อมต่อส่วนประกอบที่สร้างในภาษาโปรแกรมต่างๆโดยใช้ตัวเชื่อมต่อที่เหมาะสมกับระบบการส่งข้อความทำให้ง่ายต่อการพัฒนาซอฟต์แวร์โดยเชื่อมต่อโมดูลที่มีอยู่จากนักพัฒนาต่างๆ

• สร้างโหนดผ่านเครือข่ายอุปกรณ์โดยไม่ต้องกังวลว่าโค้ดจะถูกรันและใช้ระบบ Interprocess Communication (IPC) และ Remote Procedure Call (RPC) ที่ใด

  
  
  

• เชื่อมต่อโดยตรงกับฟีดตามความต้องการจากฮาร์ดแวร์ระยะไกลโดยไม่ต้องเขียนโค้ดเพิ่มเติมใด ๆ โดยใช้สัญลักษณ์แสดงหัวข้อย่อยสองจุดก่อนหน้านี้

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

ROS สร้างขึ้นโดยชุมชนของตนเองซึ่งมีไว้สำหรับชุมชน หลังจากผ่านไปหลายปีส่งผลให้มีแพ็กเกจที่ใช้ซ้ำได้จำนวนมากซึ่งง่ายต่อการรวมเข้าด้วยกันด้วยสถาปัตยกรรมของระบบ

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

เรากำลังจะสร้างอะไร?

เนื่องจากโฟกัสของเราคือเฟรมเวิร์กและไม่ใช่อัลกอริทึมจริงสำหรับปัญหาเฉพาะปัญหาที่ระบุจึงค่อนข้างง่าย เป้าหมายของเราคือการสร้างซอฟต์แวร์สำหรับคอมพิวเตอร์ออนบอร์ดที่ช่วยให้เราควบคุมและตรวจสอบหุ่นยนต์จากระยะไกลเชื่อมต่อกับเราผ่าน Wi-Fi โดยใช้เกมแพดบนคอมพิวเตอร์และฟีดจากกล้องที่ติดตั้งบนหุ่น

ก่อนอื่นเราจะทำให้โปรแกรมง่ายๆเชื่อมต่อกับการจำลองแบบง่ายๆเพียงเพื่อสาธิตหลักการพื้นฐานของ ROS เราจะติดเกมแพดเข้ากับคอมพิวเตอร์และพยายามออกแบบรูปแบบการควบคุมที่ดีสำหรับการเปลี่ยนอินพุตเกมแพดให้เป็นสัญญาณควบคุมสำหรับหุ่นยนต์

ภาษาหลักในการเขียนโค้ด ROS คือ C ++ และ Python ซึ่ง C ++ เป็นที่ต้องการเนื่องจากประสิทธิภาพที่ดีขึ้น เราจะอธิบายตัวอย่างของเราใน Python เนื่องจากรหัสสำเร็จรูปน้อยกว่าและไม่จำเป็นต้องมีการสร้างที่ชัดเจน

การติดตั้งและการกำหนดค่า

เวอร์ชัน ROS เรียกตามชื่อ ณ วันนี้รุ่นล่าสุดคือ เต่าหยก และ LTS เวอร์ชันล่าสุด กระท่อมน้ำแข็งคราม . ไปสำหรับเวอร์ชัน LTS ดีกว่าและไม่รับประกันความเข้ากันได้ย้อนหลังใน ROS ดังนั้นตัวอย่างทั้งหมดจะถูกเขียนขึ้นสำหรับ คราม .

ROS พร้อมใช้งานบนแพลตฟอร์ม * NIX ต่างๆ เวอร์ชันที่รองรับอย่างเป็นทางการอยู่บน Ubuntu เวอร์ชัน OS X, Arch Linux, Debian, Raspbian และ Android ได้รับการสนับสนุนโดยชุมชน

เราจะเข้าสู่ขั้นตอนการติดตั้ง Ubuntu 14.04 บนเดสก์ท็อป กระบวนการสำหรับเวอร์ชันและแพลตฟอร์มที่รองรับทั้งหมดมีอยู่อย่างเป็นทางการ เว็บไซต์ . นอกจากนี้ยังมีเครื่องเสมือนที่ติดตั้ง ROS

การติดตั้งขึ้นอยู่กับแพลตฟอร์ม (และแพลตฟอร์มส่วนใหญ่มีแพ็คเกจให้) แต่การกำหนดค่าพื้นที่ทำงานจะเหมือนกันสำหรับทุกแพลตฟอร์ม

การติดตั้งบน Ubuntu

ROS มีที่เก็บของตัวเอง ขั้นตอนแรกคือการเพิ่ม

sudo sh -c 'echo 'deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main' > /etc/apt/sources.list.d/ros-latest.list' sudo apt-key adv --keyserver hkp://pool.sks-keyservers.net --recv-key 0xB01FA116 sudo apt-get update

หลังจากนั้นคุณจะมีแพ็คเกจที่โฮสต์ทั้งหมดสำหรับเวอร์ชัน ROS ทั้งหมดสำหรับเวอร์ชัน Ubuntu ของคุณ ตัวอย่างเช่น Ubuntu 14.04 รองรับ indigo และ jade.

การติดตั้งแพ็กเกจพื้นฐานบนเดสก์ท็อปมีหนึ่งในสามตัวเลือก:

• sudo apt-get install ros-indigo-ros-base สำหรับการติดตั้งขั้นต่ำ

• sudo apt-get install ros-indigo-desktop สำหรับการมีเครื่องมือ GUI พื้นฐานเพิ่มเติม

• sudo apt-get install ros-indigo-desktop-full สำหรับการมีคุณสมบัติที่เป็นทางการทั้งหมดรวมถึงเครื่องจำลองและไลบรารีต่างๆสำหรับการนำทางและการรับรู้

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

sudo apt-get install ros-indigo-

ขีดล่างจะถูกแทนที่ด้วยขีดกลางในชื่อสุดท้ายดังนั้น stage_ros จะอยู่ในแพ็คเกจ ros-indigo-stage-ros.

ขั้นตอนต่อไปคือการเริ่มต้น rosdep แพ็กเกจใน ROS สามารถประกาศได้ว่าขึ้นอยู่กับส่วนประกอบใดบ้าง rosdep ช่วยให้คุณสามารถรวบรวมแพ็คเกจเหล่านั้นได้โดยไม่ต้องจัดการการพึ่งพาด้วยตนเองมากเกินไป ในการเริ่มต้นโทร:

sudo rosdep init rosdep update

ROS มีตัวแปรสภาพแวดล้อมหลายตัวที่ใช้โดยเครื่องมือ ด้วยการติดตั้งเริ่มต้นสคริปต์ทุบตีเพื่อเริ่มต้นจะอยู่ใน /opt/ros/indigo/setup.bash จำเป็นต้องเริ่มต้นตัวแปรภายในทุกเซสชัน bash ดังนั้นทางออกที่ดีที่สุดคือเพิ่มลงใน ~/.bashrc

echo 'source /opt/ros/indigo/setup.bash' >> ~/.bashrc source ~/.bashrc

บางแพ็คเกจติดตั้งการอ้างอิงภายนอกผ่าน rosinstall ซึ่งมีให้ในรูปแบบแพ็คเกจและติดตั้งผ่าน sudo apt-get install python-rosinstall

นี่คือจุดสิ้นสุดของการติดตั้งบน Ubuntu ต่อไปนี้เป็นคำแนะนำสั้น ๆ เกี่ยวกับการติดตั้งพื้นที่ทำงาน

การกำหนดค่า

ตั้งแต่เมื่อ Groovy Galapagos พื้นที่ทำงาน ROS ได้รับการจัดการผ่าน catkin เราจำเป็นต้องกำหนดไดเร็กทอรีสำหรับแพ็คเกจทั้งหมดที่เราโฮสต์ ภายในไดเร็กทอรีเราสร้าง src โฟลเดอร์และโทร catkin_init_workspace ก่อตัวขึ้นภายใน ซึ่งจะสร้างลิงก์สัญลักษณ์ต่างๆไปยังเวอร์ชัน ROS ที่มาในปัจจุบัน ขั้นตอนต่อไปคือการเพิ่มพื้นที่ทำงานนี้ให้กับตัวแปรสภาพแวดล้อมเช่นกัน

ในการดำเนินการกำหนดค่าพื้นที่ทำงานทั้งหมดนี้ให้เลือกไดเร็กทอรีว่างและดำเนินการคำสั่งต่อไปนี้:

mkdir src cd src catkin_init_workspace cd .. catkin_make echo 'source $(pwd)/devel/setup.bash' >> ~/.bashrc source ~/.bashrc

ตอนนี้คุณได้สร้างพื้นที่ทำงานซึ่งคุณสามารถสร้างแพ็คเกจ ROS ของคุณเองได้

ทำความคุ้นเคยกับเครื่องมือ

การสร้างโค้ดใด ๆ ถือเป็นการก้าวกระโดดครั้งใหญ่ ก่อนอื่นมาทำความคุ้นเคยกับระบบบางอย่างที่ทำงานอยู่เบื้องหลัง ขั้นตอนแรกของเราคือการเรียกใช้ GUI พื้นฐานและดูว่าข้อความใดสร้างขึ้น

ในการรันสิ่งใด ๆ ใน ROS จำเป็นต้องเปิดตัวกระบวนการหลัก ทำได้ง่ายเพียงแค่เปิดหน้าต่างเทอร์มินัลใหม่แล้วพิมพ์:

roscore

ในเครือข่ายอุปกรณ์ที่เชื่อมต่อทั้งหมดของคุณ roscore ต้องเปิดใช้งานเพียงครั้งเดียวบนอุปกรณ์ที่จะโฮสต์ฮับกลางสำหรับการส่งการสื่อสาร

บทบาทหลักของ roscore คือการบอกโหนดว่าควรเชื่อมต่อกับโหนดใดและด้วยวิธีใด (ไม่ว่าจะผ่านพอร์ตเครือข่ายหรือหน่วยความจำที่ใช้ร่วมกัน) เป้าหมายคือเพื่อให้โหนดสนใจเฉพาะข้อมูลที่พวกเขาต้องการทราบแทนที่จะเป็นโหนดที่ต้องการเชื่อมต่อในขณะที่ลดเวลาและแบนด์วิดท์ที่จำเป็นในการสื่อสารทั้งหมด

rqt

หลังจากเรียกใช้ roscore เราสามารถเปิดเครื่องมือ GUI หลักสำหรับ ROS: rqt สิ่งที่เราเห็นนั้นท่วมท้นมาก - หน้าต่างว่างเปล่า rqt โฮสต์ปลั๊กอินที่หลากหลายซึ่งสามารถกำหนดค่าในการกำหนดค่าภาพและมุมมองที่กำหนดไว้ล่วงหน้าจำนวนเท่าใดก็ได้

c และ c++

สำหรับการเริ่มต้นเรามาเรียกใช้ไฟล์ หุ่นยนต์บังคับเลี้ยว ปลั๊กอินโดยเลือกใน Plugins > Robot Tools > Robot Steering. สิ่งที่เราได้รับคือตัวเลื่อนสองตัวซึ่งแสดงถึงการเคลื่อนที่เชิงเส้นและการหมุนที่เราต้องการให้หุ่นยนต์มี ที่ด้านบนของปลั๊กอินเราจะเห็นกล่องข้อความที่มี /cmd_vel ในนั้น. เราสามารถเปลี่ยนชื่อเป็นอะไรก็ได้ที่เราต้องการ แสดงถึงชื่อของหัวข้อที่มีการเผยแพร่พวงมาลัย เครื่องมือเทอร์มินัลเป็นสถานที่ที่ดีที่สุดในการดูว่าเกิดอะไรขึ้นในเบื้องหลัง

เครื่องมือเทอร์มินัล

ROS มีเครื่องมือที่มีประสิทธิภาพมากมายสำหรับตรวจสอบสิ่งที่เกิดขึ้นในระบบ เครื่องมือแรกที่เราจะแนะนำคือ rostopic ช่วยให้เราตรวจสอบหัวข้อที่โหนดสามารถสมัครและเผยแพร่ได้ วิ่ง rostopic list จะให้ผล:

/cmd_vel /rosout /rosout_agg

2 หัวข้อหลังจะทำงานอยู่เสมอและเกี่ยวข้องกับระบบ ROS ส่วนกลาง /cmd_vel กำลังเผยแพร่หัวข้อโดยการควบคุมของเรา การเปลี่ยนชื่อหัวข้อในพวงมาลัยจะเปลี่ยนชื่อที่นี่เช่นกัน ตอนนี้เราสนใจว่าเกิดอะไรขึ้นในหัวข้อนี้ วิ่ง rostopic echo /cmd_vel จะไม่แสดงอะไรให้เราเห็น (เว้นแต่คุณจะปรับแต่งด้วยแถบเลื่อน) กระบวนการทำงานจนกว่าเราจะยกเลิก ให้เราเลื่อนแถบเลื่อนแนวตั้งไปที่ 20 ม. / วินาที เมื่อมองไปที่เสียงสะท้อนเราจะเห็นสิ่งต่อไปนี้ซ้ำแล้วซ้ำอีก:

linear: x: 0.2 y: 0.0 z: 0.0 angular: x: 0.0 y: 0.0 z: 0.0

สแปมข้อความนี้บ่อยเพียงใด rostopic hz /cmd_vel กล่าวด้วยอัตราเฉลี่ย 10 Hz ฉันจะทำงานผ่านการเชื่อมต่อ Wi-Fi ช้าได้กี่หัวข้อเช่นนี้ rostopic bw /cmd_vel ตรวจจับค่าเฉลี่ย 480 B / s

ตอนนี้ทุกอย่างเรียบร้อยดี แต่เราได้พูดคุยเกี่ยวกับประเภทข้อความ ข้อมูลนี้ดีสำหรับมนุษย์ แต่แอปพลิเคชันจะต้องใช้ข้อมูลดิบและจำเป็นต้องทราบประเภทข้อความเพื่อให้สามารถตีความข้อมูลได้ สามารถกำหนดประเภทได้ด้วย rostopic type /cmd_vel บอกเราว่าเป็น geometry_msgs/Twist เครื่องมือเทอร์มินัล ROS ทั้งหมดที่เรียกโดยไม่มีอาร์กิวเมนต์จะส่งคืนข้อความวิธีใช้มาตรฐาน

ROS Wiki ดีพอที่จะทำการค้นหาเว็บสำหรับสตริงนี้ทำให้ได้คำอธิบาย Wiki เกี่ยวกับสิ่งที่มีอยู่และโครงสร้างของมัน แต่เราไม่จำเป็นต้องพึ่งพามัน rosmsg เป็นเครื่องมือทั่วไปสำหรับประเภทข้อความ วิ่ง rosmsg show geometry_msgs/Twist จะกลับมา:

geometry_msgs/Vector3 linear float64 x float64 y float64 z geometry_msgs/Vector3 angular float64 x float64 y float64 z

ข้อความประกอบด้วยเวกเตอร์ 3 มิติสองตัวซึ่งแสดงถึงความเร็วเชิงเส้นและเชิงมุมในปริภูมิ 3 มิติ

หากเราต้องการให้โหนดเชื่อมต่อกับหัวข้อใด rosnode info จะให้ข้อมูลโดยละเอียดเกี่ยวกับโหนด เครื่องมือ rostopic, rosmsg และ rosnode เป็นเครื่องมือหลักในการตรวจสอบการทำงานของ ROS แบบดิบ ROS มี GUI และเครื่องมือเทอร์มินัลมากมาย แต่สิ่งเหล่านี้อยู่นอกขอบเขตของเราสำหรับการแนะนำนี้

เครื่องมือหลักในการรันโหนด ROS คือ rusrun และ roslaunch. rosrun สามารถเรียกใช้โหนดผ่าน rosrun และ roslaunch เรียกใช้โหนดตามไฟล์เปิดตัวซึ่งเราจะคุ้นเคยในระดับเล็กน้อยเนื่องจากเป็นองค์ประกอบที่ซับซ้อนที่สุดของระบบอัตโนมัติ ROS

เราสามารถปิดทุกอย่างที่เราทำงานเพื่อเริ่มทำงานกับโค้ดแรกของเรา สำหรับการอ้างอิงในอนาคตมันจะไปโดยไม่บอกว่าการเรียกใช้สิ่งที่เกี่ยวข้องกับ ROS ต้องมีอินสแตนซ์ที่ใช้งานอยู่ของ roscore ปัญหามากมายที่คุณพบสามารถแก้ไขได้โดยปิดหน้าต่างเทอร์มินัลที่ roscore ถูกเรียกใช้ภายในและเปิดรายการใหม่เพื่อเปิดใช้งานใหม่ สิ่งนี้จะอัปเดตการอ้างอิงทั้งหมดที่จำเป็นต้องโหลดใหม่ทั้งใน bash และใน roscore.

การสร้าง Gamepad Teleoperation

เป้าหมายแรกของเราคือเลียนแบบการทำงานของ Robot Steering โดยการสร้างโหนดที่เผยแพร่ geometry_msgs/Twist ข้อมูลถึง /cmd_vel ขึ้นอยู่กับอินพุต gamepad จุดแรกของเราคือ joy แพ็คเกจ

joy แพ็คเกจ

joy แพคเกจมีไดรเวอร์ ROS ทั่วไปสำหรับจอยสติ๊กและเกมแพด ไม่รวมอยู่ในการติดตั้งเริ่มต้นดังนั้นจึงต้องติดตั้งผ่าน:

sudo apt-get install ros-indigo-joy

หลังจากการติดตั้งเราสามารถเรียกใช้ rosrun joy joy_node สิ่งนี้จะเชื่อมต่อเรากับจอยสติ๊กหรือแป้นเกมเริ่มต้น วิ่ง rostopic list แสดงให้เราเห็นว่าเรามีหัวข้อที่ชื่อว่า /joy รับฟังได้ทาง rostopic echo แสดงข้อความในรูปแบบต่อไปนี้ให้เรา (โปรดทราบว่าคุณต้องโต้ตอบกับ gamepad หรือจอยสติ๊กสำหรับข้อความที่จะเผยแพร่)

header: seq: 4156 stamp: secs: 1450707466 nsecs: 204517084 frame_id: '' axes: [0.0, 0.0, 0.0, -0.0, 0.0, 0.0, 0.0, 0.0] buttons: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

คุณสามารถละเว้นส่วนหัวได้ในตอนนี้ นอกเหนือจากนั้นเรามี axes และ buttons อธิบายอย่างชัดเจนว่าเป็นตัวแทนของอะไร การเคลื่อนแกนและกดปุ่มบนคอนโทรลเลอร์จะส่งผลให้ตัวเลขเหล่านี้เปลี่ยนไป เมื่อใช้เครื่องมือของเราเราสามารถระบุได้ว่าประเภทข้อความคือ sensor_msgs/Joy และรูปแบบคือ:

std_msgs/Header header uint32 seq time stamp string frame_id float32[] axes int32[] buttons

การสร้าง Teleoperation ของเรา

ขั้นตอนแรกในการเขียนโค้ดคือการสร้างแพ็คเกจ ภายใน src โฟลเดอร์ของพื้นที่ทำงานเรียกใช้:

catkin_create_pkg toptal_tutorial rospy joy geometry_msgs sensor_msgs

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

llc vs s corp vs c corp

ตอนนี้เรามี toptal_tutorial โฟลเดอร์ ภายในโฟลเดอร์ให้สร้าง scripts โฟลเดอร์ที่จะเก็บสคริปต์ Python ทั้งหมดของเรา

มาสร้างไฟล์ชื่อ teleop.py จากนั้นเราจะตั้งค่า:

#!/usr/bin/env python import rospy from sensor_msgs.msg import Joy def joy_callback(data): print data def main(): rospy.init_node('teleop') rospy.Subscriber('joy', Joy, joy_callback) while not rospy.is_shutdown(): pass if __name__ == '__main__': main()

เราจะต้องตั้งค่า chmod +x teleop.py ด้วย ดังนั้นสคริปต์จึงสามารถรันได้ วิ่ง rosrun joy joy_node ในเทอร์มินัลเดียวและ rosrun toptal_tutorial teleop.py อีกอันจะส่งผลให้เอาต์พุตเทอร์มินัลของ teleop.py เต็มไปด้วยข้อความ Joy

ลองตรวจสอบว่าโค้ดทำอะไร

ขั้นแรกเรานำเข้า rospy ซึ่งโฮสต์ไลบรารีสำหรับโต้ตอบกับกรอบงาน ROS แต่ละแพ็คเกจที่กำหนดข้อความจะมี msg แพคเกจย่อยที่มีคำจำกัดความของข้อความอยู่ในนั้น เรากำลังนำเข้า Joy เพื่อจัดการกับอินพุต ไม่จำเป็นต้องนำเข้าประเภทข้อความที่ฝัง (เช่น Header จาก std_msgs.msg ที่อยู่ในข้อความ Joy) เว้นแต่เราต้องการกล่าวถึงอย่างชัดเจน

ขั้นตอนแรกของเราคือการเริ่มต้นโหนดที่มีชื่อเฉพาะ (ในกรณีนี้เราเรียกว่า 'teleop') หลังจากนั้นเราจะสร้างสมาชิกที่สมัครรับหัวข้อ 'joy' ประเภท sensor_msgs.msg.Joy และจัดการแต่ละข้อความโดยการเรียก joy_callback ฟังก์ชัน การโทรกลับจะได้รับหนึ่งพารามิเตอร์ข้อมูลจากข้อความ การเข้าถึงข้อมูลสมาชิกทำได้ง่าย หากเราต้องการพิมพ์สถานะของแกนแรกหากจำประเภทข้อความได้เราจะเรียก print data.axes[0] และจะเป็นแบบลอย ลูปที่ปลายลูปจนกว่า ROS จะปิดลง

ขั้นตอนต่อไปคือการจัดการข้อมูลของเราอย่างใด เราควรสร้างข้อความ Twist ที่เปลี่ยนแปลงไปตามข้อมูลที่ป้อนจากนั้นเราจะเผยแพร่ไปยัง cmd_vel หัวข้อ.

#!/usr/bin/env python import rospy from sensor_msgs.msg import Joy from geometry_msgs.msg import Twist # new from functools import partial # new def joy_callback(pub, data): # modified cmd_vel = Twist() # new cmd_vel.linear.x = data.axes[1] # new cmd_vel.angular.z = data.axes[0] # new pub.publish(cmd_vel) # new def main(): rospy.init_node('teleop') pub = rospy.Publisher('cmd_vel', Twist, queue_size=1000) # new rospy.Subscriber('joy', Joy, partial(joy_callback, pub)) # modified while not rospy.is_shutdown(): pass if __name__ == '__main__': main()

ก่อนอื่นเราเพิ่ม Twist ข้อความและเราเพิ่มการสนับสนุนสำหรับอาร์กิวเมนต์ของฟังก์ชันการผูกผ่าน functools.partial เราสร้างสำนักพิมพ์ pub ที่เผยแพร่ไปยัง cmd_vel ข้อความประเภท Twist. เราผูกมัดผู้เผยแพร่รายนั้นกับการติดต่อกลับและกำหนดให้เผยแพร่ข้อความ Twist ในทุกอินพุตด้วยความเร็วที่แสดงด้วยสองแกนแรก รหัสนี้ทำในสิ่งที่เราคาดหวังและเราสามารถดูผลลัพธ์ที่ได้ผ่านทาง rostopic echo /cmd_vel

เรายังมีอีกหนึ่งประเด็น /joy หัวข้อสามารถเผยแพร่ในอัตราที่ดี หากเราตรวจสอบ rostopic hz /cmd_vel และเลื่อนแท่งอนาล็อกเป็นวงกลมเราจะเห็นข้อความจำนวนมาก ไม่เพียงส่งผลให้เกิดการสื่อสารจำนวนมาก แต่กระบวนการที่ได้รับข้อความเหล่านี้จะต้องดำเนินการกับแต่ละข้อความ ไม่จำเป็นต้องเผยแพร่ข้อมูลนั้นบ่อยนักและเราควรเผยแพร่ในอัตราคงที่ 10 Hz เราสามารถทำได้ด้วยรหัสต่อไปนี้

#!/usr/bin/env python import rospy from sensor_msgs.msg import Joy from geometry_msgs.msg import Twist from functools import partial def joy_callback(cmd_vel, data): # modified cmd_vel.linear.x = data.axes[1] cmd_vel.angular.z = data.axes[0] # moved pub.publish(cmd_vel) to main loop def main(): rospy.init_node('teleop') cmd_vel = Twist() # new pub = rospy.Publisher('cmd_vel', Twist, queue_size=1000) rospy.Subscriber('joy', Joy, partial(joy_callback, cmd_vel)) # modified rate = rospy.Rate(10) # new while not rospy.is_shutdown(): pub.publish(cmd_vel) # new rate.sleep() # new if __name__ == '__main__': main()

เราแก้ไขการโทรกลับเพื่อรับการเปลี่ยนแปลง Twist วัตถุและแก้ไขภายในลูป sleep ฟังก์ชันจาก rospy.Rate รักษาความถี่เอาต์พุตให้คงที่

รหัสสุดท้ายจะส่งผลให้ /cmd_vel หัวข้อรับคำสั่งความเร็วที่ 10 เฮิร์ตซ์เลียนแบบเอาต์พุตของ หุ่นยนต์บังคับเลี้ยว rqt เสียบเข้าไป.

เรียกใช้ระบบจำลอง

จำลองโลก

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

roscd stage_ros cd world

ภายในโฟลเดอร์มีไฟล์หลายไฟล์ มาเริ่มกันเลย

rosrun stage_ros stageros willow-erratic.world

สิ่งนี้สร้างขึ้นหลายหัวข้อ ความหมายของแต่ละรายการจะถูกบันทึกไว้ในแพ็คเกจด้วย ส่วนสำคัญมันมี cmd_vel.

ภายในเวทีที่จัดแสดงจะมีสี่เหลี่ยมสีน้ำเงินซึ่งแสดงถึงหุ่นยนต์ที่คุณควบคุม โดยใช้รหัสของเราหรือ หุ่นยนต์บังคับเลี้ยว เราสามารถควบคุมหุ่นยนต์ตัวนี้ได้ ลองใช้งาน

การตั้งค่าระบบของเราผ่านไฟล์เปิดตัว

มาสร้าง launch โฟลเดอร์ภายในแพ็คเกจของเราและภายในจะสร้างไฟล์ชื่อ teleop.launch โครงสร้างโฟลเดอร์สุดท้ายควรมีลักษณะดังนี้:

toptal_tutorial/ ├── CMakeLists.txt ├── launch │ └── teleop.launch ├── package.xml ├── scripts │ └── teleop.py └── src

ภายใน teleop.launch ไฟล์เราจะกำหนดชุดของโหนดและการเชื่อมต่อระหว่างกัน

robot_

โลกใหม่ประกอบด้วยหุ่นยนต์สี่ตัวและแต่ละหัวข้อมีคำนำหน้าเป็น robot_0/cmd_vel ดังนั้นหุ่นยนต์หมายเลข 0 จึงมีหัวข้อคำสั่งความเร็วที่เรียกว่า robot_0 นั่นคือเหตุผลที่เราทำให้การควบคุมของเราอยู่ในเนมสเปซที่เรียกว่า roscore เพื่อปรับชื่อให้อยู่ในรูปแบบใหม่ ในแง่นี้คุณสามารถคิดว่าชื่อหัวข้อเป็นโฟลเดอร์ในระบบไฟล์

ในการเรียกใช้ launchfiles ไม่ roscore มันจำเป็น. ในแง่หนึ่ง roscore เป็นเพียงกรณีพิเศษของไฟล์เปิดตัวที่ไม่ได้ทำอะไรเลย ถ้า a roslaunch toptal_tutorial teleop.launch หายไปมีเพียง Launchfile แรกที่เปิดตัวเท่านั้นที่จะรันคอร์ในขณะที่ส่วนที่เหลือจะเชื่อมต่อกับไฟล์นั้น ตอนนี้เราเรียกใช้การเปิดตัวด้วย:

/robot_/base_pose_ground_truth /robot_/base_scan_0 /robot_/base_scan_1 /robot_/camera_info_0 /robot_/camera_info_1 /robot_/cmd_vel /robot_/depth_0 /robot_/depth_1 /robot_/image_0 /robot_/image_1 /robot_/odom

หากทุกอย่างถูกต้องสิ่งนี้จะทำให้เกิดหุ่นจำลองที่มีหุ่นยนต์ 4 ตัวซึ่งหนึ่งในนั้นควบคุมด้วยแป้นเกมหรือจอยสติ๊กของเรา โลกนี้มีอะไรอีกมากมายภายใต้ประทุนมากกว่าโลกที่แล้ว หุ่นยนต์แต่ละตัวมี:

rqt

เราแทนที่ด้วย 0, 1, 2 หรือ 3 สิ่งนี้นำเราไปสู่หัวข้อสุดท้ายของเรา

การดูข้อมูลของเราด้วย rqt

เราไม่ได้เจาะลึก image_0 มากเกินไป แต่เป็นเครื่องมือที่สมบูรณ์แบบสำหรับการดูข้อมูลที่ซับซ้อนมากขึ้น คุณสามารถทดลองกับหัวข้อทั้งหมดได้ แต่เราจะเน้นที่ image_1, depth_0, depth_1 และ rqt หัวข้อ

มาเริ่มกันเลย Plugins > Visualization > Image View และลบปลั๊กอินที่เปิดอยู่ ตอนนี้เราจะเปิดตัวสร้างภาพ 4 ตัว (robot_0) และวางไว้ในรูปแบบตาราง 2x2 สุดท้ายที่มุมบนซ้ายของแต่ละมุมมองให้เลือกหนึ่งในสี่หัวข้อที่ระบุไว้สำหรับ stage_ros/world

สิ่งที่เราได้รับคือการมองเห็นสเตอริโอพร้อมการรับรู้เชิงลึกด้วยกล้องความละเอียดต่ำ โปรดทราบว่าเราสามารถได้รับผลลัพธ์นี้โดยไม่ต้องมีระบบป้อนข้อมูลของเรา หากเราเรียกใช้สิ่งนี้ (จากภายในโฟลเดอร์ rosrun stage_ros stageros willow-four-erratics-multisensor.world ):

/robot_0/cmd_vel

และเพิ่มไฟล์ หุ่นยนต์บังคับเลี้ยว ปลั๊กอินที่มีหัวข้อที่เรียกว่า export ROS_MASTER_URI=http://:11311/ เราจะได้ผลลัพธ์เดียวกันโดยการควบคุมเป็นแถบเลื่อนบนหน้าจอ

การนำผลลัพธ์ไปใช้กับระบบจริง

ฮาร์ดแวร์จำนวนมากรองรับ ROS อย่างเต็มที่โดยอาสาสมัครบุคคลที่สามมักจัดหาให้ แพลตฟอร์มหุ่นยนต์จำนวนมากมีไดรเวอร์ที่สร้างข้อความประเภทนี้และ ROS มีโหนดที่ใช้เว็บแคมและเผยแพร่ฟีดรูปภาพ

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

• ติดตั้ง ROS บนคอมพิวเตอร์ออนบอร์ดของหุ่นยนต์ของคุณ
• สร้างไฟล์เปิดตัวสำหรับคอมพิวเตอร์ออนบอร์ดที่เชื่อมต่อ ROS กับแพลตฟอร์มพื้นฐานและเซ็นเซอร์ระดับสูงทั้งหมดเช่นกล้องตัวค้นหาระยะเลเซอร์และอื่น ๆ โหนดที่จำเป็นสามารถมีอยู่แล้วหรือสามารถใช้งานได้โดยการสร้างผู้เผยแพร่ / ผู้สมัครสมาชิกไปยัง ROS ด้านหนึ่งและไดรเวอร์สำหรับการสื่อสารแบบอนุกรมในอีกด้านหนึ่ง
• ให้ Launchfile ทำงานเมื่อเริ่มต้น
• บนคอมพิวเตอร์ระยะไกลของคุณเพิ่ม roscore ในการเริ่มต้นทุบตีของคุณทำให้คอมพิวเตอร์ระยะไกลมองหา rqt บนชื่อโฮสต์และพอร์ตที่กำหนด
• เปิดตัว gazebo และ / หรือสคริปต์ใด ๆ สำหรับการตรวจสอบและควบคุมหุ่นยนต์

สิ่งที่เกิดขึ้นจริงเป็นเพียงการส่งออกตัวแปรสภาพแวดล้อมที่เหมาะสมบนอุปกรณ์ระยะไกลและส่วนที่เหลือจะจัดการเอง การรัน ROS บนคลัสเตอร์คอมพิวเตอร์จะต้องทำขั้นตอนเดียวสำหรับทุกเครื่อง

สรุป

เราได้แสดงให้เห็นว่าด้วยการเข้ารหัสเพียงเล็กน้อยคุณสามารถมีระบบตัวแปรที่ซับซ้อนซึ่งคุณสามารถจัดการได้ตามที่คุณต้องการ ระบบผู้เผยแพร่ / สมาชิกที่เรียบง่ายช่วยให้คุณพัฒนาไปป์ไลน์ซอฟต์แวร์ที่ประมวลผลข้อมูลในคลัสเตอร์ของคอมพิวเตอร์ได้อย่างรวดเร็วโดยไม่ต้องกังวลเกี่ยวกับการนำองค์ประกอบบางอย่างไปใช้

ในขณะที่เราใช้โปรแกรมจำลองที่เรียบง่าย แต่เครื่องจำลองที่ซับซ้อนมากขึ้นเช่น

|_+_|

(รวมอยู่ในเวอร์ชันเดสก์ท็อปเต็มรูปแบบ) ให้คุณสร้างไฟล์ โลก 3 มิติพร้อมฟิสิกส์และเซ็นเซอร์ที่ซับซ้อน และสามารถให้คุณได้สัมผัสกับผลลัพธ์และผลิตภัณฑ์ขั้นสุดท้ายก่อนที่จะมีการพัฒนา

บทนำนี้เป็นขั้นพื้นฐานมาก แต่ความหวังก็คือคุณสนใจที่จะทำงานกับกรอบงานอเนกประสงค์นี้มากขึ้น