โดรนอัตโนมัติที่ใช้ VSLAM แบบเรียลไทม์บน Jetson Orin Nano เพื่อนำทางในพื้นที่ที่ไม่มีสัญญาณ GPS ผ่านการตรวจจับภาพร่วมกับข้อมูลความเร่ง (Visual-Inertial Sensing) และการทำแผนที่บนบอร์ด

การนำทางแบบอัตโนมัติในสภาพแวดล้อมที่ไม่มีสัญญาณ GPS ถือเป็นหนึ่งในความท้าทายที่สำคัญที่สุดของระบบอากาศยานไร้คนขับ (UAV) ในปัจจุบัน ไม่ว่าจะเป็นในเขตเมืองที่มีตึกสูง (urban canyons), อุโมงค์ใต้ดิน หรือป่าทึบ สภาพแวดล้อมเหล่านี้มักทำให้สัญญาณ GPS ไม่เสถียรหรือไม่สามารถใช้งานได้เลย
เพื่อให้โดรนสามารถปฏิบัติภารกิจในสถานการณ์เหล่านี้ได้อย่างปลอดภัยและมีประสิทธิภาพ ไม่ว่าจะเป็นภารกิจค้นหาและช่วยเหลือ, การลาดตระเวนทางทหาร, หรือการตรวจสอบในภาคอุตสาหกรรม โดรนจึงจำเป็นต้องพึ่งพาความสามารถในการรับรู้และทำแผนที่จากระบบภายในตัวเอง
โครงการนี้นำเสนอแพลตฟอร์ม UAV ที่ขับเคลื่อนด้วยเทคโนโลยี Visual Simultaneous Localization and Mapping (VSLAM) โดยใช้ Isaac ROS VSLAM ผสานกับ MAVROS และระบบบิน PX4 โดยการหลอมรวมข้อมูลจากกล้องและเซ็นเซอร์ความเร่ง (Visual-Inertial) และใช้ขุมพลังประมวลผลปลายทางของ Jetson Orin Nano ทำให้ระบบสามารถระบุตำแหน่งและสร้างแผนที่ได้แบบเรียลไทม์ ซึ่งทำให้โดรนสามารถนำทางได้ด้วยตัวเองโดยไม่ต้องพึ่งพา GPS
ด้วยการใช้งานจริงในโครงการนี้ UAV สามารถรักษาการรับรู้สถานการณ์ (situational awareness), สร้างแผนที่ของพื้นที่ที่ไม่เคยรู้จักมาก่อน และบินแบบอัตโนมัติด้วยความแม่นยำสูง งานนี้ไม่เพียงแต่แสดงให้เห็นถึงความเป็นไปได้ของการนำ VSLAM ไปใช้งานบนฮาร์ดแวร์ที่มีทรัพยากรจำกัดเท่านั้น แต่ยังตอกย้ำถึงความสำคัญของเทคโนโลยีนี้ในการขยายขอบเขตและความเชื่อถือได้ของระบบอัตโนมัติในสภาพแวดล้อมที่ไม่มี GPS
วิดีโอสาธิต
กล้อง Motion Capture ที่เห็นในวิดีโอมีไว้เพื่อการตรวจสอบตำแหน่งจริง (ground truth) เท่านั้น ขณะที่ UAV ใช้เฉพาะระบบวัดตำแหน่งจากการจับภาพและความเร่ง (Visual-Inertial Odometry – VIO) และ IMU ของตัวควบคุมการบิน โดยผ่านการคำนวณร่วมในตัวกรองคาลมานแบบขยาย (EKF) เพื่อประมาณตำแหน่งในระหว่างบิน
ความต้องการของระบบ
ระบบ VSLAM UAV นี้รองรับการทำงานร่วมกับ:
- คอนโทรลเลอร์การบิน PX4 (v1.15.4)
- กล้อง Intel D435i
- คอมพิวเตอร์ร่วม Jetson Orin Nano (JetPack 6.2)
- คอนโทรลเลอร์การบิน PX4 (v1.15.4)
หากยังไม่ได้ติดตั้ง JetPack 6.2 สำหรับ Jetson Orin Nano กรุณาดำเนินการตามคู่มือเริ่มต้นใช้งาน (Getting Started Guide)
การตั้งค่า Jetson Orin Nano
การต่อสาย
ในคู่มือนี้จะใช้พอร์ต TELEM2 ของคอนโทรลเลอร์การบินเพื่อเชื่อมต่อกับคอมพิวเตอร์ร่วม (companion computer)
แม้ว่า Jetson Orin Nano จะสามารถเชื่อมต่อผ่านขา GPIO ได้ในทางทฤษฎี แต่ในการทดสอบพบว่าการสื่อสารกับคอนโทรลเลอร์การบินมีปัญหาเนื่องจากสัญญาณรบกวน จึงแนะนำให้ใช้ อะแดปเตอร์ USB to UART แทน
- เชื่อมต่อขา TELEM2 TX/RX ของคอนโทรลเลอร์การบิน เข้ากับขา RXD/TXD ที่ตรงกันของอะแดปเตอร์ USB to UART
- เสียบกล้อง Intel D435i เข้ากับ Jetson Orin Nano ผ่านพอร์ต USB
- Jetson Orin Nano ต้องใช้แหล่งจ่ายไฟแยกต่างหาก 7-20V โดยรองรับกำลังไฟสูงสุด 36W ควรต่อเข้าที่หัวแจ็คทรงกระบอก (barrel jack) หรือพอร์ต USB-C ดังภาพที่แนบไว้

การตั้งค่าซอฟต์แวร์
ตรวจสอบให้แน่ใจว่าคุณได้ติดตั้งเวอร์ชันของ JetPack ที่ถูกต้องแล้ว โดยรันคำสั่งต่อไปนี้:
$ cat /etc/nv_tegra_release
ตรวจสอบให้อินพุตแสดงคำว่า R36 (release) และ REVISION: 4.3 ซึ่งบ่งบอกว่าคุณกำลังใช้งาน JetPack 6.2
จากนั้น ตั้งค่า ความเร็วของ GPU และ CPU ให้สูงสุด โดยทำตามขั้นตอนต่อไปนี้:
$ sudo /usr/bin/jetson_clocks
จากนั้น รันคำสั่งต่อไปนี้เพื่อ ตั้งค่าพลังงานไปที่โหมด MAXN SUPER:
$ sudo /usr/sbin/nvpmodel -m 2
JetPack มาพร้อมกับ Docker ที่ติดตั้งไว้ล่วงหน้าแล้ว อย่างไรก็ตาม คุณจำเป็นต้องเพิ่มผู้ใช้งานของคุณเข้าไปในกลุ่ม docker เพื่อให้สามารถรันคำสั่ง Docker ได้โดยไม่ต้องใช้ sudo ให้รันคำสั่งต่อไปนี้:
$ sudo usermod -aG docker $USER
$ newgrp docker
การตั้งค่า SSD
Jetson Orin Nano จำเป็นต้องใช้ SSD สำหรับเก็บ container images และไฟล์ rosbag
ให้ทำตามขั้นตอนด้านล่างเพื่อทำการติดตั้ง SSD บน Jetson Orin Nano:
ปิดเครื่อง Jetson: ถอดปลั๊กแหล่งจ่ายไฟและอุปกรณ์ต่อพ่วงทั้งหมดออกจาก Jetson developer kit
ติดตั้ง SSD: ติดตั้งการ์ด NVMe SSD ลงบนบอร์ดขยาย (carrier board) ของ Jetson developer kit ให้แน่ใจว่าขาเชื่อมต่อแนบสนิทดี แล้วขันสกรูยึดให้เรียบร้อย
เชื่อมต่ออุปกรณ์ต่อพ่วงอีกครั้ง: เสียบอุปกรณ์ต่อพ่วงทั้งหมดที่เคยถอดออก
เปิดเครื่อง Jetson: เสียบปลั๊กแหล่งจ่ายไฟอีกครั้งเพื่อเปิดเครื่อง Jetson developer kit
เมื่อระบบบูตขึ้นแล้ว ให้ตรวจสอบว่า Jetson ของคุณสามารถตรวจพบตัวควบคุมหน่วยความจำใหม่บนบัส PCI ได้โดยรันคำสั่งต่อไปนี้:
$ lspci
คุณควรจะเห็นบรรทัดที่คล้ายกับตัวอย่างต่อไปนี้:
0004:01:00.0 Non-Volatile memory controller: Sandisk Corp Device 5041 (rev 01)
เพื่อฟอร์แมต SSD ให้เริ่มต้นด้วยการตรวจสอบชื่ออุปกรณ์ของ SSD โดยรันคำสั่งต่อไปนี้:
$ lsblk
ให้ระบุอุปกรณ์ใหม่ที่แสดงขึ้นมา ซึ่งโดยทั่วไปจะมีชื่อว่า nvme0n1 ซึ่งตรงกับ SSD ของคุณ
ถัดไป ให้ฟอร์แมต SSD โดยใช้ระบบไฟล์แบบ ext4 (อย่าลืมแทนที่ nvme0n1 ด้วยชื่ออุปกรณ์จริงของ SSD คุณ):
$ sudo mkfs.ext4 /dev/nvme0n1
เมื่อต้องการเมานต์ SSD ไปยังไดเรกทอรี /ssd ให้ดำเนินการตามขั้นตอนต่อไปนี้:
$ sudo mkdir /ssd
$ sudo mount /dev/nvme0n1 /ssd
เพื่อให้ SSD เมานต์โดยอัตโนมัติทุกครั้งที่บูตเครื่อง คุณต้องเพิ่มรายการลงในไฟล์ /etc/fstab
ก่อนอื่น ให้ดึงค่า UUID ของ SSD โดยใช้คำสั่งนี้:
$ lsblk -f
ให้คุณหาบรรทัดที่ตรงกับ SSD ของคุณจากผลลัพธ์ของคำสั่ง blkid แล้วจดจำค่า UUID ไว้
จากนั้น เพิ่มรายการลงในไฟล์ /etc/fstab โดยใช้คำสั่ง:
$ echo ‘UUID=<UUID> /ssd ext4 defaults 0 2’ | sudo tee -a /etc/fstab > /dev/null
สุดท้าย ให้เปลี่ยนเจ้าของของไดเรกทอรี /ssd
$ sudo chown ${USER}:${USER} /ssd
ตอนนี้เมื่อ SSD ถูกเมานต์เรียบร้อยแล้ว ให้ดำเนินการย้ายไดเรกทอรีข้อมูลของ Docker ไปยัง SSD
เริ่มต้นด้วยการหยุดบริการ Docker ก่อน โดยใช้คำสั่ง:
$ sudo systemctl stop docker
ถัดไป ให้ย้ายไดเรกทอรีข้อมูลของ Docker ไปยัง SSD
$ sudo du -csh /var/lib/docker/ && \
sudo mkdir /ssd/docker && \
sudo rsync -axPS /var/lib/docker/ /ssd/docker/ && \
sudo du -csh /ssd/docker/
ปรับเปลี่ยนการกำหนดค่าบริการ Docker เพื่อให้ชี้ไปยังตำแหน่งใหม่ของไดเร็กทอรีข้อมูล Docker:
$ echo ‘{“runtimes”:{“nvidia”:{“path”:”nvidia-container-runtime”,”runtimeArgs”:[]}},”default-runtime”:”nvidia”,”data-root”:”/ssd/docker”}’ | sudo tee /etc/docker/daemon.json > /dev/null
เปลี่ยนชื่อไดเร็กทอรีข้อมูล Docker เก่า:
$ sudo mv /var/lib/docker /var/lib/docker.old
สุดท้ายให้รีสตาร์ทบริการ Docker:
$ sudo systemctl daemon-reload && \
sudo systemctl restart docker && \
sudo journalctl -u docker
การตั้งค่าไอแซค ROS
VSLAM UAV ใช้ กรอบงาน Isaac ROS สำหรับ VSLAM กรอบงานนี้สร้างขึ้นบน ROS2 และให้ชุดเครื่องมือและไลบรารีสำหรับการสร้างแอปพลิเคชันหุ่นยนต์
เริ่มต้นด้วยการติดตั้ง Git-LFS และส่วนที่ต้องมีอื่น ๆ:
$ sudo apt install git-lfs
$ git lfs install –skip-repo
$ sudo apt-get install -y curl jq tar
จากนั้นสร้างพื้นที่ทำงานสำหรับ Isaac ROS:
$ mkdir -p /ssd/workspaces/isaac_ros-dev/src
$ echo “export ISAAC_ROS_WS=/ssd/workspaces/isaac_ros-dev/” >> ~/.bashrc
$ source ~/.bashrc
ขั้นตอนต่อไป โคลนที่เก็บข้อมูล Isaac ROS:
$ cd ${ISAAC_ROS_WS}/src
$ git clone -b release-3.2 https://github.com/NVIDIA-ISAAC-ROS/isaac_ros_common.git isaac_ros_common
กำหนดค่าภาพ Isaac ROS Docker สำหรับกล้อง RealSense:
$ cd ${ISAAC_ROS_WS}/src/isaac_ros_common/scripts && \
touch .isaac_ros_common-config && \
echo CONFIG_IMAGE_KEY=ros2_humble.realsense > .isaac_ros_common-config
สร้างข้อมูลจำเพาะ CDI สำหรับ GPU:
$ sudo nvidia-ctk cdi generate –mode=csv –output=/etc/cdi/nvidia.yaml
โคลนที่เก็บ VSLAM-UAV และดาวน์โหลดทรัพยากรที่จำเป็น:
$ cd ${ISAAC_ROS_WS}
$ git clone https://github.com/bandofpv/VSLAM-UAV.git
$ ${ISAAC_ROS_WS}/VSLAM-UAV/vslam/setup/isaac_vslam_assets.sh
ตรวจสอบให้แน่ใจว่ากล้อง RealSense ของคุณเชื่อมต่อกับ Jetson Orin แล้วเรียกใช้คำสั่งต่อไปนี้เพื่อสร้างIsaac ROSอิมเมจ Docker:
$ cd ${ISAAC_ROS_WS}/src/isaac_ros_common && \
./scripts/run_dev.sh -d ${ISAAC_ROS_WS}
จำเป็นต้องใช้เฟิร์มแวร์ RealSense เวอร์ชัน5.13.0.50 เฟิร์มแวร์เวอร์ชันอื่นอาจไม่สามารถทำงานร่วมกับอิมเมจ Isaac ROS Docker ได้
เมื่อสร้างและรันภาพแล้ว คุณสามารถทดสอบกล้อง RealSense ได้โดยรันคำสั่งต่อไปนี้:
$ realsense-viewer
ซึ่งควรเปิดตัวดู RealSense และแสดงฟีดของกล้อง
หากไม่ตรวจพบกล้อง RealSense ของคุณ คุณอาจต้องรันคำสั่งต่อไปนี้เพื่ออัปเดตกฎ udev ในเทอร์มินัลแยกต่างหาก:
$ sudo apt install v4l-utils -y
$ cd ~
$ git clone https://github.com/IntelRealSense/librealsense.git
$ cd ~/librealsense
$ ./scripts/setup_udev_rules.sh
การตั้งค่า IMU ของกล้อง
การสอบเทียบ IMU (ทางเลือก)
หากต้องการใช้ประโยชน์จาก VSLAM ให้ได้ประโยชน์สูงสุด คุณต้องรวมข้อมูล IMU ไว้ใน VSLAM pipeline คุณสามารถใช้ IMU ในตัวของกล้อง Intel D435i ได้ IMU มาพร้อมการปรับเทียบล่วงหน้าจากโรงงาน แต่ขอแนะนำให้ปรับเทียบ IMU เพื่อให้แน่ใจว่าการวัดจะแม่นยำ
หากต้องการปรับเทียบ IMU คุณสามารถใช้เครื่องมือปรับเทียบ IMU ที่มาพร้อมกับLibrealsense ขั้นแรก คุณต้องสร้างrealsenseอิมเมจ Docker:
หมายเหตุ: ติดตั้ง librealesnes git ลงในพื้นที่ทำงาน
$ cd ~/VSLAM-UAV/docker/realsense
$ ./run_docker.sh
ซึ่งจะสร้างภาพและรันในคอนเทนเนอร์ เมื่อคอนเทนเนอร์รันแล้ว คุณสามารถรันเครื่องมือปรับเทียบ IMU ได้:
$ cd ~/librealsense/tools/rs-imu-calibration
$ python3 rs-imu-calibration.py
เพียงทำตามคำแนะนำบรรทัดคำสั่งเพื่อปรับเทียบ IMU ด้านล่างนี้คือรูปภาพของกระบวนการปรับเทียบเพื่อช่วยแนะนำคุณตลอดกระบวนการ
ตำแหน่งที่ 1 : ตั้งตรงหันออก

ตำแหน่งที่ 2: สาย USB หันขึ้นด้านนอก

ตำแหน่งที่ 3 : คว่ำลงหันออก

ตำแหน่งที่ 4: สาย USB ชี้ลง

ตำแหน่งที่ 5 : ทิศทางการมองหันลง

ตำแหน่งที่ 6 : ทิศทางการมองหันขึ้นด้านบน

ตรวจสอบให้แน่ใจว่าคุณเขียนผลการสอบเทียบลงใน EEPROM ของกล้องแล้ว
การประมาณค่าพารามิเตอร์ IMU
เมื่อปรับเทียบ IMU ภายในแล้ว คุณต้องประมาณค่าพารามิเตอร์ของ IMU โดยพารามิเตอร์ของ IMU ได้แก่ เครื่องวัดความเร่งและสัญญาณรบกวนของไจโรสโคปและความไม่เสถียรของอคติ คุณสามารถประมาณค่าพารามิเตอร์เหล่านี้ได้โดยการรวบรวมข้อมูลจาก IMU และใช้Allan Variance เพื่อประมาณค่าพารามิเตอร์
ขั้นแรก คุณต้องบันทึกข้อมูลคงที่จาก IMU เป็นระยะเวลานาน (อย่างน้อย 3 ชั่วโมง) เปิดคอนเทนเนอร์ Isaac ROS Realsense Docker และเรียกใช้โหนด Realsense เพื่อเริ่มสตรีมข้อมูลจากกล้อง:
$ cd ${ISAAC_ROS_WS}/src/isaac_ros_common && ./scripts/run_dev.sh -b
$ ${ISAAC_ROS_WS}/VSLAM-UAV/vslam/setup/realsense_node.sh
การดำเนินการนี้จะเปิดโหนด ros ของ realsense ขึ้นมา จากนั้นเปิดเทอร์มินัลใหม่และแนบกับคอนเทนเนอร์:
$ cd ${ISAAC_ROS_WS}/src/isaac_ros_common && ./scripts/run_dev.sh
ในคอนเทนเนอร์ที่แนบมา ให้รันคำสั่งต่อไปนี้เพื่อบันทึกข้อมูล IMU:
$ cd ~
$ ros2 bag record -o imu_rosbag /camera/imu
หลังจากผ่านไปอย่างน้อย 3 ชั่วโมง ให้หยุดการบันทึกด้วยCTRL+ C
ไปที่เทอร์มินัลที่รันสคริปต์ realsense-node.sh และหยุดโหนด realsense ros ด้วยCTRL+ C
ด้วยข้อมูล IMU ของเรา คุณสามารถดำเนินการประมาณค่าพารามิเตอร์ IMU ได้แล้ว ซึ่งสามารถทำได้ง่ายๆ ภายในกรอบงาน ROS2 ผ่านallan_ros2
ขั้นแรก คุณต้องโคลนที่เก็บข้อมูล VSLAM-UAV บนเดสก์ท็อปคอมพิวเตอร์ของคุณ:
$ cd ~
$ git clone https://github.com/bandofpv/VSLAM-UAV.git
จากนั้นคุณต้องคัดลอกข้อมูล IMU ไปยังคอมพิวเตอร์เดสก์ท็อปของคุณ
เริ่มต้นโดยคัดลอกไฟล์ IMU rosbag จากคอนเทนเนอร์ Docker ไปยังไดเร็กทอรีหลักของ Jetson Orin Nano ในเทอร์มินัลใหม่บน Jetson Orin Nano ให้รันคำสั่งต่อไปนี้:
$ docker cp $(docker ps -q –filter ancestor=isaac_ros_dev-aarch64):/home/admin/imu_rosbag ~
เปิดเทอร์มินัลใหม่บนคอมพิวเตอร์เดสก์ท็อปของคุณและรันคำสั่งต่อไปนี้:
$ scp <username>@<jetson_ip>:/home/<username>/imu_rosbag ~/VSLAM-UAV/docker/analysis
<username>ชื่อผู้ใช้ของคุณบน jetson อยู่ที่ไหน และ <jetson_ip>ที่อยู่ IP คืออะไร
ขั้นตอนต่อไป คุณต้องสร้างanalysisภาพ Docker บนคอมพิวเตอร์เดสก์ท็อปของคุณ:
$ cd ~/VSLAM-UAV/docker/analysis
$ ./run_docker.sh
การดำเนินการนี้จะสร้างอิมเมจและรันในคอนเทนเนอร์ เมื่อคอนเทนเนอร์ทำงานแล้ว คุณต้องแก้ไขการกำหนดค่าเพื่อชี้ไปที่ไฟล์ IMU rosbag เพียงรันคำสั่งต่อไปนี้:
$ ~/VSLAM-UAV/vslam/setup/allan_config.sh
ถัดไป ให้รัน allan_node เพื่อคำนวณค่าความเบี่ยงเบนแบบดิบ:
$ ros2 launch allan_ros2 allan_node.py
หลังจากที่คุณได้รับDONEข้อความแล้ว ให้ออกโดยใช้CTRL+C และเรียกใช้analysis.pyสคริปต์เพื่อคำนวณพารามิเตอร์ IMU:
$ python3 ~/ros2_ws/src/allan_ros2/scripts/analysis.py –data deviation.csv
นี่จะแสดงพารามิเตอร์ IMU และบันทึกลงในimu.yamlไฟล์
ตอนนี้เราสามารถใช้พารามิเตอร์เหล่านี้ใน VSLAM pipeline ได้แล้ว ในเทอร์มินัลใหม่บน Jetson Orin Nano ให้แก้ไขisaac_ros_vslam_realsense.pyสคริปต์เพื่อรวมพารามิเตอร์ IMU เปิดสคริปต์ในโปรแกรมแก้ไขข้อความ:
$ nano ${ISAAC_ROS_WS}/VSLAM-UAV/vslam/isaac_ros_vslam_realsense.py
อัปเดต พารามิเตอร์ gyro_noise_density, gyro_random_walk, accel_noise_densityและaccel_random_walkด้วยค่าจากimu.yamlไฟล์ที่คุณสร้างก่อนหน้านี้
การตั้งค่าตัวควบคุมการบิน
พารามิเตอร์ PX4
โดยถือว่าคุณได้ติดตั้ง เฟิร์มแวร์PX4 ล่าสุด(v1.15.4) แล้ว ให้เปลี่ยนพารามิเตอร์ ต่อไปนี้ ใน QGroundControl เพื่อเปิดใช้งานคอมพิวเตอร์คู่หูเพื่อสื่อสารกับตัวควบคุมการบินผ่านTELEM2พอร์ต:
MAV_1_CONFIG = TELEM2
UXRCE_DDS_CFG = 0
SER_TEL2_BAUD = 921600
นอกจากนี้ หากต้องการเปิดใช้งานการประมาณตำแหน่งการมองเห็นโดยไม่ต้องใช้ GPS คุณต้องตั้งค่าพารามิเตอร์ PX4 ต่อไปนี้:
EKF2_HGT_REF = Vision
EKF2_EV_DELAY = 50.0ms
EKF2_GPS_CTRL = 0
EKF2_BARO_CTRL = Disabled
EKF2_RNG_CTRL = Disable range fusion
EKF2_REQ_NSATS = 5
MAV_USEHILGPS = Enabled
EKF2_MAG_TYPE = None
ทดสอบการเชื่อมต่อ
MAVLink เป็นอินเทอร์เฟซการสื่อสารเริ่มต้นและมีเสถียรภาพสำหรับการทำงานกับ PX4
คุณสามารถทดสอบว่า Jetson Orin Nano และตัวควบคุมการบินสื่อสารกันผ่าน MAVLink GCS ที่เรียกว่า MAVProxy หรือไม่
เรียกใช้คำสั่งนี้บน Jetson Orin Nano ของคุณเพื่อเพิ่มผู้ใช้ของคุณลงในdialoutกลุ่ม:
$ sudo adduser ${USER} dialout
จากนั้นรีบูต Jetson Orin Nano เพื่อใช้การเปลี่ยนแปลง
คุณสามารถตรวจสอบว่าพอร์ตซีเรียลพร้อมใช้งานได้หรือไม่โดยออกคำสั่งนี้:
$ ls /dev/ttyUSB0
ผลลัพธ์ของคำสั่งควรรวมถึงการเชื่อมต่อ RX/TX/dev/ttyUSB0
ขั้นตอนต่อไปติดตั้ง MAVProxy:
$ sudo apt install -y python3-pip
$ sudo pip3 install mavproxy
$ sudo apt remove -y modemmanager
เรียกใช้ MAVProxy โดยตั้งค่าพอร์ตที่จะเชื่อมต่อ/dev/ttyUSB0และอัตราบอดเรทให้ตรงกับตัวควบคุมการบิน (921600):
$ sudo mavproxy.py –master=/dev/ttyUSB0 –baudrate 921600
ตอนนี้ MAVProxy บน Jetson Orin Nano ควรเชื่อมต่อกับตัวควบคุมการบิน PX4 ผ่านพิน RX/TX แล้วกด CTRL+C เพื่อออก
การสาธิตการบิน
การสาธิตนี้แสดงให้เห็นการทำงานของโหนด Isaac ROS VSLAM ซึ่งช่วยให้ควอดคอปเตอร์สามารถบินตามรูปแบบที่กำหนดได้โดยอัตโนมัติโดยใช้ SLAM แบบมองเห็นเพื่อประเมินท่าทาง ควอดคอปเตอร์จะใช้โหนด MAVROSPY เพื่อรับการประเมินท่าทางและควบคุมรูปแบบการบิน
ในการรันการสาธิตการบิน ให้เริ่มต้นด้วยการเปิดIsaac ROSคอนเทนเนอร์ Docker:
$ cd ${ISAAC_ROS_WS}/src/isaac_ros_common && \
./scripts/run_dev.sh -b
ภายในคอนเทนเนอร์ ไปที่vslamไดเร็กทอรี:
$ cd ${ISAAC_ROS_WS}/VSLAM-UAV/vslam
ขั้นตอนต่อไปคือการเปิดใช้งานโหนด Issac ROS VSLAM:
$ ./vslam_launch.sh
ในเทอร์มินัลใหม่ เปิดmavrospyคอนเทนเนอร์ Docker:
$ cd ${ISAAC_ROS_WS}/VSLAM-UAV/docker/mavrospy && \
./run_docker.sh
ในmavrospyคอนเทนเนอร์ เปิดmavrospyโหนด:
$ cd ~/VSLAM-UAV/vslam
$ ros2 launch mavrospy.launch.py
หากคุณต้องการตรวจสอบให้แน่ใจว่าการประมาณค่า VSLAM ถูกเผยแพร่อย่างถูกต้อง คุณสามารถรันคำสั่งต่อไปนี้ในเทอร์มินัลใหม่:
$ cd ${ISAAC_ROS_WS}/src/isaac_ros_common && \
./scripts/run_dev.sh
$ export ROS_DOMAIN_ID=1
$ ros2 topic echo /mavros/vision_pose/pose_cov
คุณยังสามารถตรวจสอบได้ว่าตัวควบคุมการบินกำลังตีความการประมาณตำแหน่งอย่างถูกต้องหรือไม่โดยการบินทดสอบในโหมดการบิน POSITION
ในที่สุดก็เปลี่ยนควอดคอปเตอร์ไปที่โหมด OFFBOARD และดูมันบิน!
คุณสามารถระบุรูปแบบการบินได้โดยใช้patternอาร์กิวเมนต์ หากไม่ได้ระบุ จะใช้ค่าเริ่มต้นsquareเป็น
$ ros2 launch mavrospy.launch.py pattern:=figure8
รูปแบบที่มีให้เลือก: square, square_head, circle, circle_head, figure8, figure8_head, spiral, และspiral_head. โดย_headจะระบุให้โดรนหันหน้าไปในทิศทางการเคลื่อนที่
การสร้างภาพ
หากคุณต้องการแสดงภาพเอาต์พุต VSLAM ใน RViz คุณสามารถรันคำสั่งต่อไปนี้ในเทอร์มินัลใหม่ได้:
$ cd ${ISAAC_ROS_WS}/src/isaac_ros_common && \
./scripts/run_dev.sh -b
$ export ROS_DOMAIN_ID=1
$ rviz2 -d ${ISAAC_ROS_WS}/VSLAM-UAV/vslam/vslam_realsense.cfg.rviz
โดยทั่วไปไม่แนะนำให้เรียกใช้ RViz บนเดสก์ท็อประยะไกลเนื่องจากปัญหาประสิทธิภาพ แม้แต่การทำงานกับการส่งต่อ X11 ก็อาจช้าได้ ขึ้นอยู่กับการเชื่อมต่อเครือข่ายของคุณ
ควรพิจารณาบันทึกการสาธิตโดยใช้ros2 bag record -a คำสั่งแล้วค่อยแสดงข้อมูลที่บันทึกไว้ในภายหลัง
อ้างอิงจาก : https://www.hackster.io/bandofpv/gps-denied-drone-with-nvidia-jetson-orin-nano-9f3417
詳しくはお問い合わせください:LINE @droneth