USB-TTL-Adapter: CH340 und CP2102 richtig anschließen

Ein USB-TTL-Adapter ist eine kleine Platine, die den USB-Anschluss deines Computers in die serielle Sprache (UART) übersetzt, die Mikrocontroller sprechen. Du brauchst ihn, um Code auf Boards ohne USB-Buchse wie Arduino Pro Mini, ESP-01 und ESP32-CAM zu laden, um die seriellen Meldungen eines Moduls mitzulesen oder um GPS- und Bluetooth-Module direkt vom Computer aus einzustellen. Eigentlich trägt jeder Arduino Uno und Nano schon eine Kopie dieser Schaltung; der Adapter macht daraus ein eigenes, mobiles Modul.

In dieser Anleitung lernst du die Pins des Adapters kennen, den häufigsten Fehler überhaupt (die TX-RX-Verdrahtung), den Jumper für 3,3-V- oder 5-V-Logikpegel und die Treiberinstallation unter Windows, macOS und Linux. Danach siehst du, wie du einen Arduino Pro Mini dank DTR-Pin ohne Tastendruck programmierst, Code auf ESP-01 und ESP32-CAM lädst, den Adapter als zweiten seriellen Monitor nutzt und worin sich die drei häufigsten Chips CH340, CP2102 und FT232 unterscheiden.

Was ist ein USB-TTL-Adapter und wofür braucht man ihn?

Computer und Mikrocontroller sprechen verschiedene Sprachen. USB ist ein komplexes Protokoll mit Paketen, Adressen und Treibern. Der UART eines Mikrocontrollers dagegen kommt mit zwei Leitungen aus: Eine sendet Daten (TX), die andere empfängt sie (RX), und jedes Byte besteht aus Bits, die nacheinander mit einer vereinbarten Geschwindigkeit (Baud) übertragen werden. Der Chip auf dem Adapter erscheint am Computer als virtueller serieller Port (unter Windows COM3, unter macOS /dev/cu.usbserial..., unter Linux /dev/ttyUSB0); jedes Byte, das du an diesen Port schreibst, verlässt den TX-Pin als UART-Signal, und jedes Byte, das am RX-Pin ankommt, wird an den Computer weitergereicht. Das TTL im Namen bedeutet, dass die Signale zwischen 0 V und 5 V bzw. 0 V und 3,3 V wechseln.

• Boards ohne USB programmieren: Arduino Pro Mini, LilyPad, ESP-01, ESP32-CAM und nackte ATmega328P-Chips mit Bootloader.
• Serielle Logs lesen: Debug-Meldungen in einem zweiten Fenster beobachten, während der eigene USB-Port des Boards anderweitig belegt ist.
• Direkt mit Modulen sprechen: AT-Befehle an einen ESP-01 senden, die NMEA-Sätze eines GPS-Moduls lesen, ein Bluetooth-Modul umbenennen.
• Ein defektes Board retten: Einen Uno oder Nano mit kaputtem USB-Chip über D0 und D1 programmieren.
• Konsolen anderer Geräte anzapfen: Die seriellen Konsolenpins von Routern, 3D-Drucker-Boards oder Einplatinencomputern.

USB-TTL-Pins: GND, VCC, TXD, RXD, DTR und RTS

TX und RX gekreuzt verbinden

Der häufigste Fehler ist, TX mit TX zu verbinden. Die Regel ist einfach: Die Leitung, auf der ein Gerät spricht, muss an die Leitung, auf der das andere zuhört. Der TXD-Pin des Adapters geht also an den RX-Pin des Ziel-Boards und sein RXD-Pin an den TX-Pin des Ziels. Manche Boards nennen die Richtung gleich in der Beschriftung, um Verwechslungen zu vermeiden: Auf dem Arduino Pro Mini steht RXI (RX-Eingang) und TXO (TX-Ausgang), und FTDI-Platinen im SparkFun-Stil sind so beschriftet, dass beim direkten Zusammenstecken die richtige Kreuzung entsteht. Wenn du der Beschriftung nicht traust, probiere die Verbindung einmal andersherum; vertauschte TX- und RX-Leitungen schaden nichts, es findet nur keine Kommunikation statt.

Der 3,3-V-/5-V-Jumper: Logikpegel richtig wählen

Arduino Uno, Nano und der 5-V-Pro-Mini arbeiten mit 5-V-Logik, ESP8266, ESP32 und Raspberry Pi Pico mit 3,3-V-Logik. Ein 5-V-Signal am RX-Pin eines ESP belastet dessen Schutzdioden und kann den Pin mit der Zeit beschädigen. Deshalb haben die meisten CH340G-Module einen dreipoligen Jumper: Er wählt die Versorgungsspannung des Chips, und der Pegel des TXD-Ausgangs folgt dieser Spannung. Der CP2102 arbeitet immer mit 3,3-V-Logik, seine Eingänge sind aber 5-V-tolerant; daher versteht er sich mit 3,3-V- und 5-V-Boards gleichermaßen, denn ein 5-V-ATmega328P wertet alles über 3 V bereits als HIGH. Auch FT232RL-Module haben oft einen Jumper, der den I/O-Pegel des Chips (VCCIO) festlegt.

Hat dein Adapter keinen Jumper und musst du eine 5-V-TX-Leitung an einen 3,3-V-Eingang anschließen, genügt ein einfacher Spannungsteiler: Mit 1 kΩ zwischen TX-Leitung und RX des Ziels und 2 kΩ zwischen RX des Ziels und GND sinken 5 V auf etwa 3,3 V. Die genaue Rechnung findest du in Spannungsteiler. Die umgekehrte Richtung, ein 3,3-V-TX an einen 5-V-Eingang, ist meist unproblematisch.

CH340, CP2102 und FT232 im Vergleich

Für alltägliche Bastelprojekte gibt es zwischen CH340 und CP2102 praktisch keinen Unterschied; beide laufen bei 115200 Baud einwandfrei und schaffen alle Geschwindigkeiten der Arduino IDE problemlos. Der interne Oszillator und der stärkere 3,3-V-Ausgang verschaffen dem CP2102 einen kleinen Vorteil, wenn er kleine 3,3-V-Boards versorgen soll, während der CH340 der günstigste und verbreitetste ist. Der FT232RL ist ein zuverlässiger Chip mit vielen Einstellmöglichkeiten, doch in einem großen Teil der billigen FT232-Module stecken Fälschungen. Die CH9102 und CH343 auf neueren ESP32-Boards sind schnellere Mitglieder derselben Familie und werden genauso verwendet.

Treiber installieren: Windows, macOS und Linux

Siehst du unter Windows nach dem Einstecken im Geräte-Manager unter Andere Geräte ein USB2.0-Serial mit gelbem Ausrufezeichen, fehlt der CH340-Treiber; steht dort CP2102 USB to UART Bridge Controller, fehlt der CP2102-Treiber. Nach der Treiberinstallation steckst du den Adapter ab und wieder an und schaust in der Arduino IDE unter Werkzeuge > Port: Der Port, der in diesem Moment neu erscheint, gehört zum Adapter. Taucht gar nichts auf, tausche zuerst das Kabel; reine Ladekabel haben keine Datenleitungen. Alle Port-, Treiber- und Berechtigungsprobleme findest du in Arduino-Sketch lässt sich nicht hochladen.

Loopback-Test: Funktioniert der Adapter?

1. Zieh alle Kabel vom Adapter ab und steck ihn in den Computer.
2. Verbinde mit einem Jumperkabel die TXD- und RXD-Pins des Adapters miteinander.
3. Wähle in der Arduino IDE den Port des Adapters und öffne den seriellen Monitor; die Baudrate spielt für diesen Test keine Rolle.
4. Tippe etwas ein und sende es. Kommt dein Text genau so zurück, sind Chip, Treiber und Kabel in Ordnung; das Problem liegt dann in der Verdrahtung oder am Ziel-Board.
5. Kommt nichts zurück, prüfe Port, Treiber und Kabel und achte darauf, ob die TX- und RX-LEDs des Adapters flackern.

Arduino Pro Mini programmieren: Auto-Reset per DTR

Beim Hochladen wird der Arduino zuerst zurückgesetzt; der Bootloader, der nach dem Reset etwa eine Sekunde läuft, prüft, ob über die serielle Schnittstelle ein neues Programm kommt. Uno und Nano erledigen diesen Reset selbst: Zwischen der DTR-Leitung des USB-Chips und dem RESET-Pin des Prozessors sitzt ein 100-nF-Kondensator. In dem Moment, in dem die IDE den Port öffnet, fällt DTR von HIGH auf LOW, der Kondensator gibt diesen Sprung als kurzen LOW-Impuls an RESET weiter, und das Board startet neu. Beim Pro Mini sitzt derselbe Kondensator auf dem Board und hängt am GRN- bzw. DTR-Pin der Stiftleiste; verbindest du dort den DTR-Pin des Adapters, ist das Hochladen so einfach wie beim Uno.

1. Finde die Version deines Boards über die Beschriftung auf der Rückseite oder auf dem Quarz heraus: Boards mit 16-MHz-Quarz sind die 5-V-Version, solche mit 8 MHz die 3,3-V-Version.
2. Stell den Jumper des Adapters passend zur Board-Version ein und verdrahte alles laut Tabelle.
3. Wähle in der Arduino IDE Werkzeuge > Board > Arduino AVR Boards > Arduino Pro or Pro Mini.
4. Wähle unter Werkzeuge > Processor passend zu deinem Board ATmega328P (5V, 16 MHz) oder ATmega328P (3.3V, 8 MHz).
5. Wähle den Port des Adapters und lade den folgenden Test-Sketch hoch; mit angeschlossenem DTR musst du keine Taste drücken.

1// Pro Mini + USB-TTL testi: LED yanıp söner, gönderdiğin satır geri gelir
2// Pro Mini + USB-TTL test: the LED blinks and every line you send comes back
3const int LED = 13;                     // Pro Mini'nin dahili LED'i / Pro Mini onboard LED
4unsigned long sonDegisim = 0;
5bool ledAcik = false;
6
7void setup() {
8  Serial.begin(9600);
9  pinMode(LED, OUTPUT);
10  Serial.println(F("Pro Mini hazir / ready"));
11  Serial.print(F("Derlenen saat / compiled clock: "));
12  Serial.print(F_CPU / 1000000UL);      // 16 = 5 V sürüm, 8 = 3,3 V sürüm / 16 = 5 V board, 8 = 3.3 V board
13  Serial.println(F(" MHz"));
14}
15
16void loop() {
17  if (millis() - sonDegisim >= 500) {   // yarım saniyede bir / every half second
18    sonDegisim = millis();
19    ledAcik = !ledAcik;
20    digitalWrite(LED, ledAcik);
21  }
22  if (Serial.available()) {
23    String satir = Serial.readStringUntil('\n');   // satır sonuna kadar oku / read up to the line ending
24    satir.trim();
25    Serial.print(F("Geldi / received: "));
26    Serial.println(satir);
27  }
28}

Nach dem Hochladen blinkt die LED auf dem Board im Halbsekundentakt. Öffne den seriellen Monitor mit 9600 Baud und der Einstellung Neue Zeile, tippe etwas ein, und der Text kommt zurück. Die F_CPU-Zeile im Code deckt eine kleine, aber wichtige Falle auf: Die Bootloader beider Pro-Mini-Versionen laden mit 57600 Baud, deshalb klappt der Upload sogar mit der falschen Processor-Option. Wählst du für ein 8-MHz-Board aber 16 MHz, läuft alles mit halber Geschwindigkeit, die LED wechselt nur einmal pro Sekunde, und im seriellen Monitor siehst du nur Zeichensalat. Hat dein Adapter keinen DTR-Pin, kannst du den Upload von Hand timen: Sobald die IDE fertig kompiliert hat und in der Ausgabe Uploading... erscheint, drückst du kurz die Reset-Taste des Pro Mini.

Code auf ESP-01 und ESP32-CAM laden

Beim ESP8266 und ESP32 steckt der Bootloader im Chip und prüft beim Start den Pin GPIO 0: Ist GPIO 0 LOW, geht er in den Download-Modus und wartet auf Code, ist er HIGH, startet das Programm im Flash. Entwicklungsboards haben eine Auto-Upload-Schaltung, die DTR und RTS über zwei Transistoren mit EN und GPIO 0 verbindet; esptool schaltet diese Leitungen nacheinander und bringt das Board so selbst in den Download-Modus. Ein einfacher USB-TTL-Adapter hat diese Schaltung nicht, also machst du es von Hand: GPIO 0 auf GND legen, Board zurücksetzen, Code hochladen, danach die GPIO-0-Verbindung lösen und erneut zurücksetzen.

Der ESP-01 zieht beim Verbinden mit dem WLAN Stromspitzen über 300 mA; der 3V3-Pin des Adapters schafft das nicht, und das Modul startet ständig neu. Nimm deshalb einen AMS1117-3.3-Regler, der aus dem 5V-Pin gespeist wird. Alle Anschlüsse und AT-Befehle des ESP-01 findest du in ESP-01-Modul, den Upload auf die ESP32-CAM Schritt für Schritt in ESP32-CAM verwenden. Wenn du ein Projekt suchst, das der ESP32-CAM einen PIR hinzufügt und das Foto aufs Handy schickt, sieh dir ESP32-CAM-Fotos per Telegram an.

Serielle Logs lesen: USB-TTL als zweite serielle Schnittstelle

Eine der unbekanntesten, aber nützlichsten Aufgaben des Adapters ist es, einem Board einen zweiten seriellen Monitor zu verschaffen. Während der eigene USB-Port des Boards mit einem Python-Programm, dem seriellen Plotter oder einem anderen Gerät spricht, beobachtest du ausführliche Debug-Meldungen über einen separaten Port. Der ESP32 hat drei Hardware-UARTs; der folgende Code legt UART2 auf GPIO 16 und 17 und schickt jede Sekunde eine Logzeile an den Adapter. Sendest du vom Adapter den Buchstaben r, wird der Zähler zurückgesetzt; so siehst du, dass es in beide Richtungen funktioniert.

1// ESP32: USB portu Serial'de kalır, ikinci log kanalı USB-TTL'ye gider
2// ESP32: the USB port stays on Serial, a second log channel goes to the USB-TTL
3#define LOG_RX 16                       // USB-TTL TXD buraya / USB-TTL TXD goes here
4#define LOG_TX 17                       // USB-TTL RXD buraya / USB-TTL RXD goes here
5
6unsigned long sayac = 0;
7
8void setup() {
9  Serial.begin(115200);                                  // kartın kendi USB portu / the board's own USB port
10  Serial2.begin(115200, SERIAL_8N1, LOG_RX, LOG_TX);     // UART2: USB-TTL'ye / UART2: to the USB-TTL
11  Serial.println("Ana port / main port");
12  Serial2.println("Log portu hazir / log port ready");
13}
14
15void loop() {
16  sayac++;
17  int deger = analogRead(34);                            // GPIO 34'e bağlı bir sensör / a sensor on GPIO 34
18  Serial2.printf("[%lu ms] #%lu ADC=%d\n", millis(), sayac, deger);   // ayrıntılı log / detailed log
19  if (sayac % 10 == 0) Serial.println(deger);            // ana portta yalnız özet / only a summary on the main port
20
21  while (Serial2.available()) {                          // USB-TTL'den gelen komut / command from the USB-TTL
22    char c = Serial2.read();
23    if (c == 'r') {
24      Serial2.println("Sayac sifirlandi / counter reset");
25      sayac = 0;
26    }
27  }
28  delay(1000);
29}

Zum Anschließen stellst du den Jumper des Adapters auf 3,3 V und verbindest TXD mit GPIO 16, RXD mit GPIO 17 und GND mit GND. Statt eine zweite Arduino IDE zu öffnen, kannst du PuTTY, unter macOS und Linux screen oder ein kleines Python-Leseprogramm verwenden; für die Python-Seite siehe Arduino und Python seriell verbinden. Auf dem Raspberry Pi Pico ist dieselbe Idee in MicroPython nur ein paar Zeilen lang: UART0 liegt auf GP0 (TX) und GP1 (RX), und der Code sendet Logs und schickt empfangene Bytes zurück.

1# Raspberry Pi Pico (MicroPython): UART0 üzerinden USB-TTL'ye log ve yankı
2# Raspberry Pi Pico (MicroPython): log and echo to a USB-TTL over UART0
3from machine import UART, Pin
4import time
5
6uart = UART(0, baudrate=115200, tx=Pin(0), rx=Pin(1))   # GP0 = TX, GP1 = RX
7led = Pin(25, Pin.OUT)                                  # Pico dahili LED / Pico onboard LED (Pico W: "LED")
8sayac = 0
9son = time.ticks_ms()
10
11uart.write("Pico UART0 hazir / ready\r\n")
12while True:
13    if time.ticks_diff(time.ticks_ms(), son) >= 1000:   # saniyede bir log / one log line per second
14        son = time.ticks_ms()
15        sayac += 1
16        led.toggle()
17        uart.write("[%d ms] #%d\r\n" % (time.ticks_ms(), sayac))
18    if uart.any():                                      # USB-TTL'den gelen baytlar / bytes from the USB-TTL
19        veri = uart.read()
20        uart.write(b"Geldi / received: " + veri)
21    time.sleep_ms(10)

Auf dieselbe Weise kannst du ohne Arduino dazwischen mithören, was ein Modul sagt. Schließt du ein NEO-6M-GPS-Modul direkt an den Adapter an und öffnest es mit 9600 Baud, siehst du die NMEA-Sätze hereinlaufen; ein HC-05-Modul im AT-Modus mit 38400 Baud kannst du umbenennen und seine PIN ändern. Alles zu Zeilenende und Baudrate im seriellen Monitor steht in Arduino Serial Monitor.

Häufige Fehler und Lösungen

Der USB-TTL-Adapter ist eines der kleinsten Werkzeuge in deiner Schublade und eines, das du am häufigsten brauchen wirst: Er programmiert Boards ohne USB, lässt den Computer mit Modulen sprechen und zeigt dir Zeile für Zeile, was in deinen Projekten passiert. Wenn du TX und RX kreuzt, den richtigen Logikpegel wählst und GND gemeinsam hältst, verschwinden fast alle Probleme. In der BlueGrays-App findest du serielle Kommunikation zwischen zwei Arduinos, Handysteuerung per Bluetooth und ESP32-WLAN-Projekte mit Schaltplänen und fertigem Code Schritt für Schritt.