unable to connect to nintendo switch joystick using bluetooth

[quantrpeter]

Port, board and/or hardware

waveshare c6 zero

MicroPython version

Hi
I am unable to use bluetooth to connect to nintendo switch joystick. The AI said:

The short answer is that, even though the ESP32-C6 hardware in the Waveshare C6 Zero is dual-mode BLE capable, MicroPython’s current ESP32 “ubluetooth” port only implements the Peripheral (server) role. Central-mode APIs like gap_scan() and gap_connect() are either stubbed out or not fully functional in the v1.25.0 firmware you’re running, so it will never actually discover or connect to a Joy-Con.

Is it true we don't have "central" mode for bluetooth?
thanks
Peter

Reproduction

import ubluetooth
from machine import Pin
import time
import struct

# Bluetooth constants
BLE_NINTENDO_VID = 0x057e  # Nintendo's Vendor ID (confirmed)
BLE_HID_SERVICE = "1812"   # HID Service UUID
BLE_SCAN_DURATION = 15000  # Scan for 15 seconds per cycle

# BLE event codes
IRQ_SCAN_RESULT = 5
IRQ_SCAN_DONE = 6
IRQ_CENTRAL_CONNECT = 1
IRQ_CENTRAL_DISCONNECT = 2
IRQ_GATTC_SERVICE_RESULT = 7
IRQ_GATTC_CHARACTERISTIC_RESULT = 8
IRQ_GATTC_READ_RESULT = 11
IRQ_GATTC_NOTIFY = 16

class BLEJoyCon:
    def __init__(self):
        self.ble = ubluetooth.BLE()
        self.ble.active(True)
        self.ble.irq(self.ble_irq)
        self.connected = False
        self.conn_handle = None
        self.hid_char_handle = None
        self.target_addr = None
        self.scan()

    def ble_irq(self, event, data):
        try:
            if event == IRQ_SCAN_RESULT:
                addr_type, addr, adv_type, rssi, adv_data = data
                addr = bytes(addr)
                addr_str = ':'.join(['%02x' % b for b in addr])
                vid_bytes = BLE_NINTENDO_VID.to_bytes(2, 'little')
                vid_detected = vid_bytes in adv_data
                # Print ALL advertisement data as hex for debugging
                #print("ADV DATA HEX:", [hex(b) for b in adv_data], "Address:", addr_str, "RSSI:", rssi)
                # Check for Joy-Con (R) specifically
                if b'Joy-Con (R)' in adv_data or vid_detected:
                    print("Found Nintendo Joy-Con (R):", adv_data)
                    self.target_addr = (addr_type, addr)
                    self.ble.gap_scan(None)
                    self.ble.gap_connect(addr_type, addr)

            elif event == IRQ_SCAN_DONE:
                print("Scan completed")
                if not self.connected and not self.target_addr:
                    print("No Nintendo controller found, attempting direct connection...")

            elif event == IRQ_CENTRAL_CONNECT:
                self.conn_handle, addr_type, addr = data
                self.connected = True
                addr_str = ':'.join(['%02x' % b for b in bytes(addr)])
                print("Connected to", addr_str)
                self.ble.gattc_discover_services(self.conn_handle)

            elif event == IRQ_CENTRAL_DISCONNECT:
                self.connected = False
                self.conn_handle = None
                self.target_addr = None
                print("Disconnected")
                self.scan()

            elif event == IRQ_GATTC_SERVICE_RESULT:
                conn_handle, start_handle, end_handle, uuid = data
                # Print ALL discovered service UUIDs for debugging
                print("Service found:", uuid)
                if conn_handle == self.conn_handle and uuid == ubluetooth.UUID(BLE_HID_SERVICE):
                    print("Found HID service")
                    self.ble.gattc_discover_characteristics(self.conn_handle, start_handle, end_handle)

            elif event == IRQ_GATTC_CHARACTERISTIC_RESULT:
                conn_handle, def_handle, value_handle, properties, uuid = data
                if conn_handle == self.conn_handle and "2A4D" in str(uuid):
                    self.hid_char_handle = value_handle
                    print("Found HID characteristic")
                    self.ble.gattc_write(self.conn_handle, self.hid_char_handle, b'\x01\x00', 1)

            elif event == IRQ_GATTC_NOTIFY:
                conn_handle, value_handle, notify_data = data
                if conn_handle == self.conn_handle and value_handle == self.hid_char_handle:
                    self.parse_hid_data(notify_data)
        except Exception as e:
            print("IRQ error:", e)

    def scan(self):
        print("Scanning for devices...")
        self.ble.gap_scan(BLE_SCAN_DURATION, 30000, 30000)

    def parse_hid_data(self, data):
        try:
            if len(data) >= 10:
                buttons = data[3]
                stick_x = (data[6] | (data[7] << 8)) & 0xFFF
                stick_y = (data[8] | (data[9] << 8)) & 0xFFF
                print("Buttons:", bin(buttons), "Stick X:", stick_x, "Stick Y:", stick_y)
                if buttons & 0x01:
                    print("A button pressed")
                if buttons & 0x02:
                    print("B button pressed")
                if buttons & 0x04:
                    print("X button pressed")
                if buttons & 0x08:
                    print("Y button pressed")
            else:
                print("Short HID report:", [hex(b) for b in data])
        except Exception as e:
            print("Error parsing HID data:", e)

    def stop(self):
        if self.connected:
            self.ble.gap_disconnect(self.conn_handle)
        self.ble.active(False)

# Initialize and run
try:
    joycon = BLEJoyCon()
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    joycon.stop()
    print("Stopped")
except Exception as e:
    print("Main error:", e)

Expected behaviour

Observed behaviour

Additional Information

No, I've provided everything above.

Code of Conduct

Yes, I agree

[peterhinch]

I have converted this to a discussion: I don't think this is a valid bug report.

[shariltumin]

I suggest you try with a simple scan first:

import bluetooth

def ble_irq(event, data):
    print('IRQ event:', event, 'IRQ data:', data)

ble = bluetooth.BLE()
ble.active(True)

ble.irq(ble_irq)

# do the scan
ble.gap_scan(1000, 30000, 30000)

You should get some data printed out

...
IRQ event: 5 IRQ data: (1, <memoryview>, 0, -86, <memoryview>)
IRQ event: 5 IRQ data: (1, <memoryview>, 0, -89, <memoryview>)
IRQ event: 5 IRQ data: (1, <memoryview>, 3, -86, <memoryview>)
IRQ event: 5 IRQ data: (0, <memoryview>, 0, -96, <memoryview>)
IRQ event: 5 IRQ data: (0, <memoryview>, 0, -89, <memoryview>)
IRQ event: 5 IRQ data: (0, <memoryview>, 0, -93, <memoryview>)
...
IRQ event: 5 IRQ data: (1, <memoryview>, 0, -90, <memoryview>)
IRQ event: 5 IRQ data: (0, <memoryview>, 0, -95, <memoryview>)
IRQ event: 6 IRQ data: ()

MicroPython BLE do supports the client role, and the ble.gap_scan() and ble.gap_connect functions work. Don't believe your AI blindly. Try asking the same question to a different AI. Be specific with your questions. AI can be helpful.

I asked perplexity, "Why I can not connect the nintendo switch joystick to ESP32 BLE running MicroPython"

The answer I got was:

Connecting a Nintendo Switch joystick to an ESP32 via Bluetooth Low Energy (BLE) in MicroPython faces fundamental compatibility challenges due to protocol differences. Here's a technical breakdown:

Key Compatibility Issues

1. Protocol Mismatch:
   Nintendo Switch controllers use Bluetooth Classic (BR/EDR) for communication, not BLE. Most ESP32 BLE implementations in MicroPython only support BLE (not Classic).

2. Hardware Limitations:
   Only original ESP32 chips support Bluetooth Classic. ESP32-C3/ESP32-S3 variants lack BR/EDR support, making them incompatible with Switch controllers.