From: Walter Fetter Lages Date: Mon, 19 Jul 2021 08:25:41 +0000 (-0300) Subject: Add tatuira_ident package. X-Git-Url: http://git.ece.ufrgs.br/?a=commitdiff_plain;h=075e530aa3b3fefedfec4cc587e69221ccc619ea;p=tatuira.git Add tatuira_ident package. --- diff --git a/tatuira_ident/CMakeLists.txt b/tatuira_ident/CMakeLists.txt new file mode 100644 index 0000000..8c56372 --- /dev/null +++ b/tatuira_ident/CMakeLists.txt @@ -0,0 +1,208 @@ +cmake_minimum_required(VERSION 3.0.2) +project(tatuira_ident) + +## 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 +) + +## System dependencies are found with CMake's conventions +# find_package(Boost REQUIRED COMPONENTS system) +find_package(Eigen3 REQUIRED) + + +## 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() + +################################################ +## Declare ROS messages, services and actions ## +################################################ + +## To declare and build messages, services or actions from within this +## package, follow these steps: +## * Let MSG_DEP_SET be the set of packages whose message types you use in +## your messages/services/actions (e.g. std_msgs, actionlib_msgs, ...). +## * In the file package.xml: +## * add a build_depend tag for "message_generation" +## * add a build_depend and a exec_depend tag for each package in MSG_DEP_SET +## * If MSG_DEP_SET isn't empty the following dependency has been pulled in +## but can be declared for certainty nonetheless: +## * add a exec_depend tag for "message_runtime" +## * In this file (CMakeLists.txt): +## * add "message_generation" and every package in MSG_DEP_SET to +## find_package(catkin REQUIRED COMPONENTS ...) +## * add "message_runtime" and every package in MSG_DEP_SET to +## catkin_package(CATKIN_DEPENDS ...) +## * uncomment the add_*_files sections below as needed +## and list every .msg/.srv/.action file to be processed +## * uncomment the generate_messages entry below +## * add every package in MSG_DEP_SET to generate_messages(DEPENDENCIES ...) + +## Generate messages in the 'msg' folder +# add_message_files( +# FILES +# Message1.msg +# Message2.msg +# ) + +## Generate services in the 'srv' folder +# add_service_files( +# FILES +# Service1.srv +# Service2.srv +# ) + +## Generate actions in the 'action' folder +# add_action_files( +# FILES +# Action1.action +# Action2.action +# ) + +## Generate added messages and services with any dependencies listed here +# generate_messages( +# DEPENDENCIES +# std_msgs # Or other packages containing msgs +# ) + +################################################ +## Declare ROS dynamic reconfigure parameters ## +################################################ + +## To declare and build dynamic reconfigure parameters within this +## package, follow these steps: +## * In the file package.xml: +## * add a build_depend and a exec_depend tag for "dynamic_reconfigure" +## * In this file (CMakeLists.txt): +## * add "dynamic_reconfigure" to +## find_package(catkin REQUIRED COMPONENTS ...) +## * uncomment the "generate_dynamic_reconfigure_options" section below +## and list every .cfg file to be processed + +## Generate dynamic reconfigure parameters in the 'cfg' folder +# generate_dynamic_reconfigure_options( +# cfg/DynReconf1.cfg +# cfg/DynReconf2.cfg +# ) + +################################### +## catkin specific configuration ## +################################### +## The catkin_package macro generates cmake config files for your package +## Declare things to be passed to dependent projects +## INCLUDE_DIRS: uncomment this if your package contains header files +## LIBRARIES: libraries you create in this project that dependent projects also need +## CATKIN_DEPENDS: catkin_packages dependent projects also need +## DEPENDS: system dependencies of this project that dependent projects also need +catkin_package( +# INCLUDE_DIRS include +# LIBRARIES tatuira_ident +# CATKIN_DEPENDS roscpp +# DEPENDS Eigen3 +) + +########### +## Build ## +########### + +## Specify additional locations of header files +## Your package locations should be listed before other locations +include_directories( +# include + ${catkin_INCLUDE_DIRS} +# TODO: Check names of system library include directories (Eigen3) + ${EIGEN3_INCLUDE_DIRS} +) + +## Declare a C++ library +# add_library(${PROJECT_NAME} +# src/${PROJECT_NAME}/tatuira_ident.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(tatuira_ident src/tatuira_ident.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(tatuira_ident + ${catkin_LIBRARIES} +# ${Eigen3_LIBRARIES} +) + +############# +## Install ## +############# + +# all install targets should use catkin DESTINATION variables +# See http://ros.org/doc/api/catkin/html/adv_user_guide/variables.html + +## Mark executable scripts (Python etc.) for installation +## in contrast to setup.py, you can choose the destination +# catkin_install_python(PROGRAMS +# scripts/my_python_script +# DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} +# ) + +## Mark executables for installation +## See http://docs.ros.org/melodic/api/catkin/html/howto/format1/building_executables.html +install(TARGETS tatuira_ident + RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} +) + +## Mark libraries for installation +## See http://docs.ros.org/melodic/api/catkin/html/howto/format1/building_libraries.html +# install(TARGETS ${PROJECT_NAME} +# ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION} +# LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION} +# RUNTIME DESTINATION ${CATKIN_GLOBAL_BIN_DESTINATION} +# ) + +## Mark cpp header files for installation +# install(DIRECTORY include/${PROJECT_NAME}/ +# DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION} +# FILES_MATCHING PATTERN "*.h" +# PATTERN ".svn" EXCLUDE +# ) + +## Mark other files for installation (e.g. launch and bag files, etc.) +# install(FILES +# # myfile1 +# # myfile2 +# DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION} +# ) + +############# +## Testing ## +############# + +## Add gtest based cpp test target and link libraries +# catkin_add_gtest(${PROJECT_NAME}-test test/test_tatuira_ident.cpp) +# if(TARGET ${PROJECT_NAME}-test) +# target_link_libraries(${PROJECT_NAME}-test ${PROJECT_NAME}) +# endif() + +## Add folders to be run by python nosetests +# catkin_add_nosetests(test) diff --git a/tatuira_ident/config/ident.yaml b/tatuira_ident/config/ident.yaml new file mode 100644 index 0000000..3380f6e --- /dev/null +++ b/tatuira_ident/config/ident.yaml @@ -0,0 +1,5 @@ +# Watch-out: The indentation here is relevant to the semantic! + +tatuira_ident: + wheel_separation: 0.322 + wheel_radius: [0.075, 0.075] diff --git a/tatuira_ident/launch/gazebo.launch b/tatuira_ident/launch/gazebo.launch new file mode 100644 index 0000000..18eb57d --- /dev/null +++ b/tatuira_ident/launch/gazebo.launch @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/tatuira_ident/launch/ident.launch b/tatuira_ident/launch/ident.launch new file mode 100644 index 0000000..bdc39e6 --- /dev/null +++ b/tatuira_ident/launch/ident.launch @@ -0,0 +1,3 @@ + + + diff --git a/tatuira_ident/package.xml b/tatuira_ident/package.xml new file mode 100644 index 0000000..cfb57a9 --- /dev/null +++ b/tatuira_ident/package.xml @@ -0,0 +1,66 @@ + + + tatuira_ident + 0.0.1 + The tatuira_ident package + + + + + Walter Fetter Lages + + + + + + GPLv3 + + + + + + + + + + + + + Walter Fetter Lages --> + + + + + + + + + + + + + + + + + + + + + + + catkin + Eigen3 + roscpp + Eigen3 + roscpp + Eigen3 + roscpp + + + + + + + + diff --git a/tatuira_ident/src/tatuira_ident.cpp b/tatuira_ident/src/tatuira_ident.cpp new file mode 100644 index 0000000..88ae85b --- /dev/null +++ b/tatuira_ident/src/tatuira_ident.cpp @@ -0,0 +1,238 @@ +/****************************************************************************** + ROS tatuira_ident Package + Tatuira Dynamics Model + Copyright (C) 2020 Walter Fetter Lages + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see + . + +*******************************************************************************/ + +#include + +#include + +#include +#include +#include + +class Prbs +{ + int index_; + unsigned int nd_; + unsigned char *sh_; + + public: + + Prbs(unsigned int n=10,unsigned int seed=0); + ~Prbs(void); + + void seed(unsigned int s) { index_=s % nd_; }; + + operator int(void); +}; + + +Prbs::Prbs(unsigned int n,unsigned int seed) +{ + nd_=n; + index_=seed % nd_; + sh_=new unsigned char[nd_]; + for(unsigned int i=0; i < nd_;i++) sh_[i]=1; + for(unsigned int i=0; i < 98;i++) (int) *this; // call operator int() to exercise +} + +Prbs::~Prbs(void) +{ +// delete[] sh; +} + +Prbs::operator int(void) +{ + unsigned char s=sh_[nd_-1]+sh_[nd_-2]; + if(s > 1) s=0; + for(int j=nd_-2;j >= 0;j--) sh_[j+1]=sh_[j]; + sh_[0]=s; + return sh_[index_]; +} + + +class Ident +{ + public: + Ident(ros::NodeHandle node); + ~Ident(void); + void setCommand(void); + + private: + ros::NodeHandle node_; + + ros::Subscriber jointStatesSubscriber_; + ros::Publisher dynParamPublisher_; + ros::Publisher leftWheelCommandPublisher_; + ros::Publisher rightWheelCommandPublisher_; + + const int nJoints_; + + Eigen::VectorXd u_; + Eigen::VectorXd thetaEst1_; + Eigen::VectorXd thetaEst2_; + Eigen::MatrixXd P1_; + Eigen::MatrixXd P2_; + + std::vector prbs_; + int iter_; + + ros::Time lastTime_; + + std::vector wheelRadius_; + double wheelBase_; + + void jointStatesCB(const sensor_msgs::JointState::ConstPtr &jointStates); + void resetCovariance(void); +}; + + +Ident::Ident(ros::NodeHandle node): + nJoints_(2),u_(nJoints_),thetaEst1_(nJoints_),thetaEst2_(nJoints_),P1_(nJoints_,nJoints_),P2_(nJoints_,nJoints_),prbs_(nJoints_),wheelRadius_(nJoints_) +{ + node_=node; + + ros::NodeHandle n("~"); + if(!n.getParam("wheel_separation",wheelBase_)) + { + ROS_ERROR("No 'wheel_separation' in node %s.",node_.getNamespace().c_str()); + return; + } + + if(!n.getParam("wheel_radius",wheelRadius_)) + { + ROS_ERROR("No 'wheel_radius' in node %s.",node_.getNamespace().c_str()); + return; + } + + jointStatesSubscriber_=node_.subscribe("joint_states",1000,&Ident::jointStatesCB,this); + dynParamPublisher_=node_.advertise("dynamic_parameters",1000); + leftWheelCommandPublisher_=node_.advertise("left_wheel_command",1000); + rightWheelCommandPublisher_=node_.advertise("right_wheel_command",1000); + + u_.setZero(); + thetaEst1_.setZero(); + thetaEst2_.setZero(); + resetCovariance(); + + lastTime_=ros::Time::now(); +} + +Ident::~Ident(void) +{ + jointStatesSubscriber_.shutdown(); +} + +void Ident::resetCovariance(void) +{ + P1_.setIdentity(); + P1_*=1; + P2_.setIdentity(); + P2_*=1; + iter_=0; +} + +void Ident::jointStatesCB(const sensor_msgs::JointState::ConstPtr &jointStates) +{ + ros::Duration dt=jointStates->header.stamp-lastTime_; + lastTime_=jointStates->header.stamp; + + Eigen::VectorXd y=-u_; //y(k+1)=(u(k+1)-u(k))/dt + + Eigen::VectorXd Phi1(nJoints_); + Eigen::VectorXd Phi2(nJoints_); + Phi1[0]=u_[1]*u_[1]; // u2^2(k) + Phi2[0]=u_[0]*u_[1]; // u1(k)*u2(k) + + Eigen::VectorXd torque(nJoints_); + + // u(k+1) + // jointStates->velocity[0] is left wheel + // jointStates->velocity[1] is right wheel + u_[0]=(jointStates->velocity[0]*wheelRadius_[0]+jointStates->velocity[1]*wheelRadius_[1])/2.0; + u_[1]=(jointStates->velocity[1]*wheelRadius_[1]-jointStates->velocity[0]*wheelRadius_[0])/wheelBase_; + + for(int i=0;i < nJoints_;i++) + torque[i]=jointStates->effort[i]; // torque(k) + + y+=u_; + y/=dt.toSec(); + + Phi1[1]=torque[0]+torque[1]; + Phi2[1]=torque[0]-torque[1]; + + double yEst1=Phi1.transpose()*thetaEst1_; + Eigen::VectorXd K1=P1_*Phi1/(1+Phi1.transpose()*P1_*Phi1); + thetaEst1_+=K1*(y[0]-yEst1); + P1_-=K1*Phi1.transpose()*P1_; + + double yEst2=Phi2.transpose()*thetaEst2_; + Eigen::VectorXd K2=P2_*Phi2/(1+Phi2.transpose()*P2_*Phi2); + thetaEst2_+=K2*(y[1]-yEst2); + P2_-=K2*Phi2.transpose()*P2_; + + std_msgs::Float64MultiArray dynParam; + dynParam.layout.dim.push_back(std_msgs::MultiArrayDimension()); + dynParam.layout.dim[0].label="K5 K6 K7 K8 P55 P66 P77 P88"; + dynParam.layout.dim[0].size=nJoints_*4; + dynParam.layout.dim[0].stride=1; + dynParam.layout.data_offset=0; + for(int i=0;i < nJoints_;i++) + { + dynParam.data.push_back(thetaEst1_[i]); + dynParam.data.push_back(thetaEst2_[i]); + } + for(int i=0;i < nJoints_;i++) + { + dynParam.data.push_back(P1_(i,i)); + dynParam.data.push_back(P2_(i,i)); + } + dynParamPublisher_.publish(dynParam); + +// if(iter++ > 2048) resetCovariance(); +} + +void Ident::setCommand(void) +{ + std_msgs::Float64 leftCommand; + std_msgs::Float64 rightCommand; + leftCommand.data=5*prbs_[0]-2.5; + rightCommand.data=5*prbs_[1]-2.5; + leftWheelCommandPublisher_.publish(leftCommand); + rightWheelCommandPublisher_.publish(rightCommand); +} + +int main(int argc,char* argv[]) +{ + ros::init(argc,argv,"tatuira_ident"); + ros::NodeHandle node; + + Ident ident(node); + + ros::Rate loop(100); + while(ros::ok()) + { + ident.setCommand(); + + ros::spinOnce(); + loop.sleep(); + } + return 0; +}