👩🏼‍🔬 🐍 💺 एक मानचित्र का निर्माण करना और लेजर में एक मोबाइल रोबोट को स्थानीय रूप में लेजर_स्कैन

शुभ दोपहर पाठकों! हमने एक बार हेक्टर SLAM के एक लेख में स्थानीयकरण और SLAM के विषय पर छुआ था । हम आरओएस में इलाके के नक्शे और स्थानीयकरण के निर्माण के लिए एल्गोरिदम के साथ अपने परिचित को जारी रखते हैं। आज हम केवल एक राडार का उपयोग कर, बिजली odometry बिना क्षेत्र का नक्शा बनाने का प्रयास करेगा Hokuyo URG-04LX-UG01 एल्गोरिथ्म gmapping और कलन विधि द्वारा निर्मित नक्शे पर रोबोट स्थानीय बनाना AMCL । इसके साथ हमारी मदद करेंगे Laser_scan_matcher । कौन परवाह करता है, कृपया, बिल्ली के नीचे।

Laser_scan_matcher पैकेज स्थापित करना

तो चलिए शुरू करते है! प्रयोगों के लिए हम ROS इंडिगो का उपयोग करेंगे, लेकिन आप ROS (जेड, काइनेटिक, हाइड्रो) के एक अलग संस्करण का उपयोग कर सकते हैं। अधिष्ठापन पैकेज उसी तरह से किया जाना चाहिए (शायद आरओएस काइनेटिक में केवल कुछ पैकेज उपयुक्त-माध्यम से उपलब्ध नहीं होंगे)।

Laser_scan_matcher पैकेज लेजर डेटा की वृद्धिशील रिकॉर्डिंग के लिए एक उपकरण है, जिसे Canonical स्कैन माचिस विधि के आधार पर कार्यान्वित किया जाता है, जिसे यहां पढ़ा जा सकता है । आप यहां पैकेज के बारे में पढ़ सकते हैं । पैकेज का उपयोग ओडोमेट्री डेटा के बिना किया जा सकता है; यह ओडोमेट्री मूल्यांकन को स्वयं करता है।

पैकेज स्थापित करें:

sudo apt-get install ros-indigo-laser-scan-matcher

आइए डेमो की कोशिश करें:

roscore
roslaunch laser_scan_matcher demo.launch

हम rviz में कुछ इसी तरह देखेंगे:

यहां दिखाया गया है लेज़र_scan_matcher एक बैग फ़ाइल में दर्ज लिडार डेटा पर कार्रवाई में। अब पैकेज लाइव का प्रयास करें। समय न गंवाने के लिए, हम तुरंत इसे gmapping एल्गोरिथम के साथ आज़माएँगे। Gmapping शुरू करने के लिए my_gmapping_launch.launch फ़ाइल के साथ एक पैकेज बनाएँ:

cd ~/catkin_ws/src
catkin_create_pkg my_laser_matcher
cd src/my_laser_matcher
mkdir launch
vim launch/my_gmapping_launch.launch

निम्नलिखित कोड को my_gmapping_launch.launch फ़ाइल में कॉपी करें:

कोड my_gmapping_launch.launch

<?xml version="1.0"?>                                                                                                                           
<launch>                                                                                                      
    <node pkg="tf" type="static_transform_publisher" name="base_link_to_laser"                                
           args="0.0 0.0 0.0 0.0 0.0 0.0 /base_link /laser 40" />                                             
                                                                                                              
  <node pkg="laser_scan_matcher" type="laser_scan_matcher_node" name="laser_scan_matcher_node" output="screen">
   <param name="fixed_frame" value = "odom"/>                                                                 
   <param name="use_odom" value="true"/>                                                                      
   <param name="publish_odom" value = "true"/>                                                                
   <param name="use_alpha_beta" value="true"/>                                                                
   <param name="max_iterations" value="10"/>                                                                  
  </node>                                                                                                     
                                                                                                              
  <node pkg="gmapping" type="slam_gmapping" name="slam_gmapping" output="screen">                             
   <param name="map_udpate_interval" value="1.0"/>                                                            
   <param name="delta" value="0.02"/>                                                                         
  </node>                                                                                                     
</launch>

यहाँ हम base_link → लेज़र निर्देशांक प्रणाली, लेज़र_scan_matcher और slam_gmapping नोड्स के बीच परिवर्तन प्रकाशित करने के लिए tf पैकेज से static_transform_publisher चलाते हैं। फाइल का सोर्स कोड यहां से डाउनलोड किया जा सकता है । Hokuyo लिडार का उपयोग करने के लिए, हमें hokuyo_node ROS पैकेज स्थापित करने की आवश्यकता है :

sudo apt-get install ros-indigo-hokuyo-node

लिडार जानकारी प्राप्त करने के लिए hokuyo_node पैकेज से getID नोड चलाएँ:

rosrun hokuyo_node getID /dev/ttyACM0

एक त्रुटि हो सकती है:

Error: Failed to open port. Permission denied.
[ERROR] 1263843357.793873000: Exception thrown while opening Hokuyo.
Failed to open port: /dev/ttyACM0. Permission denied (errno = 13). You probably don't have premission to open the port for reading and writing. (in hokuyo::laser::open) You may find further details at http://www.ros.org/wiki/hokuyo_node/Troubleshooting

इस स्थिति में, हमें पोर्ट / dev / ttyACM0 के लिए अनुमतियां जोड़ने की आवश्यकता है:

sudo chmod a+rw /dev/ttyACM0

Hokuyo_node पैकेज से फिर से चलाएँ और समान आउटपुट प्राप्त करें:

Device at /dev/ttyACM0 has ID H0906078

अब hokuyo_node नोड चलाएँ:

rosrun hokuyo_node hokuyo_node

अंत में, हमारी लॉन्चर फ़ाइल my_gmapping_launch.launch चलाएं:

roslaunch my_laser_matcher my_gmapping_launch.launch
rosrun rviz rviz

आइए विषयों को सूचीबद्ध करें:

rostopic list

विषयों के बीच हम निम्नलिखित देखेंगे:

/initialpose
/move_base_simple/goal
/odom
/pose2D
...
/imu/data

इस तरह से हम ओडोमेट्री और रोबोट की स्थिति का श्रेय लेजर_स्कैन_मैचर को देते हैं। लेख

में वर्णित अनुसार / स्कैन विषय के साथ एक लेज़रस्कैन-प्रकार के प्रदर्शन को rviz में जोड़ें । मानचित्र मानचित्र के लिए और TF के परिवर्तन के लिए भी एक प्रदर्शन जोड़ें। इसके अंदर TF सेक्शन और फ्रेम्स का विस्तार करें, फिर बिंदुओं पर ध्यान दें: odom, map, base_link। मैं आपको याद दिलाता हूं कि ये ओडोमीटर, मानचित्र और रोबोट समन्वय प्रणाली हैं। ग्लोबल ऑप्शंस सेक्शन में लेफ्ट डिस्प्ले पैनल में फिक्स्ड फ्रेम फील्ड के लिए / मैप वैल्यू सेट करना याद रखें। Rviz में हम एक समान चित्र देखेंगे: अगला, क्षेत्र का पूरा नक्शा बनाने के लिए बस अंतरिक्ष में रोबोट को स्थानांतरित करें। हम मानचित्र को बचाने के लिए map_server पैकेज से map_saver उपयोगिता का उपयोग करते हैं:

rosrun map_server map_saver

अम्मल के साथ स्थानीयकरण

अब आइए amcl एल्गोरिथम का उपयोग करके रोबोट को स्थानीय बनाने का प्रयास करें। निम्नलिखित सामग्री के साथ हमारे पैकेज के अंदर फ़ाइल my_localize.launch बनाएँ:

कोड my_localize.launch

<launch>

  <param name="/use_sim_time" value="false"/>


  <node pkg="tf" type="static_transform_publisher" name="base_link_to_laser" 
    args="0.0 0.0 0.0 0.0 0.0 0.0 /base_link /laser 40" />

  <node name="hokuyo" pkg="hokuyo_node" type="hokuyo_node" respawn="false" output="screen">
    <param name="calibrate_time" type="bool" value="false"/> 
    <param name="port" type="string" value="/dev/ttyACM0"/> 
    <param name="intensity" type="bool" value="false"/>
  </node>

  <node pkg="laser_scan_matcher" type="laser_scan_matcher_node" 
    name="laser_scan_matcher_node" output="screen">
    <param name="fixed_frame" value = "odom"/>
    <param name="use_alpha_beta" value="true"/>
    <param name="max_iterations" value="10"/>
  </node>

 <node name="map_server" pkg="map_server" type="map_server" args="/home/vladimir/catkin_ws/map.yaml"/>

  <node pkg="amcl" type="amcl" name="amcl" output="screen" >
  <!-- Publish scans from best pose at a max of 10 Hz -->
  <param name="odom_model_type" value="diff"/>
  <param name="odom_alpha5" value="0.1"/>
  <param name="transform_tolerance" value="0.2" />
  <param name="gui_publish_rate" value="10.0"/>
  <param name="laser_max_beams" value="30"/>
  <param name="min_particles" value="500"/>
  <param name="max_particles" value="5000"/>
  <param name="kld_err" value="0.05"/>
  <param name="kld_z" value="0.99"/>
  <param name="odom_alpha1" value="0.2"/>
  <param name="odom_alpha2" value="0.2"/>
  <!-- translation std dev, m -->
  <param name="odom_alpha3" value="0.8"/>
  <param name="odom_alpha4" value="0.2"/>
  <param name="laser_z_hit" value="0.5"/>
  <param name="laser_z_short" value="0.05"/>
  <param name="laser_z_max" value="0.05"/>
  <param name="laser_z_rand" value="0.5"/>
  <param name="laser_sigma_hit" value="0.2"/>
  <param name="laser_lambda_short" value="0.1"/>
  <param name="laser_lambda_short" value="0.1"/>
  <param name="laser_model_type" value="likelihood_field"/>
  <!-- <param name="laser_model_type" value="beam"/> -->
  <param name="laser_likelihood_max_dist" value="2.0"/>
  <param name="update_min_d" value="0.2"/>
  <param name="update_min_a" value="0.5"/>
  <param name="odom_frame_id" value="odom"/>

  <param name="base_frame_id" type="str" value="base_link" />
  <param name="global_frame_id" type="str" value="map" />

  <param name="resample_interval" value="1"/>
  <param name="transform_tolerance" value="0.1"/>
  <param name="recovery_alpha_slow" value="0.0"/>
  <param name="recovery_alpha_fast" value="0.0"/>
  <param name="use_map_topic" value="true" />
  <param name="first_map_only" value="true" />
</node>

</launch>

यहाँ, हम, gmapping के लिए लांचर के समान, स्थैतिक_transform_publisher नोड, hokuyo_node और laser_scan_matcher नोड का उपयोग करके परिवर्तन / लेजर → / base_link प्रकाशित करते हैं। फिर हम अपने निर्मित नक्शे को प्रकाशित करने के लिए map_server चलाते हैं, जहाँ args में हम yaml फ़ाइल में नक्शे के लिए मार्ग को पार करते हैं। अंत में, मापदंडों के साथ एमक्ल नोड शुरू करें। आप आधिकारिक एल्गोरिथ्म पृष्ठ पर एमक्ल मापदंडों के बारे में पढ़ सकते हैं ।

लॉन्चर फाइल कोड को जीथब रिपॉजिटरी से भी डाउनलोड किया जा सकता है । हमारी लॉन्चर फ़ाइल चलाएँ:

roslaunch my_laser_matcher my_localize.launch

अब हम rviz की ओर बढ़ते हैं। ग्लोबल ऑप्शन सेक्शन में फिक्स्ड फ्रेम के लिए मैप वैल्यू सेट करें। आइए विषयों को सूचीबद्ध करें:

rostopic list

नए विषय सूची में दिखाई देंगे:

...
/amcl/parameter_descriptions
/amcl/parameter_updates
/amcl_pose
...
/map
/map_metadata
/map_updates
...
/particlecloud

Amcl_pose विषय amcl द्वारा प्रकाशित रोबोट की स्थिति से मेल खाता है।
आइए देखें विषय में पोस्ट:

rostopic echo /amcl_pose

रोबोट की स्थिति पर डेटा प्राप्त करें:

header: 
  seq: 15
  stamp: 
    secs: 1482430591
    nsecs:  39625000
  frame_id: map
pose: 
  pose: 
    position: 
      x: 0.781399671581
      y: 0.273353260585
      z: 0.0
    orientation: 
      x: 0.0
      y: 0.0
      z: -0.636073020536
      w: 0.771628869694
  covariance: [0.2187289446708912, -0.010178711317316846, 0.0, 0.0, 0.0, 0.0, -0.010178711317316819, 0.23720047371620548, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.07106236846890918]
---

Rviz में हमें निम्न चित्र मिलते हैं:

जैसा कि आप देख सकते हैं, लिडार से स्कैन पॉइंट आंशिक रूप से मानचित्र पर दीवारों के साथ मेल खाते हैं। यहाँ मेरा सेटअप वास्तव में कैसा दिखता है:

चलो रोबोट को हिलाने का प्रयास करें। रोबोट की स्थिति और मानचित्र के दृष्टिकोण को rviz विंडो में एक साथ बदलना चाहिए। रोबोट को स्थानांतरित करने के बाद, रोबोट की स्थिति को अम्मल एल्गोरिदम द्वारा सटीक रूप से निर्धारित नहीं किया जा सकता है। हमें 2D पोस एस्टिमेट टूल का उपयोग करके रोबोट की स्थिति को समायोजित करने की आवश्यकता है। ऐसा करने के लिए, rviz में शीर्ष टूलबार में 2D पॉस एस्टिमेट बटन पर क्लिक करें, rviz (base_link निर्देश प्रणाली) में मैप पर रोबोट समन्वय प्रणाली के केंद्र के अनुमानित बिंदु पर क्लिक करें और माउस बटन दबाए रखें। एक हरा तीर दिखाई देता है, जो रोबोट के केंद्र से निकलता है:

तीर को अपनी दिशा बदलते हुए और नक्शे पर काले किनारों (दीवारों) के साथ लिडार से स्कैन के बिंदुओं को संयोजित करने की कोशिश करें। सबसे अच्छा संयोजन प्राप्त करने के बाद माउस बटन को छोड़ दें।

हमें टर्मिनल में ऐसे संदेश प्राप्त होंगे जहाँ my_localize.launch चल रहा है:

[ INFO] [1482431993.717411186]: Setting pose (1482431993.717383): -0.413 -0.071 0.057

एक छोटी वीडियो पर आप कार्रवाई में सब कुछ देख सकते हैं:

टॉपिक / पार्टिकलक्लाउड उन्मुख स्थिति (पोज) या कणों के तथाकथित बादल के रूप में रोबोट की स्थिति की अनिश्चितता पर डेटा प्रस्तुत करता है। संदेश प्रकार ज्यामिति_msgs / PoseArray है।

टॉपिक / पार्टिकलक्लाउड नामक डिस्प्ले जोड़ें :

rviz में, कणों का एक बादल लाल तीरों के मोटे क्लस्टर के रूप में दिखाई देगा:

कणों का क्लस्टर जितना अधिक होगा, इस स्थिति में रोबोट की स्थिति की संभावना उतनी ही अधिक होगी। आप ros.org पर ट्यूटोरियल में 2 डी पोज अनुमान उपकरण, कण बादल और अन्य अवधारणाओं के बारे में पढ़ सकते हैं ।

वह सब है! सभी माना एल्गोरिदम (gmping और amcl) आरओएस में बड़े नेविगेशन स्टैक का हिस्सा हैं, आप इंटरनेट पर इसके बारे में बहुत सारी जानकारी पा सकते हैं। आज हमने कार्रवाई में Laser_scan_matcher टूल, gmapping और amcl स्थानीयकरण एल्गोरिदम की कोशिश की। अब आप आसानी से मोबाइल रोबोट के स्थानीयकरण और नेविगेशन पर काम करना शुरू कर सकते हैं और पूरी तरह से स्वायत्त रोबोट बना सकते हैं जो मैन्युअल नियंत्रण की आवश्यकता के बिना अंतरिक्ष में नेविगेट कर सकते हैं। ROS Vkontakte पर
हमारे समूह की सदस्यता लें और ROS मंच के बारे में नए लेखों और समाचारों की उपस्थिति के साथ अद्यतित रहें। मैं आपको प्रयोगों में शुभकामनाएं देता हूं और जल्द ही आपको देखता हूं!

पुनश्च: आगामी 2017 के साथ सभी!

Laser_scan_matcher पैकेज स्थापित करना

अम्मल के साथ स्थानीयकरण

More articles: