ros2_control - rolling
Loading...
Searching...
No Matches
joint_limits_rosparam.hpp
1// Copyright 2020 PAL Robotics S.L.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
16
17#ifndef JOINT_LIMITS__JOINT_LIMITS_ROSPARAM_HPP_
18#define JOINT_LIMITS__JOINT_LIMITS_ROSPARAM_HPP_
19
20#include <fmt/compile.h>
21
22#include <cmath>
23#include <exception>
24#include <limits>
25#include <string>
26#include <vector>
27
28#include "joint_limits/joint_limits.hpp"
29#include "rclcpp/exceptions.hpp"
30#include "rclcpp/logging.hpp"
31#include "rclcpp/node.hpp"
32#include "rclcpp/parameter.hpp"
33#include "rclcpp/parameter_value.hpp"
34#include "rclcpp_lifecycle/lifecycle_node.hpp"
35
36namespace // utilities
37{
45template <typename ParameterT>
46auto auto_declare(
47 const rclcpp::node_interfaces::NodeParametersInterface::SharedPtr & param_itf,
48 const std::string & name, const ParameterT & default_value)
49{
50 if (!param_itf->has_parameter(name))
51 {
52 auto param_default_value = rclcpp::ParameterValue(default_value);
53 param_itf->declare_parameter(name, param_default_value);
54 }
55 return param_itf->get_parameter(name).get_value<ParameterT>();
56}
57} // namespace
58
59namespace joint_limits
60{
94inline bool declare_parameters(
95 const std::string & joint_name,
96 const rclcpp::node_interfaces::NodeParametersInterface::SharedPtr & param_itf,
97 const rclcpp::node_interfaces::NodeLoggingInterface::SharedPtr & logging_itf)
98{
99 const std::string param_base_name = fmt::format(FMT_COMPILE("joint_limits.{}"), joint_name);
100 try
101 {
102 auto_declare<bool>(param_itf, param_base_name + ".has_position_limits", false);
103 auto_declare<double>(
104 param_itf, param_base_name + ".min_position", std::numeric_limits<double>::quiet_NaN());
105 auto_declare<double>(
106 param_itf, param_base_name + ".max_position", std::numeric_limits<double>::quiet_NaN());
107 auto_declare<bool>(param_itf, param_base_name + ".has_velocity_limits", false);
108 auto_declare<double>(
109 param_itf, param_base_name + ".max_velocity", std::numeric_limits<double>::quiet_NaN());
110 auto_declare<bool>(param_itf, param_base_name + ".has_acceleration_limits", false);
111 auto_declare<double>(
112 param_itf, param_base_name + ".max_acceleration", std::numeric_limits<double>::quiet_NaN());
113 auto_declare<bool>(param_itf, param_base_name + ".has_deceleration_limits", false);
114 auto_declare<double>(
115 param_itf, param_base_name + ".max_deceleration", std::numeric_limits<double>::quiet_NaN());
116 auto_declare<bool>(param_itf, param_base_name + ".has_jerk_limits", false);
117 auto_declare<double>(
118 param_itf, param_base_name + ".max_jerk", std::numeric_limits<double>::quiet_NaN());
119 auto_declare<bool>(param_itf, param_base_name + ".has_effort_limits", false);
120 auto_declare<double>(
121 param_itf, param_base_name + ".max_effort", std::numeric_limits<double>::quiet_NaN());
122 auto_declare<bool>(param_itf, param_base_name + ".angle_wraparound", false);
123 auto_declare<bool>(param_itf, param_base_name + ".has_soft_limits", false);
124 auto_declare<double>(
125 param_itf, param_base_name + ".k_position", std::numeric_limits<double>::quiet_NaN());
126 auto_declare<double>(
127 param_itf, param_base_name + ".k_velocity", std::numeric_limits<double>::quiet_NaN());
128 auto_declare<double>(
129 param_itf, param_base_name + ".soft_lower_limit", std::numeric_limits<double>::quiet_NaN());
130 auto_declare<double>(
131 param_itf, param_base_name + ".soft_upper_limit", std::numeric_limits<double>::quiet_NaN());
132 }
133 catch (const std::exception & ex)
134 {
135 RCLCPP_ERROR(logging_itf->get_logger(), "%s", ex.what());
136 return false;
137 }
138 return true;
139}
140
153inline bool declare_parameters(const std::string & joint_name, const rclcpp::Node::SharedPtr & node)
154{
155 return declare_parameters(
156 joint_name, node->get_node_parameters_interface(), node->get_node_logging_interface());
157}
158
171inline bool declare_parameters(
172 const std::string & joint_name, const rclcpp_lifecycle::LifecycleNode::SharedPtr & lifecycle_node)
173{
174 return declare_parameters(
175 joint_name, lifecycle_node->get_node_parameters_interface(),
176 lifecycle_node->get_node_logging_interface());
177}
178
237inline bool get_joint_limits(
238 const std::string & joint_name,
239 const rclcpp::node_interfaces::NodeParametersInterface::SharedPtr & param_itf,
240 const rclcpp::node_interfaces::NodeLoggingInterface::SharedPtr & logging_itf,
241 JointLimits & limits)
242{
243 const std::string param_base_name = fmt::format(FMT_COMPILE("joint_limits.{}"), joint_name);
244 try
245 {
246 if (
247 !param_itf->has_parameter(param_base_name + ".has_position_limits") &&
248 !param_itf->has_parameter(param_base_name + ".min_position") &&
249 !param_itf->has_parameter(param_base_name + ".max_position") &&
250 !param_itf->has_parameter(param_base_name + ".has_velocity_limits") &&
251 !param_itf->has_parameter(param_base_name + ".max_velocity") &&
252 !param_itf->has_parameter(param_base_name + ".has_acceleration_limits") &&
253 !param_itf->has_parameter(param_base_name + ".max_acceleration") &&
254 !param_itf->has_parameter(param_base_name + ".has_deceleration_limits") &&
255 !param_itf->has_parameter(param_base_name + ".max_deceleration") &&
256 !param_itf->has_parameter(param_base_name + ".has_jerk_limits") &&
257 !param_itf->has_parameter(param_base_name + ".max_jerk") &&
258 !param_itf->has_parameter(param_base_name + ".has_effort_limits") &&
259 !param_itf->has_parameter(param_base_name + ".max_effort") &&
260 !param_itf->has_parameter(param_base_name + ".angle_wraparound"))
261 {
262 RCLCPP_ERROR(
263 logging_itf->get_logger(),
264 "No joint limits specification found for joint '%s' in the parameter server "
265 "(param name: %s).",
266 joint_name.c_str(), param_base_name.c_str());
267 return false;
268 }
269 }
270 catch (const std::exception & ex)
271 {
272 RCLCPP_ERROR(logging_itf->get_logger(), "%s", ex.what());
273 return false;
274 }
275
276 // Position limits
277 if (param_itf->has_parameter(param_base_name + ".has_position_limits"))
278 {
279 limits.has_position_limits =
280 param_itf->get_parameter(param_base_name + ".has_position_limits").as_bool();
281 if (
282 limits.has_position_limits && param_itf->has_parameter(param_base_name + ".min_position") &&
283 param_itf->has_parameter(param_base_name + ".max_position"))
284 {
285 limits.min_position = param_itf->get_parameter(param_base_name + ".min_position").as_double();
286 limits.max_position = param_itf->get_parameter(param_base_name + ".max_position").as_double();
287 }
288 else
289 {
290 limits.has_position_limits = false;
291 }
292
293 if (
294 !limits.has_position_limits &&
295 param_itf->has_parameter(param_base_name + ".angle_wraparound"))
296 {
297 limits.angle_wraparound =
298 param_itf->get_parameter(param_base_name + ".angle_wraparound").as_bool();
299 }
300 }
301
302 // Velocity limits
303 if (param_itf->has_parameter(param_base_name + ".has_velocity_limits"))
304 {
305 limits.has_velocity_limits =
306 param_itf->get_parameter(param_base_name + ".has_velocity_limits").as_bool();
307 if (limits.has_velocity_limits && param_itf->has_parameter(param_base_name + ".max_velocity"))
308 {
309 limits.max_velocity = param_itf->get_parameter(param_base_name + ".max_velocity").as_double();
310 }
311 else
312 {
313 limits.has_velocity_limits = false;
314 }
315 }
316
317 // Acceleration limits
318 if (param_itf->has_parameter(param_base_name + ".has_acceleration_limits"))
319 {
320 limits.has_acceleration_limits =
321 param_itf->get_parameter(param_base_name + ".has_acceleration_limits").as_bool();
322 if (
323 limits.has_acceleration_limits &&
324 param_itf->has_parameter(param_base_name + ".max_acceleration"))
325 {
326 limits.max_acceleration =
327 param_itf->get_parameter(param_base_name + ".max_acceleration").as_double();
328 }
329 else
330 {
331 limits.has_acceleration_limits = false;
332 }
333 }
334
335 // Deceleration limits
336 if (param_itf->has_parameter(param_base_name + ".has_deceleration_limits"))
337 {
338 limits.has_deceleration_limits =
339 param_itf->get_parameter(param_base_name + ".has_deceleration_limits").as_bool();
340 if (
341 limits.has_deceleration_limits &&
342 param_itf->has_parameter(param_base_name + ".max_deceleration"))
343 {
344 limits.max_deceleration =
345 param_itf->get_parameter(param_base_name + ".max_deceleration").as_double();
346 }
347 else
348 {
349 limits.has_deceleration_limits = false;
350 }
351 }
352
353 // Jerk limits
354 if (param_itf->has_parameter(param_base_name + ".has_jerk_limits"))
355 {
356 limits.has_jerk_limits =
357 param_itf->get_parameter(param_base_name + ".has_jerk_limits").as_bool();
358 if (limits.has_jerk_limits && param_itf->has_parameter(param_base_name + ".max_jerk"))
359 {
360 limits.max_jerk = param_itf->get_parameter(param_base_name + ".max_jerk").as_double();
361 }
362 else
363 {
364 limits.has_jerk_limits = false;
365 }
366 }
367
368 // Effort limits
369 if (param_itf->has_parameter(param_base_name + ".has_effort_limits"))
370 {
371 limits.has_effort_limits =
372 param_itf->get_parameter(param_base_name + ".has_effort_limits").as_bool();
373 if (limits.has_effort_limits && param_itf->has_parameter(param_base_name + ".max_effort"))
374 {
375 limits.has_effort_limits = true;
376 limits.max_effort = param_itf->get_parameter(param_base_name + ".max_effort").as_double();
377 }
378 else
379 {
380 limits.has_effort_limits = false;
381 }
382 }
383
384 return true;
385}
386
401inline bool get_joint_limits(
402 const std::string & joint_name, const rclcpp::Node::SharedPtr & node, JointLimits & limits)
403{
404 return get_joint_limits(
405 joint_name, node->get_node_parameters_interface(), node->get_node_logging_interface(), limits);
406}
407
422inline bool get_joint_limits(
423 const std::string & joint_name, const rclcpp_lifecycle::LifecycleNode::SharedPtr & lifecycle_node,
424 JointLimits & limits)
425{
426 return get_joint_limits(
427 joint_name, lifecycle_node->get_node_parameters_interface(),
428 lifecycle_node->get_node_logging_interface(), limits);
429}
430
445inline bool check_for_limits_update(
446 const std::string & joint_name, const std::vector<rclcpp::Parameter> & parameters,
447 const rclcpp::node_interfaces::NodeLoggingInterface::SharedPtr & logging_itf,
448 JointLimits & updated_limits)
449{
450 const std::string param_base_name = fmt::format(FMT_COMPILE("joint_limits.{}"), joint_name);
451 bool changed = false;
452
453 // update first numerical values to make later checks for "has" limits members
454 for (auto & parameter : parameters)
455 {
456 const std::string param_name = parameter.get_name();
457 try
458 {
459 if (param_name == param_base_name + ".min_position")
460 {
461 changed |= updated_limits.min_position != parameter.get_value<double>();
462 updated_limits.min_position = parameter.get_value<double>();
463 }
464 else if (param_name == param_base_name + ".max_position")
465 {
466 changed |= updated_limits.max_position != parameter.get_value<double>();
467 updated_limits.max_position = parameter.get_value<double>();
468 }
469 else if (param_name == param_base_name + ".max_velocity")
470 {
471 changed |= updated_limits.max_velocity != parameter.get_value<double>();
472 updated_limits.max_velocity = parameter.get_value<double>();
473 }
474 else if (param_name == param_base_name + ".max_acceleration")
475 {
476 changed |= updated_limits.max_acceleration != parameter.get_value<double>();
477 updated_limits.max_acceleration = parameter.get_value<double>();
478 }
479 else if (param_name == param_base_name + ".max_deceleration")
480 {
481 changed |= updated_limits.max_deceleration != parameter.get_value<double>();
482 updated_limits.max_deceleration = parameter.get_value<double>();
483 }
484 else if (param_name == param_base_name + ".max_jerk")
485 {
486 changed |= updated_limits.max_jerk != parameter.get_value<double>();
487 updated_limits.max_jerk = parameter.get_value<double>();
488 }
489 else if (param_name == param_base_name + ".max_effort")
490 {
491 changed |= updated_limits.max_effort != parameter.get_value<double>();
492 updated_limits.max_effort = parameter.get_value<double>();
493 }
494 }
495 catch (const rclcpp::exceptions::InvalidParameterTypeException & e)
496 {
497 RCLCPP_WARN(logging_itf->get_logger(), "Please use the right type: %s", e.what());
498 }
499 }
500
501 for (auto & parameter : parameters)
502 {
503 const std::string param_name = parameter.get_name();
504 try
505 {
506 if (param_name == param_base_name + ".has_position_limits")
507 {
508 const bool previous_has_position_limits = updated_limits.has_position_limits;
509 updated_limits.has_position_limits = parameter.get_value<bool>();
510 if (updated_limits.has_position_limits)
511 {
512 if (std::isnan(updated_limits.min_position) || std::isnan(updated_limits.max_position))
513 {
514 RCLCPP_WARN(
515 logging_itf->get_logger(),
516 "PARAMETER NOT UPDATED: Position limits can not be used, i.e., "
517 "'has_position_limits' flag can not be set, if 'min_position' "
518 "and 'max_position' are not set or not have valid double values.");
519 updated_limits.has_position_limits = false;
520 }
521 else if (updated_limits.min_position >= updated_limits.max_position)
522 {
523 RCLCPP_WARN(
524 logging_itf->get_logger(),
525 "PARAMETER NOT UPDATED: Position limits can not be used, i.e., "
526 "'has_position_limits' flag can not be set, if not "
527 "'min_position' < 'max_position'");
528 updated_limits.has_position_limits = false;
529 }
530 }
531 changed |= previous_has_position_limits != updated_limits.has_position_limits;
532 }
533 else if (param_name == param_base_name + ".has_velocity_limits")
534 {
535 const bool previous_has_velocity_limits = updated_limits.has_velocity_limits;
536 updated_limits.has_velocity_limits = parameter.get_value<bool>();
537 if (updated_limits.has_velocity_limits && std::isnan(updated_limits.max_velocity))
538 {
539 RCLCPP_WARN(
540 logging_itf->get_logger(),
541 "PARAMETER NOT UPDATED: 'has_velocity_limits' flag can not be set if 'min_velocity' "
542 "and 'max_velocity' are not set or not have valid double values.");
543 updated_limits.has_velocity_limits = false;
544 }
545 changed |= previous_has_velocity_limits != updated_limits.has_velocity_limits;
546 }
547 else if (param_name == param_base_name + ".has_acceleration_limits")
548 {
549 const bool previous_has_acceleration_limits = updated_limits.has_acceleration_limits;
550 updated_limits.has_acceleration_limits = parameter.get_value<bool>();
551 if (updated_limits.has_acceleration_limits && std::isnan(updated_limits.max_acceleration))
552 {
553 RCLCPP_WARN(
554 logging_itf->get_logger(),
555 "PARAMETER NOT UPDATED: 'has_acceleration_limits' flag can not be set if "
556 "'max_acceleration' is not set or not have valid double values.");
557 updated_limits.has_acceleration_limits = false;
558 }
559 changed |= previous_has_acceleration_limits != updated_limits.has_acceleration_limits;
560 }
561 else if (param_name == param_base_name + ".has_deceleration_limits")
562 {
563 const bool previous_has_deceleration_limits = updated_limits.has_deceleration_limits;
564 updated_limits.has_deceleration_limits = parameter.get_value<bool>();
565 if (updated_limits.has_deceleration_limits && std::isnan(updated_limits.max_deceleration))
566 {
567 RCLCPP_WARN(
568 logging_itf->get_logger(),
569 "PARAMETER NOT UPDATED: 'has_deceleration_limits' flag can not be set if "
570 "'max_deceleration' is not set or not have valid double values.");
571 updated_limits.has_deceleration_limits = false;
572 }
573 changed |= previous_has_deceleration_limits != updated_limits.has_deceleration_limits;
574 }
575 else if (param_name == param_base_name + ".has_jerk_limits")
576 {
577 const bool previous_has_jerk_limits = updated_limits.has_jerk_limits;
578 updated_limits.has_jerk_limits = parameter.get_value<bool>();
579 if (updated_limits.has_jerk_limits && std::isnan(updated_limits.max_jerk))
580 {
581 RCLCPP_WARN(
582 logging_itf->get_logger(),
583 "PARAMETER NOT UPDATED: 'has_jerk_limits' flag can not be set if 'max_jerk' is not set "
584 "or not have valid double values.");
585 updated_limits.has_jerk_limits = false;
586 }
587 changed |= previous_has_jerk_limits != updated_limits.has_jerk_limits;
588 }
589 else if (param_name == param_base_name + ".has_effort_limits")
590 {
591 const bool previous_has_effort_limits = updated_limits.has_effort_limits;
592 updated_limits.has_effort_limits = parameter.get_value<bool>();
593 if (updated_limits.has_effort_limits && std::isnan(updated_limits.max_effort))
594 {
595 RCLCPP_WARN(
596 logging_itf->get_logger(),
597 "PARAMETER NOT UPDATED: 'has_effort_limits' flag can not be set if 'max_effort' is not "
598 "set or not have valid double values.");
599 updated_limits.has_effort_limits = false;
600 }
601 changed |= previous_has_effort_limits != updated_limits.has_effort_limits;
602 }
603 else if (param_name == param_base_name + ".angle_wraparound")
604 {
605 const bool previous_angle_wraparound = updated_limits.angle_wraparound;
606 updated_limits.angle_wraparound = parameter.get_value<bool>();
607 if (updated_limits.angle_wraparound && updated_limits.has_position_limits)
608 {
609 RCLCPP_WARN(
610 logging_itf->get_logger(),
611 "PARAMETER NOT UPDATED: 'angle_wraparound' flag can not be set if "
612 "'has_position_limits' flag is set.");
613 updated_limits.angle_wraparound = false;
614 }
615 changed |= previous_angle_wraparound != updated_limits.angle_wraparound;
616 }
617 }
618 catch (const rclcpp::exceptions::InvalidParameterTypeException & e)
619 {
620 RCLCPP_WARN(
621 logging_itf->get_logger(), "PARAMETER NOT UPDATED: Please use the right type: %s",
622 e.what());
623 }
624 }
625
626 return changed;
627}
628
663inline bool get_joint_limits(
664 const std::string & joint_name,
665 const rclcpp::node_interfaces::NodeParametersInterface::SharedPtr & param_itf,
666 const rclcpp::node_interfaces::NodeLoggingInterface::SharedPtr & logging_itf,
667 SoftJointLimits & soft_limits)
668{
669 const std::string param_base_name = fmt::format(FMT_COMPILE("joint_limits.{}"), joint_name);
670 try
671 {
672 if (
673 !param_itf->has_parameter(param_base_name + ".has_soft_limits") &&
674 !param_itf->has_parameter(param_base_name + ".k_velocity") &&
675 !param_itf->has_parameter(param_base_name + ".k_position") &&
676 !param_itf->has_parameter(param_base_name + ".soft_lower_limit") &&
677 !param_itf->has_parameter(param_base_name + ".soft_upper_limit"))
678 {
679 RCLCPP_DEBUG(
680 logging_itf->get_logger(),
681 "No soft joint limits specification found for joint '%s' in the parameter server "
682 "(param name: %s).",
683 joint_name.c_str(), param_base_name.c_str());
684 return false;
685 }
686 }
687 catch (const std::exception & ex)
688 {
689 RCLCPP_ERROR(logging_itf->get_logger(), "%s", ex.what());
690 return false;
691 }
692
693 // Override soft limits if complete specification is found
694 if (param_itf->has_parameter(param_base_name + ".has_soft_limits"))
695 {
696 if (
697 param_itf->get_parameter(param_base_name + ".has_soft_limits").as_bool() &&
698 param_itf->has_parameter(param_base_name + ".k_position") &&
699 param_itf->has_parameter(param_base_name + ".k_velocity") &&
700 param_itf->has_parameter(param_base_name + ".soft_lower_limit") &&
701 param_itf->has_parameter(param_base_name + ".soft_upper_limit"))
702 {
703 soft_limits.k_position =
704 param_itf->get_parameter(param_base_name + ".k_position").as_double();
705 soft_limits.k_velocity =
706 param_itf->get_parameter(param_base_name + ".k_velocity").as_double();
707 soft_limits.min_position =
708 param_itf->get_parameter(param_base_name + ".soft_lower_limit").as_double();
709 soft_limits.max_position =
710 param_itf->get_parameter(param_base_name + ".soft_upper_limit").as_double();
711 return true;
712 }
713 }
714
715 return false;
716}
717
731inline bool get_joint_limits(
732 const std::string & joint_name, const rclcpp::Node::SharedPtr & node,
733 SoftJointLimits & soft_limits)
734{
735 return get_joint_limits(
736 joint_name, node->get_node_parameters_interface(), node->get_node_logging_interface(),
737 soft_limits);
738}
739
753inline bool get_joint_limits(
754 const std::string & joint_name, const rclcpp_lifecycle::LifecycleNode::SharedPtr & lifecycle_node,
755 SoftJointLimits & soft_limits)
756{
757 return get_joint_limits(
758 joint_name, lifecycle_node->get_node_parameters_interface(),
759 lifecycle_node->get_node_logging_interface(), soft_limits);
760}
761
776inline bool check_for_limits_update(
777 const std::string & joint_name, const std::vector<rclcpp::Parameter> & parameters,
778 const rclcpp::node_interfaces::NodeLoggingInterface::SharedPtr & logging_itf,
779 SoftJointLimits & updated_limits)
780{
781 const std::string param_base_name = fmt::format(FMT_COMPILE("joint_limits.{}"), joint_name);
782 bool changed = false;
783
784 for (auto & parameter : parameters)
785 {
786 const std::string param_name = parameter.get_name();
787 try
788 {
789 if (param_name == param_base_name + ".has_soft_limits")
790 {
791 if (!parameter.get_value<bool>())
792 {
793 RCLCPP_WARN(
794 logging_itf->get_logger(),
795 "Parameter 'has_soft_limits' is not set, therefore the limits will not be updated!");
796 return false;
797 }
798 }
799 }
800 catch (const rclcpp::exceptions::InvalidParameterTypeException & e)
801 {
802 RCLCPP_INFO(logging_itf->get_logger(), "Please use the right type: %s", e.what());
803 }
804 }
805
806 for (auto & parameter : parameters)
807 {
808 const std::string param_name = parameter.get_name();
809 try
810 {
811 if (param_name == param_base_name + ".k_position")
812 {
813 changed |= updated_limits.k_position != parameter.get_value<double>();
814 updated_limits.k_position = parameter.get_value<double>();
815 }
816 else if (param_name == param_base_name + ".k_velocity")
817 {
818 changed |= updated_limits.k_velocity != parameter.get_value<double>();
819 updated_limits.k_velocity = parameter.get_value<double>();
820 }
821 else if (param_name == param_base_name + ".soft_lower_limit")
822 {
823 changed |= updated_limits.min_position != parameter.get_value<double>();
824 updated_limits.min_position = parameter.get_value<double>();
825 }
826 else if (param_name == param_base_name + ".soft_upper_limit")
827 {
828 changed |= updated_limits.max_position != parameter.get_value<double>();
829 updated_limits.max_position = parameter.get_value<double>();
830 }
831 }
832 catch (const rclcpp::exceptions::InvalidParameterTypeException & e)
833 {
834 RCLCPP_INFO(logging_itf->get_logger(), "Please use the right type: %s", e.what());
835 }
836 }
837
838 return changed;
839}
840
841} // namespace joint_limits
842
843#endif // JOINT_LIMITS__JOINT_LIMITS_ROSPARAM_HPP_
joint_limits
Definition data_structures.hpp:38
joint_limits::check_for_limits_update
bool check_for_limits_update(const std::string &joint_name, const std::vector< rclcpp::Parameter > &parameters, const rclcpp::node_interfaces::NodeLoggingInterface::SharedPtr &logging_itf, JointLimits &updated_limits)
Check if any of updated parameters are related to JointLimits.
Definition joint_limits_rosparam.hpp:445
joint_limits::declare_parameters
bool declare_parameters(const std::string &joint_name, const rclcpp::node_interfaces::NodeParametersInterface::SharedPtr &param_itf, const rclcpp::node_interfaces::NodeLoggingInterface::SharedPtr &logging_itf)
Declare JointLimits and SoftJointLimits parameters for joint with joint_name using node parameters in...
Definition joint_limits_rosparam.hpp:94
joint_limits::get_joint_limits
bool get_joint_limits(const std::string &joint_name, const rclcpp::node_interfaces::NodeParametersInterface::SharedPtr &param_itf, const rclcpp::node_interfaces::NodeLoggingInterface::SharedPtr &logging_itf, JointLimits &limits)
Populate a JointLimits instance from the node parameters.
Definition joint_limits_rosparam.hpp:237
joint_limits::JointLimits
Store joint limits values from YAML definition or URDF <limits> tag.
Definition joint_limits.hpp:36
joint_limits::SoftJointLimits
Store soft joint limits values from the URDF <safety_controller> tag.
Definition joint_limits.hpp:130
Generated by doxygen 1.9.8