Lorsque vous voulez faire quelque chose comme l'apprentissage automatique qui est populaire de nos jours, il est difficile de créer un environnement avec Python. L'environnement local est également sale ... Je vois souvent des matériaux qui utilisent Anaconda ou Miniconda pour apprendre l'apprentissage automatique tout en déplaçant le code. Et lors de la création de ces environnements, les utilisateurs de ROS ont souvent beaucoup de problèmes, mais étonnamment il y a peu d'articles, alors j'ai décidé de le laisser ici. L'environnement est le suivant.
Téléchargez la version 64 bits de Python 3.7 à partir ici
$ cd ~/Downloads
$ bash Miniconda3-latest-Linux-x86_64.sh
Exécutez la commande ci-dessus et procédez à l'installation selon les instructions du terminal. Enfin, il vous sera demandé si vous souhaitez exécuter `` conda init ''. Si vous répondez oui, la construction de l'environnement sera terminée.
Voir ci-dessous ce qui se passe lorsque vous exécutez `` conda init '' si l'installation réussit
Il semble que .bashrc sera édité, alors vérifions le contenu pour le moment. Les parties suivantes ont été ajoutées.
Lors de la lecture de ROS avec .bashrc, l'avertissement suivant apparaît lorsque
conda init` ''.
C'est parce que PYTHONPATH pointe maintenant vers /opt/ros/melodic/lib/python2.7/dist-packages lors du chargement de l'environnement ROS. Alors, désactivons le chargement de ROS avant l'installation.
Tapez simplement la commande suivante
$ conda create --name ros --channel conda-forge ros-core ros-actionlib ros-dynamic-reconfigure python=2.7
$ conda activate ros
Avec cela seul, il est pratique de créer un environnement ROS sur l'environnement virtuel de conda. Vous pouvez utiliser des commandes de base telles que roscore, rosrun et roslaunch.
Lors de l'exécution de ROS dans un environnement virtuel à l'aide de conda, il s'agit d'un package auto-conçu qui est inquiétant. Puisque ROS1 est utilisé cette fois, catkin_make est requis lors de la création de packages, etc. en C ++.
https://github.com/nakano16180/roscpp_practice J'ai utilisé le package lié ci-dessus cette fois.
À l'origine, vous pouvez cloner le paquet github et catkin_make pour le démarrer avec rosrun. Mais cette fois, je suis resté coincé ici. Il semble que le chemin vers pthread ne passe pas?
Pour résoudre ce problème, j'ai modifié CMakeLists.txt comme suit.
CMakeLists.txt
cmake_minimum_required(VERSION 2.8.3)
project(roscpp_practice)
## Compile as C++11, supported in ROS Kinetic and newer
# add_compile_options(-std=c++11)
## Find catkin macros and libraries
## if COMPONENTS list like find_package(catkin REQUIRED COMPONENTS xyz)
## is used, also find other catkin packages
find_package(catkin REQUIRED COMPONENTS
roscpp
std_msgs
rosbag
)
## System dependencies are found with CMake's conventions
find_package(Boost REQUIRED COMPONENTS system)
find_package(Threads REQUIRED) #Ajouté ici
## Uncomment this if the package has a setup.py. This macro ensures
## modules and global scripts declared therein get installed
## See http://ros.org/doc/api/catkin/html/user_guide/setup_dot_py.html
# catkin_python_setup()
###########
## Build ##
###########
## Specify additional locations of header files
## Your package locations should be listed before other locations
include_directories(
# include
${catkin_INCLUDE_DIRS}
)
## Declare a C++ library
# add_library(${PROJECT_NAME}
# src/${PROJECT_NAME}/roscpp_practice.cpp
# )
## Add cmake target dependencies of the library
## as an example, code may need to be generated before libraries
## either from message generation or dynamic reconfigure
# add_dependencies(${PROJECT_NAME} ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
## Declare a C++ executable
## With catkin_make all packages are built within a single CMake context
## The recommended prefix ensures that target names across packages don't collide
# add_executable(${PROJECT_NAME}_node src/roscpp_practice_node.cpp)
add_executable(talker src/talker.cpp)
add_executable(listener src/listener.cpp)
add_executable(bag_write src/bag_write.cpp)
add_executable(bag_read src/bag_read.cpp)
## Rename C++ executable without prefix
## The above recommended prefix causes long target names, the following renames the
## target back to the shorter version for ease of user use
## e.g. "rosrun someones_pkg node" instead of "rosrun someones_pkg someones_pkg_node"
# set_target_properties(${PROJECT_NAME}_node PROPERTIES OUTPUT_NAME node PREFIX "")
## Add cmake target dependencies of the executable
## same as for the library above
# add_dependencies(${PROJECT_NAME}_node ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
## Specify libraries to link a library or executable target against
# target_link_libraries(${PROJECT_NAME}_node
# ${catkin_LIBRARIES}
# )
target_link_libraries(talker
${catkin_LIBRARIES}
Threads::Threads ##Postscript
)
target_link_libraries(listener
${catkin_LIBRARIES}
Threads::Threads ##Postscript
)
target_link_libraries(bag_write
${catkin_LIBRARIES}
Threads::Threads ##Postscript
)
target_link_libraries(bag_read
${catkin_LIBRARIES}
Threads::Threads ##Postscript
)
En éditant comme ci-dessus, j'ai pu le construire et l'exécuter en toute sécurité.
J'ai écrit jusqu'à présent, mais passons à ROS2, qui peut utiliser Python3, dès que possible!