Merge pull request #82 from elandini84/fix/ReturnValue/Rangefinder2D

randaz81 · web-flow · commit 39f8fb95e812 · 2025-02-27T14:40:31.000+01:00
Rangefinder2D_nwc_yarp compatibility fix
diff --git a/.github/workflows/conda-ci.yml b/.github/workflows/conda-ci.yml
@@ -38,7 +38,7 @@ jobs:
     - name: Check License
       run: |
         perl tests/misc/check_license.pl
-        
+
   check-tests:
     name: 'Check Devices Tests'
     runs-on: ubuntu-20.04
@@ -52,7 +52,7 @@ jobs:
     - name: Check Devices Tests
       run: |
         python3 tests/misc/check_tests.py
-        
+
   build:
     name: '[${{ matrix.os }}@${{ matrix.build_type }}@${{ matrix.ros_distro }}@conda]'
     runs-on: ${{ matrix.os }}
@@ -83,7 +83,7 @@ jobs:
       if: contains(matrix.os, 'macos') || contains(matrix.os, 'ubuntu')
       run: |
         cd ${GITHUB_WORKSPACE}
-        git clone -b yarp-3.11 https://github.com/robotology/yarp
+        git clone -b master https://github.com/robotology/yarp
 
     - name: Dependencies from source [Linux&macOS]
       if: contains(matrix.os, 'macos') || contains(matrix.os, 'ubuntu')
@@ -106,7 +106,7 @@ jobs:
       shell: bash -l {0}
       run: |
         cd ${GITHUB_WORKSPACE}
-        git clone -b yarp-3.11 https://github.com/robotology/yarp
+        git clone -b master https://github.com/robotology/yarp
         cd yarp
         mkdir build
         cd build
@@ -219,7 +219,7 @@ jobs:
       if: contains(matrix.os, 'macos') || contains(matrix.os, 'ubuntu')
       run: |
         cd ${GITHUB_WORKSPACE}
-        git clone -b yarp-3.11 https://github.com/robotology/yarp
+        git clone -b master https://github.com/robotology/yarp
 
     - name: Dependencies from source [Linux&macOS]
       if: contains(matrix.os, 'macos') || contains(matrix.os, 'ubuntu')
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -31,8 +31,8 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 set(YARP_FORCE_DYNAMIC_PLUGINS TRUE CACHE INTERNAL "yarp-devices-ros2 is always built with dynamic plugins")
 option(BUILD_SHARED_LIBS "Build libraries as shared as opposed to static" ON)
 
-find_package(YARP 3.11.1 COMPONENTS os sig dev serversql OPTIONAL_COMPONENTS math REQUIRED)
-find_package(YARP 3.11.1 COMPONENTS catch2 dev_tests QUIET)
+find_package(YARP 3.11.100 COMPONENTS os sig dev serversql OPTIONAL_COMPONENTS math REQUIRED)
+find_package(YARP 3.11.100 COMPONENTS catch2 dev_tests QUIET)
 
 if(YARP_catch2_FOUND AND YARP_dev_tests_FOUND)
   option(YARP_COMPILE_TESTS "Enable YARP tests" OFF)
diff --git a/src/devices/rangefinder2D_nwc_ros2/Rangefinder2D_nwc_ros2.cpp b/src/devices/rangefinder2D_nwc_ros2/Rangefinder2D_nwc_ros2.cpp
@@ -85,98 +85,98 @@ void Rangefinder2D_nwc_ros2::callback(sensor_msgs::msg::LaserScan::SharedPtr msg
     m_timestamp = (msg->header.stamp.sec + (msg->header.stamp.nanosec / 1000000000));
 }
 
-bool Rangefinder2D_nwc_ros2::getLaserMeasurement(std::vector<yarp::sig::LaserMeasurementData> &data, double* timestamp)
+ReturnValue Rangefinder2D_nwc_ros2::getLaserMeasurement(std::vector<yarp::sig::LaserMeasurementData> &data, double* timestamp)
 {
-    if (!m_data_valid) {return false;}
+    if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}
     std::lock_guard<std::mutex> data_guard(m_mutex);
     *timestamp = m_timestamp;
-    return true;
+    return ReturnValue_ok;
 }
 
-bool Rangefinder2D_nwc_ros2::getRawData(yarp::sig::Vector &data, double* timestamp)
+ReturnValue Rangefinder2D_nwc_ros2::getRawData(yarp::sig::Vector &data, double* timestamp)
 {
-    if (!m_data_valid) {return false;}
+    if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}
     std::lock_guard<std::mutex> data_guard(m_mutex);
     data = m_data;
     *timestamp = m_timestamp;
-    return true;
+    return ReturnValue_ok;
 }
 
-bool Rangefinder2D_nwc_ros2::getDeviceStatus(Device_status& status)
+ReturnValue Rangefinder2D_nwc_ros2::getDeviceStatus(Device_status& status)
 {
-    if (!m_data_valid) {return false;}
+    if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}
     std::lock_guard<std::mutex> data_guard(m_mutex);
-    return true;
+    return ReturnValue_ok;
 }
 
-bool Rangefinder2D_nwc_ros2::getDistanceRange(double& min, double& max)
+ReturnValue Rangefinder2D_nwc_ros2::getDistanceRange(double& min, double& max)
 {
-    if (!m_data_valid) {return false;}
+    if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}
     std::lock_guard<std::mutex> data_guard(m_mutex);
     min = m_minDistance;
     max = m_maxDistance;
-    return true;
+    return ReturnValue_ok;
 }
 
-bool Rangefinder2D_nwc_ros2::setDistanceRange(double min, double max)
+ReturnValue Rangefinder2D_nwc_ros2::setDistanceRange(double min, double max)
 {
-    if (!m_data_valid) {return false;}
+    if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}
     std::lock_guard<std::mutex> data_guard(m_mutex);
     yCTrace(RANGEFINDER2D_NWC_ROS2, "setDistanceRange not implemented");
-    return false;
+    return YARP_METHOD_NOT_YET_IMPLEMENTED();
 }
 
-bool Rangefinder2D_nwc_ros2::getScanLimits(double& min, double& max)
+ReturnValue Rangefinder2D_nwc_ros2::getScanLimits(double& min, double& max)
 {
-    if (!m_data_valid) {return false;}
+    if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}
     std::lock_guard<std::mutex> data_guard(m_mutex);
     min = m_minAngle;
     max = m_maxAngle;
-    return true;
+    return ReturnValue_ok;
 }
 
-bool Rangefinder2D_nwc_ros2::setScanLimits(double min, double max)
+ReturnValue Rangefinder2D_nwc_ros2::setScanLimits(double min, double max)
 {
-    if (!m_data_valid) {return false;}
+    if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}
     std::lock_guard<std::mutex> data_guard(m_mutex);
     yCTrace(RANGEFINDER2D_NWC_ROS2, "setScanLimits not implemented");
-    return false;
+    return YARP_METHOD_NOT_YET_IMPLEMENTED();
 }
 
-bool Rangefinder2D_nwc_ros2::getHorizontalResolution(double& step)
+ReturnValue Rangefinder2D_nwc_ros2::getHorizontalResolution(double& step)
 {
-    if (!m_data_valid) {return false;}
+    if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}
     std::lock_guard<std::mutex> data_guard(m_mutex);
     step = m_resolution;
-    return true;
+    return ReturnValue_ok;
 }
 
-bool Rangefinder2D_nwc_ros2::setHorizontalResolution(double step)
+ReturnValue Rangefinder2D_nwc_ros2::setHorizontalResolution(double step)
 {
-    if (!m_data_valid) {return false;}
+    if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}
     std::lock_guard<std::mutex> data_guard(m_mutex);
     yCTrace(RANGEFINDER2D_NWC_ROS2, "setHorizontalResolution not implemented");
-    return false;
+    return YARP_METHOD_NOT_YET_IMPLEMENTED();
 }
 
-bool Rangefinder2D_nwc_ros2::getScanRate(double& rate)
+ReturnValue Rangefinder2D_nwc_ros2::getScanRate(double& rate)
 {
-    if (!m_data_valid) {return false;}
+    if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}
     std::lock_guard<std::mutex> data_guard(m_mutex);
-    return true;
+    return ReturnValue_ok;
 }
 
-bool Rangefinder2D_nwc_ros2::setScanRate(double rate)
+ReturnValue Rangefinder2D_nwc_ros2::setScanRate(double rate)
 {
-    if (!m_data_valid) {return false;}
+    if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}
     std::lock_guard<std::mutex> data_guard(m_mutex);
     yCTrace(RANGEFINDER2D_NWC_ROS2, "setScanRate not implemented");
-    return false;
+    return YARP_METHOD_NOT_YET_IMPLEMENTED();
 }
 
-bool Rangefinder2D_nwc_ros2::getDeviceInfo(std::string &device_info)
+ReturnValue Rangefinder2D_nwc_ros2::getDeviceInfo(std::string &device_info)
 {
-    if (!m_data_valid) {return false;}
+    if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}
     std::lock_guard<std::mutex> data_guard(m_mutex);
-    return true;
+    return ReturnValue_ok;
 }
diff --git a/src/devices/rangefinder2D_nwc_ros2/Rangefinder2D_nwc_ros2.h b/src/devices/rangefinder2D_nwc_ros2/Rangefinder2D_nwc_ros2.h
@@ -54,18 +54,18 @@ class Rangefinder2D_nwc_ros2 :
 
 public:
     // IRangeFinder2D
-    bool getLaserMeasurement(std::vector<yarp::sig::LaserMeasurementData> &data, double* timestamp = nullptr) override;
-    bool getRawData(yarp::sig::Vector &data, double* timestamp = nullptr) override;
-    bool getDeviceStatus(Device_status& status) override;
-    bool getDistanceRange(double& min, double& max) override;
-    bool setDistanceRange(double min, double max) override;
-    bool getScanLimits(double& min, double& max) override;
-    bool setScanLimits(double min, double max) override;
-    bool getHorizontalResolution(double& step) override;
-    bool setHorizontalResolution(double step) override;
-    bool getScanRate(double& rate) override;
-    bool setScanRate(double rate) override;
-    bool getDeviceInfo(std::string &device_info) override;
+    yarp::dev::ReturnValue getLaserMeasurement(std::vector<yarp::sig::LaserMeasurementData> &data, double* timestamp = nullptr) override;
+    yarp::dev::ReturnValue getRawData(yarp::sig::Vector &data, double* timestamp = nullptr) override;
+    yarp::dev::ReturnValue getDeviceStatus(Device_status& status) override;
+    yarp::dev::ReturnValue getDistanceRange(double& min, double& max) override;
+    yarp::dev::ReturnValue setDistanceRange(double min, double max) override;
+    yarp::dev::ReturnValue getScanLimits(double& min, double& max) override;
+    yarp::dev::ReturnValue setScanLimits(double min, double max) override;
+    yarp::dev::ReturnValue getHorizontalResolution(double& step) override;
+    yarp::dev::ReturnValue setHorizontalResolution(double step) override;
+    yarp::dev::ReturnValue getScanRate(double& rate) override;
+    yarp::dev::ReturnValue setScanRate(double rate) override;
+    yarp::dev::ReturnValue getDeviceInfo(std::string &device_info) override;
 
 private:
     rclcpp::Node::SharedPtr m_node;

Original file line number	Diff line number	Diff line change
`@@ -85,98 +85,98 @@ void Rangefinder2D_nwc_ros2::callback(sensor_msgs::msg::LaserScan::SharedPtr msg`
`85`	`85`	`m_timestamp = (msg->header.stamp.sec + (msg->header.stamp.nanosec / 1000000000));`
`86`	`86`	`}`
`87`	`87`
`88`		`-bool Rangefinder2D_nwc_ros2::getLaserMeasurement(std::vector<yarp::sig::LaserMeasurementData> &data, double* timestamp)`
	`88`	`+ReturnValue Rangefinder2D_nwc_ros2::getLaserMeasurement(std::vector<yarp::sig::LaserMeasurementData> &data, double* timestamp)`
`89`	`89`	`{`
`90`		`- if (!m_data_valid) {return false;}`
	`90`	`+ if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}`
`91`	`91`	`std::lock_guard<std::mutex> data_guard(m_mutex);`
`92`	`92`	`*timestamp = m_timestamp;`
`93`		`- return true;`
	`93`	`+ return ReturnValue_ok;`
`94`	`94`	`}`
`95`	`95`
`96`		`-bool Rangefinder2D_nwc_ros2::getRawData(yarp::sig::Vector &data, double* timestamp)`
	`96`	`+ReturnValue Rangefinder2D_nwc_ros2::getRawData(yarp::sig::Vector &data, double* timestamp)`
`97`	`97`	`{`
`98`		`- if (!m_data_valid) {return false;}`
	`98`	`+ if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}`
`99`	`99`	`std::lock_guard<std::mutex> data_guard(m_mutex);`
`100`	`100`	`data = m_data;`
`101`	`101`	`*timestamp = m_timestamp;`
`102`		`- return true;`
	`102`	`+ return ReturnValue_ok;`
`103`	`103`	`}`
`104`	`104`
`105`		`-bool Rangefinder2D_nwc_ros2::getDeviceStatus(Device_status& status)`
	`105`	`+ReturnValue Rangefinder2D_nwc_ros2::getDeviceStatus(Device_status& status)`
`106`	`106`	`{`
`107`		`- if (!m_data_valid) {return false;}`
	`107`	`+ if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}`
`108`	`108`	`std::lock_guard<std::mutex> data_guard(m_mutex);`
`109`		`- return true;`
	`109`	`+ return ReturnValue_ok;`
`110`	`110`	`}`
`111`	`111`
`112`		`-bool Rangefinder2D_nwc_ros2::getDistanceRange(double& min, double& max)`
	`112`	`+ReturnValue Rangefinder2D_nwc_ros2::getDistanceRange(double& min, double& max)`
`113`	`113`	`{`
`114`		`- if (!m_data_valid) {return false;}`
	`114`	`+ if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}`
`115`	`115`	`std::lock_guard<std::mutex> data_guard(m_mutex);`
`116`	`116`	`min = m_minDistance;`
`117`	`117`	`max = m_maxDistance;`
`118`		`- return true;`
	`118`	`+ return ReturnValue_ok;`
`119`	`119`	`}`
`120`	`120`
`121`		`-bool Rangefinder2D_nwc_ros2::setDistanceRange(double min, double max)`
	`121`	`+ReturnValue Rangefinder2D_nwc_ros2::setDistanceRange(double min, double max)`
`122`	`122`	`{`
`123`		`- if (!m_data_valid) {return false;}`
	`123`	`+ if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}`
`124`	`124`	`std::lock_guard<std::mutex> data_guard(m_mutex);`
`125`	`125`	`yCTrace(RANGEFINDER2D_NWC_ROS2, "setDistanceRange not implemented");`
`126`		`- return false;`
	`126`	`+ return YARP_METHOD_NOT_YET_IMPLEMENTED();`
`127`	`127`	`}`
`128`	`128`
`129`		`-bool Rangefinder2D_nwc_ros2::getScanLimits(double& min, double& max)`
	`129`	`+ReturnValue Rangefinder2D_nwc_ros2::getScanLimits(double& min, double& max)`
`130`	`130`	`{`
`131`		`- if (!m_data_valid) {return false;}`
	`131`	`+ if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}`
`132`	`132`	`std::lock_guard<std::mutex> data_guard(m_mutex);`
`133`	`133`	`min = m_minAngle;`
`134`	`134`	`max = m_maxAngle;`
`135`		`- return true;`
	`135`	`+ return ReturnValue_ok;`
`136`	`136`	`}`
`137`	`137`
`138`		`-bool Rangefinder2D_nwc_ros2::setScanLimits(double min, double max)`
	`138`	`+ReturnValue Rangefinder2D_nwc_ros2::setScanLimits(double min, double max)`
`139`	`139`	`{`
`140`		`- if (!m_data_valid) {return false;}`
	`140`	`+ if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}`
`141`	`141`	`std::lock_guard<std::mutex> data_guard(m_mutex);`
`142`	`142`	`yCTrace(RANGEFINDER2D_NWC_ROS2, "setScanLimits not implemented");`
`143`		`- return false;`
	`143`	`+ return YARP_METHOD_NOT_YET_IMPLEMENTED();`
`144`	`144`	`}`
`145`	`145`
`146`		`-bool Rangefinder2D_nwc_ros2::getHorizontalResolution(double& step)`
	`146`	`+ReturnValue Rangefinder2D_nwc_ros2::getHorizontalResolution(double& step)`
`147`	`147`	`{`
`148`		`- if (!m_data_valid) {return false;}`
	`148`	`+ if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}`
`149`	`149`	`std::lock_guard<std::mutex> data_guard(m_mutex);`
`150`	`150`	`step = m_resolution;`
`151`		`- return true;`
	`151`	`+ return ReturnValue_ok;`
`152`	`152`	`}`
`153`	`153`
`154`		`-bool Rangefinder2D_nwc_ros2::setHorizontalResolution(double step)`
	`154`	`+ReturnValue Rangefinder2D_nwc_ros2::setHorizontalResolution(double step)`
`155`	`155`	`{`
`156`		`- if (!m_data_valid) {return false;}`
	`156`	`+ if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}`
`157`	`157`	`std::lock_guard<std::mutex> data_guard(m_mutex);`
`158`	`158`	`yCTrace(RANGEFINDER2D_NWC_ROS2, "setHorizontalResolution not implemented");`
`159`		`- return false;`
	`159`	`+ return YARP_METHOD_NOT_YET_IMPLEMENTED();`
`160`	`160`	`}`
`161`	`161`
`162`		`-bool Rangefinder2D_nwc_ros2::getScanRate(double& rate)`
	`162`	`+ReturnValue Rangefinder2D_nwc_ros2::getScanRate(double& rate)`
`163`	`163`	`{`
`164`		`- if (!m_data_valid) {return false;}`
	`164`	`+ if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}`
`165`	`165`	`std::lock_guard<std::mutex> data_guard(m_mutex);`
`166`		`- return true;`
	`166`	`+ return ReturnValue_ok;`
`167`	`167`	`}`
`168`	`168`
`169`		`-bool Rangefinder2D_nwc_ros2::setScanRate(double rate)`
	`169`	`+ReturnValue Rangefinder2D_nwc_ros2::setScanRate(double rate)`
`170`	`170`	`{`
`171`		`- if (!m_data_valid) {return false;}`
	`171`	`+ if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}`
`172`	`172`	`std::lock_guard<std::mutex> data_guard(m_mutex);`
`173`	`173`	`yCTrace(RANGEFINDER2D_NWC_ROS2, "setScanRate not implemented");`
`174`		`- return false;`
	`174`	`+ return YARP_METHOD_NOT_YET_IMPLEMENTED();`
`175`	`175`	`}`
`176`	`176`
`177`		`-bool Rangefinder2D_nwc_ros2::getDeviceInfo(std::string &device_info)`
	`177`	`+ReturnValue Rangefinder2D_nwc_ros2::getDeviceInfo(std::string &device_info)`
`178`	`178`	`{`
`179`		`- if (!m_data_valid) {return false;}`
	`179`	`+ if (!m_data_valid) {return ReturnValue::return_code::return_value_error_generic;}`
`180`	`180`	`std::lock_guard<std::mutex> data_guard(m_mutex);`
`181`		`- return true;`
	`181`	`+ return ReturnValue_ok;`
`182`	`182`	`}`