Initial commit

Drivers

Adding operators

Remove pptx

.gitattributes

@@ -0,0 +1,3 @@
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.mkv filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+graphs/yolov5n.pt
+*.pt
+operators/__pycache__/
+__pycache__/
+*.avi

README.md

@@ -0,0 +1,52 @@
+# Dora-Robomaster
+
+This project aims to use Dora to enhance the capabilities of a RoboMaster S1.
+You can see the presentation and demos in the folder Presentation_dora/
+
+### Getting Started
+
+command to start the demo:
+
+```bash
+alias dora='dora-cli'
+dora up
+dora start graphs/dataflow.yml --attach
+```
+
+start the reaction lighting test:
+`dora start graphs/reaction.yml --attach`
+
+## Installation of the Robomaster S1 Hack
+
+This guide is an updated version of the original [Robomaster S1 SDK Hack Guide](https://www.bug-br.org.br/s1_sdk_hack.zip) and is intended for use on a Windows 11 system.
+
+### Prerequisites
+
+Before you get started, you'll need the following:
+
+- Robomaster S1 (do not update it to the latest version, as it may block the hack).
+- [Robomaster App](https://www.dji.com/fr/robomaster-s1/downloads).
+- [Android SDK Platform-Tools](https://developer.android.com/tools/releases/platform-tools). Simply unzip it and keep the path handy.
+- A micro USB cable. If this guide doesn't work, there might be an issue with the cable, and you may need to replace it with one that supports data transfer.
+
+### Instructions
+
+1. Start the Robomaster App and connect the Robomaster S1 using one of the two options provided (via router or via Wi-Fi).
+2. While connected, use a micro USB cable to connect the robot to the computer's USB port. You should hear a beep sound, similar to when you connect any device. (Please note that no other Android device should be connected via USB during this process).
+3. In the Lab section of the app, create a new Python application and paste the following code:
+
+   ```python
+   def root_me(module):
+       __import__ = rm_define.__dict__['__builtins__']['__import__']
+       return __import__(module, globals(), locals(), [], 0)
+
+   builtins = root_me('builtins')
+   subprocess = root_me('subprocess')
+   proc = subprocess.Popen('/system/bin/adb_en.sh', shell=True, executable='/system/bin/sh', stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+   ```
+
+4. Run the code; there should be no errors, and the console should display **Execution Complete**
+5. Without closing the app, navigate to the folder containing the Android SDK Platform-Tools and open a terminal inside it.
+6. Run the ADP command `.\adb.exe devices `. If everything is working correctly, you should see output similar to this: ![image](https://github.com/Felixhuangsiling/Dora-Robomaster/assets/77993249/dc6368ec-052c-4b18-8fdc-0ec314adb073)
+7. Execute the upload.sh script located in the folder `s1_SDK`.
+8. Once everything has been executed, restart the S1 by turning it off and then back on. While it's booting up, you should hear two chimes instead of the usual single chime, indicating that the hack has been successful.

graphs/dataflow.yml

@@ -0,0 +1,156 @@
+nodes:
+  # - id: robot
+    # operator:
+      # python: ../operators/robot.py
+      # inputs:
+        # blaster:
+          # source: planning/blaster
+          # queue_size: 1
+        # led:
+          # source: planning/led
+          # queue_size: 1
+        # control:
+          # source: planning/control
+          # queue_size: 1
+        # gimbal_control:
+          # source: planning/gimbal_control
+          # queue_size: 1
+        # tick:
+          # source: dora/timer/millis/100
+          # queue_size: 1
+      # outputs:
+        # - position
+  # - id: bot_plot
+  # operator:
+  # python: ../operators/plot.py
+  # inputs:
+  # image: bot_webcam/image
+  # bbox: object_detection/bbox
+#   - id: bot_webcam
+    # custom:
+      # source: ../operators/opencv_stream.py
+      # outputs:
+        # - image
+
+  - id: object_detection
+    operator:
+      python: ../operators/object_detection.py
+      inputs:
+        image:
+          source: webcam/image
+          queue_size: 1
+      outputs:
+        - bbox
+
+  ### Second Camera
+  - id: webcam
+    operator:
+      python: ../operators/webcam.py
+      inputs:
+        tick:
+          source: dora/timer/millis/50
+          queue_size: 1
+      outputs:
+        - image
+
+  - id: plot_webcam
+    operator:
+      python: ../operators/plot.py
+      inputs:
+        image: webcam/image
+        text: whisper/text  
+        bbox: object_detection/bbox
+
+
+  # - id: plot_bot
+  #   operator:
+  #     python: ../operators/plot.py
+  #     inputs:
+  #       image: bot_webcam/image
+  #       text: whisper/text
+  #       bbox: object_detection/bbox
+  
+  # - id: planning
+  #   operator:
+  #     python: ../operators/planning_op.py
+  #     inputs:
+  #       position: robot/position
+  #       bbox: object_detection/bbox
+  #     outputs:
+  #       - control
+  #       - gimbal_control
+  #       - led
+  #       - blaster
+
+  ## Speech to text
+  - id: keyboard
+    custom:
+      source: ../operators/keybinding_op.py
+      outputs:
+        - mic_on
+        - cancel
+        - failed
+
+  - id: microphone
+    operator:
+      python: ../operators/microphone_op.py
+      inputs:
+        mic_on: keyboard/mic_on
+      outputs:
+        - audio
+
+  - id: whisper
+    operator:
+      python: ../operators/whisper_op.py
+      inputs:
+        audio: microphone/audio
+      outputs:
+        - text
+
+  ## Code Modifier
+  - id: vectordb
+    operator:
+      python: ../operators/sentence_transformers_op.py
+      inputs:
+        query: whisper/text
+        saved_file: file_saver/saved_file
+      outputs:
+        - raw_file
+
+  - id: mistral
+    operator:
+      python: ../operators/mistral_op.py
+      # python: ../operators/chatgpt_op.py
+      inputs:
+        raw_file: vectordb/raw_file
+      outputs:
+        - output_file
+
+  - id: chatgpt
+    operator:
+      python: ../operators/chatgpt_op.py
+      inputs:
+        raw_file: vectordb/raw_file
+      outputs:
+        - output_file
+  
+  - id: file_saver
+    operator:
+      python: ../operators/file_saver_op.py
+      inputs:
+        chatgpt_output_file: chatgpt/output_file
+        mistral_output_file: mistral/output_file
+        cancel: keyboard/cancel
+        failed: keyboard/failed
+      outputs:
+        - saved_file
+
+  - id: dora-record
+    custom:
+      source: dora-record
+      inputs:
+        chatgpt_output_file: chatgpt/output_file
+        mistral_output_file: mistral/output_file
+        raw_file: vectordb/raw_file
+        saved_file: file_saver/saved_file
+        

graphs/merge.py

@@ -0,0 +1,9 @@
+import pyarrow as pa
+
+with pa.memory_map("mistral_output_file.arrow", "r") as source:
+    df_i = pa.RecordBatchStreamReader(source).read_all()
+
+df_i = df_i.to_pandas()
+df_b = df_b.to_pandas()
+
+df = df_i.merge(df_b, on="trace_id")

graphs/mistral_output_file.arrow

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:764707ce8c55e898c8bd577a725af16a2fe931f83cb597cd0cb9f768214e9667
+size 29904

graphs/raw_file.arrow

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:13ea7b9c4a305d07c94616c87baa41c1c195cc67930cd57fb2e3010eea50c6d6
+size 29912

graphs/reaction.yml

@@ -0,0 +1,40 @@
+nodes:
+  - id: robot
+    operator:
+      python: ../operators/robot.py
+      inputs:
+        blaster: 
+          source: planning/blaster
+          queue_size: 1
+        led:
+          source: planning/led
+          queue_size: 1
+        tick:
+          source: dora/timer/millis/50
+          queue_size: 1
+      outputs:
+        - image
+        - position
+  - id: plot
+    operator:
+      python: ../operators/plot.py
+      inputs:
+        image: robot/image
+        bbox: object_detection/bbox
+  - id: object_detection
+    operator:
+      python: ../operators/object_detection.py
+      inputs:
+        image:
+          source: robot/image
+          queue_size: 1
+      outputs:
+        - bbox
+  - id: planning
+    operator:
+      python: ../operators/reaction_op.py
+      inputs:
+        bbox: object_detection/bbox
+      outputs:
+        - led
+        - blaster

graphs/saved_file.arrow

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a0ae045e300e026d2ceccc701b0301562d8a58b4a0de2994b5fcd2e1ed87cf5b
+size 14976

operators/chatgpt_op.py

@@ -0,0 +1,123 @@
+import os
+from openai import OpenAI
+
+
+def ask_gpt(prompt, raw):
+    client = OpenAI()
+
+    Prompt = (
+        "this is a python code :\n"
+        + "```python\n"
+        + raw
+        + "```\n"
+        + prompt
+        + "Format your response by: Showing the whole modified code. No explanation is required. Only code."
+    )
+
+    response = client.chat.completions.create(
+        model="gpt-4-1106-preview",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": Prompt},
+        ],
+    )
+
+    answer = response.choices[0].message.content
+    return answer
+
+
+def extract_command(gptCommand):
+    blocks = []
+    temp = ""
+    writing = False
+
+    for line in gptCommand.splitlines():
+        if line == "```":
+            writing = False
+            blocks.append(temp)
+            temp = ""
+
+        if writing:
+            temp += line
+            temp += "\n"
+
+        if line == "```python":
+            writing = True
+
+    return blocks
+
+
+def save_as(content, path):
+    # use at the end of replace_2 as save_as(end_result, "file_path")
+    with open(path, "w") as file:
+        file.write(content)
+
+
+import pyarrow as pa
+
+from dora import DoraStatus
+
+
+class Operator:
+    """
+    Infering object from images
+    """
+
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ) -> DoraStatus:
+        # todo: remove this
+        return DoraStatus.CONTINUE
+
+        if dora_event["type"] == "INPUT":
+            input = dora_event["value"][0].as_py()
+            with open(input["path"], "r", encoding="utf8") as f:
+                raw = f.read()
+            print("--- Asking chatGPT ", flush=True)
+            response = ask_gpt(input["query"], raw)
+            blocks = extract_command(response)
+            print(response, flush=True)
+            print(blocks[0], input["path"], flush=True)
+            send_output(
+                "output_file",
+                pa.array(
+                    [{"raw": blocks[0], "path": input["path"], "gen_output": response}]
+                ),
+                dora_event["metadata"],
+            )
+
+        return DoraStatus.CONTINUE
+
+
+if __name__ == "__main__":
+    op = Operator()
+
+    # Path to the current file
+    current_file_path = __file__
+
+    # Directory of the current file
+    current_directory = os.path.dirname(current_file_path)
+
+    path = current_directory + "/planning_op.py"
+    with open(path, "r", encoding="utf8") as f:
+        raw = f.read()
+
+    op.on_event(
+        {
+            "type": "INPUT",
+            "id": "tick",
+            "value": pa.array(
+                [
+                    {
+                        "raw": raw,
+                        "path": path,
+                        "query": "Can you change the RGB to change according to the object distances",
+                    }
+                ]
+            ),
+            "metadata": [],
+        },
+        print,
+    )

operators/file_saver_op.py

@@ -0,0 +1,62 @@
+import pyarrow as pa
+
+from dora import DoraStatus
+
+
+class Operator:
+    """
+    Infering object from images
+    """
+
+    def __init__(self):
+        self.last_file = ""
+        self.last_path = ""
+        self.last_netadata = None
+
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT" and dora_event["id"] == "mistral_output_file":
+            input = dora_event["value"][0].as_py()
+
+            with open(input["path"], "r") as file:
+                self.last_file = file.read()
+                self.last_path = input["path"]
+                self.last_metadata = dora_event["metadata"]
+            with open(input["path"], "w") as file:
+                file.write(input["raw"])
+
+            send_output(
+                "saved_file",
+                pa.array(
+                    [
+                        {
+                            "raw": input["raw"],
+                            "path": input["path"],
+                            "origin": dora_event["id"],
+                        }
+                    ]
+                ),
+                dora_event["metadata"],
+            )
+        if dora_event["type"] == "INPUT" and dora_event["id"] in ["cancel", "failed"]:
+
+            with open(self.last_path, "w") as file:
+                file.write(self.last_file)
+
+            send_output(
+                "saved_file",
+                pa.array(
+                    [
+                        {
+                            "raw": self.last_file,
+                            "path": self.last_path,
+                            "origin": dora_event["id"],
+                        }
+                    ]
+                ),
+                self.last_metadata,
+            )
+        return DoraStatus.CONTINUE

operators/keybinding_op.py

@@ -0,0 +1,27 @@
+import pynput
+import pyarrow as pa
+
+from dora import Node
+
+node = Node()
+
+
+def on_key_release(key):
+    try:
+        if key.char == "1":
+            print("Key 'm' pressed up")
+            node.send_output("mic_on", pa.array([]))
+        elif key.char == "2":
+            print("Key '2' pressed up")
+            node.send_output("cancel", pa.array([]))
+        elif key.char == "3":
+            print("Key '3' pressed up")
+            node.send_output("failed", pa.array([]))
+        elif key.char == "0":
+            exit()
+
+    except AttributeError:
+        pass
+
+
+pynput.keyboard.Listener(on_release=on_key_release).run()

operators/microphone_op.py

@@ -0,0 +1,43 @@
+# Run this in the consol first :
+
+# pip install sounddevice numpy
+
+# Don't forget to install whisper
+
+import time
+
+import numpy as np
+import pyarrow as pa
+import sounddevice as sd
+
+from dora import DoraStatus
+
+# Set the parameters for recording
+SAMPLE_RATE = 16000
+MAX_DURATION = 1
+
+
+class Operator:
+    """
+    Infering object from images
+    """
+
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT":
+            audio_data = sd.rec(
+                int(SAMPLE_RATE * MAX_DURATION),
+                samplerate=SAMPLE_RATE,
+                channels=1,
+                dtype=np.int16,
+                blocking=False,
+            )
+            time.sleep(MAX_DURATION)
+
+            audio_data = audio_data.ravel().astype(np.float32) / 32768.0
+            if len(audio_data) > 0:
+                send_output("audio", pa.array(audio_data), dora_event["metadata"])
+        return DoraStatus.CONTINUE

operators/mistral_op.py

@@ -0,0 +1,149 @@
+from dora import DoraStatus
+import pylcs
+import textwrap
+import pandas as pd
+import os
+import pyarrow as pa
+import numpy as np
+from ctransformers import AutoModelForCausalLM
+
+MIN_NUMBER_LINES = 4
+MAX_NUMBER_LINES = 21
+
+
+def search_most_simlar_line(text, searched_line):
+    lines = text.split("\n")
+    values = []
+
+    for line in lines[MIN_NUMBER_LINES:MAX_NUMBER_LINES]:
+        values.append(pylcs.edit_distance(line, searched_line))
+    output = lines[np.array(values).argmin() + MIN_NUMBER_LINES]
+    return output
+
+
+def strip_indentation(code_block):
+    # Use textwrap.dedent to strip common leading whitespace
+    dedented_code = textwrap.dedent(code_block)
+
+    return dedented_code
+
+
+def replace_code_with_indentation(original_code, replacement_code):
+    # Split the original code into lines
+    lines = original_code.splitlines()
+    if len(lines) != 0:
+        # Preserve the indentation of the first line
+        indentation = lines[0][: len(lines[0]) - len(lines[0].lstrip())]
+
+        # Create a new list of lines with the replacement code and preserved indentation
+        new_code_lines = indentation + replacement_code
+    else:
+        new_code_lines = replacement_code
+    return new_code_lines
+
+
+def replace_source_code(source_code, gen_replacement):
+    initial = search_most_simlar_line(source_code, gen_replacement)
+    print("Initial source code: %s" % initial)
+    replacement = strip_indentation(
+        gen_replacement.replace("```python\n", "")
+        .replace("\n```", "")
+        .replace("\n", "")
+    )
+    intermediate_result = replace_code_with_indentation(initial, replacement)
+    print("Intermediate result: %s" % intermediate_result)
+    end_result = source_code.replace(initial, intermediate_result)
+    return end_result
+
+
+def save_as(content, path):
+    # use at the end of replace_2 as save_as(end_result, "file_path")
+    with open(path, "w") as file:
+        file.write(content)
+
+
+class Operator:
+    def __init__(self):
+        # Load tokenizer
+        self.llm = AutoModelForCausalLM.from_pretrained(
+            "TheBloke/OpenHermes-2.5-Mistral-7B-GGUF",
+            model_file="openhermes-2.5-mistral-7b.Q4_K_M.gguf",
+            model_type="mistral",
+            gpu_layers=50,
+        )
+
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT":
+            input = dora_event["value"][0].as_py()
+
+            with open(input["path"], "r", encoding="utf8") as f:
+                raw = f.read()
+            prompt = f"{raw[:400]} \n\n {input['query']}.  "
+            print("revieved prompt: {}".format(prompt))
+            output = self.ask_mistral(
+                "You're a python code expert. Respond with only one line of code that modify a constant variable. Keep the uppercase.",
+                prompt,
+            )
+            print("output: {}".format(output))
+            source_code = replace_source_code(raw, output)
+            send_output(
+                "output_file",
+                pa.array(
+                    [{"raw": source_code, "path": input["path"], "gen_output": output}]
+                ),
+                dora_event["metadata"],
+            )
+        return DoraStatus.CONTINUE
+
+    def ask_mistral(self, system_message, prompt):
+        prompt_template = f"""<|im_start|>system
+        {system_message}<|im_end|>
+        <|im_start|>user
+        {prompt}<|im_end|>
+        <|im_start|>assistant
+        """
+
+        # Generate output
+        outputs = self.llm(
+            prompt_template,
+        )
+        # Get the tokens from the output, decode them, print them
+
+        # Get text between im_start and im_end
+        return outputs.split("<|im_end|>")[0]
+
+
+if __name__ == "__main__":
+    op = Operator()
+
+    # Path to the current file
+    current_file_path = __file__
+
+    # Directory of the current file
+    current_directory = os.path.dirname(current_file_path)
+
+    path = current_directory + "/planning_op.py"
+    with open(path, "r", encoding="utf8") as f:
+        raw = f.read()
+
+    op.on_event(
+        {
+            "type": "INPUT",
+            "id": "tick",
+            "value": pa.array(
+                [
+                    {
+                        "raw": raw,
+                        "path": path,
+                        "query": "Set rotation to 20",
+                    }
+                ]
+            ),
+            "metadata": [],
+        },
+        print,
+    )

operators/object_detection.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import numpy as np
+import pyarrow as pa
+
+from dora import DoraStatus
+from ultralytics import YOLO
+
+pa.array([])
+
+CAMERA_WIDTH = 960
+CAMERA_HEIGHT = 540
+
+
+class Operator:
+    """
+    Infering object from images
+    """
+
+    def __init__(self):
+        self.model = YOLO("yolov8n.pt")
+
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT":
+            return self.on_input(dora_event, send_output)
+        return DoraStatus.CONTINUE
+
+    def on_input(
+        self,
+        dora_input,
+        send_output,
+    ) -> DoraStatus:
+        """Handle image
+        Args:
+            dora_input (dict) containing the "id", value, and "metadata"
+            send_output Callable[[str, bytes | pa.Array, Optional[dict]], None]:
+                Function for sending output to the dataflow:
+                - First argument is the `output_id`
+                - Second argument is the data as either bytes or `pa.Array`
+                - Third argument is dora metadata dict
+                e.g.: `send_output("bbox", pa.array([100], type=pa.uint8()), dora_event["metadata"])`
+        """
+
+        frame = dora_input["value"].to_numpy().reshape((CAMERA_HEIGHT, CAMERA_WIDTH, 3))
+        frame = frame[:, :, ::-1]  # OpenCV image (BGR to RGB)
+        results = self.model(frame)  # includes NMS
+        # Process results
+        boxes = np.array(results[0].boxes.xyxy.cpu())
+        conf = np.array(results[0].boxes.conf.cpu())
+        label = np.array(results[0].boxes.cls.cpu())
+        # concatenate them together
+        arrays = np.concatenate((boxes, conf[:, None], label[:, None]), axis=1)
+
+        send_output("bbox", pa.array(arrays.ravel()), dora_input["metadata"])
+        return DoraStatus.CONTINUE

operators/opencv2_stream.py

@@ -0,0 +1,36 @@
+import ffmpeg
+import numpy as np
+from dora import Node
+import pyarrow as pa
+import cv2
+
+node = Node()
+
+in_filename = "tcp://192.168.2.1:40921"
+# Global variables, change it to adapt your needs
+CAMERA_WIDTH = 960
+CAMERA_HEIGHT = 540
+
+process1 = (
+    ffmpeg.input(in_filename)
+    .output("pipe:", format="rawvideo", pix_fmt="rgb24")
+    .run_async(pipe_stdout=True)
+)
+
+audio = ffmpeg.input(in_filename).audio
+
+while True:
+    in_bytes = process1.stdout.read(1280 * 720 * 3)
+    if not in_bytes:
+        break
+    in_frame = np.frombuffer(in_bytes, np.uint8).reshape([720, 1280, 3])
+
+    ## RGB to BGR
+    in_frame = in_frame[..., ::-1]
+
+    in_frame = cv2.resize(in_frame, (CAMERA_WIDTH, CAMERA_HEIGHT))
+    # out_frame = in_frame * 0.5  # do some processing
+    node.send_output("image", pa.array(in_frame.ravel()))
+    node.send_output("audio", pa.array(in_frame.ravel()))
+
+process1.wait()

operators/opencv_stream.py

@@ -0,0 +1,31 @@
+import cv2
+import pyarrow as pa
+from dora import Node
+
+node = Node()
+# TCP stream URL (replace with your stream URL)
+TCP_STREAM_URL = "tcp://192.168.2.1:40921"
+# Global variables, change it to adapt your needs
+CAMERA_WIDTH = 960
+CAMERA_HEIGHT = 540
+
+# Create a VideoCapture object using the TCP stream URL
+cap = cv2.VideoCapture(TCP_STREAM_URL)
+
+# Check if the VideoCapture object opened successfully
+assert cap.isOpened(), "Error: Could not open video capture."
+
+while True:
+    # Read a frame from the stream
+    ret, frame = cap.read()
+
+    if not ret:
+        break  # Break the loop when no more frames are available
+    frame = cv2.resize(frame, (CAMERA_WIDTH, CAMERA_HEIGHT))
+
+    node.send_output("image", pa.array(frame.ravel()))
+
+
+# Release the VideoCapture object and any OpenCV windows
+cap.release()
+cv2.destroyAllWindows()

operators/planning_op.py

@@ -0,0 +1,120 @@
+import numpy as np
+import pyarrow as pa
+from dora import DoraStatus
+
+X = 0
+# left-right: [-1,1]
+Y = 0
+SPEED = 0.5
+# pitch-axis angle in degrees(int): [-55, 55]
+PITCH = 0
+# yaw-axis angle in degrees(int): [-55, 55]
+ROTATION = 0
+# RGB LED(int) [0, 255]
+RGB = [1, 0, 1] # Purple         BBOX_COLOR = [1, 0, 1] # Purple
+BRIGHTNESS = [0]  # [0, 128]
+
+GOAL_OBJECTIVES = [X, Y, 0]
+GIMBAL_POSITION_GOAL = [PITCH, ROTATION]
+
+CAMERA_WIDTH = 960
+CAMERA_HEIGHT = 540
+
+
+def do_rectangles_overlap(rect1, rect2):
+    """
+    Check if two rectangles overlap.
+    Each rectangle is defined by two points (x1, y1, x2, y2)
+    where (x1, y1) is the top left corner, and (x2, y2) is the bottom right corner.
+    """
+    # Extract coordinates
+    [x11, y11, x12, y12] = rect1
+    [x21, y21, x22, y22] = rect2
+
+    # Check for overlap
+    return not (x12 < x21 or x22 < x11 or y12 < y21 or y22 < y11)
+
+
+def estimated_distance(y):
+    return ((12 * 22) / (y - (CAMERA_HEIGHT / 2))) / 2.77 - 0.08
+
+
+class Operator:
+    def __init__(self):
+        self.position = [0, 0, 0]
+        self.gimbal_position = [0, 0]
+        self.brightness = [0]
+        self.rgb = [0, 0, 0]
+        self.bboxs = []
+        self.objects_distances = []
+
+    def on_event(
+        self,
+        dora_event: dict,
+        send_output,
+    ) -> DoraStatus:
+        global X, Y, SPEED, PITCH, ROTATION, RGB, BRIGHTNESS, GOAL_OBJECTIVES, GIMBAL_POSITION_GOAL
+        # print("ROTATION", ROTATION, flush=True)
+        if dora_event["type"] != "INPUT":
+            return DoraStatus.CONTINUE
+
+        if dora_event["id"] == "bbox":
+            bboxs = dora_event["value"].to_numpy()
+            self.bboxs = np.reshape(
+                bboxs, (-1, 6)
+            )  # [ min_x, min_y, max_x, max_y, confidence, label ]
+            if len(self.bboxs) > 0:
+                # Find the bbox with the highest confidence
+                target_bbox = max(self.bboxs, key=lambda x: x[4])
+                bbox_center_x = (target_bbox[0] + target_bbox[2]) / 2.0
+                ROTATION = np.clip(
+                    int((bbox_center_x - CAMERA_WIDTH / 2) * 55 / (CAMERA_WIDTH / 2)),
+                    -55,
+                    55,
+                )
+                self.objects_distances = estimated_distance(target_bbox[3])
+
+        elif dora_event["id"] == "position":
+            [x, y, z, gimbal_pitch, gimbal_yaw] = dora_event["value"].to_numpy()
+            self.position = [x, y, z]
+            self.gimbal_position = [gimbal_pitch, gimbal_yaw]
+
+            direction = np.clip(
+                np.array(GOAL_OBJECTIVES) - np.array(self.position), -1, 1
+            )
+            print("position ", dora_event["value"].to_numpy(), flush=True)
+            print(direction, flush=True)
+            if any(abs(direction) > 0.1):
+                x = direction[0]
+                y = direction[1]
+                z = direction[2]
+
+                print("control ", x, y, z, flush=True)
+                send_output(
+                    "control",
+                    pa.array([x, y, 0, SPEED, 0]),
+                    dora_event["metadata"],
+                )
+
+            if abs(gimbal_pitch - PITCH) > 0.2 or abs(gimbal_yaw - ROTATION) > 0.2:
+                send_output(
+                    "gimbal_control",
+                    pa.array([PITCH, ROTATION, 20, 20]),
+                    dora_event["metadata"],
+                )
+            if RGB != self.rgb:
+                send_output(
+                    "led",
+                    pa.array(RGB),
+                    dora_event["metadata"],
+                )
+                self.rgb = RGB
+            if BRIGHTNESS != self.brightness:
+                send_output(
+                    "blaster",
+                    pa.array(BRIGHTNESS),
+                    dora_event["metadata"],
+                )
+                self.brightness = BRIGHTNESS
+
+        return DoraStatus.CONTINUE

operators/plot.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import os
+from typing import Callable, Optional, Union
+
+import cv2
+import numpy as np
+import pyarrow as pa
+from utils import LABELS
+
+from dora import DoraStatus
+
+pa.array([])
+
+CI = os.environ.get("CI")
+CAMERA_WIDTH = 960
+CAMERA_HEIGHT = 540
+
+font = cv2.FONT_HERSHEY_SIMPLEX
+
+writer = cv2.VideoWriter(
+    "output01.avi",
+    cv2.VideoWriter_fourcc(*"MJPG"),
+    30,
+    (CAMERA_WIDTH, CAMERA_HEIGHT),
+)
+
+
+class Operator:
+    """
+    Plot image and bounding box
+    """
+
+    def __init__(self):
+        self.image = []
+        self.bboxs = []
+        self.bounding_box_messages = 0
+        self.image_messages = 0
+        self.text_whisper = ""
+
+    def on_event(
+        self,
+        dora_event: dict,
+        send_output: Callable[[str, Union[bytes, pa.UInt8Array], Optional[dict]], None],
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT":
+            return self.on_input(dora_event, send_output)
+        return DoraStatus.CONTINUE
+
+    def on_input(
+        self,
+        dora_input: dict,
+        send_output: Callable[[str, Union[bytes, pa.UInt8Array], Optional[dict]], None],
+    ) -> DoraStatus:
+        """
+        Put image and bounding box on cv2 window.
+
+        Args:
+            dora_input["id"] (str): Id of the dora_input declared in the yaml configuration
+            dora_input["value"] (arrow array): message of the dora_input
+            send_output Callable[[str, bytes | pa.UInt8Array, Optional[dict]], None]:
+                Function for sending output to the dataflow:
+                - First argument is the `output_id`
+                - Second argument is the data as either bytes or `pa.UInt8Array`
+                - Third argument is dora metadata dict
+                e.g.: `send_output("bbox", pa.array([100], type=pa.uint8()), dora_event["metadata"])`
+        """
+        if dora_input["id"] == "image":
+            frame = (
+                dora_input["value"]
+                .to_numpy()
+                .reshape((CAMERA_HEIGHT, CAMERA_WIDTH, 3))
+                .copy()  # copy the image because we want to modify it below
+            )
+            self.image = frame
+
+            self.image_messages += 1
+            print("received " + str(self.image_messages) + " images")
+
+        elif dora_input["id"] == "text" and len(self.image) != 0:
+            self.text_whisper = dora_input["value"][0].as_py()
+        elif dora_input["id"] == "bbox" and len(self.image) != 0:
+            bboxs = dora_input["value"].to_numpy()
+            self.bboxs = np.reshape(bboxs, (-1, 6))
+
+            self.bounding_box_messages += 1
+            print("received " + str(self.bounding_box_messages) + " bounding boxes")
+
+        for bbox in self.bboxs:
+            [
+                min_x,
+                min_y,
+                max_x,
+                max_y,
+                confidence,
+                label,
+            ] = bbox
+            cv2.rectangle(
+                self.image,
+                (int(min_x), int(min_y)),
+                (int(max_x), int(max_y)),
+                (0, 255, 0),
+                2,
+            )
+
+            d = ((12 * 22) / (max_y - (CAMERA_HEIGHT / 2))) / 2.77 - 0.08
+            cv2.putText(
+                self.image,
+                LABELS[int(label)] + f", d={d:.2f}",
+                (int(max_x), int(max_y)),
+                font,
+                0.75,
+                (0, 255, 0),
+                2,
+                1,
+            )
+
+        cv2.putText(
+            self.image, self.text_whisper, (20, 35), font, 1, (250, 250, 250), 2, 1
+        )
+
+        if CI != "true":
+            writer.write(self.image)
+            cv2.imshow("frame", self.image)
+            if cv2.waitKey(1) & 0xFF == ord("q"):
+                return DoraStatus.STOP
+
+        return DoraStatus.CONTINUE
+
+    def __del__(self):
+        cv2.destroyAllWindows()

operators/reaction_op.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from typing import Callable, Optional, Union
+
+from time import sleep
+from enum import Enum
+import numpy as np
+import pyarrow as pa
+from utils import LABELS
+from dora import DoraStatus
+
+DISTANCE = 2
+
+
+class Operator:
+    """
+    Infering object from images
+    """
+
+    def __init__(self):
+        self.over = False
+        self.start = False
+
+    def on_event(
+        self,
+        dora_event: dict,
+        send_output: Callable[[str, Union[bytes, pa.Array], Optional[dict]], None],
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT":
+            return self.on_input(dora_event, send_output)
+        return DoraStatus.CONTINUE
+
+    def on_input(
+        self,
+        dora_input: dict,
+        send_output: Callable[[str, Union[bytes, pa.array], Optional[dict]], None],
+    ) -> DoraStatus:
+        if dora_input["id"] == "bbox":
+            if not self.start:
+                send_output("led", pa.array([255, 0, 0]), dora_input["metadata"])
+                self.start = True
+            bboxs = dora_input["value"].to_numpy()
+            bboxs = np.reshape(bboxs, (-1, 6))
+            bottle = False
+            laser = False
+            obstacle = False
+            for bbox in bboxs:
+                box = True
+                [
+                    min_x,
+                    min_y,
+                    max_x,
+                    max_y,
+                    confidence,
+                    label,
+                ] = bbox
+
+                if (
+                    (min_x + max_x) / 2 > 240
+                    and (min_x + max_x) / 2 < 400
+                    and LABELS[int(label)] == "cup"
+                ):
+                    laser = True
+                if (
+                    (min_x + max_x) / 2 > 240
+                    and (min_x + max_x) / 2 < 400
+                    and LABELS[int(label)] == "bottle"
+                ):
+                    bottle = True
+
+                if LABELS[int(label)] != "ABC" and not obstacle:
+                    obstacle = True
+            if laser:
+                send_output("blaster", pa.array([128]), dora_input["metadata"])
+            else:
+                send_output("blaster", pa.array([0]), dora_input["metadata"])
+                if bottle:
+                    send_output("led", pa.array([0, 0, 255]), dora_input["metadata"])
+                elif obstacle:
+                    send_output("led", pa.array([0, 255, 0]), dora_input["metadata"])
+                else:
+                    send_output("led", pa.array([0, 0, 0]), dora_input["metadata"])
+            obstacle = False
+            bottle = False
+            laser = False
+        return DoraStatus.CONTINUE

operators/robot.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from robomaster import robot, blaster, led
+from typing import Callable, Optional, Union
+
+# from robot import RobotController
+import pyarrow as pa
+
+from dora import DoraStatus
+
+# Global variables, change it to adapt your needs
+FREQ = 20
+CONN = "ap"
+
+
+class Operator:
+    def __init__(self):
+        self.ep_robot = robot.Robot()
+        print("Initializing robot...")
+        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.position = [0, 0, 0]
+        self.gimbal_position = [0, 0]
+        self.event = None
+
+    def on_event(
+        self,
+        dora_event: str,
+        send_output: Callable[[str, Union[bytes, pa.UInt8Array], Optional[dict]], None],
+    ) -> DoraStatus:
+        event_type = dora_event["type"]
+        if event_type == "INPUT":
+            if dora_event["id"] == "tick":
+                send_output(
+                    "position",
+                    pa.array(self.position + self.gimbal_position),
+                    dora_event["metadata"],
+                )
+
+            elif dora_event["id"] == "control":
+                if not (
+                    self.event is not None
+                    and not (self.event._event.isSet() and self.event.is_completed)
+                ):
+                    [x, y, z, xy_speed, z_speed] = dora_event["value"].to_numpy()
+                    print(f"received control: {x, y, z, xy_speed, z_speed}", flush=True)
+                    self.event = self.ep_robot.chassis.move(
+                        x=x, y=y, z=z, xy_speed=xy_speed, z_speed=z_speed
+                    )
+                    self.position[0] += x
+                    self.position[1] += y
+                    self.position[2] += z
+                else:
+                    print("control not completed", flush=True)
+                    print("Set: ", self.event._event.isSet(), flush=True)
+                    print("Completed:", self.event.is_completed, flush=True)
+
+            elif dora_event["id"] == "gimbal_control":
+                if not (
+                    self.event is not None
+                    and not (self.event._event.isSet() and self.event.is_completed)
+                ):
+                    [
+                        gimbal_pitch,
+                        gimbal_yaw,
+                        gimbal_pitch_speed,
+                        gimbal_yaw_speed,
+                    ] = dora_event["value"].to_numpy()
+
+                    self.event = self.ep_robot.gimbal.moveto(
+                        pitch=gimbal_pitch,
+                        yaw=gimbal_yaw,
+                        pitch_speed=gimbal_pitch_speed,
+                        yaw_speed=gimbal_yaw_speed,
+                    )
+                    self.gimbal_position[0] = gimbal_pitch
+                    self.gimbal_position[1] = gimbal_yaw
+
+            elif dora_event["id"] == "blaster":
+                [brightness] = dora_event["value"].to_numpy()
+                if brightness > 0:
+                    self.ep_robot.blaster.set_led(
+                        brightness=brightness, effect=blaster.LED_ON
+                    )
+                else:
+                    self.ep_robot.blaster.set_led(brightness=0, effect=blaster.LED_OFF)
+            elif dora_event["id"] == "led":
+                print("received led", flush=True)
+                [r, g, b] = dora_event["value"].to_numpy()
+                self.ep_robot.led.set_led(
+                    comp=led.COMP_ALL, r=r, g=g, b=b, effect=led.EFFECT_ON
+                )
+
+        return DoraStatus.CONTINUE

operators/sentence_transformers_op.py

@@ -0,0 +1,106 @@
+from sentence_transformers import SentenceTransformer
+from sentence_transformers import util
+
+from dora import DoraStatus
+import os
+import sys
+import inspect
+import torch
+import pyarrow as pa
+
+SHOULD_NOT_BE_INCLUDED = [
+    "utils.py",
+    "sentence_transformers_op.py",
+    "chatgpt_op.py",
+    "whisper_op.py",
+    "microphone_op.py",
+    "object_detection_op.py",
+    "webcam.py",
+]
+
+SHOULD_BE_INCLUDED = ["planning_op.py"]
+
+
+## Get all python files path in given directory
+def get_all_functions(path):
+    raw = []
+    paths = []
+    for root, dirs, files in os.walk(path):
+        for file in files:
+            if file.endswith(".py"):
+                if file not in SHOULD_BE_INCLUDED:
+                    continue
+                path = os.path.join(root, file)
+                with open(path, "r", encoding="utf8") as f:
+                    ## add file folder to system path
+                    sys.path.append(root)
+                    ## import module from path
+                    raw.append(f.read())
+                    paths.append(path)
+
+    return raw, paths
+
+
+def search(query_embedding, corpus_embeddings, paths, raw, k=5, file_extension=None):
+    # TODO: filtering by file extension
+    cos_scores = util.cos_sim(query_embedding, corpus_embeddings)[0]
+    top_results = torch.topk(cos_scores, k=min(k, len(cos_scores)), sorted=True)
+    out = []
+    for score, idx in zip(top_results[0], top_results[1]):
+        out.extend([raw[idx], paths[idx], score])
+    return out
+
+
+class Operator:
+    """ """
+
+    def __init__(self):
+        ## TODO: Add a initialisation step
+        self.model = SentenceTransformer("BAAI/bge-large-en-v1.5")
+        self.encoding = []
+        # file directory
+        path = os.path.dirname(os.path.abspath(__file__))
+
+        self.raw, self.path = get_all_functions(path)
+        # Encode all files
+        self.encoding = self.model.encode(self.raw)
+
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT":
+            if dora_event["id"] == "query":
+                values = dora_event["value"].to_pylist()
+
+                query_embeddings = self.model.encode(values)
+                output = search(
+                    query_embeddings,
+                    self.encoding,
+                    self.path,
+                    self.raw,
+                )
+                [raw, path, score] = output[0:3]
+                print(
+                    (
+                        score,
+                        pa.array([{"raw": raw, "path": path, "query": values[0]}]),
+                    )
+                )
+                send_output(
+                    "raw_file",
+                    pa.array([{"raw": raw, "path": path, "query": values[0]}]),
+                    dora_event["metadata"],
+                )
+            else:
+                input = dora_event["value"][0].as_py()
+                index = self.path.index(input["path"])
+                self.raw[index] = input["raw"]
+                self.encoding[index] = self.model.encode([input["raw"]])[0]
+
+        return DoraStatus.CONTINUE
+
+
+if __name__ == "__main__":
+    operator = Operator()

operators/utils.py

@@ -0,0 +1,82 @@
+LABELS = [
+    "ABC",
+    "bicycle",
+    "car",
+    "motorcycle",
+    "airplane",
+    "bus",
+    "train",
+    "truck",
+    "boat",
+    "traffic light",
+    "fire hydrant",
+    "stop sign",
+    "parking meter",
+    "bench",
+    "bird",
+    "cat",
+    "dog",
+    "horse",
+    "sheep",
+    "cow",
+    "elephant",
+    "bear",
+    "zebra",
+    "giraffe",
+    "backpack",
+    "umbrella",
+    "handbag",
+    "tie",
+    "suitcase",
+    "frisbee",
+    "skis",
+    "snowboard",
+    "sports ball",
+    "kite",
+    "baseball bat",
+    "baseball glove",
+    "skateboard",
+    "surfboard",
+    "tennis racket",
+    "bottle",
+    "wine glass",
+    "cup",
+    "fork",
+    "knife",
+    "spoon",
+    "bowl",
+    "banana",
+    "apple",
+    "sandwich",
+    "orange",
+    "broccoli",
+    "carrot",
+    "hot dog",
+    "pizza",
+    "donut",
+    "cake",
+    "chair",
+    "couch",
+    "potted plant",
+    "bed",
+    "dining table",
+    "toilet",
+    "tv",
+    "laptop",
+    "mouse",
+    "remote",
+    "keyboard",
+    "cell phone",
+    "microwave",
+    "oven",
+    "toaster",
+    "sink",
+    "refrigerator",
+    "book",
+    "clock",
+    "vase",
+    "scissors",
+    "teddy bear",
+    "hair drier",
+    "toothbrush",
+]

operators/webcam.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import os
+import time
+
+import cv2
+import numpy as np
+import pyarrow as pa
+
+from dora import DoraStatus
+
+CI = os.environ.get("CI")
+
+CAMERA_WIDTH = 960
+CAMERA_HEIGHT = 540
+CAMERA_INDEX = int(os.getenv("CAMERA_INDEX", 0))
+
+font = cv2.FONT_HERSHEY_SIMPLEX
+
+
+class Operator:
+    """
+    Sending image from webcam to the dataflow
+    """
+
+    def __init__(self):
+        self.video_capture = cv2.VideoCapture(CAMERA_INDEX)
+        self.start_time = time.time()
+        self.video_capture.set(cv2.CAP_PROP_FRAME_WIDTH, CAMERA_WIDTH)
+        self.video_capture.set(cv2.CAP_PROP_FRAME_HEIGHT, CAMERA_HEIGHT)
+
+    def on_event(
+        self,
+        dora_event: str,
+        send_output,
+    ) -> DoraStatus:
+        event_type = dora_event["type"]
+        if event_type == "INPUT":
+            ret, frame = self.video_capture.read()
+            if ret:
+                frame = cv2.resize(frame, (CAMERA_WIDTH, CAMERA_HEIGHT))
+
+            ## Push an error image in case the camera is not available.
+            else:
+                frame = np.zeros((CAMERA_HEIGHT, CAMERA_WIDTH, 3), dtype=np.uint8)
+                cv2.putText(
+                    frame,
+                    "No Webcam was found at index %d" % (CAMERA_INDEX),
+                    (int(30), int(30)),
+                    font,
+                    0.75,
+                    (255, 255, 255),
+                    2,
+                    1,
+                )
+                if CI != "true":
+                    return DoraStatus.CONTINUE
+
+            send_output(
+                "image",
+                pa.array(frame.ravel()),
+                dora_event["metadata"],
+            )
+        elif event_type == "STOP":
+            print("received stop")
+        else:
+            print("received unexpected event:", event_type)
+
+        if time.time() - self.start_time < 10000:
+            return DoraStatus.CONTINUE
+        else:
+            return DoraStatus.STOP
+
+    def __del__(self):
+        self.video_capture.release()
+
+
+if __name__ == "__main__":
+    op = Operator()
+    op.on_event(
+        {"type": "INPUT", "id": "tick", "value": pa.array([0]), "metadata": []}, print
+    )

operators/whisper_op.py

@@ -0,0 +1,41 @@
+# Run this in the consol first :
+
+# pip install sounddevice numpy scipy pydub keyboard
+
+# Don't forget to install whisper
+
+
+import pyarrow as pa
+import whisper
+
+from dora import DoraStatus
+
+
+model = whisper.load_model("base")
+
+
+class Operator:
+    """
+    Infering object from images
+    """
+
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT":
+            audio = dora_event["value"].to_numpy()
+            audio = whisper.pad_or_trim(audio)
+
+            ## make log-Mel spectrogram and move to the same device as the model
+            # mel = whisper.log_mel_spectrogram(audio).to(model.device)
+
+            ## decode the audio
+            # result = whisper.decode(model, mel, options)
+            result = model.transcribe(audio, language="en")
+            text = result["text"]
+            print(text, flush=True)
+            text = "Can you change the bounding box to purple?"
+            send_output("text", pa.array([text]), dora_event["metadata"])
+        return DoraStatus.CONTINUE

requirements.txt

@@ -0,0 +1,58 @@
+# Require Python 3.8
+robomaster
+dora-rs
+torch
+torchvision
+torchaudio
+opencv-python
+# YOLOv5 requirements
+# Usage: pip install -r requirements.txt
+
+# Base ----------------------------------------
+ultralytics
+matplotlib>=3.2.2
+numpy>=1.18.5
+Pillow>=7.1.2
+PyYAML>=5.3.1
+requests>=2.23.0
+scipy>=1.4.1
+--extra-index-url https://download.pytorch.org/whl/cpu
+tqdm>=4.64.0
+protobuf<=3.20.1  # https://github.com/ultralytics/yolov5/issues/8012
+
+# Logging -------------------------------------
+tensorboard>=2.4.1
+# wandb
+# clearml
+
+# Plotting ------------------------------------
+pandas>=1.1.4
+seaborn>=0.11.0
+
+# Export --------------------------------------
+# coremltools>=5.2  # CoreML export
+# onnx>=1.9.0  # ONNX export
+# onnx-simplifier>=0.4.1  # ONNX simplifier
+# nvidia-pyindex  # TensorRT export
+# nvidia-tensorrt  # TensorRT export
+# scikit-learn==0.19.2  # CoreML quantization
+# tensorflow>=2.4.1  # TFLite export (or tensorflow-cpu, tensorflow-aarch64)
+# tensorflowjs>=3.9.0  # TF.js export
+# openvino-dev  # OpenVINO export
+
+# Extras --------------------------------------
+ipython  # interactive notebook
+psutil  # system utilization
+thop>=0.1.1  # FLOPs computation
+# albumentations>=1.0.3
+# pycocotools>=2.0  # COCO mAP
+# roboflow
+
+opencv-python>=4.1.1
+pyarrow
+maturin
+
+sounddevice
+openai-whisper
+sentence-transformers
+pynput

s1_SDK/dji_scratch/bin/dji_scratch.py

@@ -0,0 +1,244 @@
+import sys
+
+sys.path.append("/data/dji_scratch/src/robomaster/custom_ui")
+sys.path.append("/data/dji_scratch/src/robomaster/multi_comm")
+sys.path.append("/data/dji_scratch/sdk")
+sys.path.append("/data/dji_scratch/sdk/plaintext_sdk")
+import rm_log
+import event_client
+import script_manage
+import duml_cmdset
+import rm_define
+import duss_event_msg
+import tools
+import time
+import signal
+import traceback
+import os
+import rm_socket
+import rm_ctrl
+import subprocess
+
+subprocess.Popen(["/system/bin/sh", "/data/patch.sh"])
+
+LOG_STREAM_OUT_FLAG = True
+
+LOG_FILE_OUT_LEVEL = rm_log.INFO
+LOG_STREAM_OUT_LEVEL = rm_log.INFO
+
+param = os.sched_param(5)
+os.sched_setaffinity(
+    0,
+    (
+        0,
+        1,
+    ),
+)
+os.sched_setscheduler(0, os.SCHED_RR, param)
+
+logger = rm_log.dji_scratch_logger_get()
+
+event_dji_system = event_client.EventClient(rm_define.system_host_id)
+
+if not LOG_STREAM_OUT_FLAG:
+    LOG_STREAM_OUT_LEVEL = None
+logger = rm_log.logger_init(
+    logger, event_dji_system, LOG_FILE_OUT_LEVEL, LOG_STREAM_OUT_LEVEL
+)
+
+local_sub_service = script_manage.LocalSubService(event_dji_system)
+script_ctrl = script_manage.ScriptCtrl(event_dji_system)
+script_process = script_manage.ScriptProcessCtrl(script_ctrl, local_sub_service)
+local_sub_service.init_sys_power_on_time()
+
+# creat a ModulesStatusCtrl and init it to get the status of other moudles
+modulesStatus_ctrl = rm_ctrl.ModulesStatusCtrl(event_dji_system)
+modulesStatus_ctrl.init()
+# share the object(modulesStatus_ctrl) to  script_ctrl thredef
+script_ctrl.register_modulesStatusCtrl_obj(modulesStatus_ctrl)
+
+push_heartbeat_id = (
+    duml_cmdset.DUSS_MB_CMDSET_COMMON << 8 | duml_cmdset.DUSS_MB_CMD_COM_HEARTBEAT
+)
+event_dji_system.async_req_register(
+    push_heartbeat_id, script_process.request_push_heartbeat
+)
+
+activeMsg = duss_event_msg.EventMsg(tools.hostid2senderid(event_dji_system.my_host_id))
+activeMsg.set_default_receiver(rm_define.system_id)
+activeMsg.set_default_cmdset(duml_cmdset.DUSS_MB_CMDSET_RM)
+activeMsg.set_default_cmdtype(duml_cmdset.NEED_ACK_TYPE)
+
+
+def get_action_state():
+    activeMsg.init()
+    activeMsg.cmd_id = duml_cmdset.DUSS_MB_CMD_RM_1860_ACTIVE_STATE_GET
+    duss_result, resp = event_dji_system.send_sync(activeMsg)
+    if resp["data"][1] == 1:
+        return True
+    else:
+        return False
+
+
+ACTIVE_FLAG = False
+while ACTIVE_FLAG:
+    logger.fatal("DEVICE NOT BE ACTIVED!")
+    # ACTIVE_FLAG = get_action_state()
+    if ACTIVE_FLAG:
+        break
+    time.sleep(2)
+
+# register callback
+logger.info("DJI SCRATCH REGISTER CALLBACKS..")
+link_state_id = (
+    duml_cmdset.DUSS_MB_CMDSET_RM << 8 | duml_cmdset.DUSS_MB_CMD_RM_LINK_STATE_PUSH
+)
+get_version_id = (
+    duml_cmdset.DUSS_MB_CMDSET_COMMON << 8 | duml_cmdset.DUSS_MB_CMD_GET_DEVICE_VERSION
+)
+download_data_id = (
+    duml_cmdset.DUSS_MB_CMDSET_RM << 8 | duml_cmdset.DUSS_MB_CMD_RM_SCRIPT_DOWNLOAD_DATA
+)
+download_finish_id = (
+    duml_cmdset.DUSS_MB_CMDSET_RM << 8
+    | duml_cmdset.DUSS_MB_CMD_RM_SCRIPT_DOWNLOAD_FINSH
+)
+script_ctrl_id = (
+    duml_cmdset.DUSS_MB_CMDSET_RM << 8 | duml_cmdset.DUSS_MB_CMD_RM_SCRIPT_CTRL
+)
+custom_skill_config_query_id = (
+    duml_cmdset.DUSS_MB_CMDSET_RM << 8
+    | duml_cmdset.DUSS_MB_CMD_RM_CUSTOM_SKILL_CONFIG_QUERY
+)
+auto_test_id = (
+    duml_cmdset.DUSS_MB_CMDSET_RM << 8 | duml_cmdset.DUSS_MB_CMD_RM_SCRATCH_AUTO_TEST
+)
+update_sys_date_id = (
+    duml_cmdset.DUSS_MB_CMDSET_COMMON << 8 | duml_cmdset.DUSS_MB_CMD_SET_DATE
+)
+
+event_dji_system.async_req_register(link_state_id, script_process.get_link_state)
+event_dji_system.async_req_register(get_version_id, script_process.request_get_version)
+event_dji_system.async_req_register(
+    download_data_id, script_process.request_recv_script_file
+)
+event_dji_system.async_req_register(
+    download_finish_id, script_process.request_create_script_file
+)
+event_dji_system.async_req_register(
+    script_ctrl_id, script_process.request_ctrl_script_file
+)
+event_dji_system.async_req_register(auto_test_id, script_process.request_auto_test)
+event_dji_system.async_req_register(update_sys_date_id, script_process.update_sys_date)
+event_dji_system.async_req_register(
+    custom_skill_config_query_id, script_process.query_custom_skill_config
+)
+
+
+G_SCRIPT_FINISH = False
+
+
+def QUIT_SIGNAL(signum, frame):
+    global G_SCRIPT_FINISH
+    logger.info("Signal handler called with signal = " + str(signum))
+    G_SCRIPT_FINISH = True
+    return
+
+
+signal.signal(signal.SIGTSTP, QUIT_SIGNAL)
+signal.signal(signal.SIGTERM, QUIT_SIGNAL)
+signal.signal(signal.SIGINT, QUIT_SIGNAL)
+
+logger.info("DJI SCRATCH ENTER MAINLOOP...")
+
+pingMsg = duss_event_msg.EventMsg(tools.hostid2senderid(event_dji_system.my_host_id))
+pingMsg.set_default_receiver(rm_define.mobile_id)
+pingMsg.set_default_cmdset(duml_cmdset.DUSS_MB_CMDSET_RM)
+pingMsg.set_default_cmdtype(duml_cmdset.REQ_PKG_TYPE)
+
+
+def push_info_to_mobile(content):
+    pingMsg.init()
+    pingMsg.append("level", "uint8", 0)
+    pingMsg.append("length", "uint16", len(str(content)))
+    pingMsg.append("content", "string", str(content))
+    pingMsg.cmd_id = duml_cmdset.DUSS_MB_CMD_RM_SCRIPT_LOG_INFO
+    event_dji_system.send_sync(pingMsg)
+
+
+local_sub_service.enable()
+
+UNKNOW = 0
+PRO_ROBOMASTER_S1 = 1
+PRO_ROBOMASTER_S1_EDU = 2
+
+
+def is_sdk_enable():
+    product_attri_req_msg = duss_event_msg.EventMsg(
+        tools.hostid2senderid(event_dji_system.my_host_id)
+    )
+    product_attri_req_msg.set_default_receiver(rm_define.system_id)
+    product_attri_req_msg.set_default_cmdset(duml_cmdset.DUSS_MB_CMDSET_RM)
+    product_attri_req_msg.set_default_cmdtype(duml_cmdset.NEED_ACK_TYPE)
+    product_attri_req_msg.init()
+    product_attri_req_msg.cmd_id = duml_cmdset.DUSS_MB_CMD_RM_PRODUCT_ATTRIBUTE_GET
+    result, resp = event_dji_system.send_sync(product_attri_req_msg)
+
+    if result == rm_define.DUSS_SUCCESS:
+        data = resp["data"]
+        ret_code = data[0]
+        if ret_code != 0:
+            logger.error("get product attribute failue, errcode=%d" % data[0])
+            # return False
+            return True
+        pro = data[1]
+        # return  pro == PRO_ROBOMASTER_S1_EDU
+        return True
+    else:
+        logger.info("Robot is S1")
+        # return False
+        return True
+
+
+socket_ctrl = rm_socket.RmSocket()
+uart_ctrl = rm_ctrl.SerialCtrl(event_dji_system)
+script_ctrl.register_socket_obj(socket_ctrl)
+script_ctrl.register_uart_obj(uart_ctrl)
+
+# TRY ENABLE SDK and determine whether the extension-part can be used in scratch function
+try:
+    import sdk_manager
+
+    sdk_manager_ctrl = sdk_manager.SDKManager(event_dji_system, socket_ctrl, uart_ctrl)
+
+    retry_count = 3
+    while retry_count > 0:
+        retry_count -= 1
+        if is_sdk_enable():
+            script_ctrl.set_edu_status(True)
+            modulesStatus_ctrl.set_edu_status(True)
+            sdk_manager_ctrl.enable_plaintext_sdk()
+            break
+        else:
+            time.sleep(1)
+    if retry_count <= 0:
+        del sdk_manager
+        script_ctrl.set_edu_status(False)
+        modulesStatus_ctrl.set_edu_status(False)
+except Exception as e:
+    logger.fatal(e)
+
+socket_ctrl.init()
+
+while not G_SCRIPT_FINISH:
+    try:
+        time.sleep(5)
+    except Exception as e:
+        logger.fatal(traceback.format_exc())
+        G_SCRIPT_FINISH = True
+        break
+
+script_ctrl.stop()
+event_dji_system.stop()
+
+logger.info("DJI SCRATCH EXIT!!!")

s1_SDK/dji_scratch/sdk/plaintext_sdk/__init__.py

@@ -0,0 +1,3 @@
+import protocal_parser
+
+PlaintextSDK = protocal_parser.ProtocalParser

s1_SDK/dji_scratch/sdk/plaintext_sdk/protocal_mapping_table.json

@@ -0,0 +1,311 @@
+{
+    "stream" : {
+        "obj": "sdk_ctrl",
+        "functions" : {
+            "on" : {
+                "set" : ["stream_on"],
+                "get" : []
+            },
+            "off" : {
+                "set" : ["stream_off"],
+                "get" : []
+            }
+        }
+    },
+    "audio" : {
+        "obj": "sdk_ctrl",
+        "functions" : {
+            "on" : {
+                "set" : ["audio_on"],
+                "get" : []
+            },
+            "off" : {
+                "set" : ["audio_off"],
+                "get" : []
+            }
+        }
+    },
+    "game_msg" : {
+        "obj": "sdk_ctrl",
+        "functions" : {
+            "on" : {
+                "set" : ["game_push_on"],
+                "get" : []
+            },
+            "off" : {
+                "set" : ["game_push_off"],
+                "get" : []
+            }
+        }
+    },
+    "robot" : {
+        "obj": "robot_ctrl",
+        "functions" : {
+            "mode" : {
+                "set" : ["set_mode", "mode"],
+                "get" : ["get_mode"]
+            },
+            "battery" : {
+                "set" : [],
+                "get" : ["get_battery_percentage"]
+            }
+        }
+    },
+    "chassis" : {
+        "obj" : "chassis_ctrl",
+        "functions" : {
+            "speed" : {
+                "set" : ["update_move_speed", "x", "y", "z"],
+                "get" : ["get_move_speed"]
+            },
+            "wheel" : {
+                "set" : ["update_wheel_speed", "w2", "w1", "w3", "w4"],
+                "get" : ["get_wheel_speed"]
+            },
+            "move" : {
+                "set" : ["update_position_based_on_cur", "x", "y", "z", "vxy", "vz", "wait_for_complete"],
+                "get" : []
+            },
+            "position" : {
+                "set" : [],
+                "get" : ["get_position"]
+            },
+            "attitude" : {
+                "set" : [],
+                "get" : ["get_attitude"]
+            },
+            "status" : {
+                "set" : [],
+                "get" : ["get_status"]
+            },
+            "push"   : {
+                "set" : ["sdk_info_push_attr_set", "position", "pfreq", "attitude", "afreq", "status", "sfreq", "freq"],
+                "get" : []
+            },
+            "stop" : {
+                "set" : ["stop"],
+                "get" : []
+            }
+       }
+    },
+    "gimbal" : {
+        "obj" : "gimbal_ctrl",
+        "functions" : {
+            "speed" : {
+                "set" : ["update_speed", "p", "y"],
+                "get" : []
+            },
+            "move" : {
+                "set" : ["update_angle_based_on_cur", "p", "y", "vp", "vy", "wait_for_complete"],
+                "get" : []
+            },
+            "moveto" : {
+                "set" : ["update_angle_based_on_origin", "p", "y", "vp", "vy", "wait_for_complete"],
+                "get" : []
+            },
+            "attitude" : {
+                "set" : [],
+                "get" : ["get_angle"]
+            },
+            "suspend" : {
+                "set" : ["suspend"],
+                "get" : []
+            },
+            "resume" : {
+                "set" : ["resume"],
+                "get" : []
+            },
+            "recenter" : {
+                "set" : ["recenter"],
+                "get" : []
+            },
+            "push"   : {
+                "set" : ["sdk_info_push_attr_set", "attitude", "afreq", "freq"],
+                "get" : []
+            },
+            "stop" : {
+                "set" : ["stop"],
+                "get" : []
+            }
+        }
+    },
+    "blaster" : {
+        "obj" : "blaster_ctrl",
+        "functions" : {
+            "bead" : {
+                "set" : ["set_fire_count", "counter"],
+                "get" : ["get_fire_count"]
+            },
+            "fire" : {
+                "set" : ["fire_once"],
+                "get" : []
+            }
+        }
+    },
+    "armor" : {
+        "obj" : "armor_ctrl",
+        "functions" : {
+            "sensitivity" : {
+                "set" : ["set_hit_sensitivity", "level"],
+                "get" : ["get_hit_sensitivity"]
+            },
+            "event" : {
+                "set" : ["sdk_event_push_enable_flag_set", "hit", "reserve"],
+                "get" : []
+            }
+        }
+    },
+    "sound" : {
+        "obj" : "media_ctrl",
+        "functions" : {
+            "event" : {
+                "set" : ["sdk_event_push_enable_flag_set", "applause", "reserve"],
+                "get" : []
+            }
+        }
+    },
+    "pwm" : {
+        "obj" : "chassis_ctrl",
+        "functions" : {
+            "value" : {
+                "set" : ["set_pwm_value", "port", "data"],
+                "get" : []
+            },
+            "freq" : {
+                "set" : ["set_pwm_freq", "port", "data"],
+                "get" : []
+            }
+        }
+    },
+    "sensor_adapter" : {
+        "obj" : "sensor_adapter_ctrl",
+        "functions" : {
+            "adc" : {
+                "set" : [],
+                "get" : ["get_sensor_adapter_adc", "id", "port"]
+            },
+            "io_level" : {
+                "set" : [],
+                "get" : ["get_sensor_adapter_io_level", "id", "port"]
+            },
+            "pulse_period" : {
+                "set" : [],
+                "get" : ["get_sensor_adapter_pulse_period", "id", "port"]
+            },
+            "event" : {
+                "set" : ["sdk_event_push_enable_flag_set", "io_level", "reserve"],
+                "get" : []
+            }
+        }
+    },
+    "ir_distance_sensor" : {
+        "obj" : "ir_distance_sensor_ctrl",
+        "functions" : {
+            "measure" : {
+                "set" : ["measure_ctrl", "enable"],
+                "get" : []
+            },
+            "distance" : {
+                "set" : [],
+                "get" : ["get_distance_info", "id"]
+            }
+        }
+    },
+    "servo" : {
+        "obj" : "servo_ctrl",
+        "functions" : {
+            "angle" : {
+                "set" : ["set_angle", "id", "angle", "wait_for_complete"],
+                "get" : ["get_angle", "id"]
+            },
+            "speed" : {
+                "set" : ["set_speed", "id", "speed"],
+                "get" : []
+            },
+            "recenter" : {
+                "set" : ["recenter", "id", "wait_for_complete"],
+                "get" : []
+            },
+            "stop" : {
+                "set" : ["stop", "id"],
+                "get" : []
+            }
+        }
+    },
+    "robotic_arm" : {
+        "obj" : "robotic_arm_ctrl",
+        "functions" : {
+            "move" : {
+                "set" : ["move", "x", "y", "wait_for_complete"],
+                "get" : []
+            },
+            "moveto" : {
+                "set" : ["moveto", "x", "y", "wait_for_complete"],
+                "get" : []
+            },
+            "position" : {
+                "set" : [],
+                "get" : ["get_position"]
+            },
+            "recenter" : {
+                "set" : ["recenter", "wait_for_complete"],
+                "get" : []
+            },
+            "stop" : {
+                "set" : ["stop"],
+                "get" : []
+            }
+        }
+    },
+    "robotic_gripper" : {
+        "obj" : "gripper_ctrl",
+        "functions" : {
+            "open" : {
+                "set" : ["open", "level"],
+                "get" : []
+            },
+            "close" : {
+                "set" : ["close", "level"],
+                "get" : []
+            },
+            "status" : {
+                "set" : [],
+                "get" : ["get_status"]
+            },
+            "stop" : {
+                "set" : ["stop"],
+                "get" : []
+            }
+        }
+    },
+    "led" : {
+        "obj" : "led_ctrl",
+        "functions" : {
+            "control" : {
+                "set" : ["update_led_t", "comp", "effect", "r", "g", "b", "blink_freq", "single_led_index"],
+                "get" : []
+            }
+        }
+    },
+    "AI" : {
+        "obj" : "AI_ctrl",
+        "functions" : {
+            "push" : {
+                "set" : ["ctrl_detection", "people", "pose", "line", "marker", "robot", "freq"],
+                "get" : []
+            },
+            "attribute" : {
+                "set" : ["attr_set", "line_color", "marker_color", "marker_dist"]
+            }
+        }
+    },
+    "camera" : {
+        "obj" : "media_ctrl",
+        "functions" : {
+            "exposure" : {
+                "set" : ["exposure_value_update_sdk", "ev"],
+                "get" : []
+            }
+        }
+    }
+}

s1_SDK/dji_scratch/sdk/plaintext_sdk/protocal_parser.py

@@ -0,0 +1,855 @@
+import queue
+import threading
+import time
+import json
+import traceback
+import os
+import re
+
+import event_client
+import rm_ctrl
+import rm_define
+import rm_log
+import tools
+
+import rm_socket
+
+logger = rm_log.dji_scratch_logger_get()
+
+PROTOCAL_MAPPING_TABLE_PATH = os.path.dirname(__file__) + "/protocal_mapping_table.json"
+
+COMMAND_PORT = 40923
+PUSH_PORT = 40924
+EVENT_PORT = 40925
+BROADCAST_PORT = 40926
+
+INADDR_ANY = "0.0.0.0"
+WIFI_DIRECT_CONNECTION_IP = "192.168.2.1"
+
+
+class ProtocalParser(object):
+    UART = "uart"
+    NETWORK = "network"
+
+    def __init__(self, event_dji_system, socket_obj, uart_obj):
+        self.event_client = event_dji_system
+        self.sdk_ctrl = rm_ctrl.SDKCtrl(event_dji_system)
+        self.version = ""
+
+        self.socket_obj = socket_obj
+        self.uart_obj = uart_obj
+        self.connection_obj = None
+
+        self.command_socket_fd = None
+        self.event_socket_fd = None
+        self.push_socket_fd = None
+
+        self.remote_host_ip = set()
+        self.connection_socket_fd = {}
+
+        self.data_queue = queue.Queue(512)
+        self.uart_data_t = ""
+        self.socket_data_t = ""
+
+        # make command exec order
+        # if there is command has been execed
+        # will return error when user send command
+        # support 'command1; command2;' to order run many commands
+        self.command_execing_event = threading.Event()
+
+        self.command_parser_callback = {
+            "command": self.command_protocal_format_parser,
+            "version": self.version_protocal_format_parser,
+            "quit": self.quit_protocal_format_parser,
+        }
+
+        self.data_process_thread = None
+
+        self.protocal_mapping_table = None
+
+        self.sdk_mode = False
+
+        self.ctrl_obj = {}
+
+        self.report_local_host_ip_timer = None
+
+    def init(self, config={}):
+        self.config = config
+
+        f = open(PROTOCAL_MAPPING_TABLE_PATH, "r")
+        self.protocal_mapping_table = json.load(f)
+        f.close()
+
+        self.command_socket_fd = self.socket_obj.create(
+            self.socket_obj.TCP_MODE,
+            (INADDR_ANY, COMMAND_PORT),
+            server=True,
+            recv_msgq_size=8,
+            send_msgq_size=8,
+            connected_callback=self.__command_connected_callback,
+            disconnected_callback=self.__command_disconnected_callback,
+        )
+        if self.command_socket_fd:
+            # TODO: handle the error
+            logger.info("command socket create successfully.")
+
+        self.event_socket_fd = self.socket_obj.create(
+            self.socket_obj.TCP_MODE,
+            (INADDR_ANY, EVENT_PORT),
+            server=True,
+            recv_msgq_size=8,
+            send_msgq_size=8,
+            connected_callback=self.__event_connected_callback,
+        )
+        if self.event_socket_fd:
+            logger.info("event socket create successfully.")
+
+        self.push_socket_fd = self.socket_obj.create(
+            self.socket_obj.UDP_MODE,
+            (INADDR_ANY, PUSH_PORT),
+            server=False,
+            recv_msgq_size=1,
+            send_msgq_size=8,
+        )
+        if self.push_socket_fd:
+            logger.info("push socket create successfully.")
+
+        self.broadcast_socket_fd = self.socket_obj.create(
+            self.socket_obj.UDP_MODE,
+            (INADDR_ANY, BROADCAST_PORT),
+            server=False,
+            recv_msgq_size=1,
+            send_msgq_size=8,
+        )
+
+        if self.broadcast_socket_fd:
+            self.socket_obj.set_udp_default_target_addr(
+                self.broadcast_socket_fd, ("<broadcast>", BROADCAST_PORT)
+            )
+            logger.info("broadcast socket create successfully.")
+
+        self.ctrl_obj = {}
+
+        if self.report_local_host_ip_timer == None:
+            self.report_local_host_ip_timer = tools.get_timer(
+                2, self.report_local_host_ip
+            )
+            self.report_local_host_ip_timer.start()
+
+        self.uart_obj.sdk_process_callback_register(self.__uart_command_recv_callback)
+
+    def __event_connected_callback(self, fd, new_fd):
+        logger.info("New event connected")
+        self.socket_obj.update_socket_info(
+            new_fd,
+            recv_msgq_size=1,
+            send_msgq_size=8,
+        )
+        if fd not in self.connection_socket_fd.keys():
+            self.connection_socket_fd[fd] = []
+
+        self.connection_socket_fd[fd].append(new_fd)
+
+    def __event_recv_callback(self, fd, data):
+        pass
+
+    def __event_disconnected_callback(self, fd):
+        pass
+
+    def __command_connected_callback(self, fd, new_fd):
+        if self.connection_obj == self.uart_obj:
+            logger.info("Uart has already connected")
+            return
+        else:
+            logger.info("New command connected")
+            self.connection_status_report("connected", fd, new_fd)
+            self.socket_obj.update_socket_info(
+                new_fd,
+                recv_msgq_size=8,
+                send_msgq_size=8,
+                recv_callback=self.__command_recv_callback,
+            )
+
+            self.remote_host_ip.add(self.socket_obj.get_remote_host_ip(new_fd))
+
+            if fd not in self.connection_socket_fd.keys():
+                self.connection_socket_fd[fd] = []
+            self.connection_socket_fd[fd].append(new_fd)
+
+    def __command_recv_callback(self, fd, data):
+        if self.connection_obj == self.uart_obj:
+            logger.info("Uart has already connected")
+            return
+        else:
+            self.socket_data_t += data
+            if ";" in self.socket_data_t:
+                data_list = self.socket_data_t.split(";")
+
+                # tail symbal is invalid, whether the data is end of ';' or incomplete command, so pop and save it
+                self.socket_data_t = data_list.pop(-1)
+
+                for msg in data_list:
+                    self.protocal_parser(fd, msg, self.NETWORK)
+            else:
+                logger.info("Not found ; in data_list, waitting for next data")
+                return
+
+    def __command_disconnected_callback(self, fd):
+        self.quit_protocal_format_parser(self.NETWORK, fd, None)
+        self.connection_status_report("disconnected", fd, None)
+
+    def __uart_command_recv_callback(self, data):
+        logger.info(data)
+        if self.connection_obj == self.socket_obj:
+            logger.info("Network has already connected")
+        else:
+            self.uart_data_t += data
+
+            if ";" in self.uart_data_t:
+                data_list = self.uart_data_t.split(";")
+
+                # tail symbal is invalid, whether the data is end of ';' or incomplete command, so pop and save it
+                self.uart_data_t = data_list.pop(-1)
+
+                logger.info(data_list)
+                for msg in data_list:
+                    self.protocal_parser(None, msg, self.UART)
+            else:
+                logger.info("Not found ; in data_list, waitting for next data")
+                return
+
+    def command_execing_start(self):
+        self.command_execing_event.set()
+
+    def command_execing_is_finish(self):
+        self.command_execing_event.is_set()
+
+    def command_execing_finish(self):
+        self.command_execing_event.clear()
+
+    def report_local_host_ip(self):
+        ip = self.socket_obj.get_local_host_ip()
+        if ip and tools.is_station_mode():
+            self.socket_obj.send(self.broadcast_socket_fd, "robot ip %s" % ip)
+
+    def sdk_robot_ctrl(self, ctrl):
+        def init():
+            self.ctrl_obj["event"] = event_client.EventClient()
+            self.ctrl_obj["modulesStatus_ctrl"] = rm_ctrl.ModulesStatusCtrl(
+                self.ctrl_obj["event"]
+            )
+            self.ctrl_obj["blaster_ctrl"] = rm_ctrl.GunCtrl(self.ctrl_obj["event"])
+            self.ctrl_obj["armor_ctrl"] = rm_ctrl.ArmorCtrl(self.ctrl_obj["event"])
+            self.ctrl_obj["AI_ctrl"] = rm_ctrl.VisionCtrl(self.ctrl_obj["event"])
+            self.ctrl_obj["chassis_ctrl"] = rm_ctrl.ChassisCtrl(self.ctrl_obj["event"])
+            self.ctrl_obj["gimbal_ctrl"] = rm_ctrl.GimbalCtrl(self.ctrl_obj["event"])
+            self.ctrl_obj["robot_ctrl"] = rm_ctrl.RobotCtrl(
+                self.ctrl_obj["event"],
+                self.ctrl_obj["chassis_ctrl"],
+                self.ctrl_obj["gimbal_ctrl"],
+            )
+            self.ctrl_obj["led_ctrl"] = rm_ctrl.LedCtrl(self.ctrl_obj["event"])
+            self.ctrl_obj["media_ctrl"] = rm_ctrl.MediaCtrl(self.ctrl_obj["event"])
+            self.ctrl_obj["mobile_ctrl"] = rm_ctrl.MobileCtrl(self.ctrl_obj["event"])
+            self.ctrl_obj["tools"] = rm_ctrl.RobotTools(self.ctrl_obj["event"])
+            self.ctrl_obj["sensor_adapter_ctrl"] = rm_ctrl.SensorAdapterCtrl(
+                self.ctrl_obj["event"]
+            )
+            self.ctrl_obj["ir_distance_sensor_ctrl"] = rm_ctrl.IrDistanceSensorCtrl(
+                self.ctrl_obj["event"]
+            )
+            self.ctrl_obj["servo_ctrl"] = rm_ctrl.ServoCtrl(self.ctrl_obj["event"])
+            self.ctrl_obj["robotic_arm_ctrl"] = rm_ctrl.RoboticArmCtrl(
+                self.ctrl_obj["event"]
+            )
+            self.ctrl_obj["gripper_ctrl"] = rm_ctrl.RoboticGripperCtrl(
+                self.ctrl_obj["event"]
+            )
+            self.ctrl_obj["sdk_ctrl"] = rm_ctrl.SDKCtrl(self.ctrl_obj["event"])
+            # log_ctrl = rm_ctrl.LogCtrl(event)
+
+        def ready():
+            self.ctrl_obj["robot_ctrl"].init()
+            self.ctrl_obj["modulesStatus_ctrl"].init()
+            self.ctrl_obj["gimbal_ctrl"].init()
+            self.ctrl_obj["chassis_ctrl"].init()
+            self.ctrl_obj["led_ctrl"].init()
+            self.ctrl_obj["blaster_ctrl"].init()
+            self.ctrl_obj["mobile_ctrl"].init()
+            self.ctrl_obj["servo_ctrl"].init()
+            self.ctrl_obj["ir_distance_sensor_ctrl"].init()
+            self.ctrl_obj["tools"].init()
+
+            self.ctrl_obj["robot_ctrl"].enable_sdk_mode()
+            self.ctrl_obj["robot_ctrl"].set_mode(rm_define.robot_mode_gimbal_follow)
+            self.ctrl_obj["chassis_ctrl"].stop()
+            self.ctrl_obj["tools"].program_timer_start()
+
+            self.ctrl_obj["AI_ctrl"].sdk_info_push_callback_register(
+                self.AI_info_push_callback
+            )
+            self.ctrl_obj["armor_ctrl"].sdk_event_push_callback_register(
+                self.armor_event_push_callback
+            )
+            self.ctrl_obj["media_ctrl"].sdk_event_push_callback_register(
+                self.applause_event_push_callback
+            )
+            self.ctrl_obj["chassis_ctrl"].sdk_info_push_callback_register(
+                self.chassis_info_push_callback
+            )
+            self.ctrl_obj["gimbal_ctrl"].sdk_info_push_callback_register(
+                self.gimbal_info_push_callback
+            )
+            self.ctrl_obj["sensor_adapter_ctrl"].sdk_event_push_callback_register(
+                self.io_level_event_push_callback
+            )
+            self.ctrl_obj["sdk_ctrl"].sdk_info_push_callback_register(
+                self.youth_competition_msg_push_callback
+            )
+
+        def stop():
+            self.ctrl_obj["blaster_ctrl"].stop()
+            self.ctrl_obj["chassis_ctrl"].stop()
+            self.ctrl_obj["gimbal_ctrl"].stop()
+            self.ctrl_obj["media_ctrl"].stop()
+            self.ctrl_obj["AI_ctrl"].stop()
+            self.ctrl_obj["armor_ctrl"].stop()
+
+        def exit():
+            stop()
+            self.ctrl_obj["robot_ctrl"].disable_sdk_mode()
+            self.ctrl_obj["robot_ctrl"].exit()
+            self.ctrl_obj["gimbal_ctrl"].exit()
+            self.ctrl_obj["chassis_ctrl"].exit()
+            self.ctrl_obj["blaster_ctrl"].exit()
+            self.ctrl_obj["mobile_ctrl"].exit()
+            self.ctrl_obj["armor_ctrl"].exit()
+            self.ctrl_obj["media_ctrl"].exit()
+            self.ctrl_obj["sdk_ctrl"].exit()
+            self.ctrl_obj["ir_distance_sensor_ctrl"].exit()
+            self.ctrl_obj["sensor_adapter_ctrl"].exit()
+            self.ctrl_obj["servo_ctrl"].exit()
+            self.ctrl_obj["gripper_ctrl"].exit()
+            self.ctrl_obj["event"].stop()
+            self.ctrl_obj.clear()
+
+        if ctrl == "init":
+            init()
+        elif ctrl == "ready":
+            ready()
+        elif ctrl == "stop":
+            stop()
+        elif ctrl == "exit":
+            exit()
+
+    def __data_process(self):
+        self.sdk_robot_ctrl("init")
+        self.sdk_robot_ctrl("ready")
+
+        while self.sdk_mode:
+            result = False
+            try:
+                fd, data = self.data_queue.get(timeout=1)
+            except queue.Empty:
+                continue
+            self.command_execing_start()
+            if data.req_type == "set":
+                cmd = str(data.obj) + "." + str(data.function) + str(data.param)
+
+                logger.info(cmd)
+
+                try:
+                    result = eval(cmd, self.ctrl_obj)
+
+                except Exception as e:
+                    logger.fatal(traceback.format_exc())
+                    self.ack(fd, "fail", data.seq)
+                    continue
+                if (
+                    (type(result) == tuple and result[-1] is 0)
+                    or (type(result) == bool and result == True)
+                    or result == None
+                    or result is 0
+                ):
+                    self.ack(fd, "ok", data.seq)
+                else:
+                    self.ack(fd, "fail", data.seq)
+                logger.fatal(
+                    "process : "
+                    + str(data.obj)
+                    + "."
+                    + str(data.function)
+                    + str(data.param)
+                    + " exec_result:"
+                    + str(result)
+                )
+            elif data.req_type == "get":
+                if data.param == None:
+                    cmd = str(data.obj) + "." + str(data.function) + "()"
+                else:
+                    cmd = str(data.obj) + "." + str(data.function) + str(data.param)
+
+                logger.info(cmd)
+
+                try:
+                    result = eval(cmd, self.ctrl_obj)
+
+                except Exception as e:
+                    logger.fatal(traceback.format_exc())
+                    self.ack(fd, "fail", data.seq)
+                seq = data.seq
+                data = ""
+                if type(result) == tuple or type(result) == list:
+                    for i in result:
+                        if type(i) == float:
+                            data = data + "%.3f" % i + " "
+                        else:
+                            data = data + str(i) + " "
+                else:
+                    data = str(result) + " "
+                self.ack(fd, data, seq)
+            else:
+                time.sleep(0.05)
+            self.command_execing_finish()
+
+        self.sdk_robot_ctrl("exit")
+
+    def protocal_parser(self, fd, data, mode=None):
+        # command
+        logger.info("Recv string: %s" % (data))
+        command = data.split(" ")
+
+        if len(command) == 0:
+            return
+
+        # find 'seq'
+        seq = None
+        if "seq" in command:
+            seq_pos = command.index("seq")
+            if len(command) > seq_pos + 1:
+                seq = command[seq_pos + 1]
+                if seq.isdigit():
+                    seq = int(seq)
+                elif re.match(r"^0x[0-9a-fA-F]+$", seq):
+                    seq = int(seq, 16)
+                else:
+                    self.ack(fd, "command format error: seq parse error")
+            else:
+                self.ack(fd, "command format error: no seq value")
+            command = command[0:seq_pos]
+
+        if self.command_execing_is_finish():
+            self.ack(fd, "error", seq)
+            return False
+
+        # check protocal format
+        command_obj = command[0]
+
+        # call process function
+        if command_obj in self.command_parser_callback.keys():
+            result = self.command_parser_callback[command_obj](mode, fd, seq)
+            if result == False or result == None:
+                self.ack(fd, "%s exec error" % command_obj, seq)
+            elif result == True:
+                self.ack(fd, "ok", seq)
+            else:
+                self.ack(fd, result, seq)
+        else:
+            if not self.sdk_mode:
+                self.ack(fd, "not in sdk mode", seq)
+                return False
+            result = self.ctrl_protocal_format_parser(command, seq)
+            if result == False or result == None:
+                self.ack(fd, "command format error: command parse error", seq)
+            else:
+                if not self.data_queue.full():
+                    try:
+                        self.data_queue.put_nowait((fd, result))
+                    except Exception as e:
+                        # full ?
+                        logger.fatal(e)
+
+    def command_protocal_format_parser(self, mode, fd, seq):
+        if self.sdk_mode == False:
+            self.sdk_mode = True
+            if (
+                self.data_process_thread == None
+                or self.data_process_thread.is_alive() == False
+            ):
+                self.data_process_thread = threading.Thread(target=self.__data_process)
+                self.data_process_thread.start()
+
+            if (
+                self.report_local_host_ip_timer
+                and self.report_local_host_ip_timer.is_start()
+            ):
+                self.report_local_host_ip_timer.join()
+                self.report_local_host_ip_timer.stop()
+
+            if mode == self.UART:
+                self.connection_obj = self.uart_obj
+                self.uart_data_t = ""
+            elif mode == self.NETWORK:
+                self.connection_obj = self.socket_obj
+                self.socket_data_t = ""
+
+            return True
+        else:
+            return "Already in SDK mode"
+
+    def version_protocal_format_parser(self, mode, fd, seq):
+        if "version" in self.config.keys():
+            return "version " + self.config["version"]
+
+    def quit_protocal_format_parser(self, mode, fd, seq):
+        if self.data_process_thread and self.data_process_thread.is_alive():
+            if self.report_local_host_ip_timer == None:
+                self.report_local_host_ip_timer = tools.get_timer(
+                    2, self.connection_obj.report_local_host_ip
+                )
+                self.report_local_host_ip_timer.start()
+            else:
+                self.report_local_host_ip_timer.start()
+            self.sdk_mode = False
+            self.data_process_thread.join()
+            self.ack(fd, "ok", seq)
+            if mode:
+                self.connection_obj = None
+                self.socket_data_t = ""
+                self.uart_data_t = ""
+            return True
+        else:
+            self.ack(fd, "quit sdk mode failed", seq)
+            if mode:
+                self.connection_obj = None
+            return False
+
+    def ctrl_protocal_format_parser(self, command, seq):
+        cmdpkg = CommandPackage()
+        cmdpkg.seq = seq
+
+        try:
+            # get object
+            obj = command[0]
+            if obj in self.protocal_mapping_table.keys():
+                cmdpkg.obj = self.protocal_mapping_table[obj]["obj"]
+            else:
+                logger.error("obj parse error")
+                return False
+
+            # get function key
+            function = command[1]
+            if function in self.protocal_mapping_table[obj]["functions"].keys():
+                function_dict = self.protocal_mapping_table[obj]["functions"][function]
+
+                # check if get command
+                if "?" in command:
+                    params_list = command[2:]
+                    if "?" in params_list:
+                        params_list.remove("?")
+                    cmdpkg.function = function_dict["get"][0]
+                    cmdpkg.req_type = "get"
+                    params = []
+
+                    """
+                    if len(function_dict['get'][1:]) != 0 and len(params_list) != 0:
+                        cmdpkg.param = tuple(params_list[0:len(function_dict['get'][1:])])
+                    """
+
+                    for param in function_dict["get"][1:]:
+                        # handle the first param is status bit
+                        if len(function_dict["get"][1:]) == 1:
+                            value = None
+                            if len(params_list) == 0:
+                                value = None
+                            elif len(params_list) == 1:
+                                value = params_list[0]
+                            elif params_list[0] == function_dict["get"][1:][0]:
+                                value = params_list[1]
+                            if value and value.isdigit():
+                                value = int(value)
+                            elif re.match(r"^0x[0-9a-fA-F]+$", value):
+                                value = int(value, 16)
+                            elif value == "True" or value == "true":
+                                value = True
+                            elif value == "False" or value == "false":
+                                value = False
+                            else:
+                                try:
+                                    value = float(value)
+                                except Exception as e:
+                                    pass
+                            params.append(value)
+                            break
+
+                        # check params
+                        if param in params_list and params_list.index(param) + 1 < len(
+                            params_list
+                        ):
+                            value = params_list[params_list.index(param) + 1]
+                            if value and value.isdigit():
+                                value = int(value)
+                            elif re.match(r"^0x[0-9a-fA-F]+$", value):
+                                value = int(value, 16)
+                            elif value == "True" or value == "true":
+                                value = True
+                            elif value == "False" or value == "false":
+                                value = False
+                            else:
+                                try:
+                                    value = float(value)
+                                except Exception as e:
+                                    pass
+                            params.append(value)
+                        else:
+                            params.append(None)
+
+                    cmdpkg.param = tuple(params)
+                    logger.info(cmdpkg.param)
+
+                # set command
+                else:
+                    # get params list
+                    params_list = command[2:]
+                    cmdpkg.function = function_dict["set"][0]
+                    cmdpkg.req_type = "set"
+                    params = []
+
+                    for param in function_dict["set"][1:]:
+                        # handle the first param is status bit
+                        if len(function_dict["set"][1:]) == 1:
+                            value = None
+                            if len(params_list) == 0:
+                                value = None
+                            elif len(params_list) == 1:
+                                value = params_list[0]
+                            elif len(params_list) == 2:
+                                value = params_list[1]
+                            if value and value.isdigit():
+                                value = int(value)
+                            elif value and re.match(r"^0x[0-9a-fA-F]+$", value):
+                                value = int(value, 16)
+                            elif value == "True" or value == "true":
+                                value = True
+                            elif value == "False" or value == "false":
+                                value = False
+                            else:
+                                try:
+                                    value = float(value)
+                                except Exception as e:
+                                    pass
+                            params.append(value)
+                            break
+
+                        # check params
+                        if param in params_list and params_list.index(param) + 1 < len(
+                            params_list
+                        ):
+                            value = params_list[params_list.index(param) + 1]
+                            if value.isdigit():
+                                value = int(value)
+                            elif re.match(r"^0x[0-9a-fA-F]+$", value):
+                                value = int(value, 16)
+                            elif value == "True" or value == "true":
+                                value = True
+                            elif value == "False" or value == "false":
+                                value = False
+                            else:
+                                try:
+                                    value = float(value)
+                                except Exception as e:
+                                    pass
+                            params.append(value)
+                        else:
+                            params.append(None)
+
+                    cmdpkg.param = tuple(params)
+                    logger.info(cmdpkg.param)
+            else:
+                logger.error("function key parse error")
+                return False
+        except Exception as e:
+            logger.fatal(traceback.format_exc())
+            return False
+
+        return cmdpkg
+
+    def connection_status_report(self, status, fd, data):
+        logger.info(
+            "connect status changed, local host ip info : %s remote host ip info: %s, cur status: %s"
+            % (
+                self.socket_obj.get_local_host_ip(data),
+                self.socket_obj.get_remote_host_ip(data),
+                status,
+            )
+        )
+        mode = "wifi"
+        if data != None:
+            ip = self.socket_obj.get_local_host_ip(data)
+            if ip == tools.get_ip_by_dev_name("wlan0"):
+                mode = "wifi"
+            elif ip == tools.get_ip_by_dev_name("rndis0"):
+                mode = "rndis"
+            logger.info("connect mode: %s" % (mode))
+
+        if status == "connected":
+            self.sdk_ctrl.sdk_on(mode)
+        elif status == "disconnected":
+            self.sdk_ctrl.sdk_off()
+
+    def armor_event_push_callback(self, event):
+        if len(event) == 0:
+            return
+
+        msg = "armor event"
+        if "hit" in event.keys():
+            msg += " hit %d %d ;" % (event["hit"])
+        self.send("event", msg)
+
+    def applause_event_push_callback(self, event):
+        if len(event) == 0:
+            return
+
+        msg = "sound event"
+        if "applause" in event.keys():
+            msg += " applause %d ;" % (event["applause"])
+        self.send("event", msg)
+
+    def io_level_event_push_callback(self, event):
+        if len(event) == 0:
+            return
+
+        msg = "sensor_adapter event"
+        if "io_level" in event.keys():
+            msg += " io_level %d ;" % (event["io_level"])
+        self.send("event", msg)
+
+    def chassis_position_info_push_callback(self, x, y):
+        pass
+
+    def chassis_info_push_callback(self, info):
+        if len(info) == 0:
+            return
+
+        msg = "chassis push"
+        if "position" in info.keys():
+            msg += " position %.3f %.3f ;" % (info["position"])
+        if "attitude" in info.keys():
+            msg += " attitude %.3f %.3f %.3f ;" % (info["attitude"])
+        if "status" in info.keys():
+            msg += " status %d %d %d %d %d %d %d %d %d %d %d ;" % (info["status"])
+        self.send("push", msg)
+
+    def gimbal_info_push_callback(self, info):
+        if len(info) == 0:
+            return
+
+        msg = "gimbal push"
+        if "attitude" in info.keys():
+            msg += " attitude %.3f %.3f ;" % (info["attitude"])
+        self.send("push", msg)
+
+    def AI_info_push_callback(self, info):
+        if len(info) == 0:
+            return
+        msg = "AI push"
+        if "people" in info.keys():
+            msg += " people %d" % len(info["people"])
+            for i in info["people"]:
+                msg += " %.3f %.3f %.3f %.3f" % (i.pos.x, i.pos.y, i.size.w, i.size.h)
+        if "pose" in info.keys():
+            msg += " pose %d" % len(info["pose"])
+            for i in info["pose"]:
+                msg += " %d %.3f %.3f %.3f %.3f" % (
+                    i.info,
+                    i.pos.x,
+                    i.pos.y,
+                    i.size.w,
+                    i.size.h,
+                )
+        if "marker" in info.keys():
+            msg += " marker %d" % len(info["marker"])
+            for i in info["marker"]:
+                msg += " %d %.3f %.3f %.3f %.3f" % (
+                    i.info,
+                    i.pos.x,
+                    i.pos.y,
+                    i.size.w,
+                    i.size.h,
+                )
+        if "line" in info.keys():
+            msg += " line %d" % int(len(info["line"]) / 10)
+            for i in info["line"]:
+                msg += " %.3f %.3f %.3f %.3f" % (i.pos.x, i.pos.y, i.size.w, i.size.h)
+        if "robot" in info.keys():
+            msg += " robot %d" % len(info["robot"])
+            for i in info["robot"]:
+                msg += " %.3f %.3f %.3f %.3f" % (i.pos.x, i.pos.y, i.size.w, i.size.h)
+
+        self.send("push", msg)
+
+    def gimbal_status_info_push_callback(self):
+        pass
+
+    def youth_competition_msg_push_callback(self, info):
+        if len(info) == 0:
+            logger.error("SYS_GAME : msg is none")
+            return
+        msg = "game msg push "
+        if "data" in info["game_msg"].keys():
+            msg += str(info["game_msg"]["data"])
+        self.send("push", msg)
+
+    def ack(self, fd, data, seq=None):
+        msg = data
+        if seq != None:
+            msg += " seq %s" % (str(seq))
+
+        msg += ";"
+
+        if self.connection_obj:
+            self.connection_obj.send(fd, msg)
+
+    def req(self):
+        pass
+
+    def send(self, obj, data):
+        fd = None
+
+        data += ";"
+
+        if self.connection_obj == self.uart_obj:
+            self.connection_obj.send(None, data)
+        else:
+            if obj == "command":
+                if self.connection_obj:
+                    return self.connection_obj.send(self.command_socket_fd, data)
+                else:
+                    return None
+            elif obj == "event":
+                logger.info(self.connection_socket_fd)
+                for user_fd in self.connection_socket_fd[self.event_socket_fd]:
+                    if self.connection_obj:
+                        self.connection_obj.send(user_fd, data)
+                return 0
+            elif obj == "push":
+                for ip in self.remote_host_ip:
+                    if self.connection_obj:
+                        self.connection_obj.send(
+                            self.push_socket_fd, data, (ip, PUSH_PORT)
+                        )
+                return 0
+            else:
+                return None
+
+    def recv(self):
+        pass
+
+
+class CommandPackage(object):
+    def __init__(self):
+        self.obj = None
+        self.function = None
+        self.param = None
+        self.seq = None
+        self.req_type = None

s1_SDK/dji_scratch/sdk/sdk_manager.py

@@ -0,0 +1,29 @@
+import os
+import plaintext_sdk
+
+
+class SDKManager(object):
+    def __init__(self, event_client, socket_obj, uart_obj):
+        self.plaintext_sdk = plaintext_sdk.PlaintextSDK(
+            event_client, socket_obj, uart_obj
+        )
+        self.plaintext_sdk_config = {}
+        self.load_cfg()
+
+    def load_cfg(self):
+        # load version
+        cur_dir = os.path.dirname(__file__)
+        f = open(cur_dir + "/version.txt")
+        version_ori = f.readlines()
+        f.close()
+
+        version = ""
+        for i in version_ori:
+            version = version + "%.2d." % int(i.split(" ")[-1][0:-1])
+
+        version = version[0:-1]
+
+        self.plaintext_sdk_config["version"] = version
+
+    def enable_plaintext_sdk(self):
+        self.plaintext_sdk.init(self.plaintext_sdk_config)

s1_SDK/dji_scratch/sdk/version.txt

@@ -0,0 +1,4 @@
+#SDK_VERSION_MAJOR     0
+#SDK_VERSION_MINOR     0
+#SDK_VERSION_REVISION  00
+#SDK_VERSION_BUILD     70

s1_SDK/patch.sh

@@ -0,0 +1,22 @@
+#!/system/bin/sh
+
+# Run adbd for convenience. Not required to get SDK support.
+/system/bin/adb_en.sh &
+
+# Stop affected services.
+stop dji_sys
+stop dji_hdvt_uav
+stop dji_vision
+
+# Overwrite S1's dji.json with EP's one. Use a bind mount as the file is in the
+# system partition.
+mount -o bind /data/dji.json /system/etc/dji.json
+
+# This allows accessing the robot with DJI's binary protocol on port 20020.
+mount -o bind /data/dji_hdvt_uav /system/bin/dji_hdvt_uav
+
+# Restart services.
+start dji_sys
+start dji_hdvt_uav
+start dji_vision
+

s1_SDK/upload.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+adb shell rm -rf /data/dji_scratch/sdk
+adb push dji_scratch/sdk /data/dji_scratch/.
+
+adb push dji_scratch/bin/dji_scratch.py /data/dji_scratch/bin/.
+
+adb push dji.json /data/.
+
+adb push dji_hdvt_uav /data/.
+adb shell chmod 755 /data/dji_hdvt_uav
+
+adb push patch.sh /data/.
+