Add files.

Author: zhoufeiy

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "blossom-public"]
+	path = blossom-public
+	url = https://github.com/interaction-lab/blossom-public

README.md

@@ -1,2 +1,23 @@
 # Blossom-Controller
 Blossom controller scripts that contain a interface to control blossom robot either via USB or via network.
+
+## TLDR;
+- Setup `.env` file for server IP and port.
+- Import `BlossomInterface` from `blossom_interface.py` and implement your logic.
+- Run `blossom_client.py` on the machine that is connected to blossom via USB.
+- Run `blossom_server.py` on the server.
+- Run your script.
+
+## Notes:
+- `blossom_interface.py`: Entry point of the interface, import this file to use the interface.
+- `blossom_client.py`: Client class for the interface. Run this script on the machine connects to Blossom.
+- `blossom_server.py`: Server class for the interface. Run this script on cloud server.
+- `blossom_local_interface.py`: Wrapper class for the Blossom API, used in `blossom_interface.py`.
+- `blossom_network_interface.py`: This class sends data to server, used in `blossom_interface.py`.
+- `blossom_sequence_comb.py`: Utility class for combining sequences. See comments in the file for more details.
+- `note.py`: Initially used as `__init__.py` for the package, but because of the blossom-public package, it is better to
+  keep it as a separate file.
+- `.env`: Server IP and port goes in here.
+    - ```
+        SERVER_IP=192.168.0.1
+        SERVER_PORT=5000

blossom-public

@@ -0,0 +1,62 @@
+# Description: This is the client script that runs on the machine connected to Blossom via USB.
+# This is only needed if you want to use network controller.
+# This is the standalone script that runs on the machine connected to Blossom via USB.
+blossom_id_ = 0
+# Define blossom ID above
+
+import socketio
+import os
+import json
+import dotenv
+import logging
+from blossom_local_interface import BlossomLocalInterface
+
+logger = logging.getLogger(__name__)
+logger.info("Client Started.")
+
+example_data = {
+    "function": "do_start_sequence",
+    "kwargs": {
+        "blossom_id": 0,
+        "delay_time": 0.5,
+        "audio_length": 20,
+        "seq": "reset"
+    }
+}
+
+
+class BlossomClient:
+    def __init__(self, server_ip, server_port, blossom_id=0):
+        self.bl = BlossomLocalInterface()
+        self.blossom_id = blossom_id
+        self.sio = socketio.Client()
+        self.sio.connect(f"http://{server_ip}:{server_port}")
+        self.sio.on('data_update', self.on_data_update)
+        self.sio.on('connect', self.on_connect)
+        self.sio.on('disconnect', self.on_disconnect)
+        # self.sio.wait()
+
+    def on_data_update(self, data):
+        logger.info(f"Received data: {json.dumps(data, indent=2)}")
+        if data["kwargs"]["blossom_id"] == self.blossom_id:
+            if data["function"] == "do_sequence":
+                self.bl.do_sequence(data["kwargs"]["seq"], data["kwargs"]["delay_time"])
+            elif data["function"] == "reset":
+                self.bl.reset()
+            else:
+                logger.error(f"Function {data['function']} not found.")
+
+    def wait(self):
+        self.sio.wait()
+
+    def on_connect(self):
+        logger.info("Connected to server.")
+
+    def on_disconnect(self):
+        logger.info("Disconnected from server.")
+
+
+if __name__ == '__main__':
+    dotenv.load_dotenv()
+    client = BlossomClient(os.getenv("SERVER_IP"), os.getenv("SERVER_PORT"), blossom_id_)
+    client.wait()

blossom_client.py

@@ -0,0 +1,20 @@
+# Description: This file is the main interface to the Blossom robot.
+# Note: Set use_network_interface to False if you want to control blossom from the same machine.
+# Import this file into your project
+from blossom_network_interface import BlossomNetworkInterface
+from blossom_local_interface import BlossomLocalInterface
+
+
+class BlossomInterface:
+    def __init__(self, use_network_interface=True, server_ip=None, server_port=None):
+        self.bli = None
+        if use_network_interface:
+            self.bli = BlossomNetworkInterface(server_ip, server_port)
+        else:
+            self.bli = BlossomLocalInterface()
+
+    def do_sequence(self, seq, delay_time=0, blossom_id=0):
+        self.bli.do_sequence(seq, delay_time, blossom_id)
+
+    def reset(self, blossom_id=0):
+        self.bli.reset(blossom_id)

blossom_interface.py

@@ -0,0 +1,29 @@
+# Description: This file is used to control Blossom robot using the Blossom API.
+# This is not a standalone script. Use BlossomInterface instead.
+import random
+import sys
+import time
+import logging
+
+sys.path.append("./blossom-public")
+from blossompy import Blossom
+
+logger = logging.getLogger(__name__)
+
+
+class BlossomLocalInterface:
+    def __init__(self):
+        self.bl = Blossom(sequence_dir='./blossom-public/blossompy/src/sequences')
+        self.bl.connect()  # safe init and connects to blossom and puts blossom in reset position
+        self.bl.load_sequences()
+        self.bl.do_sequence("reset")
+        logger.info("Blossom Connected & Initialized.")
+
+    def reset(self, blossom_id=0):
+        self.bl.do_sequence("reset")
+
+    def do_sequence(self, seq="reset", delay_time=0, blossom_id=0):
+        logger.info(f"Blossom start playing sequence {seq} with {delay_time}s of delay.")
+        time.sleep(delay_time)
+        logger.info(f"Blossom playing sequence {seq}")
+        self.bl.do_sequence(seq)

blossom_local_interface.py

@@ -0,0 +1,44 @@
+# Description: This file contains the BlossomNetworkInterface class which is used to send data to the server.
+# This is not a standalone script. Use BlossomInterface instead.
+import logging
+import requests
+import json
+
+logger = logging.getLogger(__name__)
+
+
+class BlossomNetworkInterface:
+    def __init__(self, server_ip, server_port):
+        # dotenv.load_dotenv()
+        # self.server_ip = os.getenv("SERVER_IP")
+        # self.server_port = os.getenv("SERVER_PORT")
+        self.server_ip = server_ip
+        self.server_port = server_port
+        # self.blossom_id = blossom_id
+
+        self.url = f"http://{self.server_ip}:{self.server_port}/data"
+        self.data = {
+            "function": "do_start_sequence",
+            "kwargs": {
+                "blossom_id": 0,
+                "delay_time": 0.5,
+                "audio_length": 20,
+                "seq": "reset"
+            }
+        }
+
+    def do_sequence(self, seq, delay_time=0, blossom_id=0):
+        self.data["function"] = "do_sequence"
+        self.data["kwargs"]["seq"] = seq
+        self.data["kwargs"]["delay_time"] = delay_time
+        self.data["kwargs"]["blossom_id"] = blossom_id
+        response = requests.post(self.url, json=self.data)
+        logger.info(f"Sending data to server: {json.dumps(self.data, indent=2)}")
+        logger.info(f"Response from server: {response.text}")
+
+    def reset(self, blossom_id=0):
+        self.data["function"] = "reset"
+        self.data["kwargs"]["blossom_id"] = blossom_id
+        response = requests.post(self.url, json=self.data)
+        logger.info(f"Sending data to server: {json.dumps(self.data, indent=2)}")
+        logger.info(f"Response from server: {response.text}")

blossom_network_interface.py

@@ -0,0 +1,34 @@
+# Description: This script is used to combine multiple sequences into a single sequence.
+# Usage: combine_sequences(list_of_sequences, new_sequence_name)
+# Example: combine_sequences(["yes", "no"], "yes_no")
+# Note: change output sequence directory to the desired directory, but make sure new directory is a sub directory of
+# the original sequence directory
+import json
+
+sequence_dir = "./blossom-public/blossompy/src/sequences/woody/"
+
+output_sequence_dir = "./blossom-public/blossompy/src/sequences/woody/cognitive/"
+
+
+def combine_sequences(sequences: list, sequence_name=None):
+    output_sequence = {
+        "animation": "",
+        "frame_list": []
+    }
+    last_sequence_duration = 0.0
+    for seq in sequences:
+        with open(sequence_dir + seq + "_sequence.json") as seq_file:
+            sequence_data = json.load(seq_file)
+            current_frame_list = sequence_data["frame_list"]
+            for frame in current_frame_list:
+                frame["millis"] += last_sequence_duration
+            last_sequence_duration = current_frame_list[-1]["millis"]
+            output_sequence["frame_list"].extend(current_frame_list)
+            output_sequence["animation"] += sequence_data["animation"]
+    if sequence_name is None:
+        with open(output_sequence_dir + output_sequence["animation"] + "_sequence.json", "w") as outfile:
+            json.dump(output_sequence, outfile, indent=2)
+    else:
+        with open(output_sequence_dir + sequence_name + "_sequence.json", "w") as outfile:
+            output_sequence["animation"] = sequence_name
+            json.dump(output_sequence, outfile, indent=2)

blossom_sequence_comb.py

@@ -0,0 +1,18 @@
+# Description: This is the server script that will receive data from network controller and send it to client.
+from flask import Flask, request
+from flask_socketio import SocketIO, emit
+
+app = Flask(__name__)
+socketio = SocketIO(app)
+
+
+@app.route('/data', methods=['POST'])
+def receive_data():
+    data = request.json
+    print(f"Received data: {data}")
+    socketio.emit('data_update', data)
+    return "Data received", 200
+
+
+if __name__ == '__main__':
+    socketio.run(app, host='0.0.0.0', port=5000)

blossom_server.py

@@ -0,0 +1,30 @@
+import os
+from time import sleep
+
+import dotenv
+from blossom_interface import BlossomInterface
+
+import random
+
+if __name__ == '__main__':
+    dotenv.load_dotenv()
+    bl = BlossomInterface(False, os.getenv("SERVER_IP"), os.getenv("SERVER_PORT"))
+
+    # Control blossom with bl object
+    bl.reset()
+    bl.do_sequence("yes", 0, 1)
+    bl.do_sequence("no", 0, 0)
+    sleep(1)
+    bl.do_sequence("grand/grand1", 1.0, 0)
+    bl.do_sequence("grand/grand2", 1.0, 1)
+    sleep(5)
+
+    # More complex behavior
+    print("Random selection of idle sequences")
+    idle_sequences = ["breathing/exhale", "breathing/inhale", "fear/fear_startled", "happy/happy_lookingup",
+                      "sad/sad_downcast"]
+    random.shuffle(idle_sequences)
+    bl.do_sequence(idle_sequences[0], 0, 0)
+    random.shuffle(idle_sequences)
+    bl.do_sequence(idle_sequences[0], 0, 1)
+    input()

example.py

@@ -0,0 +1,10 @@
+from .blossom_interface import BlossomInterface
+import logging
+
+__version__ = '1.0.0'
+__description__ = 'A interface to control blossom via network or local usb.'
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+__all__ = [BlossomInterface]