Improving overall components

graphs/dataflow_robot_vlm.yml

@@ -1,18 +1,22 @@
 nodes:
    ### Camera
-  - id: plot_bot
-    operator:
-      python: ../operators/plot.py
+  - id: rerun
+    custom:
+      source: dora-rerun
       inputs:
         image: webcam/image
-        user_message: whisper/text
-        position: robot/position
+        textlog_llm: whisper/text_llm
+        textlog_policy: whisper/text_policy
+      envs:
+        IMAGE_WIDTH: 1280
+        IMAGE_HEIGHT: 720
+        IMAGE_DEPTH: 3
+        RERUN_MEMORY_LIMIT: 10%
 
   - id: robot
-    operator:
-      python: 
-        source: ../operators/robot.py
-        conda_env: robomaster
+    custom:
+      source: /home/peter/miniconda3/envs/robomaster/bin/python
+      args: ../operators/robot.py 
       inputs:
         tick: dora/timer/millis/750
         planning_control: planning/control
@@ -28,34 +32,31 @@ nodes:
         - image
   
   - id: whisper
-    operator:
-      python: ../operators/whisper_op.py
+    custom:
+      source: ../operators/whisper_op.py
       inputs:
         audio: dora/timer/millis/1000
       outputs:
-        - text
+        - text_policy
+        - text_llm
         - led
 
   - id: llm
     operator:
       python: ../operators/llm_op.py
       inputs:
-        text: whisper/text
-        reloaded: policy/reloaded
-      outputs:
-        - init
+        text: whisper/text_llm
 
   - id: policy
     operator:
       python: ../operators/policy.py
       inputs: 
-        init: llm/init
+        speech: whisper/text_policy
         reached_kitchen: planning/reached_kitchen
         reached_living_room: planning/reached_living_room
         reached_office: planning/reached_office
       outputs:
         - go_to
-        - reloaded
 
   - id: planning
     operator:

operators/constants.py

@@ -7,14 +7,27 @@ import numpy as np
 
 LOCATION = {
     "HOME": {
-        "OFFICE": np.array([[-1.3, 0.0], [-1.3, 0.5]]),
-        "KITCHEN": np.array([[-1.0, -0.5], [1.5, 0.0], [1.5, 0.5]]),
+        "OFFICE": np.array([[1.0, 1.0]]),
+        "KITCHEN": np.array([[0.0, 1.0]]),
         "LIVING_ROOM": np.array([[0.0, 0.3], [-1.5, 0.7]]),
     },
-    "OFFICE": {
-        "KITCHEN": np.array([[-1.0, -0.5], [2.5, 0.0], [2.5, 0.5]]),
-    },
+    "OFFICE": {"KITCHEN": np.array([[0.0, 1.0]]), "HOME": np.array([0.0, 0.0])},
     "KITCHEN": {
-        "OFFICE": np.array([[2.5, 0.0], [-1.5, -0.5], [-1.5, 0.5]]),
+        "OFFICE": np.array([[1.0, 1.0]]),
+        "HOME": np.array([0.0, 0.0]),
     },
 }
+
+# LOCATION = {
+# "HOME": {
+# "OFFICE": np.array([[0.0, 0.3], [-1.5, 0.7]]),
+# "KITCHEN": np.array([[-1.0, -0.5], [1.5, 0.0], [1.5, 0.5]]),
+# "LIVING_ROOM": np.array([[0.0, 0.3], [-1.5, 0.7]]),
+# },
+# "OFFICE": {
+# "KITCHEN": np.array([[0.0, 0.5], [1.5, -1.0]]),
+# },
+# "KITCHEN": {
+# "OFFICE": np.array([[-1.5, -0.5], [-1.5, 1.0]]),
+# },
+# }

operators/idefics2_op_demo.py

@@ -67,6 +67,9 @@ def ask_vlm(image, instruction):
     return generated_texts[0].split("\nAssistant: ")[1]
 
 
+import time
+
+
 class Operator:
     def __init__(self):
         self.image = None
@@ -91,17 +94,25 @@ class Operator:
                     "speak",
                     pa.array([output]),
                 )
-                """
-                if "sofa" in output:
+                if "yes" in output:
+                    send_output(
+                        "control",
+                        pa.array([0.0, 0.0, 0.0, 0.0, 0.0, 50.0, 0.0]),
+                    )
+                    time.sleep(2)
+                    send_output(
+                        "control",
+                        pa.array([0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0]),
+                    )
+                elif "no" in output:
                     send_output(
                         "control",
-                        pa.array([0.0, 0.0, 0.0, 0.0, 0.0, 50.0, 50.0]),
+                        pa.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 50.0]),
                     )
-                elif "back" in self.text:
+                    time.sleep(2)
                     send_output(
                         "control",
-                        pa.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]),
+                        pa.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]),
                     )
-                """
 
         return DoraStatus.CONTINUE

operators/llm_op.py

@@ -174,10 +174,6 @@ class Operator:
 
             gc.collect()
             torch.cuda.empty_cache()
-            time.sleep(6)
-            if not self.policy_init:
-                send_output("init", pa.array([]))
-                self.policy_init = True
 
         return DoraStatus.CONTINUE
 

operators/planning_op.py

@@ -4,8 +4,8 @@ import pyarrow as pa
 from dora import DoraStatus
 from constants import LOCATION
 
-CAMERA_WIDTH = 960
-CAMERA_HEIGHT = 540
+CAMERA_WIDTH = 1280
+CAMERA_HEIGHT = 720
 
 
 def check_clear_road(bboxes, image_width, goal_x):
@@ -127,7 +127,7 @@ class Operator:
                     self.waypoints.shape[0] == 1
                     and np.linalg.norm(self.waypoints[0] - np.array([x, y])) < 0.2
                 ):
-                    print("goal reached", flush=True)
+                    print(f"goal {self.goal} reached", flush=True)
                     self.current_location = self.goal
                     send_output(
                         f"reached_{self.goal.lower()}", pa.array(self.image.ravel())
@@ -169,21 +169,14 @@ class Operator:
 
                 message = pa.array(
                     [
-                        {
-                            "action": "gimbal",
-                            "value": [10.0, float(int(goal_angle))],
-                            "count": self.count,
-                        },
-                        {
-                            "value": [
-                                self.waypoints[0][0] - x,
-                                self.waypoints[0][1] - y,
-                                0.0,  # -goal_angle,
-                                0.8,
-                                0.0,  # 50,
-                            ],
-                            "action": "control",
-                        },
+                        self.waypoints[0][0] - x,
+                        self.waypoints[0][1] - y,
+                        0.0,  # -goal_angle,
+                        0.8,
+                        0.0,  # 50,
+                        10.0,
+                        float(int(goal_angle)),
+                        self.count,
                     ]
                 )
                 print("sending:", message, flush=True)

operators/policy.py

@@ -1,26 +1,26 @@
 import pyarrow as pa
 from dora import DoraStatus
-from utils import speak, play
+from utils import speak
 from time import sleep
 
 
 class Operator:
     def __init__(self):
         self.location = ["KITCHEN", "OFFICE"]
-        self.music = ["office.mp3"]
+        self.current_location = "KITCHEN"
 
     def speak(self, text: str):
         speak(text)
 
-    def play(self, file: str):
-        play(file)
-
-    def on_event(self, event: dict, send_output) -> DoraStatus:
+    def on_event(self, event, send_output):
         if event["type"] == "INPUT":
             id = event["id"]
             # On initialization
-            if id == "init":
-                send_output("go_to", pa.array([""]))
+            if id == "speech":
+                text: str = event["value"][0].as_py().lower()
+                if "stop" in text:
+                    return DoraStatus.STOP
+                # send_output("go_to", pa.array([""]))
             elif id == "reached_office":
                 pass
             elif id == "reached_kitchen":

operators/robot.py

@@ -1,86 +1,64 @@
 from robomaster import robot, led
-from typing import Callable, Optional
-from dora import DoraStatus
 
+from dora import Node
+from time import sleep
 import numpy as np
 import pyarrow as pa
 
 
 CONN = "ap"
 
-print("Initialization...", flush=True)
 
+ep_robot = robot.Robot()
+print("Initializing robot...", flush=True)
+assert ep_robot.initialize(conn_type=CONN), "Could not initialize ep_robot"
+assert ep_robot.camera.start_video_stream(display=False), "Could not start video stream"
 
-class Operator:
-    def __init__(self):
-        self.ep_robot = robot.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"
+node = Node()
+ep_robot.gimbal.recenter().wait_for_completed()
+backlog = []
+last_control = ""
+position = np.array([0.0, 0.0, 0.0])
+count = -1
+event = None
+rgb = [0, 0, 0]
 
-        self.ep_robot.gimbal.recenter().wait_for_completed()
-        self.backlog = []
-        self.last_control = ""
-        self.position = np.array([0.0, 0.0, 0.0])
-        self.count = -1
-        self.event = None
-        self.rgb = [0, 0, 0]
 
-    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"]
-                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
-                )
-
-            elif command["action"] == "gimbal":
-                [pitch, yaw] = command["value"]
-                self.event = self.ep_robot.gimbal.moveto(
-                    pitch=pitch, yaw=yaw, pitch_speed=50.0, yaw_speed=50.0
-                )
+def wait(event):
+    if event is not None and not (event._event.isSet() and event.is_completed):
+        sleep(1)
 
-    def on_event(
-        self,
-        dora_event: str,
-        send_output: Callable[[str, pa.Array, Optional[dict]], None],
-    ) -> DoraStatus:
-        event_type = dora_event["type"]
-        if event_type == "INPUT":
-            if dora_event["id"] == "tick":
 
-                if not (
-                    self.event is not None
-                    and not (self.event._event.isSet() and self.event.is_completed)
-                ):
-                    if len(self.backlog) > 0:
-                        self.execute_backlog()
-                    else:
-                        print(f"sending control reply: {self.count}", flush=True)
-                        send_output("position", pa.array(self.position))
-                        send_output("control_reply", pa.array([self.count]))
-                    return DoraStatus.CONTINUE
+for dora_event in node:
+    event_type = dora_event["type"]
+    if event_type == "INPUT":
+        if dora_event["id"] == "tick":
+            node.send_output("position", pa.array(position))
+            node.send_output("control_reply", pa.array([count]))
 
-                print("sending position", flush=True)
-                send_output("position", pa.array(self.position))
+        elif dora_event["id"] == "planning_control":
+            [x, y, z, xy_speed, z_speed, pitch, yaw, count] = dora_event[
+                "value"
+            ].to_numpy()
+            if any([pitch, yaw]):
+                event = ep_robot.gimbal.moveto(
+                    pitch=pitch, yaw=yaw, pitch_speed=60.0, yaw_speed=50.0
+                )
+                wait(event)
+                sleep(2)
+            if any([x, y, z]):
+                event = ep_robot.chassis.move(
+                    x=x, y=y, z=z, xy_speed=xy_speed, z_speed=z_speed
+                )
+                position = position + np.array([x, y, z])
+                wait(event)
+                sleep(6)
 
-            elif dora_event["id"] == "planning_control":
-                command = dora_event["value"].to_pylist()
-                self.count = command[0]["count"]
-                if len(self.backlog) == 0:
-                    self.backlog += command
-                    self.execute_backlog()
-            elif dora_event["id"] == "led":
-                [r, g, b] = dora_event["value"].to_numpy()
-                rgb = [r, g, b]
-                if rgb != self.rgb:
-                    self.ep_robot.led.set_led(
-                        comp=led.COMP_ALL, r=r, g=g, b=b, effect=led.EFFECT_ON
-                    )
-                    self.rgb = rgb
-        return DoraStatus.CONTINUE
+        elif dora_event["id"] == "led":
+            [r, g, b] = dora_event["value"].to_numpy()
+            rgb = [r, g, b]
+            if rgb != rgb:
+                ep_robot.led.set_led(
+                    comp=led.COMP_ALL, r=r, g=g, b=b, effect=led.EFFECT_ON
+                )
+                rgb = rgb

operators/whisper_op.py

@@ -16,7 +16,7 @@ SAMPLE_RATE = 16000
 MAX_DURATION = 30
 
 policy_init = True
-
+audio_data = None
 node = Node()
 
 for dora_event in node:
@@ -26,7 +26,7 @@ for dora_event in node:
             event = events.get(1.0)
             if (
                 event is not None
-                and event.key == Key.alt_r
+                and (event.key == Key.alt_r or event.key == Key.ctrl_r)
                 and isinstance(event, Events.Press)
             ):
 
@@ -45,13 +45,36 @@ for dora_event in node:
                 and isinstance(event, Events.Release)
             ):
                 sd.stop()
+                if audio_data is None:
+                    continue
+                audio = audio_data.ravel().astype(np.float32) / 32768.0
+
+                ## Speech to text
+                audio = whisper.pad_or_trim(audio)
+                result = model.transcribe(audio, language="en")
+                node.send_output(
+                    "text_llm", pa.array([result["text"]]), dora_event["metadata"]
+                )
+                # send_output("led", pa.array([0, 0, 255]))
+
+                gc.collect()
+                torch.cuda.empty_cache()
+
+            elif (
+                event is not None
+                and event.key == Key.ctrl_r
+                and isinstance(event, Events.Release)
+            ):
+                sd.stop()
+                if audio_data is None:
+                    continue
                 audio = audio_data.ravel().astype(np.float32) / 32768.0
 
                 ## Speech to text
                 audio = whisper.pad_or_trim(audio)
                 result = model.transcribe(audio, language="en")
                 node.send_output(
-                    "text", pa.array([result["text"]]), dora_event["metadata"]
+                    "text_policy", pa.array([result["text"]]), dora_event["metadata"]
                 )
                 # send_output("led", pa.array([0, 0, 255]))