Preempting actions in ROS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when an action server receives a preempt request?

In ROS actionlib, when an action server receives a preempt request from a client, what is the typical behavior of the server?

A The server sets the goal state to preempted and can perform cleanup before stopping the goal execution.

B The server immediately stops processing and returns the current result to the client.

C The server ignores the preempt request and continues processing the current goal until completion.

D The server cancels all goals and shuts down the action server node.

💡 Hint

Think about how the server handles goal states and cleanup.

When an action server receives a preempt request, it sets the current goal state to preempted. This allows the server to perform any necessary cleanup or partial result reporting before stopping the goal execution.

❓ state_output

intermediate

What is the state of a goal after preemption?

In ROS actionlib, after a goal is preempted by the client, what is the state of that goal as reported by the action server?

A ACTIVE

B PREEMPTED

C ABORTED

D SUCCEEDED

💡 Hint

Consider the meaning of each goal state.

The PREEMPTED state indicates that the goal was canceled or replaced before completion, which is exactly what happens when a preempt request is accepted.

📝 Syntax

advanced

Identify the correct way to check for preemption in a ROS action server callback

Which of the following code snippets correctly checks if a preempt request has been received inside an action server execute callback in ROS?

ROS

void executeCB(const YourActionGoalConstPtr &goal) {
  // ... some processing ...
  // Check for preemption here
}

A

if (as_.isPreemptRequested()) {
  as_.setPreempted();
  return;
}

B

if (as_.isActive()) {
  as_.setSucceeded();
  return;
}

C

if (as_.isNewGoalAvailable()) {
  as_.setAborted();
  return;
}

D

if (as_.isPreempted()) {
  as_.setPreempted();
  return;
}

💡 Hint

Look for the method that detects a preempt request.

The method isPreemptRequested() returns true if the client has requested to preempt the current goal. The server should then call setPreempted() to acknowledge and stop processing.

🔧 Debug

advanced

Why does the action server not stop after preempt request?

An action server in ROS receives a preempt request, but it continues processing the goal instead of stopping. Which is the most likely cause?

A The server called <code>setSucceeded()</code> before checking for preemption.

B The client did not send a cancel request, so preemption is ignored.

C The server never calls <code>setPreempted()</code> after detecting the preempt request.

D The action server node is not running.

💡 Hint

Think about what the server must do to acknowledge preemption.

Detecting a preempt request is not enough; the server must call setPreempted() to change the goal state and stop processing. Without this call, the server continues as if nothing happened.

🧠 Conceptual

expert

How does preempting an action affect feedback and result messages?

When a ROS action server preempts a goal, what happens to the feedback and result messages sent to the client?

A Feedback continues as normal, but the result message is never sent.

B Feedback and result messages are both sent with status SUCCEEDED.

C Feedback is sent with an error code, and the result message is aborted.

D Feedback stops immediately, and the result message indicates the goal was preempted.

💡 Hint

Consider what the client expects after preemption.

When a goal is preempted, the server stops sending feedback because the goal is no longer active. The result message is sent with a status indicating the goal was preempted, so the client knows the goal did not complete normally.

Practice

1.

What does cancel_goal() do in ROS action clients?

easy

A. It requests to stop the currently running action goal.

B. It starts a new action goal immediately.

C. It pauses the action without stopping it.

D. It resets the action server to its initial state.

Solution

1. Step 1: Understand the purpose of cancel_goal()

   This function is used to request the cancellation of the current goal being processed by the action server.

2. Step 2: Differentiate from other actions

   Starting a new goal or pausing are different operations; cancel_goal() specifically requests stopping the current goal.

3. Final Answer:

   It requests to stop the currently running action goal. -> Option A

4. Quick Check:

   cancel_goal() stops current goal [OK]

Hint: Remember: cancel_goal() means stop current action [OK]

Common Mistakes:

• Confusing cancel_goal() with starting a new goal
• Thinking cancel_goal() pauses instead of cancels
• Assuming cancel_goal() resets the server

2.

Which of the following is the correct sequence to preempt an action in ROS?

1. cancel_goal()
2. send_goal(new_goal)

easy

A. Call cancel_goal() first, then send_goal(new_goal).

B. Call send_goal(new_goal) first, then cancel_goal().

C. Call cancel_goal() twice, then send_goal(new_goal).

D. Only call send_goal(new_goal) without canceling.

Solution

1. Step 1: Understand preempting order

   You must first cancel the current goal to stop it before sending a new goal to replace it.

2. Step 2: Confirm correct method calls

   Calling cancel_goal() first ensures the old task stops, then send_goal(new_goal) starts the new task.

3. Final Answer:

   Call cancel_goal() first, then send_goal(new_goal). -> Option A

4. Quick Check:

   Cancel before sending new goal [OK]

Hint: Cancel first, then send new goal to preempt [OK]

Common Mistakes:

• Sending new goal before canceling old one
• Calling cancel_goal() multiple times unnecessarily
• Skipping cancel_goal() and sending new goal directly

3.

Given this ROS action client code snippet, what will be the output behavior?

client.send_goal(goal1)
client.cancel_goal()
client.send_goal(goal2)

What happens to goal1 and goal2?

medium

A. Neither goal runs because cancel_goal() stops all actions.

B. goal1 runs fully; goal2 is ignored.

C. Both goal1 and goal2 run simultaneously.

D. goal1 is canceled; goal2 starts running.

Solution

1. Step 1: Analyze the cancel_goal() effect

   After sending goal1, cancel_goal() requests to stop it immediately.

2. Step 2: Understand sending goal2

   Sending goal2 after canceling goal1 starts the new action goal.

3. Final Answer:

   goal1 is canceled; goal2 starts running. -> Option D

4. Quick Check:

   Cancel old goal, start new goal [OK]

Hint: Cancel stops old goal; new send_goal starts new task [OK]

Common Mistakes:

• Assuming goal1 runs fully despite cancel
• Thinking both goals run at once
• Believing cancel_goal() stops all future goals

4.

Identify the error in this ROS action client code snippet:

client.send_goal(goal1)
client.send_goal(goal2)
client.cancel_goal()

What is wrong with this sequence?

medium

A. The code should call cancel_goal() twice to cancel both goals.

B. You cannot send two goals without canceling the first one first.

C. Calling cancel_goal() after sending two goals does not preempt correctly.

D. There is no error; this sequence is correct.

Solution

1. Step 1: Understand goal handling

   Sending two goals in a row without canceling means the second goal overrides the first immediately.

2. Step 2: Analyze cancel_goal() timing

   Calling cancel_goal() after both sends only cancels the currently active goal, not preempting properly between goals.

3. Final Answer:

   Calling cancel_goal() after sending two goals does not preempt correctly. -> Option C

4. Quick Check:

   Cancel before sending new goal to preempt [OK]

Hint: Cancel before sending next goal, not after [OK]

Common Mistakes:

• Sending multiple goals without canceling first
• Assuming cancel_goal() cancels all previous goals
• Calling cancel_goal() too late to preempt

5.

You want to preempt a running action only if it has been active for more than 5 seconds. Which approach correctly implements this logic?

if client.get_state() == ACTIVE and client.get_time_active() > 5:
    client.cancel_goal()
    client.send_goal(new_goal)

hard

A. You must call cancel_goal() before checking the state.

B. This approach correctly preempts only after 5 seconds of activity.

C. You should send the new goal first, then cancel the old one.

D. ROS actions do not support checking active time for preemption.

Solution

1. Step 1: Check action state and duration

   The code checks if the action is active and has been running longer than 5 seconds.

2. Step 2: Cancel and send new goal conditionally

   Only if both conditions are true, it cancels the current goal and sends a new one, correctly preempting.

3. Final Answer:

   This approach correctly preempts only after 5 seconds of activity. -> Option B

4. Quick Check:

   Check state and time before canceling [OK]

Hint: Check active state and time before canceling [OK]

Common Mistakes:

• Canceling without checking active time
• Sending new goal before canceling old one
• Assuming ROS lacks timing info for actions