Mackie Showbox Reverse Engineering

[6stringtheory]

In diesem Thread werde ich meine Erkenntnisse über die Mackie Showbox teilen, die über die offizielle Dokumentation hinausgehen. Jeder der sich anschließen möchte ist herzlich willkommen.
Ziel ist es erstmal die Möglichkeit zu schaffen zusätzliche Hardware für die Mackie Showbox selber zu bauen, die sich den RJ-45 Anschluss zu Nutze macht. Beispielsweise ein Fußschalter, der den Looper mit mehr als nur einem Fußschalter steuern kann. (Ich bevorzuge es beim Loopen einen separaten Stop Schalter zu haben.) Aber auch Fußschalter um Presets zu wechseln sind denkbar.
Ich fange erstmal an mit einem Foto von der Platine des Breakaway Mixers:

Im Anhang liegt auch noch ein Bild von der Vorderseite, aber diese ist relativ uninteressant für den Rahmen des Projektes.

Weitere Erkenntnisse folgen morgen. Ich kann aber schonmal soviel verraten: Die RJ-45 Buchse ist nicht Ethernet-konform.

---

Durchgangsprüfung
Wenn ich hier von Orange, Orange-White, Green, Green-White, Blue, Blue-White, Brown und Brown-White rede, dann beziehe ich mich auf die Drähte im Cat 5 Kabel nach T568B:

Wenn ich von Pin X (mixer) rede, meine ich die Pogo-Pin Kontakte am Breakaway Mixer.
Wenn ich von Pin X (base) rede, meine ich die Pogo-Pins an der Box selbst (Mackie nennt sie oft einfach "Base Unit").
X -> Y, Z bedeutet, dass ein Durchgan von X nach Y, sowie ein Durchgang von X nach Z gemessen wurde.

Breakaway Mixer:

RJ-45:
Cat5 Shield -> Pin 4 (mixer), Pin 7 (mixer), USB Shield (mixer), USB Gnd (mixer), Orange-White, Orange
Orange-White -> Pin 4 (mixer), Pin 7 (mixer), USB Shield, USB Gnd (mixer), Orange, Cat5 Shield
Orange -> Pin 4 (mixer), Pin 7 (mixer), USB Shield (mixer), USB Gnd (mixer), Cat5 Shield, Orange-White
Blue-White -> Pin 3 (mixer)
Blue -> Pin 5 (mixer)
Green-White -> Pin 6 (mixer)
Green -> Pin 2 (mixer)
Brown-White -> Brown
Brown -> Brown-White

Pogo-Pin Interface:
Pin 1 -> ---
Pin 2 -> Green
Pin 3 -> Blue-White
Pin 4 -> Pin 7 (mixer), Cat5 Shield, USB Shield (mixer), USB Gnd (mixer)
Pin 5 -> Blue
Pin 6 -> Green-White
Pin 7 -> Pin 4 (mixer), Cat5 Shield, USB Shield (mixer), USB Gnd (mixer)

USB:
Shield -> Pin 4 (mixer), Pin 7 (mixer), Cat5 Shield, Orange, Orange-White
VCC -> ---
Gnd -> Pin 4 (mixer), Pin 7 (mixer), Cat5 Shield, Orange, Orange-White
D+ -> ---
D- -> ---

Box (Base Unit):

RJ-45:
Cat5 Shield -> Pin 7 (base), Orange-White, Orange
Orange-White -> Pin 7 (base), Cat5 Shield, Orange
Orange -> Pin 7 (base), Cat5 Shield, Orange-White
Green-White -> Pin 6 (base)
Blue -> Pin 5 (base)
Blue-White -> Pin 3 (base), Pin 7 (base), Cat5 Shield, Orange, Orange-White, Brown, Brown-White
Green -> Pin 2 (base)
Brown-White -> Pin 7 (base), Cat5 Shield, Orange, Orange-White, Brown
Brown -> Pin 7 (base), Cat5 Shield, Orange, Orange-White, Brown-White

Pogo-Pins:
Pin 1 -> ---
Pin 2 -> Green
Pin 3 -> Pin 7 (base), Cat5 Shield, Orange, Orange-White, Green-White, Brown, Brown-White, USB Gnd, USB Shield
Pin 4 -> ---
Pin 5 -> Blue
Pin 6 -> Green-White
Pin 7 -> Cat5 Shield, Orange, Orange-White

USB:
Shield -> Pin 7 (base)
VCC -> ---
Gnd -> Pin 7 (base)
D+ -> ---
D- -> ---

---

Spannungsmessung

Alle Messungen werden in folgendem Zustand durchgeführt:
- Showbox ist eingeschaltet
- Breakaway Mixer ist über Cat 5 Kabel mit der Box (Base Unit) verbunden
Für die Messungen der Verbindung der beiden RJ-45 Anschlüsse wird ein einfaches Breakout Board benutzt, welches nichts tut außer die einzelnen Pins/Drähte zugänglich zu machen:

Pogo-Pins (am Breakaway Mixer):

Gnd -> Pin 1: 11.4V
Gnd -> Pin 2: 3.27V
Gnd -> Pin 3: 3.27
Gnd -> Pin 4: 0V
Gnd -> Pin 5: 3.3V
Gnd -> Pin 6: 3.3V

RJ-45 / Cat5 Verbindung:

Gnd -> Orange: 0V
Gnd -> Orange-White: 0V
Gnd -> Blue: 3.30V
Gnd -> Blue-White: 3.26V
Gnd -> Green: 3.26V
Gnd -> Green-White: 3.30V
Gnd -> Brown: 11.84V
Gnd -> Brown-White: 11.84V

---

Erkenntnisse

Es wird sofort klar, dass das keinem Ethernet Standard folgt, wenn die Ladebuchse am Breakaway Mixer erlaubt eine Versorgung mit bis zu 10W. Das wäre mit Ethernet nur über dem PoE-Standard möglich und dieser arbeitet mit wesentlich höheren Spannungen:

Was wir uns aber denken können ist:
- Orange, Orange-White, sowie die Cat 5 Abschirmung sind GND
- Brown und Brown-White übertragen zusammen ~12V welche im Breakaway Mixer dann für den USB Port in 5V gewandelt wird.
- Green, Green-White, Blue, Blue-White haben alle ungefähr 3,3V (was ist eine typische logic-level Spannung, die gerne für die Datenübertragung genutzt wird). Es ist also davon auszugehen, dass die Daten über diese Leitungen fließen.

---

Signal-Analyse
Nun nehme ich mir einen Logic-Analyzer (die sind für unter 10€ auf ebay und aliexpress zu haben und haben gleich 8 Kanäle, hier Z. B.):

Ich verbinde GND der RJ-45 Verbindung mit GND vom Logic-Analyzer. Und Green, Blue, Green-White, sowie Blue-White mit den ersten 4 Kanälen.

Am Rechner nehme ich mir dann den fx2lafw Treiber, welcher sich wunderbar eignet um mit der freien Software PipeView die Signale eines solchen Logic-Analyzers einzufangen und auszuwerten.
Wie ihr nun auf folgendem Screenshot seht, findet eine Datenübertragung lediglich auf den ersten beiden Kanälen statt (Das sind Green und Blue des Cat 5 Kabels (technisch gesehen Pin 6 und 4 des RJ45-Anschluss).

---

Protokoll-Analyse (Erste Schicht)
Da wir nur 2 Datenpins haben, können wir durch ein einfaches Ausschlussverfahren schon hunderte Protokolle ausschließen.
Zwei Protokolle, die naheliegend erscheinen, weil sie vom verwendeten MIMXRT1010 Mikrocontroller unterstützt werden, weit verbreitet sind und nur 2 Datenpins benötigen sind I²C und UART.
I²C benutzt eine Datenleitung allerdings nur für ein Taktsignal. Seht ihr auf dem Screenshot eins? Ich nicht und damit bleibt nur noch UART.
Aber welche Baudrate könnte es sein? Probieren wir doch einfach mal ein paar typische Baudraten aus. 9600 und 115200 sind wahrscheinlich die am weitesten verbreitetsten...
Siehe da 115200 passt PERFEKT. Wer genauer hingeschaut hat, dem wird schon aufgefallen sein, dass ich den Protokoll-Decoder für UART ganz unten schon entsprechend eingerichtet habe.

---

Protokoll-Analyse (Zweite Schicht)
Wenn man noch genauer hinschaut, fällt auf, dass die verdächtig oft mit 1011111011101111 (das entspricht den Bytes 0xBE 0xEF) anfangen und mit 1110111110111110 aufhören (das entspricht den Bytes 0xEF 0xBE). Auch nach längerer Analyze größerer Datenmengen, war dieses Muster ganz klar zu sehen.
Daraus lässt sich schließen, dass der Anfang jedes Daten-Packets mit 0xBE 0xEF gekennzeichnet ist und das Ende mit 0xEF 0xBE.

---

Protokoll-Analyse (Dritte Schicht)
Da mir kein auf UART basierendes Protokoll bekannt ist, welches seine Pakete mit BEEF ... EFBE kennzeichnet, gehe ich davon aus, dass es sich hierbei um ein proprietäres Protokoll handelt.
Da wir nun aber schonmal wissen, dass es sich um UART handelt, wechsle ich mal vom Logic-Analyzer auf einen einfachen USB UART Adapter (die gibt es für unter 5€ auf ebay und aliexpress). Dieser wird nun auf 3.3V gestellt. (Genaugenommen brauchen wir zwei Stück, weil Green und Blue für uns beide RX sind.) Aber gut, erstmal nur eine Leitung.

Nun schreiben wir ein kurzes Python-Script, welches den Inhalt der Datenpakete Zeile für Zeile ausgibt:

import serial

# Define the markers
START_MARKER = bytes([0xBE, 0xEF])
END_MARKER = bytes([0xEF, 0xBE])

# Open serial port
ser = serial.Serial('/dev/ttyUSB0', baudrate=115200)

# Buffer to store received bytes
buffer = bytearray()

while True:
    # Read one byte from serial port
    byte = ser.read()
  
    # Append byte to buffer
    buffer.append(byte[0])
  
    # Check if buffer contains start and end markers
    if buffer[-len(END_MARKER):] == END_MARKER:
        start_idx = buffer.find(START_MARKER)
        if start_idx != -1:
            # Extract the packet (excluding markers)
            packet = buffer[start_idx+len(START_MARKER):-len(END_MARKER)]
          
            # Print packet in hexadecimal format
            print('Packet:', packet.hex())
          
            # Remove processed bytes from buffer
            del buffer[:start_idx+len(START_MARKER)+len(packet)+len(END_MARKER)]

# Close serial port
ser.close()

Der Output ist ein regelrechtes gespamme dieser beiden Pakete:
00ff00
010100ff

Aber jedes mal wenn ich die Showbox über den Mute-Button stumm schalte, taucht plötzlich dieses Datenpaket in der Leitung auf:
0503005900000001

und immer wenn ich wieder un-mute, dann wird dieses Paket geschickt:
0503005900000000

Ich weiß jetzt nicht, ob das das Signal vom Mixer an die Box war oder ob das die Bestätigung bzw das Status-Update der Box an den Mixer war, aber es ist klar, dass wir nun mit Leichtigkeit mitschneiden können, wann die Box stummgeschaltet wird.

Der nächste Schritt wäre mal eine Tabelle mit allen Datenpaketen und deren Bedeutung anzulegen und zu schauen was wohl passiert, wenn man diese Pakete in die Datenleitungen einschleust ohne, dass der Mute Button gedrückt wurde.

 

[6stringtheory]

Ich habe nun glaube ich fast alle Datenpakete dekodiert und kann nun alles mitschneiden, was der Mixer bzw die Box tut:

Diese Benamung wie USER_INPUT1_MUTE usw. habe ich mir übrigens nicht ausgedacht. Diese habe ich beim Analysieren der Firmware gefunden. Das geht in Ghirda mit diesen Einstellungen ganz gut:

Um überhaupt an die Firmware zu kommen, muss man sich den Firmwareupdater herunterladen (ShowBoxUpdater_v1.1.x_Win.zip) diese ZIP-Datei extrahiert man ganz normal, dann nimmt man sich UniExtract zur Hand und extrahiert die eben entpackte ShowBoxUpdater_v1.1.x.msi, wodurch man unter anderem eine Datei namens disk1.cab erhält, welche man dann mit 7z entpackt, welche die binären Firmware-Images enthält:

• ivt_performer_ui_extracted_unsigned_nopadding.bin
• ivt_performer_dcd_unsigned_nopadding.bin
• ivt_flashloader.bin
• unsigned_MIMXRT1010_flashloader_nopadding.bin

Die Mackie Showbox hat zwei Firmwares (eine in der Box, die andere im Breakaway Mixer) und diese Firmwares sind wiederum aufgeteilt in einen sogenannten Flashloader und die Application Firmware, welche dann im Endeffekt auf die SPI Flash Chips geflasht werden. Den SPI Flash Chip des Breakaway Mixers hatte ich auch im zweiten Foto markiert.

Aber bevor ich weiter abschweife, hier ist mein überarbeitetes Python Script, welches die Kommunikation zwischen Box und Mixer dekodiert:

import serial
import threading
import signal
import sys
# Define the markers
START_MARKER = bytes([0xBE, 0xEF])
END_MARKER = bytes([0xEF, 0xBE])
# Define exclusion list for packets that are constantly sent without interaction
exclude_base_hex = [
    '00ff00',
    '010100ff'
]
exclude_mixer_hex = [
    '00ff00',
    '010100ff',
    '0803005b0000006227eec2',
    '0803005b0000000000f0c2',
    '08030057000000287652c2',
    '08030057000000ecc44ec2',
    '0803005b000000c54eecc2'
]
# Function to convert hex strings to byte sequences
def hex_list_to_bytes(hex_list):
    return {bytes.fromhex(hex_str) for hex_str in hex_list}
# Convert hex string lists to byte sequences sets
exclude_base = hex_list_to_bytes(exclude_base_hex)
exclude_mixer = hex_list_to_bytes(exclude_mixer_hex)
# Known packet patterns with descriptions
known_packet_patterns = {
    '05030000000000': 'USER_FRONT_LED {}',
    '05030001000000': 'USER_FEEDBACK_ELIM {}',
    '05030002000000': 'USER_AMP_PA_MODE {}',
    '05030003000000': 'USER_LOCATION_MODE {}',
    '05030004000000': 'USER_SELECTED_CHAN {}',
    '080300050000000': 'USER_INPUT1_GAIN {}',
    '08030006000000': 'USER_INPUT1_VOLUME {}',
    '05030007000000': 'USER_INPUT1_MUTE {}',
    '05030008000000': 'USER_INPUT1_CLIP_OL_PRE {}',
    '05030009000000': 'USER_INPUT1_CLIP_OL_POST {}',
    '0503000a000000': 'USER_INPUT1_EFFECT_1_MUTE {}',
    '0803000b000000': 'USER_INPUT1_EFFECT_1_AMOUNT {}',
    '0503000c000000': 'USER_INPUT1_EFFECT_2_MUTE {}',
    '0803000d000000': 'USER_INPUT1_EFFECT_2_AMOUNT {}',
    '0503000e000000': 'USER_INPUT1_EQ_ENABLE {}',
    '0803000f000000': 'USER_INPUT1_EQ_LOW_GAIN {}',
    '08030010000000': 'USER_INPUT1_EQ_MID_GAIN {}',
    '08030011000000': 'USER_INPUT1_EQ_HIGH_GAIN {}',
    '05030012000000': 'USER_INPUT1_COMPRESSOR_ENABLE {}',
    '08030013000000': 'USER_INPUT1_COMPRESSOR_AMOUNT {}',
    '05030014000000': 'USER_INPUT1_EXT_FX_MUTE {}',
    '08030015000000': 'USER_INPUT1_EXT_FX_SENDS {}',
    '080300160000000': 'USER_INPUT2_GAIN {}',
    '08030017000000': 'USER_INPUT2_VOLUME {}',
    '05030018000000': 'USER_INPUT2_MUTE {}',
    '05030019000000': 'USER_INPUT2_CLIP_OL_PRE {}',
    '0503001a000000': 'USER_INPUT2_CLIP_OL_POST {}',
    '0503001b000000': 'USER_INPUT2_EFFECT_1_MUTE {}',
    '0803001c000000': 'USER_INPUT2_EFFECT_1_AMOUNT {}',
    '0503001d000000': 'USER_INPUT2_EFFECT_2_MUTE {}',
    '0803001e000000': 'USER_INPUT2_EFFECT_2_AMOUNT {}',
    '0503001f000000': 'USER_INPUT2_EQ_ENABLE {}',
    '08030020000000': 'USER_INPUT2_EQ_LOW_GAIN {}',
    '08030021000000': 'USER_INPUT2_EQ_MID_GAIN {}',
    '08030022000000': 'USER_INPUT2_EQ_HIGH_GAIN {}',
    '05030023000000': 'USER_INPUT2_COMPRESSOR_ENABLE {}',
    '08030024000000': 'USER_INPUT2_COMPRESSOR_AMOUNT {}',
    '05030025000000': 'USER_INPUT2_EXT_FX_MUTE {}',
    '08030026000000': 'USER_INPUT2_EXT_FX_SENDS {}',
    '080300270000000': 'USER_INPUT3_GAIN {}',
    '08030028000000': 'USER_INPUT3_VOLUME {}',
    '05030029000000': 'USER_INPUT3_MUTE {}',
    '0503002a000000': 'USER_INPUT3_CLIP_OL_PRE {}',
    '0503002b000000': 'USER_INPUT3_CLIP_OL_POST {}',
    '0503002c000000': 'USER_INPUT3_EFFECT_1_MUTE {}',
    '0803002d000000': 'USER_INPUT3_EFFECT_1_AMOUNT {}',
    '0503002e000000': 'USER_INPUT3_EFFECT_2_MUTE {}',
    '0803002f000000': 'USER_INPUT3_EFFECT_2_AMOUNT {}',
    '05030030000000': 'USER_INPUT3_EQ_ENABLE {}',
    '08030031000000': 'USER_INPUT3_EQ_LOW_GAIN {}',
    '08030032000000': 'USER_INPUT3_EQ_MID_GAIN {}',
    '08030033000000': 'USER_INPUT3_EQ_HIGH_GAIN {}',
    '05030034000000': 'USER_INPUT3_COMPRESSOR_ENABLE {}',
    '08030035000000': 'USER_INPUT3_COMPRESSOR_AMOUNT {}',
    '05030036000000': 'USER_INPUT3_EXT_FX_MUTE {}',
    '08030037000000': 'USER_INPUT3_EXT_FX_SENDS {}',
    '080300380000000': 'USER_INPUT4_GAIN {}',
    '08030039000000': 'USER_INPUT4_VOLUME {}',
    '0503003a000000': 'USER_INPUT4_MUTE {}',
    '0503003b000000': 'USER_INPUT4_CLIP_OL_PRE {}',
    '0503003c000000': 'USER_INPUT4_CLIP_OL_POST {}',
    '0503003d000000': 'USER_INPUT4_EFFECT_1_MUTE {}',
    '0803003e000000': 'USER_INPUT4_EFFECT_1_AMOUNT {}',
    '0503003f000000': 'USER_INPUT4_EFFECT_2_MUTE {}',
    '08030040000000': 'USER_INPUT4_EFFECT_2_AMOUNT {}',
    '05030041000000': 'USER_INPUT4_EQ_ENABLE {}',
    '08030042000000': 'USER_INPUT4_EQ_LOW_GAIN {}',
    '08030043000000': 'USER_INPUT4_EQ_MID_GAIN {}',
    '08030044000000': 'USER_INPUT4_EQ_HIGH_GAIN {}',
    '05030045000000': 'USER_INPUT4_COMPRESSOR_ENABLE {}',
    '08030046000000': 'USER_INPUT4_COMPRESSOR_AMOUNT {}',
    '05030047000000': 'USER_INPUT4_EXT_FX_MUTE {}',
    '08030048000000': 'USER_INPUT4_EXT_FX_SENDS {}',
    '08030049000000': 'USER_STEREO_INPUT1_VOLUME {}',
    '0503004a000000': 'USER_STEREO_INPUT1_MUTE {}',
    '0503004b000000': 'USER_STEREO_INPUT1_CLIP_OL_PRE {}',
    '0503004c000000': 'USER_STEREO_INPUT1_CLIP_OL_POST {}',
    '0503004d000000': 'USER_STEREO_INPUT1_EQ_ENABLE {}',
    '0803004e000000': 'USER_STEREO_INPUT1_EQ_LOW_GAIN {}',
    '0803004f000000': 'USER_STEREO_INPUT1_EQ_MID_GAIN {}',
    '08030050000000': 'USER_STEREO_INPUT1_EQ_HIGH_GAIN {}',
    '05030051000000': 'USER_EFFECT11_TYPEID {}',
    '05030052000000': 'USER_EFFECT12_TYPEID {}',
    '05030053000000': 'USER_EFFECT13_TYPEID {}',
    '05030054000000': 'USER_EFFECT14_TYPEID {}',
    '05030055000000': 'USER_EFFECT21_TYPEID {}',
    '05030056000000': 'USER_EFFECT22_TYPEID {}',
    '08030057000000': 'USER_MAIN_HEADPHONE_GAIN {}',
    '08030058000000': 'USER_MAIN_MASTER_GAIN {}',
    '050300590000000': 'USER_MAIN_MUTE {}',
    '0503005a0000000': 'USER_MAIN_CLIP_OL {}',
    '0803005b000000': 'USER_LOOPER_LEVEL {}',
    '0503005c000000': 'USER_LOOPER_STATE {}',
    '0503005d000000': 'USER_FX_BYPASS {}',
    '001e02': 'SD_RECORD'
}
class PacketLogger:
    def __init__(self, known_patterns):
        self.known_patterns = known_patterns
    def add_packet(self, packet):
        key = packet.hex()
        if key not in self.known_patterns:
            self.known_patterns[key] = 'Unknown Packet'
     
    def get_packet_description(self, packet):
        packet_hex = packet.hex()
        for pattern, description in self.known_patterns.items():
            if packet_hex.startswith(pattern):
                # Extract the variable part
                variable_part = packet_hex[len(pattern):]
                if variable_part:
                    # Convert the variable part to an integer and format the description
                    variable_value = int(variable_part, 16)
                    return description.format(variable_value)
                return description
        return 'Unknown Packet'
    def print_packet(self, label, packet):
        description = self.get_packet_description(packet)
        print(f'{label}: {description} - Raw: {packet.hex()}')
# Initialize the packet logger with known packet patterns
packet_logger = PacketLogger(known_packet_patterns)
# Buffer to store received bytes
buffer0 = bytearray()
buffer1 = bytearray()
# Flag to indicate if the script should keep running
running = True
# Function to read from a serial port
def read_from_port(ser, buffer, label, exclude_list):
    global running
    while running:
        if ser.in_waiting > 0:
            # Read one byte from serial port
            byte = ser.read()
         
            # Append byte to buffer
            buffer.append(byte[0])
         
            # Check if buffer contains start and end markers
            if buffer[-len(END_MARKER):] == END_MARKER:
                start_idx = buffer.find(START_MARKER)
                if start_idx != -1:
                    # Extract the packet (excluding markers)
                    packet = buffer[start_idx+len(START_MARKER):-len(END_MARKER)]
                 
                    # Convert packet to bytes before checking for exclusion
                    packet_bytes = bytes(packet)
                 
                    # Check if the packet should be excluded
                    if packet_bytes not in exclude_list:
                        # Use the packet logger to print and log the packet
                        packet_logger.print_packet(label, packet_bytes)
                 
                    # Remove processed bytes from buffer
                    del buffer[:start_idx+len(START_MARKER)+len(packet)+len(END_MARKER)]
# Signal handler to cleanly exit the script
def signal_handler(sig, frame):
    global running
    running = False
    print('Exiting...')
    ser0.close()
    ser1.close()
    sys.exit(0)
# Register the signal handler for SIGINT (Ctrl+C)
signal.signal(signal.SIGINT, signal_handler)
# Open serial ports
ser0 = serial.Serial('/dev/ttyUSB0', baudrate=115200)
ser1 = serial.Serial('/dev/ttyUSB1', baudrate=115200)
# Start threads to read from each port
thread0 = threading.Thread(target=read_from_port, args=(ser0, buffer0, 'Base', exclude_base))
thread1 = threading.Thread(target=read_from_port, args=(ser1, buffer1, 'Mixer', exclude_mixer))
thread0.start()
thread1.start()
# Join threads to main thread to keep the program running
thread0.join()
thread1.join()

So sieht der Spaß übrigens aus. Zwischen Mixer und Box ein Breakout PCB und dann zwei USB UART Adapter.
USB-UART-Adapter 1: Gnd an Orange, RX an Blue (liest die Nachrichten vom Mixer an die Box mit)
USB-UART-Adapter 2: Gnd an Orange-White, RX an Green (liest die Nachrichten von der Box an den Mixer mit)

(Das schwarze UGREEN-Gerät ist übrigens nur ein USB-Hub, weil der Laptop kein USB-A hat.)