ROS2 Node or os call

[azbitak-invn]

Hello,

I m running ROS2 in Raspberry using python. I can drive the robot and getting bump events, but I would like to know the best approach.
I want to drive the robot and when bumps occur doing a rotation and continue my drives.

Should I use os.system('ros2 action send_goal...") approach or it's better to have Nodes ?

Also I m wondering how to have several Node working together ?

I used rclpy.executors.MultiThreadedExecutor() but when executor.spin_once() is executed the drive is "sacading".

Thanks

[azbitak-invn]

Here is my question updated for more clarity :

I have an action goal to drive calling a node like this :

node3 = DriveDistanceActionClient()
dist  = 5.0
speed = 0.15
node3.send_goal(dist, speed)
rclpy.spin(node3)

I want to stop the current action if a bump is detected (reflexes are enabled) and I added this hazard subsricption in the drivedistance node :

self.bump = 0

# Subscribe to the /interface_buttons topic
self.hazard_subscriber = self.create_subscription(
    HazardDetectionVector,
    '/hazard_detection',
    self.hazard_callback,
    qos_profile_sensor_data)

# Interface buttons subscription callback
def hazard_callback(self, create3_hazard_msg: HazardDetectionVector):
if create3_hazard_msg.detections != []:
    if create3_hazard_msg.detections[0].type == 1 and self.bump == 0:
        self.bump = 1
        print("BUMP")
        #drive()
        rotate()
        self.bump = 0

My issue is the drive action is not stopped when a bump happens. The robot is only driving/bump/reflex/drive/bump... indefinitely.
How to resolve that ?

[alsora]

Hi @azbitak-invn;
The recommended way is to use the rclpy library and create nodes.
The command line interface such as ros2 action send_goal ... should be only used for very simple interactions and it will not scale to more complex applications (besides being much more inefficient as it creates and destroy nodes under the hood all the time.

You can create as many nodes as you want in a single application or you can have multiple applications running at the same time each with one single node.
The latter approach may be easier for prototyping purposes as you can better isolate failures and error facilitating debug.

What do you mean by "sacading" ?
I strongly recommend you to not use the MultiThreaded executor and to have each node in a separate application if you are a beginner with ROS 2.
See here examples on how to use the ROS 2 python examples: https://docs.ros.org/en/humble/Tutorials/Beginner-Client-Libraries/Writing-A-Simple-Py-Publisher-And-Subscriber.html

[azbitak-invn]

Hi @alsora ,
Thank you for your response, I'm trying to follow the node usage by having one node doing the process but the result is not predictible.
I have followed the ROS2 example you pointed me but the action seems not finishing properly.
Here is my node which I m calling in a loop to have the robot driving indefinitely. I should use a publisher to do the rotation instead ?

`class DriveDistanceActionClient(Node):
'''
An example of an action client that will cause the iRobot
Create3 to drive a specific distance. Subclass of Node.
'''

def __init__(self):
    '''
    Purpose
    -------
    initialized by calling the Node constructor, naming our node 
    'drive_distance_action_client'
    '''
    super().__init__('drive_distance_action_client')
    
    self._action_client = ActionClient(
        self, DriveDistance, 'drive_distance')

    self._action_client_rot = ActionClient(self, RotateAngle, 'rotate_angle')

    self.bump = 0
    self.back = 0
    self.rot = 0

    # Subscribe to the /hazard_detection topic
    self.hazard_subscriber = self.create_subscription(
        HazardDetectionVector,
        '/hazard_detection',
        self.hazard_callback,
        qos_profile_sensor_data)

def send_goal_rot(self, angle=1.57, max_rotation_speed=0.5):
    '''
    Purpose
    -------
    This method waits for the action server to be available, then sends a 
    goal to the server. It returns a future that we can later wait on.
    '''
    goal_msg = RotateAngle.Goal()
    goal_msg.angle = angle 
    goal_msg.max_rotation_speed = max_rotation_speed

    self._action_client_rot.wait_for_server()
    self._send_goal_future_rot = self._action_client_rot.send_goal_async(goal_msg)
    self._send_goal_future_rot.add_done_callback(self.goal_response_callback_rot)

def goal_response_callback_rot(self, future):
    '''
    Purpose
    -------
    A callback that is executed when the future is complete.
    The future is completed when an action server accepts or rejects the goal request.
    '''
    goal_handle = future.result()
    if not goal_handle.accepted:
        self.get_logger().info('Goal rejected :(')
        return

    self.get_logger().info('Goal accepted :)')

    self._get_result_future_rot = goal_handle.get_result_async()
    self._get_result_future_rot.add_done_callback(self.get_result_callback_rot)

def get_result_callback_rot(self, future):
    '''
    Purpose
    -------
    Similar to sending the goal, we will get a future that will complete when the result is ready.
    '''
    result = future.result().result
    self.get_logger().info('Result: {0}'.format(result))
    #rclpy.shutdown()
    self.rot = 1
    self.bump = 0

# Interface buttons subscription callback
def hazard_callback(self, create3_hazard_msg: HazardDetectionVector):
    if create3_hazard_msg.detections != []:
        if create3_hazard_msg.detections[0].type == 1 and self.bump == 0:
            self.bump = 1
            self.back = 1
            print("BUMP!!!!")
            self.send_goal(-1.0, 0.15)
            #self.send_goal_rot(1.57, 1.0)
            

def send_goal(self, distance=0.5, max_translation_speed=0.15):
    '''
    Purpose
    -------
    This method waits for the action server to be available, then sends a 
    goal to the server. It returns a future that we can later wait on.
    '''
    goal_msg = DriveDistance.Goal()
    goal_msg.distance = distance
    goal_msg.max_translation_speed = max_translation_speed

    self._action_client.wait_for_server()

    self._send_goal_future = self._action_client.send_goal_async(goal_msg)

    self._send_goal_future.add_done_callback(self.goal_response_callback)

def goal_response_callback(self, future):
    '''
    Purpose
    -------
    A callback that is executed when the future is complete.
    The future is completed when an action server accepts or rejects the goal request.
    '''
    goal_handle = future.result()
    if not goal_handle.accepted:
        self.get_logger().info('Goal rejected :(')
        return

    self.get_logger().info('Goal accepted :)')

    self._get_result_future = goal_handle.get_result_async()
    self._get_result_future.add_done_callback(self.get_result_callback)

def get_result_callback(self, future):
    '''
    Purpose
    -------
    Similar to sending the goal, we will get a future that will complete when the result is ready.
    '''
    result = future.result().result
    self.get_logger().info('Result: {0}'.format(result))

    if(self.back == 1) :
        print("back done")
        self.send_goal_rot(1.57, 1.0)
        self.back = 0

    rclpy.shutdown()

`