Fix formatting

Author: urfeex

ur_controllers/include/ur_controllers/freedrive_mode_controller.hpp

@@ -64,7 +64,7 @@ enum CommandInterfaces
   FREEDRIVE_MODE_ABORT = 2,
 };
 
-using namespace std::chrono_literals; // NOLINT
+using namespace std::chrono_literals;  // NOLINT
 
 class FreedriveModeController : public controller_interface::ControllerInterface
 {

ur_controllers/src/freedrive_mode_controller.cpp

@@ -122,7 +122,7 @@ ur_controllers::FreedriveModeController::on_activate(const rclcpp_lifecycle::Sta
 
   {
     const std::string interface_name = freedrive_params_.tf_prefix + "freedrive_mode/"
-                                                                       "async_success";
+                                                                     "async_success";
     auto it = std::find_if(command_interfaces_.begin(), command_interfaces_.end(),
                            [&](auto& interface) { return (interface.get_name() == interface_name); });
     if (it != command_interfaces_.end()) {
@@ -135,7 +135,7 @@ ur_controllers::FreedriveModeController::on_activate(const rclcpp_lifecycle::Sta
 
   {
     const std::string interface_name = freedrive_params_.tf_prefix + "freedrive_mode/"
-                                                                       "enable";
+                                                                     "enable";
     auto it = std::find_if(command_interfaces_.begin(), command_interfaces_.end(),
                            [&](auto& interface) { return (interface.get_name() == interface_name); });
     if (it != command_interfaces_.end()) {
@@ -148,7 +148,7 @@ ur_controllers::FreedriveModeController::on_activate(const rclcpp_lifecycle::Sta
 
   {
     const std::string interface_name = freedrive_params_.tf_prefix + "freedrive_mode/"
-                                                                       "abort";
+                                                                     "abort";
     auto it = std::find_if(command_interfaces_.begin(), command_interfaces_.end(),
                            [&](auto& interface) { return (interface.get_name() == interface_name); });
     if (it != command_interfaces_.end()) {
@@ -178,11 +178,11 @@ ur_controllers::FreedriveModeController::on_deactivate(const rclcpp_lifecycle::S
 }
 
 controller_interface::return_type ur_controllers::FreedriveModeController::update(const rclcpp::Time& /*time*/,
-                                                                              const rclcpp::Duration& /*period*/)
+                                                                                  const rclcpp::Duration& /*period*/)
 {
   async_state_ = async_success_command_interface_->get().get_value();
 
-  if(change_requested_) {
+  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.
@@ -213,51 +213,45 @@ controller_interface::return_type ur_controllers::FreedriveModeController::updat
     change_requested_ = false;
   }
 
-  if((async_state_ == 1.0) && (first_log_)){
+  if ((async_state_ == 1.0) && (first_log_)) {
     first_log_ = false;
-    logging_requested_= true;
+    logging_requested_ = true;
 
     // Notify logging thread
     logging_condition_.notify_one();
-
   }
   return controller_interface::return_type::OK;
 }
 
 void FreedriveModeController::readFreedriveModeCmd(const std_msgs::msg::Bool::SharedPtr msg)
 {
   // Process the freedrive_mode command.
-  if (get_node()->get_current_state().id() == lifecycle_msgs::msg::State::PRIMARY_STATE_ACTIVE)
-  {
-    if(msg->data)
-    {
-      if((!freedrive_active_) && (!change_requested_)){
+  if (get_node()->get_current_state().id() == lifecycle_msgs::msg::State::PRIMARY_STATE_ACTIVE) {
+    if (msg->data) {
+      if ((!freedrive_active_) && (!change_requested_)) {
         freedrive_active_ = true;
         change_requested_ = true;
         start_timer();
       }
-    } else{
-      if((freedrive_active_) && (!change_requested_)){
+    } else {
+      if ((freedrive_active_) && (!change_requested_)) {
         freedrive_active_ = false;
         change_requested_ = true;
       }
     }
   }
 
-  if (freedrive_sub_timer_)
-  {
+  if (freedrive_sub_timer_) {
     freedrive_sub_timer_->reset();
   }
 }
 
 void FreedriveModeController::start_timer()
 {
-  if (!timer_started_)
-  {
+  if (!timer_started_) {
     // Start the timer only after the first message is received
-    freedrive_sub_timer_ = get_node()->create_wall_timer(
-        timeout_interval_,
-        std::bind(&FreedriveModeController::timeout_callback, this));
+    freedrive_sub_timer_ =
+        get_node()->create_wall_timer(timeout_interval_, std::bind(&FreedriveModeController::timeout_callback, this));
     timer_started_ = true;
 
     RCLCPP_INFO(get_node()->get_logger(), "Timer started after receiving first command.");
@@ -266,7 +260,7 @@ void FreedriveModeController::start_timer()
 
 void FreedriveModeController::timeout_callback()
 {
-  if(timer_started_ && freedrive_active_){
+  if (timer_started_ && freedrive_active_) {
     RCLCPP_INFO(get_node()->get_logger(), "Freedrive mode will be deactivated since client is not reachable.");
 
     freedrive_active_ = false;
@@ -276,45 +270,45 @@ void FreedriveModeController::timeout_callback()
   timer_started_ = false;
 }
 
-  void FreedriveModeController::start_logging_thread() {
-    if (!logging_thread_running_) {
-      logging_thread_running_ = true;
-      logging_thread_ = std::thread(&FreedriveModeController::log_task, this);
-    }
+void FreedriveModeController::start_logging_thread()
+{
+  if (!logging_thread_running_) {
+    logging_thread_running_ = true;
+    logging_thread_ = std::thread(&FreedriveModeController::log_task, this);
   }
+}
 
-  void FreedriveModeController::stop_logging_thread() {
-    logging_thread_running_ = false;
-    if (logging_thread_.joinable()) {
-      logging_thread_.join();
-    }
+void FreedriveModeController::stop_logging_thread()
+{
+  logging_thread_running_ = false;
+  if (logging_thread_.joinable()) {
+    logging_thread_.join();
   }
+}
 
-  void FreedriveModeController::log_task() {
-    while (logging_thread_running_) {
-
-      std::unique_lock<std::mutex> lock(log_mutex_);
-
-      auto condition = [this] {
-            return !logging_thread_running_ || logging_requested_;
-      };
+void FreedriveModeController::log_task()
+{
+  while (logging_thread_running_) {
+    std::unique_lock<std::mutex> lock(log_mutex_);
 
-      // Wait for the condition
-      logging_condition_.wait(lock, condition);
+    auto condition = [this] { return !logging_thread_running_ || logging_requested_; };
 
+    // Wait for the condition
+    logging_condition_.wait(lock, condition);
 
-      if (!logging_thread_running_) break;
+    if (!logging_thread_running_)
+      break;
 
-      if(freedrive_active_){
-        RCLCPP_INFO(get_node()->get_logger(), "Freedrive mode has been enabled successfully.");
-      } else {
-        RCLCPP_INFO(get_node()->get_logger(), "Freedrive mode has been disabled successfully.");
-      }
-
-      // Reset to log only once
-      logging_requested_ = false;
+    if (freedrive_active_) {
+      RCLCPP_INFO(get_node()->get_logger(), "Freedrive mode has been enabled successfully.");
+    } else {
+      RCLCPP_INFO(get_node()->get_logger(), "Freedrive mode has been disabled successfully.");
     }
+
+    // Reset to log only once
+    logging_requested_ = false;
   }
+}
 
 bool FreedriveModeController::waitForAsyncCommand(std::function<double(void)> get_value)
 {