Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • gsaurel/dynamic_graph_bridge
  • stack-of-tasks/dynamic_graph_bridge
2 results
Show changes
Commits on Source (91)
Hide whitespace changes
Inline Side-by-side
Showing
with 264 additions and 291 deletions
.git-blame-ignore-revs 0 → 100644
View file @ c2c3026d
# format (Guilhem Saurel, 2022-09-06)
426c21a7f4e5b445d17825235f983e2f8e1a86ec
.gitlab-ci.yml
View file @ c2c3026d
include: http://rainboard.laas.fr/project/dynamic-graph-bridge/.gitlab-ci.yml
include: http://rainboard.laas.fr/project/dynamic_graph_bridge/.gitlab-ci.yml
.gitmodules
View file @ c2c3026d
[submodule "cmake"]
path = cmake
url = git://github.com/jrl-umi3218/jrl-cmakemodules.git
url = https://github.com/jrl-umi3218/jrl-cmakemodules.git
.pre-commit-config.yaml 0 → 100644
View file @ c2c3026d
ci:
autoupdate_branch: 'devel'
repos:
- repo: https://github.com/pre-commit/mirrors-clang-format
rev: v14.0.6
hooks:
- id: clang-format
args: [--style=Google]
- repo: https://github.com/pre-commit/pre-commit-hooks
rev: v4.3.0
hooks:
- id: check-added-large-files
- id: check-ast
- id: check-executables-have-shebangs
- id: check-json
- id: check-merge-conflict
- id: check-symlinks
- id: check-toml
- id: check-yaml
- id: debug-statements
- id: destroyed-symlinks
- id: detect-private-key
- id: end-of-file-fixer
- id: fix-byte-order-marker
- id: mixed-line-ending
- id: trailing-whitespace
- repo: https://github.com/psf/black
rev: 22.8.0
hooks:
- id: black
- repo: https://github.com/PyCQA/flake8
rev: 5.0.4
hooks:
- id: flake8
- repo: https://github.com/cheshirekow/cmake-format-precommit
rev: v0.6.13
hooks:
- id: cmake-format
.travis.yml deleted 100644 → 0
View file @ 387b381d
sudo: required
services:
- docker
before_install:
- docker build -t dyngb-trusty -f ./travis_custom/Dockerfile .
- docker run -t -d --name dyngb-trusty-test dyngb-trusty
- docker exec dyngb-trusty-test sudo mkdir -p /catkin_ws_dyngb/src
- docker exec dyngb-trusty-test sudo sh -c "cd /catkin_ws_dyngb/src;. /opt/ros/indigo/setup.sh;catkin_init_workspace"
- docker exec dyngb-trusty-test sudo git clone --recursive https://github.com/stack-of-tasks/dynamic_graph_bridge.git /catkin_ws_dyngb/src/dynamic_graph_bridge
script:
- docker exec dyngb-trusty-test sudo sh -c "cd /catkin_ws_dyngb;. /opt/ros/indigo/setup.sh;. /home/docker/setup-opt-robotpkg.sh;catkin_make"
CMakeLists.txt
View file @ c2c3026d
# Copyright (C) 2008-2013 LAAS-CNRS, JRL AIST-CNRS.
# Copyright (C) 2008-2020 LAAS-CNRS, JRL AIST-CNRS.
#
# Author: Florent Lamiraux, Nirmal Giftsun
# Author: Florent Lamiraux, Nirmal Giftsun, Guilhem Saurel
#
# Catkin part
cmake_minimum_required(VERSION 3.1)
cmake_minimum_required(VERSION 2.8.0)
set(PROJECT_NAMESPACE stack-of-tasks)
# Project properties
set(PROJECT_ORG stack-of-tasks)
set(PROJECT_NAME dynamic_graph_bridge)
set(PROJECT_DESCRIPTION "Dynamic graph bridge library")
set(PROJECT_URL "https://github.com/${PROJECT_NAMESPACE}/${PROJECT_NAME}")
set(PROJECT_SUFFIX "-v3")
include(cmake/base.cmake)
INCLUDE(cmake/boost.cmake)
INCLUDE(cmake/eigen.cmake)
include(cmake/ros.cmake)
include(cmake/python.cmake)
include(cmake/test.cmake)
set(PROJECT_URL "https://github.com/${PROJECT_ORG}/${PROJECT_NAME}")
set(CUSTOM_HEADER_DIR dynamic_graph_bridge)
# Project options
option(BUILD_PYTHON_INTERFACE "Build the python bindings" ON)
CMAKE_POLICY(SET CMP0048 OLD)
project(${PROJECT_NAME} CXX)
# Project configuration
set(PROJECT_USE_CMAKE_EXPORT TRUE)
set(CUSTOM_HEADER_DIR ${PROJECT_NAME})
set(CXX_DISABLE_WERROR FALSE)
set(DOXYGEN_USE_MATHJAX YES)
set(CATKIN_ENABLE_TESTING OFF)
SET(CATKIN_REQUIRED_COMPONENTS roscpp std_msgs message_generation std_srvs geometry_msgs sensor_msgs tf2_ros)
SET(CATKIN_DEPENDS_LIBRARIES ros_bridge sot_loader)
## LAAS cmake submodule part
SET(DOXYGEN_USE_MATHJAX YES)
OPTION (BUILD_PYTHON_INTERFACE "Build the python binding" ON)
IF(BUILD_PYTHON_INTERFACE)
FINDPYTHON()
STRING(REGEX REPLACE "-" "_" PY_NAME ${PROJECT_NAME})
INCLUDE_DIRECTORIES(${PYTHON_INCLUDE_DIRS})
ADD_REQUIRED_DEPENDENCY("dynamic-graph-python >= 3.0.0")
SET(CATKIN_REQUIRED_COMPONENTS ${CATKIN_REQUIRED_COMPONENTS} rospy)
SET(CATKIN_DEPENDS_LIBRARIES ${CATKIN_DEPENDS_LIBRARIES} ros_interpreter)
ENDIF(BUILD_PYTHON_INTERFACE)
# JRL-cmakemodule setup
include(cmake/base.cmake)
include(cmake/boost.cmake)
include(cmake/ros.cmake)
SET(CATKIN_ENABLE_TESTING OFF)
# Project definition
compute_project_args(PROJECT_ARGS LANGUAGES CXX)
project(${PROJECT_NAME} ${PROJECT_ARGS})
# Project dependencies
set(CATKIN_REQUIRED_COMPONENTS
roscpp
std_msgs
message_generation
std_srvs
geometry_msgs
sensor_msgs
tf2_ros
realtime_tools)
if(BUILD_PYTHON_INTERFACE)
add_project_dependency(dynamic-graph-python 4.0.0 REQUIRED)
string(REGEX REPLACE "-" "_" PY_NAME ${PROJECT_NAME})
set(CATKIN_REQUIRED_COMPONENTS ${CATKIN_REQUIRED_COMPONENTS} rospy)
endif(BUILD_PYTHON_INTERFACE)
add_project_dependency(Boost REQUIRED COMPONENTS program_options)
add_project_dependency(dynamic_graph_bridge_msgs 0.3.0 REQUIRED)
add_project_dependency(sot-core REQUIRED)
if(Boost_VERSION GREATER 107299 OR Boost_VERSION_MACRO GREATER 107299)
# Silence a warning about a deprecated use of boost bind by boost >= 1.73
# without dropping support for boost < 1.73
add_definitions(-DBOOST_BIND_GLOBAL_PLACEHOLDERS)
endif()
find_package(catkin REQUIRED COMPONENTS ${CATKIN_REQUIRED_COMPONENTS})
find_package(realtime_tools)
set(CXX_DISABLE_WERROR False)
# Main Library
set(${PROJECT_NAME}_HEADERS
include/dynamic_graph_bridge/ros_init.hh
include/dynamic_graph_bridge/sot_loader.hh
include/dynamic_graph_bridge/sot_loader_basic.hh
)
IF(BUILD_PYTHON_INTERFACE)
set(${PROJECT_NAME}_HEADERS ${${PROJECT_NAME}_HEADERS}
include/dynamic_graph_bridge/ros_interpreter.hh )
ENDIF(BUILD_PYTHON_INTERFACE)
SEARCH_FOR_EIGEN()
SEARCH_FOR_BOOST()
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)
set(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib)
set(CMAKE_INSTALL_RPATH "${LIBRARY_OUTPUT_PATH}")
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${LIBRARY_OUTPUT_PATH}")
set(PKG_CONFIG_ADDITIONAL_VARIABLES
${PKG_CONFIG_ADDITIONAL_VARIABLES}
plugindirname
plugindir
)
# Add dependency to SoT specific packages.
SET(SOT_PKGNAMES
dynamic_graph_bridge_msgs)
add_required_dependency(roscpp)
add_required_dependency(tf2_ros)
add_required_dependency("realtime_tools >= 1.8")
ADD_REQUIRED_DEPENDENCY("dynamic-graph >= 3.0.0")
ADD_REQUIRED_DEPENDENCY("sot-core >= 3.0.0")
add_required_dependency(dynamic_graph_bridge_msgs)
foreach(sot_pkgname ${SOT_PKGNAMES})
add_required_dependency(${sot_pkgname})
pkg_check_modules(SOT_${sot_pkgname} REQUIRED ${sot_pkgname})
endforeach(sot_pkgname)
# Build ros_bridge library
add_library(ros_bridge
src/converter.hh
include/dynamic_graph_bridge/ros_init.hh src/ros_init.cpp
src/sot_to_ros.hh src/sot_to_ros.cpp
)
pkg_config_use_dependency(ros_bridge dynamic_graph_bridge_msgs)
install(TARGETS ros_bridge DESTINATION lib)
# Add ros_bridge in the dynamic-graph-bridge pkg-config file.
# Make sure rpath are preserved during the install as ROS dependencies
# are not installed.
set_target_properties(ros_bridge PROPERTIES BUILD_WITH_INSTALL_RPATH True
LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
macro(compile_plugin NAME)
message(lib path ${LIBRARY_OUTPUT_PATH})
file(MAKE_DIRECTORY "${LIBRARY_OUTPUT_PATH}/dynamic_graph/ros/${NAME}")
add_library(${NAME} SHARED src/${NAME}.cpp src/${NAME}.hh)
pkg_config_use_dependency(${NAME} dynamic-graph)
pkg_config_use_dependency(${NAME} sot-core)
pkg_config_use_dependency(${NAME} dynamic_graph_bridge_msgs)
add_dependencies(${NAME} ros_bridge)
target_link_libraries(${NAME} ros_bridge)
set_target_properties(${NAME} PROPERTIES BUILD_WITH_INSTALL_RPATH True)
set_target_properties(${NAME} PROPERTIES PREFIX "")
install(TARGETS ${NAME} DESTINATION lib/plugin)
endmacro()
# Build Sot Entities
set(listplugins ros_publish ros_subscribe ros_queued_subscribe ros_tf_listener ros_time)
foreach(aplugin ${listplugins})
compile_plugin(${aplugin})
endforeach()
target_link_libraries(ros_publish ros_bridge)
IF(BUILD_PYTHON_INTERFACE)
foreach(NAME ${listplugins})
dynamic_graph_python_module("ros/${NAME}"
${NAME}
ros/${NAME}/wrap
)
PKG_CONFIG_USE_DEPENDENCY(ros/${NAME}/wrap realtime_tools)
PKG_CONFIG_USE_DEPENDENCY(ros/${NAME}/wrap dynamic_graph)
PKG_CONFIG_USE_DEPENDENCY(ros/${NAME}/wrap sot-core)
PKG_CONFIG_USE_DEPENDENCY(ros/${NAME}/wrap dynamic_graph_bridge_msgs)
PKG_CONFIG_USE_DEPENDENCY(ros/${NAME}/wrap tf2_ros)
endforeach()
# ros_interperter library.
add_library(ros_interpreter src/ros_interpreter.cpp)
pkg_config_use_dependency(ros_interpreter dynamic-graph)
pkg_config_use_dependency(ros_interpreter sot-core)
pkg_config_use_dependency(ros_interpreter roscpp)
pkg_config_use_dependency(ros_interpreter dynamic_graph_bridge_msgs)
pkg_config_use_dependency(ros_interpreter dynamic-graph-python)
add_dependencies(ros_interpreter ros_bridge)
target_link_libraries(ros_interpreter ros_bridge)
set_target_properties(ros_interpreter PROPERTIES BUILD_WITH_INSTALL_RPATH True
LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
message(cmakeinstalllibdir " is ${CMAKE_INSTALL_LIBDIR} ")
install(TARGETS ros_interpreter DESTINATION lib)
ENDIF(BUILD_PYTHON_INTERFACE)
# Stand alone embedded intepreter with a robot controller.
add_executable(geometric_simu src/geometric_simu.cpp src/sot_loader.cpp src/sot_loader_basic.cpp)
pkg_config_use_dependency(geometric_simu tf2_ros)
pkg_config_use_dependency(geometric_simu roscpp)
pkg_config_use_dependency(geometric_simu dynamic-graph)
target_link_libraries(geometric_simu ros_bridge tf2_ros ${Boost_LIBRARIES} ${CMAKE_DL_LIBS})
# Sot loader library
add_library(sot_loader src/sot_loader.cpp src/sot_loader_basic.cpp)
pkg_config_use_dependency(sot_loader dynamic-graph)
pkg_config_use_dependency(sot_loader sot-core)
target_link_libraries(sot_loader ${Boost_LIBRARIES} roscpp ros_bridge tf2_ros)
install(TARGETS sot_loader DESTINATION lib)
include/${PROJECT_NAME}/fwd.hh
include/${PROJECT_NAME}/ros_init.hh
include/${PROJECT_NAME}/sot_loader.hh
include/${PROJECT_NAME}/sot_loader_basic.hh
include/${PROJECT_NAME}/ros_interpreter.hh
src/converter.hh
src/sot_to_ros.hh)
set(${PROJECT_NAME}_SOURCES src/ros_init.cpp src/sot_to_ros.cpp
src/ros_parameter.cpp)
add_library(ros_bridge SHARED ${${PROJECT_NAME}_SOURCES}
${${PROJECT_NAME}_HEADERS})
target_include_directories(ros_bridge SYSTEM PUBLIC ${catkin_INCLUDE_DIRS})
target_include_directories(ros_bridge PUBLIC $<INSTALL_INTERFACE:include>)
target_link_libraries(
ros_bridge ${catkin_LIBRARIES} sot-core::sot-core pinocchio::pinocchio
dynamic_graph_bridge_msgs::dynamic_graph_bridge_msgs)
if(SUFFIX_SO_VERSION)
set_target_properties(ros_bridge PROPERTIES SOVERSION ${PROJECT_VERSION})
endif(SUFFIX_SO_VERSION)
if(NOT INSTALL_PYTHON_INTERFACE_ONLY)
install(
TARGETS ros_bridge
EXPORT ${TARGETS_EXPORT_NAME}
DESTINATION lib)
endif(NOT INSTALL_PYTHON_INTERFACE_ONLY)
add_subdirectory(src)
add_subdirectory(tests)
# Deal with the ROS part.
add_service_files( FILES RunPythonFile.srv )
generate_messages( DEPENDENCIES std_msgs )
# This is necessary so that the pc file generated by catking is similar to the on
# done directly by jrl-cmake-modules
catkin_package(CATKIN_DEPENDS message_runtime roscpp realtime_tools ${SOT_PKGNAMES} tf2_ros
LIBRARIES ${CATKIN_DEPENDS_LIBRARIES}
)
# Add libraries in pc file generated by cmake submodule
PKG_CONFIG_APPEND_LIBS(ros_bridge sot_loader)
IF(BUILD_PYTHON_INTERFACE)
PKG_CONFIG_APPEND_LIBS(ros_interpreter)
#install ros executables
install(PROGRAMS
${CMAKE_SOURCE_DIR}/scripts/robot_pose_publisher
${CMAKE_SOURCE_DIR}/scripts/run_command
${CMAKE_SOURCE_DIR}/scripts/tf_publisher
DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}
)
# Service file.
install(FILES ./srv/RunPythonFile.srv DESTINATION ${CMAKE_INSTALL_PREFIX}/share/${PROJECT_NAME}/srv)
ENDIF(BUILD_PYTHON_INTERFACE)
# install ros executables
install(PROGRAMS scripts/robot_pose_publisher scripts/run_command
scripts/tf_publisher DESTINATION share/${PROJECT_NAME})
message(cmake_install_bindir " is ${CMAKE_INSTALL_BINDIR} ")
install(TARGETS geometric_simu DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION})
install(FILES manifest.xml DESTINATION ${CMAKE_INSTALL_PREFIX}/share/${PROJECT_NAME}/)
# Install package information
install(FILES manifest.xml package.xml DESTINATION share/${PROJECT_NAME})
README.md
View file @ c2c3026d
dynamic-graph bindings
======================
# Dynamic Graph bindings
[![Building Status](https://travis-ci.org/stack-of-tasks/dynamic_graph_bridge.svg?branch=master)](https://travis-ci.org/stack-of-tasks/dynamic_graph_bridge)
[![Pipeline status](https://gepgitlab.laas.fr/stack-of-tasks/dynamic_graph_bridge/badges/master/pipeline.svg)](https://gepgitlab.laas.fr/stack-of-tasks/dynamic_graph_bridge/commits/master)
[![Coverage report](https://gepgitlab.laas.fr/stack-of-tasks/dynamic_graph_bridge/badges/master/coverage.svg?job=doc-coverage)](http://projects.laas.fr/gepetto/doc/stack-of-tasks/dynamic_graph_bridge/master/coverage/)
[![Pipeline status](https://gitlab.laas.fr/stack-of-tasks/dynamic_graph_bridge/badges/master/pipeline.svg)](https://gitlab.laas.fr/stack-of-tasks/dynamic_graph_bridge/commits/master)
[![Coverage report](https://gitlab.laas.fr/stack-of-tasks/dynamic_graph_bridge/badges/master/coverage.svg?job=doc-coverage)](https://gepettoweb.laas.fr/doc/stack-of-tasks/dynamic_graph_bridge/master/coverage/)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/stack-of-tasks/dynamic_graph_bridge/master.svg)](https://results.pre-commit.ci/latest/github/stack-of-tasks/dynamic_graph_bridge)
This ROS package binds together the ROS framework with the
dynamic-graph real-time control architecture.
cmake @ 57c46b2d
Subproject commit 63efaecd7c1fa3f9c190b5365561c38ea33f3236
Subproject commit 57c46b2d7b26bb0c25f8f98cfc2a9868e03be603
doc/Doxyfile.extra.in
View file @ c2c3026d
INPUT = @PROJECT_SOURCE_DIR@/include \
@PROJECT_SOURCE_DIR@/doc
include/dynamic_graph_bridge/fwd.hh 0 → 100644
View file @ c2c3026d
/*
* Copyright CNRS 2021
*
* Author: Florent Lamiraux
*
* This file is part of sot-core.
*/
#ifndef DYNAMIC_GRAPH_BRIDGE_FWD_HH
#define DYNAMIC_GRAPH_BRIDGE_FWD_HH
#include <dynamic-graph/fwd.hh>
namespace dynamicgraph {
// classes defined in sot-core
class Interpreter;
typedef std::shared_ptr<Interpreter> InterpreterPtr_t;
} // namespace dynamicgraph
#endif // DYNAMIC_GRAPH_PYTHON_FWD_HH
include/dynamic_graph_bridge/ros_init.hh
View file @ c2c3026d
......@@ -3,7 +3,8 @@
#include <ros/ros.h>
namespace dynamicgraph {
ros::NodeHandle& rosInit(bool createAsyncSpinner = false, bool createMultiThreadSpinner = true);
ros::NodeHandle& rosInit(bool createAsyncSpinner = false,
bool createMultiThreadSpinner = true);
/// \brief Return spinner or throw an exception if spinner
/// creation has been disabled at startup.
......
include/dynamic_graph_bridge/ros_interpreter.hh
View file @ c2c3026d
#ifndef DYNAMIC_GRAPH_BRIDGE_INTERPRETER_HH
#define DYNAMIC_GRAPH_BRIDGE_INTERPRETER_HH
#pragma GCC diagnostic push
#pragma GCC system_header
#include <ros/ros.h>
#pragma GCC diagnostic pop
#include <dynamic_graph_bridge_msgs/RunCommand.h>
#include <dynamic_graph_bridge_msgs/RunPythonFile.h>
#include <dynamic-graph/python/interpreter.hh>
#include <dynamic_graph_bridge/fwd.hh>
namespace dynamicgraph {
/// \brief This class wraps the implementation of the runCommand
......@@ -14,19 +20,22 @@ namespace dynamicgraph {
/// the outside.
class Interpreter {
public:
typedef boost::function<bool(dynamic_graph_bridge_msgs::RunCommand::Request&,
dynamic_graph_bridge_msgs::RunCommand::Response&)>
typedef boost::function<bool(
dynamic_graph_bridge_msgs::RunCommand::Request&,
dynamic_graph_bridge_msgs::RunCommand::Response&)>
runCommandCallback_t;
typedef boost::function<bool(dynamic_graph_bridge_msgs::RunPythonFile::Request&,
dynamic_graph_bridge_msgs::RunPythonFile::Response&)>
typedef boost::function<bool(
dynamic_graph_bridge_msgs::RunPythonFile::Request&,
dynamic_graph_bridge_msgs::RunPythonFile::Response&)>
runPythonFileCallback_t;
explicit Interpreter(ros::NodeHandle& nodeHandle);
/// \brief Method to start python interpreter and deal with messages.
/// \param Command string to execute, result, stdout, stderr strings.
void runCommand(const std::string& command, std::string& result, std::string& out, std::string& err);
void runCommand(const std::string& command, std::string& result,
std::string& out, std::string& err);
/// \brief Method to parse python scripts.
/// \param Input file name to parse.
......@@ -41,8 +50,9 @@ class Interpreter {
dynamic_graph_bridge_msgs::RunCommand::Response& res);
/// \brief Run a Python file.
bool runPythonFileCallback(dynamic_graph_bridge_msgs::RunPythonFile::Request& req,
dynamic_graph_bridge_msgs::RunPythonFile::Response& res);
bool runPythonFileCallback(
dynamic_graph_bridge_msgs::RunPythonFile::Request& req,
dynamic_graph_bridge_msgs::RunPythonFile::Response& res);
private:
python::Interpreter interpreter_;
......
include/dynamic_graph_bridge/ros_parameter.hh 0 → 100644
View file @ c2c3026d
#ifndef _ROS_DYNAMIC_GRAPH_PARAMETER_
#define _ROS_DYNAMIC_GRAPH_PARAMETER_
namespace dynamicgraph {
bool parameter_server_read_robot_description();
}
#endif /* _ROS_DYNAMIC_GRAPH_PARAMETER_ */
include/dynamic_graph_bridge/sot_loader.hh
View file @ c2c3026d
......@@ -18,21 +18,25 @@
// STL includes
#include <map>
// Pinocchio includes
#include <pinocchio/fwd.hpp>
// Boost includes
#include <boost/program_options.hpp>
#include <boost/foreach.hpp>
#include <boost/format.hpp>
#include <boost/program_options.hpp>
#include <boost/thread/thread.hpp>
// ROS includes
#include "ros/ros.h"
#include "std_srvs/Empty.h"
#include <sensor_msgs/JointState.h>
#include <tf2_ros/transform_broadcaster.h>
#include "ros/ros.h"
#include "std_srvs/Empty.h"
// Sot Framework includes
#include <sot/core/debug.hh>
#include <sot/core/abstract-sot-external-interface.hh>
#include <sot/core/debug.hh>
// Dynamic-graph-bridge includes.
#include <dynamic_graph_bridge/sot_loader_basic.hh>
......
include/dynamic_graph_bridge/sot_loader_basic.hh
View file @ c2c3026d
......@@ -18,19 +18,23 @@
// STL includes
#include <map>
// Pinocchio includes
#include <pinocchio/fwd.hpp>
// Boost includes
#include <boost/program_options.hpp>
#include <boost/foreach.hpp>
#include <boost/format.hpp>
#include <boost/program_options.hpp>
// ROS includes
#include <sensor_msgs/JointState.h>
#include "ros/ros.h"
#include "std_srvs/Empty.h"
#include <sensor_msgs/JointState.h>
// Sot Framework includes
#include <sot/core/debug.hh>
#include <sot/core/abstract-sot-external-interface.hh>
#include <sot/core/debug.hh>
namespace po = boost::program_options;
namespace dgs = dynamicgraph::sot;
......@@ -91,10 +95,12 @@ class SotLoaderBasic {
virtual void initializeRosNode(int argc, char* argv[]);
// \brief Callback function when starting dynamic graph.
bool start_dg(std_srvs::Empty::Request& request, std_srvs::Empty::Response& response);
bool start_dg(std_srvs::Empty::Request& request,
std_srvs::Empty::Response& response);
// \brief Callback function when stopping dynamic graph.
bool stop_dg(std_srvs::Empty::Request& request, std_srvs::Empty::Response& response);
bool stop_dg(std_srvs::Empty::Request& request,
std_srvs::Empty::Response& response);
// \brief Read the state vector description based upon the robot links.
int readSotVectorStateParam();
......
package.xml
View file @ c2c3026d
<package format="2">
<name>dynamic_graph_bridge</name>
<version>3.0.8</version>
<version>3.4.5</version>
<description>
ROS bindings for dynamic graph.
</description>
<maintainer email="hpp@laas.fr">hpp@laas.fr</maintainer>
<maintainer email="guilhem.saurel@laas.fr">guilhem.saurel@laas.fr</maintainer>
<author email="hpp@laas.fr">hpp@laas.fr</author>
<license>LGPL</license>
......@@ -16,7 +16,7 @@
<rosdoc config="rosdoc.yaml" />
</export>
<buildtool_depend>catkin</buildtool_depend>
<buildtool_depend>catkin</buildtool_depend>
<build_depend>std_msgs</build_depend>
<build_depend>std_srvs</build_depend>
......
pyproject.toml 0 → 100644
View file @ c2c3026d
[tool.black]
exclude = "cmake"
scripts/robot_pose_publisher
View file @ c2c3026d
......@@ -8,23 +8,26 @@ import rospy
import tf
import sensor_msgs.msg
frame = ''
childFrame = ''
frame = ""
childFrame = ""
#DEPRECATED. Robot Pose is already being published
def pose_broadcaster(msg):
translation = msg.position[0:3];
rotation = tf.transformations.quaternion_from_euler(msg.position[3], msg.position[4], msg.position[5])
# DEPRECATED. Robot Pose is already being published
translation = msg.position[0:3]
rotation = tf.transformations.quaternion_from_euler(
msg.position[3], msg.position[4], msg.position[5]
)
tfbr = tf.TransformBroadcaster()
tfbr.sendTransform(translation, rotation,
rospy.Time.now(), childFrame, frame)
tfbr.sendTransform(translation, rotation, rospy.Time.now(), childFrame, frame)
if __name__ == "__main__":
rospy.init_node("robot_pose_publisher", anonymous=True)
if __name__ == '__main__':
rospy.init_node('robot_pose_publisher', anonymous=True)
frame = rospy.get_param("~frame", "odom")
childFrame = rospy.get_param("~child_frame", "base_link")
topic = rospy.get_param("~topic", "joint_states")
frame = rospy.get_param('~frame', 'odom')
childFrame = rospy.get_param('~child_frame', 'base_link')
topic = rospy.get_param('~topic', 'joint_states')
rospy.Subscriber(topic, sensor_msgs.msg.JointState, pose_broadcaster)
rospy.spin()
scripts/run_command
View file @ c2c3026d
......@@ -2,7 +2,7 @@
import rospy
import dynamic_graph
import dynamic_graph # noqa: F401
import dynamic_graph_bridge_msgs.srv
import sys
import code
......@@ -18,7 +18,8 @@ except ImportError:
print("Module readline not available.")
# Enable a History
HISTFILE="%s/.pyhistory" % os.environ["HOME"]
HISTFILE = "%s/.pyhistory" % os.environ["HOME"]
def savehist():
readline.write_history_file(HISTFILE)
......@@ -29,30 +30,31 @@ class RosShell(InteractiveConsole):
self.cache = ""
InteractiveConsole.__init__(self)
rospy.loginfo('waiting for service...')
rospy.wait_for_service('run_command')
rospy.loginfo("waiting for service...")
rospy.wait_for_service("run_command")
self.client = rospy.ServiceProxy(
'run_command', dynamic_graph_bridge_msgs.srv.RunCommand, True)
rospy.wait_for_service('run_script')
"run_command", dynamic_graph_bridge_msgs.srv.RunCommand, True
)
rospy.wait_for_service("run_script")
self.scriptClient = rospy.ServiceProxy(
'run_script', dynamic_graph_bridge_msgs.srv.RunPythonFile, True)
"run_script", dynamic_graph_bridge_msgs.srv.RunPythonFile, True
)
readline.set_completer(DGCompleter(self.client).complete)
readline.parse_and_bind("tab: complete")
# Read the existing history if there is one
if os.path.exists(HISTFILE):
readline.read_history_file(HISTFILE)
# Set maximum number of items that will be written to the history file
readline.set_history_length(300)
import atexit
atexit.register(savehist)
atexit.register(savehist)
def runcode(self, code, retry = True):
def runcode(self, code, retry=True):
source = self.cache[:-1]
self.cache = ""
if source != "":
......@@ -60,50 +62,53 @@ class RosShell(InteractiveConsole):
if not self.client:
print("Connection to remote server lost. Reconnecting...")
self.client = rospy.ServiceProxy(
'run_command', dynamic_graph_bridge_msgs.srv.RunCommand, True)
"run_command", dynamic_graph_bridge_msgs.srv.RunCommand, True
)
if retry:
print("Retrying previous command...")
self.cache = source
return self.runcode(code, False)
response = self.client(str(source))
if response.standardoutput != "":
print response.standardoutput[:-1]
print(response.standardoutput[:-1])
if response.standarderror != "":
print response.standarderror[:-1]
print(response.standarderror[:-1])
elif response.result != "None":
print response.result
except rospy.ServiceException, e:
print(response.result)
except rospy.ServiceException:
print("Connection to remote server lost. Reconnecting...")
self.client = rospy.ServiceProxy(
'run_command', dynamic_graph_bridge_msgs.srv.RunCommand, True)
"run_command", dynamic_graph_bridge_msgs.srv.RunCommand, True
)
if retry:
print("Retrying previous command...")
self.cache = source
self.runcode(code, False)
def runsource(self, source, filename = '<input>', symbol = 'single'):
def runsource(self, source, filename="<input>", symbol="single"):
try:
c = code.compile_command(source, filename, symbol)
if c:
return self.runcode(c)
else:
return True
except SyntaxError, OverflowError:
except (SyntaxError, OverflowError):
self.showsyntaxerror()
self.cache = ""
return False
def push(self,line):
def push(self, line):
self.cache += line + "\n"
return InteractiveConsole.push(self,line)
return InteractiveConsole.push(self, line)
if __name__ == '__main__':
if __name__ == "__main__":
import optparse
import os.path
rospy.init_node('run_command', argv=sys.argv)
rospy.init_node("run_command", argv=sys.argv)
sys.argv = rospy.myargv(argv=None)
parser = optparse.OptionParser(
usage='\n\t%prog [options]')
parser = optparse.OptionParser(usage="\n\t%prog [options]")
(options, args) = parser.parse_args(sys.argv[1:])
sh = RosShell()
......@@ -118,6 +123,6 @@ if __name__ == '__main__':
if not response:
print("Error while file parsing ")
else:
print("Provided file does not exist: %s"%(infile))
print("Provided file does not exist: %s" % (infile))
else:
sh.interact("Interacting with remote server.")
scripts/tf_publisher
View file @ c2c3026d
......@@ -6,6 +6,8 @@
# through dynamic_graph_bridge.
#
import logging
import rospy
import tf
......@@ -13,15 +15,15 @@ import geometry_msgs.msg
def main():
rospy.init_node('tf_publisher', anonymous=True)
rospy.init_node("tf_publisher", anonymous=True)
frame = rospy.get_param('~frame', '')
childFrame = rospy.get_param('~child_frame', '')
topic = rospy.get_param('~topic', '')
rateSeconds = rospy.get_param('~rate', 5)
frame = rospy.get_param("~frame", "")
childFrame = rospy.get_param("~child_frame", "")
topic = rospy.get_param("~topic", "")
rateSeconds = rospy.get_param("~rate", 5)
if not frame or not childFrame or not topic:
logpy.error("frame, childFrame and topic are required parameters")
logging.error("frame, childFrame and topic are required parameters")
return
rate = rospy.Rate(rateSeconds)
......@@ -35,11 +37,10 @@ def main():
ok = False
while not rospy.is_shutdown() and not ok:
try:
tl.waitForTransform(childFrame, frame,
rospy.Time(), rospy.Duration(0.1))
tl.waitForTransform(childFrame, frame, rospy.Time(), rospy.Duration(0.1))
ok = True
except tf.Exception, e:
rospy.logwarn("waiting for tf transform")
except tf.Exception:
logging.warning("waiting for tf transform")
ok = False
while not rospy.is_shutdown():
......@@ -60,4 +61,5 @@ def main():
pub.publish(transform)
rate.sleep()
main()