Simplifying robot control behavior

graphs/dataflow_robot_basic.yml

@@ -0,0 +1,51 @@
+nodes:
+   ### Camera
+  - id: plot_bot
+    operator:
+      python: ../operators/plot.py
+      inputs:
+        image: webcam/image
+        position: robot/position
+
+  - id: robot
+    operator:
+      python:  ../operators/robot.py
+      inputs:
+        tick: dora/timer/millis/750
+        planning_control: planning/control
+      outputs:
+        - control_reply
+        - position
+
+  - id: webcam
+    custom:
+      source: ../operators/opencv_stream.py
+      outputs:
+        - image
+
+  - id: policy
+    operator:
+      python: ../operators/policy.py
+      inputs: 
+        init: dora/timer/millis/750
+        goal_reached: planning/goal_reached
+      outputs:
+        - go_to
+        - reloaded
+
+  - id: planning
+    operator:
+      python: ../operators/planning_op.py
+      inputs:
+        position: robot/position
+        control_reply: robot/control_reply
+        set_goal: policy/go_to
+        image: 
+          source: webcam/image
+          queue_size: 1
+      outputs:
+        - control
+        - goal_reached
+
+  
+      

graphs/dataflow_robot_vlm.yml

@@ -60,7 +60,9 @@ nodes:
         position: robot/position
         control_reply: robot/control_reply
         set_goal: policy/go_to
-        image: webcam/image
+        image: 
+          source: webcam/image
+          queue_size: 1
       outputs:
         - control
         - goal_reached

operators/robot.py

@@ -1,6 +1,5 @@
 from robomaster import robot
-from typing import Callable, Optional, Union
-from enum import Enum
+from typing import Callable, Optional
 from dora import DoraStatus
 
 import numpy as np
@@ -9,101 +8,38 @@ import pyarrow as pa
 
 CONN = "ap"
 
-
-class Command(Enum):
-    NOD_YES = [
-        {"action": "gimbal", "value": [20.0, 0.0]},
-        {"action": "gimbal", "value": [0.0, 0.0]},
-    ]
-    NOD_NO = [
-        {"action": "gimbal", "value": [0, -55.0]},
-        {"action": "gimbal", "value": [0.0, 0.0]},
-    ]
-    FORWARD = [
-        {
-            "action": "control",
-            "value": [2.0, 0.0, 0.0, 0.8, 0],
-        }
-    ]
-    BACKWARD = [
-        {"action": "gimbal", "value": [0, -180.0]},
-        {
-            "action": "control",
-            "value": [-2.0, 0, 180.0, 0.8, 50],
-        },
-    ]
-    LEFT = [
-        {"action": "gimbal", "value": [0, -90.0]},
-        {
-            "action": "control",
-            "value": [0.0, -1.0, 90.0, 0.6, 50],
-        },
-    ]
-    SLIGHT_LEFT = [
-        {"action": "gimbal", "value": [0.0, -30.0]},
-        {
-            "action": "control",
-            "value": [1.0, -0.5, 30.0, 0.6, 50],
-        },
-    ]
-    RIGHT = [
-        {"action": "gimbal", "value": [0.0, 90.0]},
-        {
-            "value": [0.0, 1.0, -90.0, 0.6, 50],
-            "action": "control",
-        },
-    ]
-    SLIGHT_RIGHT = [
-        {"action": "gimbal", "value": [0.0, 30.0]},
-        {
-            "value": [1.0, 0.5, -30.0, 0.6, 50],
-            "action": "control",
-        },
-    ]
-    UNKNOWN = []
-    # STOP = [0, 0, 0, 0]
-    # COMPLETED = [0, 0, 0, 0]
-
-    @classmethod
-    def parse(cls, value):
-        for k, v in cls.__members__.items():
-            if k == value:
-                return v
-        return cls.UNKNOWN
+print("Initialization...", flush=True)
 
 
 class Operator:
     def __init__(self):
         self.ep_robot = robot.Robot()
-        print("Initializing robot...")
+        print("Initializing robot...", flush=True)
         assert self.ep_robot.initialize(conn_type=CONN), "Could not initialize ep_robot"
         assert self.ep_robot.camera.start_video_stream(
             display=False
         ), "Could not start video stream"
 
         self.ep_robot.gimbal.recenter().wait_for_completed()
-        self.event = self.ep_robot.gimbal.moveto(
-            pitch=-5, yaw=0, pitch_speed=50.0, yaw_speed=50.0
-        )
         self.backlog = []
         self.last_control = ""
-        self.position = np.array([0, 0, 0])
+        self.position = np.array([0.0, 0.0, 0.0])
         self.count = -1
+        self.event = None
 
     def execute_backlog(self):
         if len(self.backlog) > 0:
             command = self.backlog.pop(0)
+            print(command, flush=True)
             if command["action"] == "control":
                 [x, y, z, xy_speed, z_speed] = command["value"]
-                print(command, flush=True)
+                self.position += np.array([x, y, z])
                 self.event = self.ep_robot.chassis.move(
                     x=x, y=y, z=z, xy_speed=xy_speed, z_speed=z_speed
                 )
-                self.position = np.array([x, y, z])
 
             elif command["action"] == "gimbal":
                 [pitch, yaw] = command["value"]
-                print(command, flush=True)
                 self.event = self.ep_robot.gimbal.moveto(
                     pitch=pitch, yaw=yaw, pitch_speed=50.0, yaw_speed=50.0
                 )
@@ -124,45 +60,14 @@ class Operator:
                     if len(self.backlog) > 0:
                         self.execute_backlog()
                     else:
-                        print(f"sending control reply: {self.last_control}", flush=True)
+                        print(f"sending control reply: {self.count}", flush=True)
                         send_output("position", pa.array(self.position))
                         send_output("control_reply", pa.array([self.count]))
-                elif self.event is None:
-                    send_output("position", pa.array(self.position))
+                    return DoraStatus.CONTINUE
+
+                print("sending position", flush=True)
+                send_output("position", pa.array(self.position))
 
-            elif dora_event["id"] == "control":
-                raw_command = dora_event["value"][0].as_py()
-                print(raw_command, flush=True)
-                self.last_control = raw_command
-                if "slight right" in raw_command:
-                    cmd = Command.BACKWARD
-                elif "slight left" in raw_command:
-                    cmd = Command.BACKWARD
-                elif "right" in raw_command:
-                    cmd = Command.RIGHT
-                elif "left" in raw_command:
-                    cmd = Command.LEFT
-                elif "forward" in raw_command:
-                    cmd = Command.FORWARD
-                elif "backward" in raw_command:
-                    cmd = Command.BACKWARD
-                else:
-                    cmd = Command.UNKNOWN
-                if len(self.backlog) == 0:
-                    self.backlog += cmd.value
-                    self.execute_backlog()
-            elif dora_event["id"] == "assistant_message":
-                raw_command = dora_event["value"][0].as_py()
-                print(raw_command, flush=True)
-                self.last_control = raw_command
-                if "No, " in raw_command:
-                    cmd = Command.NOD_NO
-                elif "Yes, " in raw_command:
-                    cmd = Command.NOD_YES
-                else:
-                    cmd = Command.UNKNOWN
-                    self.backlog += cmd.value
-                    self.execute_backlog()
             elif dora_event["id"] == "planning_control":
                 command = dora_event["value"].to_pylist()
                 self.count = command[0]["count"]