refactor(palletizing): move conveyor handshake into HAL

Add HAL.WaitForBox() / HAL.BoxDone(name) wrapping the /box_ready and
/box_done topics, and drop the FeederLink class + rclpy imports from
solution.py so the exercise template uses only the HAL API.

Author: Ashwani1330

exercises/palletizing/python_template/HAL_Harmonic.py

@@ -61,6 +61,54 @@ def publish_graspable_objects():
 # Periodic republish so late-joining subscribers receive the list
 HAL.create_timer(1.0, publish_graspable_objects)
 
+# ==============================================================
+# CONVEYOR HANDSHAKE (feeder coordination)
+# ==============================================================
+# The conveyor feeder (box_spawner) and the robot coordinate with a two-message
+# handshake so boxes are picked one at a time and never pile up:
+#   - the feeder publishes a box name on /box_ready when a box is stopped at the
+#     pickup point, then waits;
+#   - the robot calls BoxDone(name) once the box is palletized, which publishes
+#     on /box_done and releases the next box.
+# Keeping this on the HAL node means the student's solution only ever calls
+# WaitForBox()/BoxDone() and never touches ROS topics directly.
+
+HAL._ready_box = None
+HAL._processed_boxes = set()
+
+
+def _on_box_ready(msg):
+    # Ignore re-announcements of a box we've already handed to the solution.
+    if msg.data not in HAL._processed_boxes:
+        HAL._ready_box = msg.data
+
+
+HAL.create_subscription(String, "/box_ready", _on_box_ready, 10)
+HAL.box_done_pub = HAL.create_publisher(String, "/box_done", 10)
+
+
+def WaitForBox():
+    """Block until the feeder announces a box at the pickup point.
+
+    Returns the box name (str). Use it as the handle to pass to BoxDone() once
+    the box has been stacked on the pallet.
+    """
+    HAL._ready_box = None
+    while rclpy.ok() and HAL._ready_box is None:
+        rclpy.spin_once(HAL, timeout_sec=0.1)
+    HAL._processed_boxes.add(HAL._ready_box)
+    return HAL._ready_box
+
+
+def BoxDone(name):
+    """Tell the feeder the box has been palletized; releases the next box.
+
+    Pass the name returned by WaitForBox().
+    """
+    HAL.box_done_pub.publish(String(data=name))
+    print(f"[HAL] BoxDone({name}) -> released next box")
+
+
 # ==============================================================
 # MoveAbsJ (IDÉNTICO a classic)
 # ==============================================================

exercises/palletizing/python_template/solution.py

@@ -4,11 +4,11 @@
 gripper through the palletizing task: a conveyor feeds boxes one at a time to a
 fixed pickup point, and the robot stacks them into an ordered grid on the pallet.
 
-Coordination with the feeder (box_spawner.py) is a two-message handshake:
-  - the feeder publishes the box name on /box_ready when a box is stopped at the
-    pickup point, and then waits;
-  - this code picks and stacks the box, then publishes the name on /box_done,
-    which releases the next box.
+Coordination with the feeder (box_spawner.py) is a two-call handshake, fully
+wrapped by the HAL so this code never touches ROS directly:
+  - HAL.WaitForBox() blocks until a box is stopped at the pickup point and
+    returns its name;
+  - HAL.BoxDone(name) reports the box is stacked, which releases the next box.
 
 IMPORTANT — coordinate frames and tuning
 ========================================
@@ -24,10 +24,6 @@
 cup just touches the box. Everything marked `# TUNE` is a candidate to adjust.
 """
 
-import rclpy
-from rclpy.node import Node
-from std_msgs.msg import String
-
 import HAL_Harmonic as HAL
 
 # --- Geometry ---------------------------------------------------------------
@@ -101,34 +97,7 @@ def grid_cell(index):
     return x, y, z, layer, row, col
 
 
-class FeederLink(Node):
-    """Handshake node: receive /box_ready, acknowledge with /box_done."""
-
-    def __init__(self):
-        super().__init__("palletizing_solution")
-        self._ready_box = None
-        self._processed_boxes = set()
-        self.create_subscription(String, "/box_ready", self._on_ready, 10)
-        self._done_pub = self.create_publisher(String, "/box_done", 10)
-
-    def _on_ready(self, msg):
-        if msg.data not in self._processed_boxes:
-            self._ready_box = msg.data
-
-    def wait_for_box(self):
-        """Block until a box is announced at the pickup point; return its name."""
-        self._ready_box = None
-        while rclpy.ok() and self._ready_box is None:
-            rclpy.spin_once(self, timeout_sec=0.1)
-        self._processed_boxes.add(self._ready_box)
-        return self._ready_box
-
-    def box_done(self, name):
-        """Tell the feeder the box has been palletized; release the next."""
-        self._done_pub.publish(String(data=name))
-
-
-def pick(link):
+def pick():
     """Lower onto the box at the pickup point, grip, and lift clear."""
     bx = PICK_WORLD_X
     by = PICK_WORLD_Y
@@ -137,17 +106,17 @@ def pick(link):
 
     # Swing gracefully from home to a safe high clearance point directly over the box
     HAL.MoveJoint([bx, by, approach_z + 0.3], CUP_DOWN_YPR, SPEED, SETTLE)
-    
+
     # Smooth, single vertical descent onto the box
     HAL.MoveLinear([bx, by, grip_z], CUP_DOWN_YPR, SPEED, SETTLE)
-    
+
     HAL.SuctionSet(True, GRIP_PAUSE)                                   # vacuum on
-    
+
     # Lift the box clear in a single motion
     HAL.MoveLinear([bx, by, approach_z + 0.3], CUP_DOWN_YPR, SPEED, SETTLE)
 
 
-def place(link, index):
+def place(index):
     """Carry the held box to grid cell `index` and release it."""
     wx, wy, wz, layer, row, col = grid_cell(index)
     # tool0 sits CUP_REACH + box height above the target box centre.
@@ -163,30 +132,26 @@ def place(link, index):
 
 
 def main():
-    # rclpy is already initialised by HAL; just add our coordination node.
-    link = FeederLink()
-
     # Natural 'up' home pose: [pan, lift, elbow, w1, w2, w3] in DEGREES
     # This keeps the arm safely clear of the workspace without awkward IK contortions.
     home_joints = [0.0, -90.0, 0.0, -90.0, 0.0, 0.0]
     HAL.MoveAbsJ(home_joints, SPEED, SETTLE)
 
     total = GRID_COLS * GRID_ROWS * GRID_LAYERS
     for index in range(total):
-        name = link.wait_for_box()
+        name = HAL.WaitForBox()
         if name is None:
             break
         print(f"box {name} ready -> placing as #{index}")
-        
-        pick(link)
-        place(link, index)
-        link.box_done(name)
-        
+
+        pick()
+        place(index)
+        HAL.BoxDone(name)
+
         # Return to home pose before waiting for the next box to ensure a clean sweep
         HAL.MoveAbsJ(home_joints, SPEED, SETTLE)
 
     print("palletizing complete")
-    link.destroy_node()
 
 
 if __name__ == "__main__":