Fix Format

Author: VinDp

ur_controllers/include/ur_controllers/freedrive_mode_controller.hpp

@@ -119,5 +119,5 @@ class FreedriveModeController : public controller_interface::ControllerInterface
    */
   bool waitForAsyncCommand(std::function<double(void)> get_value);
 };
-} // namespace ur_controllers
-#endif // UR_CONTROLLERS__PASSTHROUGH_TRAJECTORY_CONTROLLER_HPP_
+}  // namespace ur_controllers
+#endif  // UR_CONTROLLERS__PASSTHROUGH_TRAJECTORY_CONTROLLER_HPP_

ur_controllers/src/freedrive_mode_controller.cpp

@@ -71,7 +71,8 @@ controller_interface::InterfaceConfiguration FreedriveModeController::command_in
   return config;
 }
 
-controller_interface::InterfaceConfiguration ur_controllers::FreedriveModeController::state_interface_configuration() const
+controller_interface::InterfaceConfiguration
+ur_controllers::FreedriveModeController::state_interface_configuration() const
 {
   controller_interface::InterfaceConfiguration config;
   config.type = controller_interface::interface_configuration_type::NONE;
@@ -82,7 +83,6 @@ controller_interface::InterfaceConfiguration ur_controllers::FreedriveModeContro
 controller_interface::CallbackReturn
 ur_controllers::FreedriveModeController::on_configure(const rclcpp_lifecycle::State& previous_state)
 {
-
   // Subscriber definition
   enable_freedrive_mode_sub_ = get_node()->create_subscription<std_msgs::msg::Bool>(
       "~/freedrive_mode_active", 10,
@@ -164,7 +164,7 @@ ur_controllers::FreedriveModeController::on_deactivate(const rclcpp_lifecycle::S
 
   // Set enable value to false, so in the update
   // we can deactivate the freedrive mode
-  //Old comment?
+  // Old comment?
   freedrive_active_ = false;
 
   return CallbackReturn::SUCCESS;
@@ -177,15 +177,14 @@ controller_interface::return_type ur_controllers::FreedriveModeController::updat
 
   if(change_requested_) {
     if (freedrive_active_) {
-      // Check if the freedrive mode has been aborted from the hardware interface. E.g. the robot was stopped on the teach
-      // pendant.
+      // Check if the freedrive mode has been aborted from the hardware interface. E.g. the robot was stopped on the
+      // teach pendant.
       if (!std::isnan(abort_command_interface_->get().get_value()) &&
           abort_command_interface_->get().get_value() == 1.0) {
         RCLCPP_INFO(get_node()->get_logger(), "Freedrive mode aborted by hardware, aborting action.");
         freedrive_active_ = false;
         return controller_interface::return_type::OK;
       } else {
-
         RCLCPP_INFO(get_node()->get_logger(), "Received command to start Freedrive Mode.");
 
         // Set command interface to enable
@@ -220,7 +219,6 @@ controller_interface::return_type ur_controllers::FreedriveModeController::updat
 
 void FreedriveModeController::readFreedriveModeCmd(const std_msgs::msg::Bool::SharedPtr msg)
 {
-
   // Process the freedrive_mode command.
   if(msg->data)
   {
@@ -259,7 +257,6 @@ void FreedriveModeController::start_timer()
 
 void FreedriveModeController::timeout_callback()
 {
-
   if(timer_started_){
     RCLCPP_INFO(get_node()->get_logger(), "Freedrive mode will be deactivated since client is not reachable.");
 

ur_robot_driver/src/hardware_interface.cpp

@@ -834,15 +834,17 @@ void URPositionHardwareInterface::checkAsyncIO()
 
   if (!std::isnan(freedrive_mode_enable_) && ur_driver_ != nullptr) {
     RCLCPP_INFO(get_logger(), "Starting freedrive mode.");
-    freedrive_mode_async_success_ = ur_driver_->writeFreedriveControlMessage(urcl::control::FreedriveControlMessage::FREEDRIVE_START);
+    freedrive_mode_async_success_ =
+        ur_driver_->writeFreedriveControlMessage(urcl::control::FreedriveControlMessage::FREEDRIVE_START);
     freedrive_mode_enable_ = NO_NEW_CMD_;
     freedrive_action_requested_ = true;
   }
 
   if (!std::isnan(freedrive_mode_abort_) && freedrive_mode_abort_ == 1.0 && freedrive_action_requested_ &&
       ur_driver_ != nullptr) {
     RCLCPP_INFO(get_logger(), "Stopping freedrive mode.");
-    freedrive_mode_async_success_ = ur_driver_->writeFreedriveControlMessage(urcl::control::FreedriveControlMessage::FREEDRIVE_STOP);
+    freedrive_mode_async_success_ =
+        ur_driver_->writeFreedriveControlMessage(urcl::control::FreedriveControlMessage::FREEDRIVE_STOP);
     freedrive_action_requested_ = false;
     freedrive_mode_abort_ = NO_NEW_CMD_;
 }
@@ -882,13 +884,13 @@ void URPositionHardwareInterface::transformForceTorque()
   tcp_force_.setValue(urcl_ft_sensor_measurements_[0], urcl_ft_sensor_measurements_[1],
                       urcl_ft_sensor_measurements_[2]);
   tcp_torque_.setValue(urcl_ft_sensor_measurements_[3], urcl_ft_sensor_measurements_[4],
-                        urcl_ft_sensor_measurements_[5]);
+                       urcl_ft_sensor_measurements_[5]);
 
   tcp_force_ = tf2::quatRotate(tcp_rotation_quat_.inverse(), tcp_force_);
   tcp_torque_ = tf2::quatRotate(tcp_rotation_quat_.inverse(), tcp_torque_);
 
   urcl_ft_sensor_measurements_ = { tcp_force_.x(),  tcp_force_.y(),  tcp_force_.z(),
-                                  tcp_torque_.x(), tcp_torque_.y(), tcp_torque_.z() };
+                                   tcp_torque_.x(), tcp_torque_.y(), tcp_torque_.z() };
 }
 
 void URPositionHardwareInterface::extractToolPose()
@@ -907,7 +909,7 @@ void URPositionHardwareInterface::extractToolPose()
 }
 
 hardware_interface::return_type URPositionHardwareInterface::prepare_command_mode_switch(
-  const std::vector<std::string>& start_interfaces, const std::vector<std::string>& stop_interfaces)
+   const std::vector<std::string>& start_interfaces, const std::vector<std::string>& stop_interfaces)
 {
   hardware_interface::return_type ret_val = hardware_interface::return_type::OK;
 
@@ -1011,11 +1013,11 @@ hardware_interface::return_type URPositionHardwareInterface::prepare_command_mod
        }))) {
     ret_val = hardware_interface::return_type::ERROR;
   }
-  if (std::any_of(start_modes_.begin(), start_modes_.end(),
-                  [this](auto& item) { return (item == FREEDRIVE_MODE); }) &&
+  if (std::any_of(start_modes_.begin(), start_modes_.end(), [this](auto& item) { return (item == FREEDRIVE_MODE); }) &&
       (std::any_of(start_modes_.begin(), start_modes_.end(),
                    [this](auto& item) {
-                     return (item == hardware_interface::HW_IF_VELOCITY || item == hardware_interface::HW_IF_POSITION || item == PASSTHROUGH_GPIO);
+                     return (item == hardware_interface::HW_IF_VELOCITY || item == hardware_interface::HW_IF_POSITION ||
+                             item == PASSTHROUGH_GPIO);
                    }) ||
        std::any_of(control_modes.begin(), control_modes.end(), [this](auto& item) {
          return (item == hardware_interface::HW_IF_VELOCITY || item == hardware_interface::HW_IF_POSITION ||