Transmit xBox controls from a TechnicHub and display them on another hub

[BertLindeman]

TechnicHub disconnects from the PC on connect to an xBox controller.
That makes it hard to debug.

Maybe these programs help a bit:

Program	description
xbox_example_config.py	The common configuration
xbox_example_sender.py	Program to run on the hub that connects to the xbox controller
xbox_example_receiver.py	Program that shows the xbox controls

How to use:

• Upload all 3 programs to beta.pybricks.com. Later code.pybricks.com will be OK too (if at 2.6.0 or later)
• Load the sender program to the hub and connect the xbox.
  The hub will disconnect (if it's a TechnicHub) or disconnect yourself.
• Load the receiver program into another hub (not a MoveHub) and see the controls in the pybricks terminal screen.

The programs (clicl to open):

xbox_example_sender.py

"""Test technic HUB / xbox controller combination
   broadcast the status of the controller via BLE,
   so another HUB can print the data to the PC

   (C) 2024 Program by Bert Lindeman
   Free for non-commercial, personal use.
"""

# Updates:
# 20240228 BL Send all buttons in one tranmission
#             make sure the value of each one is correctly mapped.
# 20241003 BL Move some shared procedures to xbox_example_config.py

# /BL a few lines to delimit the python-style checker messages:
# pylint: disable=E0401  # Unable to import 'ustruct'
# pylint: disable=W0603  # using global
# pylint: disable=R0801  # Similar lines in 2 files
# pylint: enable=C0116  # Missing function or method docstring

import ustruct as struct
import usys as sys
import uio

from pybricks.hubs import TechnicHub
from pybricks.iodevices import XboxController
# from pybricks.parameters import Port
from pybricks.parameters import Color
# from pybricks.parameters import Button  # imported in the config program
# from pybricks.pupdevices import Motor
from pybricks.tools import wait

# import constants that are for both the sender and the receiver:
import xbox_example_config

BROADCAST_CHANNEL = xbox_example_config.BROADCAST_CHANNEL
DEBUG_MAP = xbox_example_config.DEBUG_MAP  # debug the mapping functions and after that stop
DEBUG = xbox_example_config.DEBUG

# Initialize the HUB.
HUB = TechnicHub(broadcast_channel=BROADCAST_CHANNEL)

# Use two different buffer formats but use only ONE buffer (The largest)

# Create a reusable xmit_buffer 8 bytes for various buttons and two bytes unsigned int for all pressed buttons
XBOX_BUFFER_FMT = xbox_example_config.XBOX_BUFFER_FMT

# 4 long string,
# a halfword,
# the MAX payload is 26 bytes so the varing length string can be max 19 long
# MAX_VAR_STR_LEN = xbox_example_config.MAX_VAR_STR_LEN
# XMIT_BUFFER_FMT = xbox_example_config.XMIT_BUFFER_FMT

# Take the largest of the two buffers, so it will always fit.
BUFFER_SIZE = struct.calcsize(XBOX_BUFFER_FMT)

# BUFFER_SIZE = max(struct.calcsize(XMIT_BUFFER_FMT), struct.calcsize(XBOX_BUFFER_FMT))
print("xmit_buffer size:", BUFFER_SIZE)
xmit_buffer = bytearray(BUFFER_SIZE)
BUFFER_OFFSET = 0

# pylint: disable=C0103
fixed_str = 3 * " "  # 3 byte long global variable, to prevent garbage collect
# max length (plus some spare) of variable string; global to prevent garbage collect
# variable_str = (MAX_VAR_STR_LEN + 16) * 0x00

XBOX_LONG_KEY = xbox_example_config.XBOX_LONG_KEY

XBOX_SHORT_KEY = {v: k for k, v in XBOX_LONG_KEY.items()}  # the inverse of XBOX_LONG_KEY

BUTTON_MAP = xbox_example_config.BUTTON_MAP


def encode_buttons(buttons):
    """
        function to encode all buttons into an unsigned int
    """
    # Initialize the encoded value
    encoded = 0

    # Set the corresponding bit for each button
    for button in buttons:
        if DEBUG:
            print("try button", type(button), button, end="\t")
        if button in BUTTON_MAP:
            if DEBUG:
                print("encode BUTTON_MAP[button]", BUTTON_MAP[button])
            encoded |= 1 << BUTTON_MAP[button]
    # Check if the encoded value exceeds the 16-bit range
    if encoded > 65535:
        print("Warning: Encoded value exceeds 16-bit range!")
    if DEBUG:
        print("in encode:", buttons, "encoded:", encoded)
    # if bytes needed: encoded.to_bytes(2, 'little')
    return encoded


# pylint: disable=R0913  # Too many arguments (8/5) (too-many-arguments)
# pylint: disable=R0914  # Too many local variables
# Define a function to pack the variables into a struct so we can transmit all in ONE broadcast
def pack_variables_into_buffer(lt, rt, jlh, jrh, jlv, jrv, dpad, prof, encoded_buttons):
    """ create the buffer containing each joystick-like values plus all buttons"""
    # Map the variables to bytes
    lt_int = xbox_example_config.map_to_int(lt)
    rt_int = xbox_example_config.map_to_int(rt)
    jlh_int = xbox_example_config.map_to_int(jlh)
    jrh_int = xbox_example_config.map_to_int(jrh)
    jlv_int = xbox_example_config.map_to_int(jlv)
    jrv_int = xbox_example_config.map_to_int(jrv)
    dpad_int = xbox_example_config.map_to_int(dpad)
    prof_int = xbox_example_config.map_to_int(prof)
    if DEBUG:
        print("\tprof_int      ", type(prof_int), prof_int)
        print("\tencoded buttons", type(encoded_buttons), encoded_buttons)

    # # Pack the bytes into a struct
    return struct.pack_into(XBOX_BUFFER_FMT, xmit_buffer, 0, lt_int, rt_int,
                            jlh_int, jrh_int, jlv_int, jrv_int, dpad_int, prof_int, encoded_buttons)


def pack(fixed_in, var_in):
    """
    This function packs the fixed length string and variable length string into a struct.
    The struct format is defined as follows:
    - "!"  : network byte order (big-endian) for the data in the struct
    - '4s' : a fixed length string of 4 characters
    - 'H'  : a two byte field indicating the length of the following string
    - '{}s': a variable length string, with max length 19 due to payload max of broadcast (26).
    The size of a string in this case is the number of bytes in the string plus one byte.
    """
    global xmit_buffer

    if not 1 <= len(fixed_str) <= 4:
        print("ERR\tfixed code should be 1 to 4 bytes long, got '" + str(fixed_in) + "'")
        xmit_buffer = 0x00  # indicate no data
        return

    # if len(var_in) > MAX_VAR_STR_LEN:
    #     print("ERR\tVariable string must not exceed MAX_VAR_STR_LEN characters, now", len(var_in))
    #     var_in = var_in[0:MAX_VAR_STR_LEN - 2]
    #     return

    if DEBUG:
        print("pack_into var len", len(var_in), "'" + str(var_in) + "'")
    # Pack the data into the xmit_buffer
    struct.pack_into(f'!4sH{len(var_in)}s', xmit_buffer, 0, fixed_in, len(var_in), var_in)


def transmit_xbox_data(hub, ctrl):
    """
        broadcast xBox controller buttons etc.
    """
    if ctrl.buttons.pressed():
        hub.light.on(Color.ORANGE)
        if DEBUG:
            print("in transmit buttons:", list(ctrl.buttons.pressed()))
    lt = ctrl.triggers()[0]  # left trigger
    rt = ctrl.triggers()[1]  # right trigger
    jlh = ctrl.joystick_left()[0]    # horizontal
    jlv = ctrl.joystick_left()[1]    # vertical
    jrh = ctrl.joystick_right()[0]   # horizontal
    jrv = ctrl.joystick_right()[1]   # vertical
    dpad = ctrl.dpad()
    prof = ctrl.profile()
    buttons_code = encode_buttons(list(ctrl.buttons.pressed()))
    if any([lt, rt, jlh, jlv, jrh, jrv, dpad, prof]):
        hub.light.on(Color.CYAN)
        if DEBUG:
            print("At least one joystick value is non-zero.")

    pack_variables_into_buffer(lt, rt, jlh, jrh, jlv, jrv, dpad, prof, buttons_code)
    buffer_needed = struct.calcsize(XBOX_BUFFER_FMT)
    if DEBUG:
        print("len used:", buffer_needed, "used", (xmit_buffer[0:buffer_needed]))
    hub.ble.broadcast(xmit_buffer[0:buffer_needed])
    hub.light.on(Color.YELLOW)


def transmit_controller(hub, this_code, this_item):
    """
    Broadcast a transmit buffer
    """
    HUB.light.on(Color.MAGENTA)
    if DEBUG:
        print("transmit_controller", this_code, this_item)
    xmit_data_type = XBOX_LONG_KEY[this_code]
    # Pack data into the xmit_buffer
    if not isinstance(this_item, str):
        print(xmit_data_type, str(this_item), type(this_item))
        wait(2000)
    if DEBUG:
        print("pack(", xmit_data_type, ",", this_item, ")")
    pack(xmit_data_type, str(this_item))
    # buffer_needed = 6 + len(this_item)  # 4 str + 2 Halfword
    buffer_needed = struct.calcsize(f'!4sH{len(this_item):<1}s')
    if DEBUG:
        print("len used:", buffer_needed, "used", (xmit_buffer[0:buffer_needed]))
    hub.ble.broadcast(xmit_buffer[0:buffer_needed])
    HUB.light.on(Color.YELLOW)
    wait(100)


def split_string(s, chunk_size):
    """
        Split a string in chunks to fit in a bluetooth buffer
    """
    return [s[i:i + chunk_size] for i in range(0, len(s), chunk_size)]


if DEBUG_MAP:
    # test mapping:
    for __i in range(-100, 100):
        __byte = xbox_example_config.map_to_int(__i)
        __value = xbox_example_config.byte_to_value(__byte)
        correct = __i == __value
        print("check", __i, "byte", __byte, "value again", __value, correct)
        raise SystemExit(99)


try:
    controller = XboxController()  # the default
    # 'stay_connected=True' instructs a Technic hub to KEEP the PC connection, so no disconnect.
    # Does NOT work on windows / MAC
    # controller = XboxController(stay_connected=True)  # Works on Android, but not on windows.
    # controller = XboxController(stay_connected=False)
    print("connected")
except Exception:  # pylint: disable=W0718  # Catching too general exception Exception
    print("No controller found")
    print("abandon run")
    controller = None

try:
    while True:
        HUB.light.on(Color.YELLOW)

        if controller is None:
            HUB.light.on(Color.RED)
            wait(2000)
            raise SystemExit(0)  # just transmit once to test the transmission

        transmit_xbox_data(HUB, controller)

        HUB.light.on(Color.GREEN)

        # Broadcasts are only sent every 100 milliseconds,
        # so there is no reason to call the broadcast() method more often than that.
        # Within function transmit_controller is a wait(100)
        # so no need for it here..........
except Exception as e:
    # In MicroPython, sys.print_exception(e) prints the exception to the standard error stream,
    # it does not return the exception as a string.
    # A workaround: redirect the standard output
    # to a "file" in storage,
    # and get the traceback from there:

    my_file = uio.StringIO()
    sys.print_exception(e, my_file)  # write the exception to this memory file
    traceback_info = my_file.getvalue()
    print('\n====================\nTraceback info:\n',
          traceback_info, "\n====================\n")

    raise SystemExit(2) from e

xbox_example_receiver.py

"""
program to show the tranmissions of program xbox_example_sender.py

The technichub disconnects from the PC on connection to an xbox controller
xbox_example_sender sends the status of buttons and other knobs, coded in one transmission

Intention is that the technic hub also sends data about error conditions.
The transmit has only limmited size: 26

(C) 2024 Bert Lindeman
Free for non-commercial, personal use.

"""

# tools/android/xbox_example_receiver.py

# 20240228 BL Send all buttons and joystick-like values in one tranmission
# 20241002 BL Allow all hubs to do this, except the movehub.

# pylint: disable=E0401  # Unable to import 'struct'
# pylint: disable=W0603  # using global
# pylint: disable=R0801  # Similar lines in 2 files
# pylint: disable=C0116  # Missing function or method docstring

import ustruct as struct

from pybricks.hubs import ThisHub
# from pybricks.parameters import Color
# from pybricks.parameters import Button  # imported in the config program
from pybricks.tools import wait, StopWatch

import xbox_example_config

OBSERVE_CHANNEL = xbox_example_config.OBSERVE_CHANNEL
MAX_VAR_STR_LEN = xbox_example_config.MAX_VAR_STR_LEN

# Set up all devices.
HUB = ThisHub(observe_channels=[OBSERVE_CHANNEL])
DEBUG = xbox_example_config.DEBUG
DEBUG_BUFFER = xbox_example_config.DEBUG_BUFFER

# Create a reusable xmit_buffer
XBOX_BUFFER_FMT = xbox_example_config.XBOX_BUFFER_FMT

# 4 long string, halfword, as MAX payload is 26 bytes so var may be 19 long?
XMIT_BUFFER_FMT = xbox_example_config.XMIT_BUFFER_FMT

xmit_buff_size_errors = struct.calcsize(XMIT_BUFFER_FMT)  # Size of this structure
xmit_buff_size_buttons = struct.calcsize(XBOX_BUFFER_FMT)  # Size of this structure
BUFFER_SIZE = max(xmit_buff_size_errors, xmit_buff_size_buttons)

print("xmit_buffer size:", BUFFER_SIZE)
xmit_buffer = bytearray(BUFFER_SIZE)
BUFFER_OFFSET = 0

# pylint: disable=C0103
fixed_str = 3 * " "  # 3 byte long global to prevent garbage collect
# max length ( plus some spare) of variable string; global to prevent garbage collect
variable_str = (MAX_VAR_STR_LEN + 16) * 0x00

XBOX_LONG_KEY = xbox_example_config.XBOX_LONG_KEY

# invert the long / short codes
XBOX_SHORT_KEY = {v: k for k, v in XBOX_LONG_KEY.items()}  # the inverse

none_index = 0

ARROWS = {  # from http://xahlee.info/comp/unicode_arrows.html
    0: '   ',  # Nothing
    1: '\u21E7',  # Up
    2: '\u2B00',  # Up-Right
    3: '\u21E8',  # Right
    4: '\u2B02',  # Down-Right
    5: '\u21E9',  # Down
    6: '\u2B03',  # Down-Left
    7: '\u21E6',  # Left
    8: '\u2B01',  # Up-Left
}


WIDTH = 30
# define "line number" and "character position" on that line for each item
PRINT_POS = {
    b"LT": (1, 1),
    b"RT": (1, WIDTH),
    b"JLH": (2, 1),
    b"JRH": (2, WIDTH),
    b"JLV": (3, 1),
    b"JRV": (3, WIDTH),
    b"DPAD": (4, 1),
    b"PROF": (4, WIDTH),
    b"LETB1": (5, WIDTH),       # button  Y
    b"LETB2": (6, WIDTH),       # button x b
    b"LETB3": (7, WIDTH),       # button a
    b"LETB4": (5, 3),           # button GUIDE
    b"LETB5": (6, 3),           # button view button menu
    b"LETB6": (7, 3),           # button upload
    b"LETB7": (1, 14),          # Bumpers
    b"LETB8": (2, 13),          # Left joystick
    b"LETB9": (2, WIDTH - 6),   # Right joystick
    b"BTTN": (9, 1),            # button code + text
    b"None": (16, 1),           # nothing received
}

# ANSI code parts
ESC = '\x1b['
ESC0 = ESC + "0"
ESC1 = ESC + "1"
ESC7 = ESC + "7"

endColor = ESC0 + 'm'

# pylint: disable=C0321  # More than one statement on a single line
# noqa=E203  # whitespace before ';'
# noqa=E702  # multiple commands on one line
_green  = ";92m" ; green  = ESC0 + _green  ; brgreen  = ESC1 + _green  ; rvgreen  = ESC7 + _green   # noqa
_red    = ";31m" ; red    = ESC0 + _red    ; brred    = ESC1 + _red    ; rvred    = ESC7 + _red     # noqa
_yellow = ";33m" ; yellow = ESC0 + _yellow ; bryellow = ESC1 + _yellow ; rvyellow = ESC7 + _yellow  # noqa

clear_log = ESC + "H" + ESC + "2J"

BUTTON_MAP = xbox_example_config.BUTTON_MAP

# Calculate the inverse button mapping
BIT_TO_BUTTON_MAP = {v: k for k, v in BUTTON_MAP.items()}

# # pylint: disable=C0103
# fixed_str = "   "  # 3 byte long global to prevent garbage collect
variable_str = 255 * 0x00  # max length of variable string also global to prevent garbage collect


def decode_buttons(encoded):
    # Initialize the list of pressed buttons
    buttons = []

    # Check each bit in the value
    for bit, button in BIT_TO_BUTTON_MAP.items():
        # If the bit is set, add the button to the list
        if encoded & (1 << bit):
            buttons.append(str(button))

    # # Convert the list of pressed buttons to a string
    # return ', '.join(buttons)
    # print(print_pos_func("None"), f'in decode_buttons with {type(encoded)} {encoded} return {buttons}')
    return buttons


def unpack():
    """
    This function unpacks the data from the struct into the variables packed in there
    """
    global fixed_str
    global variable_str

    if isinstance(xmit_buffer, type(None)):
        print("ERR\tgot invalid xmit_buffer:", xmit_buffer[0])
        return "", ""

    fixed_str, var_len = struct.unpack_from('!4sH', xmit_buffer, BUFFER_OFFSET)
    # place the rest at offset (fixed length + length byte length) = 6
    variable_str = struct.unpack_from(f'!{var_len}s', xmit_buffer, 6)[0]

    if fixed_str == b"B   " and len(variable_str) > 0:
        variable_str_button = decode_buttons(variable_str)
        variable_str = variable_str_button

    return fixed_str, variable_str


def print_pos_func(var_name):
    var_bytes = bytes(var_name, 'utf-8')
    # print(f"in print_pos_func({var_bytes}) type {type(var_bytes)}")
    prt_line = f'\x1b[H\x1b[{PRINT_POS[var_bytes][0]}B'
    prt_pos = f'\x1b[{PRINT_POS[var_bytes][1]}C'
    return prt_line + prt_pos  # Move the cursor to line x and position y


def print_one_control_on_screen(ctrl, val):
    # print(f'ctrl {type(ctrl)} {ctrl}')
    pos = str(ctrl, 'utf-8').upper()
    if val > 0:
        val_color = brgreen
    elif val < 0:
        val_color = bryellow
    else:
        val_color = ""
    print(print_pos_func(pos), f'{pos:<4} {val_color}{val:>4}{endColor}', end="")


def color_button(but_text):
    # The left and right joystick-PRESS have no lowercase/uppercase letters, but "*"
    if but_text.isupper() or but_text[0] == "*":
        return f'{bryellow}{but_text}{endColor}'
    return f'{but_text}{endColor}'


def print_buttons(buttons_pressed):
    # Mapping button names to their printed forms
    pressed_but_map = {
        'Button.A': 'A', 'Button.B': 'B', 'Button.X': 'X', 'Button.Y': 'Y',
        'Button.GUIDE': 'GUIDE', 'Button.VIEW': 'VIEW ', 'Button.MENU': 'MENU ',
        'Button.UPLOAD': 'UPLOAD', 'Button.LB': 'LB', 'Button.RB': 'RB',
        'Button.LJ': '*<*', 'Button.RJ': '*>*'
    }

    # Default lowercase versions
    default_button_map = {
        'Button.A': 'a', 'Button.B': 'b', 'Button.X': 'x', 'Button.Y': 'y',
        'Button.GUIDE': 'guide', 'Button.VIEW': 'view ', 'Button.MENU': 'menu ',
        'Button.UPLOAD': 'upload', 'Button.LB': 'lb', 'Button.RB': 'rb',
        'Button.LJ': ' < ', 'Button.RJ': ' > '
    }

    # Create a dictionary that holds the result based on presence in buttons_pressed
    printed_buttons = {
        name: pressed_but_map.get(name, default_button_map.get(name))
        if name in buttons_pressed
        else default_button_map.get(name)
        for name in pressed_but_map
    }

    # Remove processed buttons from the list
    remaining_buttons = tuple(button for button in buttons_pressed if button not in pressed_but_map)

    # Format and color the button strings
    return (
        f'  {color_button(printed_buttons["Button.Y"])}',
        f'{color_button(printed_buttons["Button.X"])}   {color_button(printed_buttons["Button.B"])}',
        f'  {color_button(printed_buttons["Button.A"])}   ',
        f'    {color_button(printed_buttons["Button.GUIDE"])}   ',
        f'{color_button(printed_buttons["Button.VIEW"])}    {color_button(printed_buttons["Button.MENU"])}',
        f'    {color_button(printed_buttons["Button.UPLOAD"])}   ',
        f'{color_button(printed_buttons["Button.LB"])}        {color_button(printed_buttons["Button.RB"])}',
        f'{color_button(printed_buttons["Button.LJ"])}',
        f'{color_button(printed_buttons["Button.RJ"])}',
    ), remaining_buttons


def print_and_color_controls_on_screen(buffer):
    lt, rt, jlh, jrh, jlv, jrv, dpad, prof, bttn = unpack_variables(buffer)

    ctrl_variables = {
        'lt': lt,
        'rt': rt,
        'jlh': jlh,
        'jrh': jrh,
        'jlv': jlv,
        'jrv': jrv,
        'dpad': dpad,
        'prof': prof,
        'bttn': bttn
    }

    # You can now access both the name and the value of each variable
    for this_ctrl, this_value in ctrl_variables.items():
        if DEBUG:
            print(f'this_ctrl {type(this_ctrl)} {this_ctrl}')
        if this_ctrl == 'dpad':
            print(print_pos_func(b"DPAD"), f'{"DPAD":<4} {int(dpad):>4}{bryellow}', end=" ")
            # wait(25)  # this helps to keep the utf8 arrows intact (no longer needed)
            print(ARROWS[dpad], end="")
            # wait(25)  # this helps to keep the utf8 arrows intact (no longer needed)
            print(f'{endColor}')
        elif this_ctrl == 'bttn':
            if DEBUG:
                print(print_pos_func(b"BTTN"), "\n\n\n\n", end="")
                print(type(bttn), end=" ")
                print(bttn, hex(bttn), end=" ")
                print(f'{"BTTN":<4}', end=" ")
                print(f'{str(decode_buttons(bttn)):<70}', end="")
            print(print_pos_func(b"BTTN"), f'{bttn:>4} {"BTTN":<4} {str(decode_buttons(bttn)):<150}', end="")

            buttons_pressed_tuple = decode_buttons(bttn)
            l_buttons, updated_buttons = print_buttons(buttons_pressed_tuple)
            if DEBUG:
                print(print_pos_func('None'), "buttons_pressed type", type(buttons_pressed_tuple), "str:", str(buttons_pressed_tuple))
                print(f'updated {type(updated_buttons)} {updated_buttons} str:{str(updated_buttons)}')
                wait(1000)

            print(print_pos_func(b"LETB1"), f'{l_buttons[0]:>1}', end="")     # button y
            print(print_pos_func(b"LETB2"), f'{l_buttons[1]:>1}', end="")     # button x  button b
            print(print_pos_func(b"LETB3"), f'{l_buttons[2]:>1}', end="")     # button a

            print(print_pos_func(b"LETB4"), f'{l_buttons[3]:>6}', end="")     # button guide
            print(print_pos_func(b"LETB5"), f'{l_buttons[4]:>6}', end="")     # button view button menu
            print(print_pos_func(b"LETB6"), f'{l_buttons[5]:>6}', end="")     # button upload

            print(print_pos_func(b"LETB7"), f'{l_buttons[6]:<12}', end="")    # both bumpers

            print(print_pos_func(b"LETB8"), f'{l_buttons[7]:<3}', end="")     # L Joy pressed
            print(print_pos_func(b"LETB9"), f'{l_buttons[8]:<3}', end="")     # R Joy pressed

            # print the remaining buttons that have not yet been printed only confusing, so do not do this
            # print(print_pos_func(b"BTTN"), f'{bttn:>4} {"BTTN":<4} {str(updated_buttons):<150}', end="")

        else:
            print_one_control_on_screen(this_ctrl, this_value)


prev_buffer = b'0x00'


def print_all_controls(_xmit_buffer):
    global prev_buffer, prev_buffer_was_same
    if bytes(_xmit_buffer) == prev_buffer:  # skip further processing to get a more stable screen
        prev_buffer_was_same = True
    else:
        prev_buffer_was_same = False
        prev_buffer = bytes(_xmit_buffer)
        print_and_color_controls_on_screen(xmit_buffer)


def unpack_variables(packed_struct):
    # Unpack the struct into bytes
    (
        lt_byte,
        rt_byte,
        jlh_byte,
        jrh_byte,
        jlv_byte,
        jrv_byte,
        dpad_byte,
        prof_byte,
        button_halfword
    ) = struct.unpack(XBOX_BUFFER_FMT, packed_struct)

    # Convert bytes to values directly within the return statement
    return (
        xbox_example_config.byte_to_value(lt_byte),
        xbox_example_config.byte_to_value(rt_byte),
        xbox_example_config.byte_to_value(jlh_byte),
        xbox_example_config.byte_to_value(jrh_byte),
        xbox_example_config.byte_to_value(jlv_byte),
        xbox_example_config.byte_to_value(jrv_byte),
        xbox_example_config.byte_to_value(dpad_byte),
        xbox_example_config.byte_to_value(prof_byte),
        button_halfword
    )


def show_none_line_if_wanted(none_line_printed, buffer_empty):
    global none_index
    # none_characters = ("-", "/", "|", "\\")
    none_characters = (ARROWS[1], ARROWS[3], ARROWS[5], ARROWS[7])

    if buffer_empty:
        print(print_pos_func(b"None"), "none received ", end="")
        # wait(10)  # this helps to keep the utf8 arrows intact (No longer needed)
        print(none_characters[none_index], end="  ")
        # wait(10)  # this helps to keep the utf8 arrows intact (No longer needed)
        none_index += 1
        if none_index > 3:
            none_index = 0
            none_line_printed = True
    else:
        if none_line_printed:
            # print empty none line
            print(print_pos_func(b"None"), "                     ", end="")
            none_line_printed = False
    return none_line_printed


timer = StopWatch()
print("\x1b[H\x1b[2J", end="")  # Clear the console

# # Test print_pos_func
# for name in PRINT_POS:
#     print(print_pos_func(name), end="")
#     print(f'{name:>4} {PRINT_POS[name]}', end="")
#     wait(500)
#     # print(print_pos_func(name), name, end="")

ERR2_buffer = ""
prev_err2 = ""
empty_none_line_printed = False
prev_buffer_was_same = False

while True:
    xmit_buffer = HUB.ble.observe(OBSERVE_CHANNEL)
    if DEBUG_BUFFER:
        print(xmit_buffer, type(xmit_buffer), f'{str(xmit_buffer):>1}')
        wait(1000)

    if xmit_buffer is None:  # no input now
        empty_none_line_printed = show_none_line_if_wanted(empty_none_line_printed, buffer_empty=True)
    else:
        empty_none_line_printed = show_none_line_if_wanted(empty_none_line_printed, buffer_empty=False)

        if len(xmit_buffer) == xmit_buff_size_buttons:  # Received normal size of data
            if bytes(prev_buffer) == bytes(xmit_buffer):  # only process if buffer differs from previous buffer
                pass
            else:
                print_all_controls(xmit_buffer)
        else:
            print("\nWrong data:", xmit_buffer)
            print("run time:", timer.time(), "mSec\n\n")
            raise SystemExit()

xbox_example_config.py

"""
configuration for xbox_example sender and receiver programs.

(C) 2024 Bert Lindeman
Free for non-commercial, personal use.

"""

from pybricks.parameters import Button

# set your own constants if you like (be consistent on both sides):
BROADCAST_CHANNEL = 57
OBSERVE_CHANNEL = BROADCAST_CHANNEL

MAX_VAR_STR_LEN = 19
# Create a reusable xmit_buffer
XBOX_BUFFER_FMT = '!8BH'  # "H" for a unsigned int of 2 bytes

# 4 long string, halfword, as MAX payload is 26 bytes so var may be 19 long?
XMIT_BUFFER_FMT = "!4sH" + str(MAX_VAR_STR_LEN) + "s"

BUFFER_OFFSET = 0

DEBUG_BUFFER = False
DEBUG_MAP = False  # debug the mapping functions and after that stop
DEBUG = False  # True

# data variables:

# directory of codes to be sent / observed
XBOX_LONG_KEY = {
    'left  trigger': b"LT  ",
    'right trigger': b"RT  ",
    'left  joystick hor': b"JLH ",
    'right joystick hor': b"JRH ",
    'left  joystick vertical': b"JLV ",
    'right joystick vertical': b"JRV ",
    'D-pad': b"DPAD",
    'profile': b"P   ",
    'button': b"B   ",
    # to transmit some error in the sender program
    'error-linenum': b'ERR0',
    'error-program': b'ERR1',
    'error-descript': b'ERR2',
    'end-run': b'ZZZZ',
}


BUTTON_MAP = {
    Button.A: 0, Button.B: 1, Button.X: 2, Button.Y: 3,
    Button.LB: 4, Button.RB: 5,
    Button.LJ: 6, Button.RJ: 7,
    Button.VIEW: 8, Button.MENU: 9, Button.GUIDE: 10, Button.UPLOAD: 11,
    Button.P1: 12, Button.P2: 13, Button.P3: 14, Button.P4: 15
}


# centralized procedures:
def map_to_int(value):
    """ function to map a value to a byte
        Map value from -100 to 100 to 0 to 200.
        A byte can be max 255
    """
    return value + 100


def byte_to_value(byte_value):
    """
        function to map a byte back to a value
        Map byte_value from 0 to 200 back to -100 to 100
    """
    return byte_value - 100

I noticed it is not easy to make a movie with one hand while the other tries to manipulate an xBox conotroller.
So no fancy movie, but it may show a bit of the result of the programs:

xBox.example.mp4

The program(s) might be too difficult and not enough pythonic, so improvements are welcome.

Bert