Help Implementing Bluetooth Classic RFCOMM program upload/run on EV3 without USB

[GLEM-Nambiar]

Hi Pybricks team and community,

I am looking for some help getting wireless program uploading working on the LEGO MINDSTORMS EV3 with Pybricks.

My main goal is simple:

Computer / VS Code
        ↓
Bluetooth or another wireless connection
        ↓
EV3 running Pybricks
        ↓
Upload Python program
        ↓
Run program

I would like to be able to program the EV3 from my Mac without having to connect a USB cable every time I want to upload and run a new program.

I am completely fine using USB initially to install Pybricks firmware.

What I am trying to eliminate is needing USB for normal development afterward.

Ideally, I would like a workflow such as:

pybricksdev run bluetooth mover.py

or something similar where I can press Run in VS Code and have the program transferred wirelessly to the EV3.

---

What I am trying to achieve

My ideal workflow would be:

1. Install Pybricks firmware on EV3 using USB once.

2. Disconnect USB.

3. Turn on the EV3.

4. Connect to the EV3 wirelessly from my Mac.

5. Upload a new Python program.

6. Run that program.

7. Modify the program.

8. Upload it again wirelessly.

9. Repeat without reconnecting USB.

The important part for me is:

USB required for firmware installation: OK

USB required every time I run code: NOT desired

---

My setup

I am currently using:

• LEGO MINDSTORMS EV3
• macOS
• VS Code
• Pybricks MicroPython
• pybricksdev
• Custom Pybricks firmware builds
• Bluetooth Classic experiments using RFCOMM

---

What already works

USB program upload works

I can currently upload and run programs using USB.

For example:

pybricksdev run usb test.py

This works correctly.

I can also successfully build custom EV3 Pybricks firmware from source.

The resulting firmware package is:

bricks/ev3/build/firmware.zip

So my development environment itself appears to be working.

---

What I tried with Bluetooth

Because my main goal is wireless uploading, I started experimenting with the Bluetooth Classic RFCOMM work from PR #452 / the ev3-bluetooth-rfcomm branch.

I was able to get an EV3 Python program to listen for an RFCOMM connection.

For example:

from pybricks.messaging import RFCOMMSocket
from pybricks.tools import run_task


async def main():
    sock = RFCOMMSocket()

    print("Waiting for Bluetooth connection...")

    await sock.listen()

    print("Connected!")


run_task(main())

This worked.

I was able to see a successful RFCOMM connection.

For example:

RFCOMM_EVENT_INCOMING_CONNECTION
RFCOMM_EVENT_CHANNEL_OPENED
[btc:rfcomm_listen] Connected

---

I also got Mac → EV3 Bluetooth communication working

On macOS, I created a small native test program using Apple's IOBluetooth framework.

I was able to connect from the Mac to the EV3 over Bluetooth Classic RFCOMM.

I was also able to send data such as:

Hello EV3 from Mac!

and receive it on the EV3.

So I have successfully reached this point:

Mac
 ↓
Bluetooth Classic
 ↓
RFCOMM
 ↓
EV3

That made me think Bluetooth may be a possible transport for wireless program uploading.

However, I do not know if RFCOMM is actually the best or intended solution.

I am open to using a different wireless method if Pybricks already has a better architecture for this.

---

The problem with my current Bluetooth approach

The RFCOMM connection currently requires a Python program on the EV3 to already be running something like:

await sock.listen()

That does not solve my actual problem.

It results in something like:

Connect EV3 using USB
        ↓
Upload Bluetooth receiver program
        ↓
Run receiver program
        ↓
Connect using Bluetooth

But what I want is:

Turn EV3 on
        ↓
EV3 is available wirelessly
        ↓
Computer connects
        ↓
Upload program
        ↓
Run program

I do not want a separate Bluetooth receiver Python program to be required before I can upload the real program.

---

What I found while looking through Pybricks

While investigating the source, I noticed that the Pybricks host system already has commands related to program uploading and execution.

I found commands including:

PBIO_PYBRICKS_COMMAND_WRITE_USER_PROGRAM_META
PBIO_PYBRICKS_COMMAND_WRITE_USER_RAM
PBIO_PYBRICKS_COMMAND_START_USER_PROGRAM

From what I understand, these already provide functionality similar to:

Tell EV3 program size
        ↓
Transfer program bytes
        ↓
Store program
        ↓
Start program

I also found code where USB and Bluetooth register the Pybricks host command handler.

For example:

pbdrv_bluetooth_set_receive_handler(pbsys_command);
pbdrv_usb_set_receive_handler(pbsys_command);

This made me wonder whether there is already a way, or an intended architecture, for adding another wireless host connection.

---

What I tried next

I experimented with modifying the EV3 RFCOMM implementation so that Bluetooth could exist at the firmware level rather than requiring:

RFCOMMSocket.listen()

inside a user program.

I was able to make modified firmware compile successfully.

However, I ran into problems with Bluetooth discoverability/connectability after boot.

At that point I decided that I was probably going too far into modifying the Bluetooth driver without understanding the intended Pybricks architecture.

Rather than continue guessing, I wanted to ask here.

---

My main questions

1. Is wireless program upload to the EV3 already possible?

Is there currently any supported or experimental way to do something equivalent to:

pybricksdev run bluetooth program.py

with the EV3?

If so, I would much rather use the existing method.

---

2. What is the best wireless transport for the EV3?

Would you recommend using:

Bluetooth Classic / RFCOMM

or:

Bluetooth Low Energy

or:

Wi-Fi

or another approach?

My priority is simply getting a reliable wireless connection for uploading and running Pybricks programs.

---

3. Can Bluetooth be available immediately after Pybricks boots?

Ideally I want:

Power on EV3
    ↓
Wireless connection becomes available
    ↓
Computer connects

without first running a Python program such as:

await RFCOMMSocket().listen()

Is there an existing Pybricks host service that provides something like this?

---

4. Can the existing host command system be reused?

Since I found:

WRITE_USER_PROGRAM_META
WRITE_USER_RAM
START_USER_PROGRAM

would a wireless transport normally feed into the existing Pybricks host command system?

Conceptually:

Bluetooth / Wireless
        ↓
Pybricks host protocol
        ↓
Program upload
        ↓
Program start

Or am I misunderstanding the role of those commands?

---

5. Is RFCOMM the wrong layer to modify?

I started modifying:

lib/pbio/drv/bluetooth/rfcomm_btstack.c

but I suspect program uploading should probably be implemented at a higher level.

Is there a host/transport abstraction that I should be looking at instead?

---

6. How does Pybricks normally transfer a compiled program?

On the Mac side, I would eventually like to do:

pybricks-bt mover.py

or possibly add support directly to pybricksdev.

What is the recommended way to compile a .py program into exactly the data that the EV3 program loader expects?

I would prefer to reuse the existing Pybricks tooling rather than recreate the compiler/upload protocol.

---

7. Would this be easier on the current Pybricks 4.1 codebase?

I originally experimented with the RFCOMM development branch.

Would you recommend moving this work to the current Pybricks 4.1 beta/main branch before going any further?

---

I am not committed to RFCOMM

I want to emphasize that RFCOMM itself is not my end goal.

RFCOMM was simply the first wireless method I managed to get working between my Mac and EV3.

My actual goal is:

Edit Python program on computer
        ↓
Upload to EV3 wirelessly
        ↓
Run it

If Bluetooth Classic RFCOMM is not the right solution, I am completely open to another approach.

---

Ideal final result

Ultimately, I would love to be able to do something like:

pybricksdev run bluetooth mover.py

or:

pybricks-bt mover.py

and have it perform:

Connect wirelessly
      ↓
Compile program
      ↓
Upload program
      ↓
Start program
      ↓
Receive program output

Then I could eventually connect that command to the Run button in VS Code.

That would give me a normal development cycle without repeatedly plugging and unplugging USB from the EV3.

---

If anyone can point me toward the correct Pybricks host architecture, an existing wireless implementation, relevant source files, or a better approach than RFCOMM, I would really appreciate the help.

I am happy to test experimental changes and build custom EV3 firmware if necessary.

Thank you!

[laurensvalk]

As it happens, we're working on this right now! We're hoping to publish a test version in a week or so.