Merge pull request #14 from Zeroth-Robotics/revert-12-runtime2

Revert "Runtime2"

Author: hatomist

.gitignore

@@ -51,8 +51,6 @@ logs/
 
 # artifacts
 artifacts/
-# Model artifacts directories in models/
-models/*_artifacts/
 
 # gitlab-ci-local
 .gitlab-ci-local/

.gitlab-ci-local/.gitignore

@@ -7,6 +7,6 @@
 [submodule "runtime/firmware/duo-sdk"]
 	path = runtime/firmware/duo-sdk
 	url = https://github.com/milkv-duo/duo-sdk.git
-[submodule "models/tpu-mlir"]
-	path = models/tpu-mlir
-	url = https://github.com/milkv-duo/tpu-mlir.git
+[submodule "runtime/models/tpu-mlir"]
+	path = runtime/models/tpu-mlir
+	url = https://github.com/milkv-duo/tpu-mlir

.gitmodules

@@ -6,10 +6,6 @@ rustflags = [
     "-L", "./firmware/sts3215",
     "-L", "./firmware/tpu-sdk-sg200x/lib",
     "-L", "./firmware/duo-sdk/rootfs/usr/lib",
-    "-L", "./models/tpu-mlir/lib",
-    "-Clink-arg=-Wl,-rpath,../models/tpu-mlir/lib",
-    "-Clink-arg=-Wl,-rpath,./firmware/tpu-sdk-sg200x/lib",
-    "-Clink-arg=-Wl,-rpath,./firmware/duo-sdk/rootfs/lib",
     "-Clink-arg=-Wl,-rpath,./tpu-libs",
     "-Clink-arg=-Wl,-rpath,./sysroot/lib",
     "-Clink-arg=-Wl,-rpath,./sysroot/usr/lib",

models/ppo_standing.pt

@@ -36,22 +36,22 @@ If you're connecting via USB, use the following details:
 SSH:
 `ssh [email protected]`
 
-4. Build Runtime
-```bash
-cargo check && gitlab-ci-local # check and build
-```
+4. Download Required Artifacts
+Go to OpenLCH Artifacts and download the following:
+`runtime`
+`servo`
+`cviwrapper`
 
-5. Transfer Files to the Target Device
-Find binaries in target/riscv64gc-unknown-linux-musl/release/
-
-`scp -O target/riscv64gc-unknown-linux-musl/release/runtime $MILKV_IP:/usr/local/bin/`
+6. Transfer Files to the Target Device
+Run the following commands to copy the necessary files to your device:
 
-Debug:
-Note that you cannot ping the device in Cursor editor terminal for some reason. Try:
 ```bash
-ping 192.168.42.1
-```
+scp -O runtime [email protected]:/usr/local/bin/
+scp -O servo [email protected]:/usr/local/bin/
+scp -O cviwrapper [email protected]:/usr/local/bin/
+
 
+```
 6. Run the Application
 To run the servo setup, execute the following on the target device:
 
@@ -61,12 +61,27 @@ To run the servo setup, execute the following on the target device:
 ls /usr/local/bin/
 
 # Run your desired binary (example: runtime)
- /usr/local/bin/runtime
+sudo /usr/local/bin/runtime
+```
+
+
+
+
+```
+# Install docker / docker desktop
+brew install gitlab-ci-local
 ```
 
+### Build
 
+```bash
+gitlab-ci-local --stage build-runtime
+```
 
+Find binaries in target/riscv64gc-unknown-linux-musl/release/
 
+### Copy to the milk-v board
+`scp -O target/riscv64gc-unknown-linux-musl/release/runtime $MILKV_IP:/usr/local/bin/`
 
 If the board is connected over usb, ip is `192.168.42.1`
 

models/ppo_walking.pt

@@ -0,0 +1,80 @@
+import json
+import numpy as np
+
+# Define the number of servos
+NUM_SERVOS = 12
+
+# Static movement states with positions and transition times
+raw_movements = {
+    "move_forward": [
+        {"pos": [867, 91, 225, 903, 330, 769, 250, 387, 587, 197, 210, 562, 569], "trans_time": 600},
+        {"pos": [868, 91, 225, 1004, 330, 769, 250, 387, 587, 199, 151, 562, 570], "trans_time": 600},
+        {"pos": [867, 91, 225, 1001, 329, 769, 250, 387, 587, 225, 299, 560, 569], "trans_time": 600},
+        {"pos": [867, 91, 225, 1019, 330, 766, 250, 386, 587, 211, 143, 562, 569], "trans_time": 600},
+        {"pos": [867, 92, 225, 837, 328, 766, 250, 387, 586, 210, 144, 562, 569], "trans_time": 600},
+        {"pos": [867, 91, 225, 955, 328, 769, 250, 387, 587, 210, 82, 561, 569], "trans_time": 600},
+        {"pos": [867, 91, 225, 956, 328, 769, 250, 387, 587, 213, 250, 562, 569], "trans_time": 600},
+        {"pos": [867, 91, 225, 1037, 331, 767, 250, 387, 587, 210, 158, 562, 569], "trans_time": 600},
+        {"pos": [867, 91, 225, 865, 329, 768, 250, 387, 587, 210, 159, 562, 569], "trans_time": 600},
+        {"pos": [867, 91, 225, 946, 329, 768, 250, 387, 587, 211, 78, 561, 569], "trans_time": 600},
+        {"pos": [867, 91, 225, 948, 328, 769, 250, 387, 587, 213, 234, 562, 569], "trans_time": 600},
+        {"pos": [867, 91, 225, 1016, 329, 768, 250, 387, 587, 210, 150, 562, 569], "trans_time": 600},
+        {"pos": [867, 91, 225, 857, 330, 767, 250, 387, 587, 210, 151, 562, 569], "trans_time": 600},
+    ],
+    "zero": [
+        {"pos": [865, 92, 228, 895, 514, 628, 249, 385, 586, 338, 195, 387, 570], "trans_time": 600},
+        {"pos": [865, 92, 228, 895, 514, 628, 249, 385, 586, 338, 195, 387, 570], "trans_time": 600}
+
+    ],
+    "bounce": [
+    {"pos": [867, 90, 225, 895, 510, 625, 247, 386, 587, 341, 195, 391, 570], "trans_time": 600},
+    {"pos": [867, 91, 225, 887, 374, 751, 247, 387, 587, 210, 187, 544, 570], "trans_time": 600},
+    ],
+    #  "dabbing": [
+        
+    #     # {"pos": [668, 64, -160, 907, -11, 20, 446, 432, 99, -31, 962, -1, 3], "trans_time": 300},
+    #     # {"pos": [668, 64, -160, 907, -11, 20, 446, 431, 99, -31, 961, -1, 112], "trans_time": 300},
+    #     # {"pos":  [668, 64, -160, 907, -11, 20, 446, 431, 99, -31, 960, -1, 300], "trans_time": 300},
+
+    #     {"pos": [668, 64, -160, 907, -11, 20, 446, 432, 99, -31, 962, -1, 3], "trans_time": 300},
+    #     {"pos": [619, 254, 1193, 907, 2, 20, 446, 483, 100, -10, 960, -1, 0], "trans_time": 300},
+    #     {"pos": [668, 64, -160, 907, -11, 20, 446, 432, 99, -31, 962, -1, 3], "trans_time": 300},
+
+
+        
+        # {"pos": [1081, 147, -83, 907, 126, -19, 82, 393, 166, 44, 959, 0, 0], "trans_time": 300},
+        # {"pos": [1081, 147, -83, 907, 216, -188, 82, 394, 166, 199, 960, -194, 0], "trans_time": 300},
+        # {"pos": [896, 59, -194, 857, 342, 1194, 240, 394, 165, 288, 921, 1193, 0], "trans_time": 300},
+
+    # ],
+}
+
+def interpolate_positions(start, end, steps):
+    """Interpolate between start and end positions over the given number of steps."""
+    return np.linspace(start, end, steps).tolist()
+
+# Generate the fully interpolated movements
+movements = {}
+
+for movement_name, movement_data in raw_movements.items():
+    interpolated_movement = []
+    for i in range(len(movement_data)):
+        start_pos = np.array(movement_data[i]["pos"])
+        transition_time = movement_data[i]["trans_time"]
+        steps = max(1, int(transition_time / 50))  # Calculate the number of 50ms steps
+        end_pos = np.array(movement_data[(i + 1) % len(movement_data)]["pos"])  # Next position
+        
+        # Interpolate between the current position and the next
+        interpolated_positions = interpolate_positions(start_pos, end_pos, steps)
+        
+        # Append the interpolated positions to the movement list
+        interpolated_movement.extend(interpolated_positions)
+
+    movements[movement_name] = interpolated_movement
+
+# Save the movements to a JSON file
+with open('movements.json', 'w') as f:
+    json.dump(movements, f, indent=4)
+
+print("Interpolated movements array saved to movements.json")
+

runtime/.cargo/config.toml

@@ -0,0 +1,120 @@
+import pygame
+import asyncio
+import websockets
+import json
+import time
+
+import sys, time
+
+from ..servo_driver.hiwonder_lsbc_v16 import ServoController
+
+# import serial
+# import lewansoul_lx16a
+
+# SERIAL_PORT = '/dev/cu.usbserial-110'
+
+ctrl = ServoController(vid=0x0483, pid=0x5750)
+global prev_movement
+prev_movement = None    
+# Initialize Pygame
+pygame.init()
+
+# WebSocket server URI
+# Load the pre-generated movement arrays from the JSON file
+with open('movements.json', 'r') as f:
+    movements = json.load(f)
+
+# Active movement state key
+current_movement = None
+
+# Circular buffer to manage movement states
+movement_buffer = []
+current_step = 0
+
+# Time tracking for transitions
+last_transition_time = 0
+transition_interval = 0.05  # 50ms
+
+# Function to handle state transitions
+async def handle_transitions(websocket):
+    global current_step, last_transition_time
+
+    # Check the current time
+    current_time = time.time()
+    elapsed_time = current_time - last_transition_time
+
+    if elapsed_time >= transition_interval:
+        if current_movement:
+            # Get the current position from the buffer
+            servo_states = movement_buffer[current_step]
+            message = json.dumps({"servo_states": servo_states})
+
+            for n, val in enumerate(servo_states):
+                ctrl.move_servos([(n + 1, int(val))], 20)
+                # ctrl.move(n + 1, val, 20)
+
+            # await websocket.send(message)
+
+            # Move to the next step
+            current_step = (current_step + 1) % len(movement_buffer)
+            
+            # Update the last transition time
+            last_transition_time = current_time
+
+# Function to set the current movement and prepare the buffer
+def set_movement(movement_name):
+    global current_movement, movement_buffer, current_step, last_transition_time, prev_movement
+    if movement_name in movements and current_movement != movement_name:
+        current_movement = movement_name
+        movement_buffer = movements[movement_name]
+        if prev_movement != current_movement:
+            current_step = 0
+            prev_movement = current_movement
+        last_transition_time = time.time()  # Reset the timer
+        print(f"Transitioning to movement: {movement_name}")
+
+# Function to stop the current movement
+def stop_movement():
+    global current_movement
+    current_movement = None
+    print("Stopped movement")
+
+# Main function to run the websocket client
+async def main():
+    # Set up a simple Pygame window (required to capture events)
+    screen = pygame.display.set_mode((640, 480))
+    pygame.display.set_caption('Servo Movement Controller')
+
+    # Connect to the WebSocket server
+    # async with websockets.connect(WEBSOCKET_URI) as websocket:
+
+    running = True
+    while running:
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                running = False
+            elif event.type == pygame.KEYDOWN:
+                if event.key == pygame.K_w:  # Move forward on 'W' key press
+                    set_movement("move_forward")
+                elif event.key == pygame.K_a:  # Move left on 'A' key press
+                    set_movement("move_left")
+                elif event.key == pygame.K_d:  # Move left on 'A' key press
+                    set_movement("dabbing")
+                elif event.key == pygame.K_z:  # Move left on 'A' key press
+                    set_movement("zero")
+                elif event.key == pygame.K_q:  # Quit on 'Q' key press
+                    running = False
+            elif event.type == pygame.KEYUP:
+                if event.key in [pygame.K_w, pygame.K_a, pygame.K_d, pygame.K_z]:
+                    stop_movement()
+
+        # Call handle_transitions every 50ms if a movement is active
+        await handle_transitions(None)
+
+        # Allow other events to be processed
+        await asyncio.sleep(0)  # Yield control to the event loop
+
+    pygame.quit()
+
+# Run the main function
+asyncio.run(main())

runtime/README.md

@@ -0,0 +1,10 @@
+# The following lines of boilerplate have to be in your project's CMakeLists
+# in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.16)
+
+# (Not part of the boilerplate)
+# This example uses an extra component for common functions such as Wi-Fi and Ethernet connection.
+set(EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/examples/common_components/protocol_examples_common)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(ws_echo_server)