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())

[BertLindeman]

Hi Jelle (I assume).

Sorry for the late answer.

Did you make any progress on this already?

At first glance, and that has nothing to do with the problem you post here:
Why do you make all messages 48 bytes long (and document them to be 24 bytes).
It is good to have the messages all the same size.
Although I forgot why...

Where I might see a problem related thing:

1. the test if payload == b"rdy": might not hit if there is a newline and / or carriage-return in the message.
   maybe if payload[:3] == b"rdy":

2. When I run the programs I see the first message being sent from the PC before the rdy is received from the hub.
   Probably due to the way ready_event is used.

Let me know if you need more hints 😄

Bert