Issues receiving commands over bluetooth

[jelleholtkamp]

Hi,

I'm working on a project where I want the hub to be listening for incoming commands. I have a sort-of working concept, but there's a couple of things I'm struggling with. Admittedly, it is code that I found somewhere on the internet and modified a while ago so I'm not 100% sure on what everything does anymore. I have a couple of questions

1. The main issue is that the hub waits for me to press the button before it processes the command. I want the hub to start processing as soon as it receives a command. I can tell when it receives, because the light will turn solid blue instead of blinking.
2. At the time I never really figured out how to send a proper payload. Specifically how send them in any particular size. I figured out that for some reason if I make it 48 bits it would work, so I just wrote some code to append underscores untill it was of that length. I found this article explaining that there are particular headers in a message you need to send, but I'm not sure how to apply this.
3. At the time I used the BleakClient for sending the commands, but is there a better option?

Also I realise that there are more efficient ways to structure the code than a bunch of if/elifs but I'll get to that when I fix the above mentioned issues.

The code I'm running on the hub:

from pybricks.pupdevices import Motor, ColorSensor
from pybricks.parameters import Port, Color
from pybricks.tools import wait, run_task
from usys import stdin, stdout
from uselect import poll
from pybricks.hubs import PrimeHub
from pybricks.parameters import Side

# Initialize devices
motor = Motor(Port.A)
hub = PrimeHub()
hub.display.orientation(up=Side.RIGHT)

# Register stdin for polling
keyboard = poll()
keyboard.register(stdin)

async def play_sound(frequency, duration):
    await hub.speaker.beep(frequency, duration)

# Main loop
while True:
    # Notify readiness
    stdout.buffer.write(b"rdy\n")
    stdout.flush()  # Ensure it gets sent immediately

    # Check for input (non-blocking)
    cmd = stdin.buffer.read(48)

    # Debug: Log the received command
    print(f"Received: {cmd}")

    # Skip processing the "ready" acknowledgment
    if cmd.startswith(b"rdy"):
        continue

    # Process commands
    if cmd.startswith(b"co_"):
        if cmd.startswith(b"co_GREEN"):
            hub.light.on(Color.GREEN)
            print("Set light to GREEN")  # Debug
        elif cmd.startswith(b"co_YELLOW"):
            hub.light.on(Color.YELLOW)
            print("Set light to YELLOW")  # Debug
        elif cmd.startswith(b"co_RED"):
            hub.light.on(Color.RED)
            print("Set light to RED")  # Debug
        elif cmd.startswith(b"co_BLUE"):
            hub.light.on(Color.BLUE)
            print("Set light to BLUE")  # Debug

    elif cmd.startswith(b"me_"):
        message = str(cmd[3:], "utf-8").rstrip("_")
        hub.display.text(message, 1000)
        print(f"Displayed message: {message}")  # Debug

    elif cmd.startswith(b"cs_"):
        # Read the color sensor value
        color_sensor = ColorSensor(Port.D)
        color = str(color_sensor.color())
        stdout.buffer.write(color.encode("utf-8"))
        stdout.flush()
        print(f"Read color: {color}")  # Debug

    elif cmd.startswith(b"so_"):
        message = str(cmd[3:], "utf-8")
        print(f"Received sound command: {message}") 
        sounds = message.split(",")
        for sound in sounds:
            frequency, duration = sound.split("/")
            run_task(play_sound(int(frequency), int(duration)))
            print(f"Played sound: {frequency} Hz for {duration} ms")  # Debug
    else:
        # Optional: Perform idle tasks
        wait(100)
        # run_task(play_sound(int(200), int(200)))

I currently use the following code to test sending commands:

"""
Example program for computer-to-hub communication.

Requires Pybricks firmware >= 3.3.0.
"""

import asyncio
import logging
import time
from contextlib import suppress
from usys import stdin
from bleak import BleakScanner, BleakClient

PYBRICKS_COMMAND_EVENT_CHAR_UUID = "c5f50002-8280-46da-89f4-6d8051e4aeef"

# Replace this with the name of your hub if you changed
# it when installing the Pybricks firmware.
HUB_NAME = "Henkie"

logging.basicConfig(level=logging.INFO)


last_received = None

async def main():
    global last_received
    main_task = asyncio.current_task()

    def handle_disconnect(_):
        print("Hub was disconnected.")

        # If the hub disconnects before this program is done,
        # cancel this program so it doesn't get stuck waiting
        # forever.
        if not main_task.done():
            main_task.cancel()

    ready_event = asyncio.Event()

    def handle_rx(_, data: bytearray):
        global last_received
        if data[0] == 0x01:  # "write stdout" event (0x01)
            payload = data[1:]

            if payload == b"rdy":
                ready_event.set()
            else:
                last_received = payload
                print("Received:", payload)

    # Do a Bluetooth scan to find the hub.
    device = await BleakScanner.find_device_by_name(HUB_NAME)

    if device is None:
        print(f"could not find hub with name: {HUB_NAME}")
        return

    # Connect to the hub.
    async with BleakClient(device, handle_disconnect) as client:

        # Subscribe to notifications from the hub.
        await client.start_notify(PYBRICKS_COMMAND_EVENT_CHAR_UUID, handle_rx)

        # Shorthand for sending some data to the hub.
        async def send(data):
            # Wait for hub to say that it is ready to receive data.
            await ready_event.wait()
            # Prepare for the next ready event.
            ready_event.clear()
            # Send the data to the hub.
            await client.write_gatt_char(
                PYBRICKS_COMMAND_EVENT_CHAR_UUID,
                b"\x06" + data,  # prepend "write stdin" command (0x06)
                response=True
            )

        # Tell user to start program on the hub.
        print("Start the program on the hub now with the button.")
        
        # # Prefix me_
        message = "so_400/200,600/300"
        logging.info(f"Sending command: {message}")

        # # Add underscores untill it is 24 characters long
        message = message.ljust(48, "_")

        actionable_byte_data = message.encode()
        
        # actionable_byte_data = message.encode()
        await send(actionable_byte_data)       

        # Send a message to indicate stop.
        await send(b"bye")

        print("done.")

    # Hub disconnects here when async with block exits.

# Run the main async program.
if __name__ == "__main__":
    with suppress(asyncio.CancelledError):
        asyncio.run(main())