USB to TTL Serial Adapter: Using the CH340 and CP2102

A USB to TTL adapter is a small board that translates your computer's USB port into the serial (UART) language that microcontrollers speak. You need one to upload code to boards with no USB socket, such as the Arduino Pro Mini, ESP-01 and ESP32-CAM, to read the serial messages coming out of a module, or to configure GPS and Bluetooth modules straight from your computer. In fact every Arduino Uno and Nano already carries a copy of this circuit; the adapter turns it into a separate, portable module.

In this guide you'll learn the adapter's pins, the most common mistake of all (TX-RX wiring), the jumper that selects 3.3 V or 5 V logic level, and driver installation on Windows, macOS and Linux. Then you'll see how to program an Arduino Pro Mini without pressing a button thanks to the DTR pin, upload code to the ESP-01 and ESP32-CAM, use the adapter as a second serial monitor, and how the three most common chips, the CH340, CP2102 and FT232, differ.

What is a USB to TTL adapter and what is it for?

Your computer and a microcontroller speak different languages. USB is a complex protocol built on packets, addresses and drivers. A microcontroller's UART, on the other hand, uses just two lines: one sends data (TX), the other receives it (RX), and each byte is made of bits sent one after another at an agreed speed (baud). The chip on the adapter shows up on your computer as a virtual serial port (COM3 on Windows, /dev/cu.usbserial... on macOS, /dev/ttyUSB0 on Linux); every byte you write to that port leaves the TX pin as a UART signal, and every byte arriving on the RX pin is passed to the computer. The TTL in its name means the signals swing between 0 V and 5 V, or 0 V and 3.3 V.

• Programming boards without USB: Arduino Pro Mini, LilyPad, ESP-01, ESP32-CAM and bare ATmega328P chips with a bootloader.
• Reading serial logs: Watching debug messages in a second window while the board's own USB is busy with something else.
• Talking to modules directly: Sending AT commands to an ESP-01, reading a GPS module's NMEA sentences, renaming a Bluetooth module.
• Rescuing a damaged board: Programming an Uno or Nano whose USB chip has died through its D0 and D1 pins.
• Connecting to other devices' consoles: The serial console pins of routers, 3D printer boards or single-board computers.

USB to TTL pins: GND, VCC, TXD, RXD, DTR and RTS

TX-RX crossover wiring

The most common mistake is connecting TX to TX. The rule is simple: the line one device talks on must go to the line the other one listens on. So the adapter's TXD pin goes to the target board's RX pin, and its RXD pin goes to the target's TX pin. Some boards add the direction to their labels to avoid confusion: the Arduino Pro Mini says RXI (RX in) and TXO (TX out), and SparkFun-style FTDI boards are labelled so that plugging the two boards straight together produces the correct crossover. If you can't trust the labels, try the wiring the other way round once; swapping TX and RX doesn't damage anything, there's just no communication.

The 3.3 V / 5 V jumper: how to choose the logic level

The Arduino Uno, Nano and the 5 V Pro Mini use 5 V logic; the ESP8266, ESP32 and Raspberry Pi Pico use 3.3 V logic. Feeding a 5 V signal into an ESP's RX pin stresses its input protection diodes and can wear out the pin over time. That's why most CH340G modules have a three-pin jumper: it selects the chip's supply voltage, and the level of the TXD output follows that voltage. The CP2102 always runs at 3.3 V logic but its inputs are 5 V tolerant, so it talks happily to both 3.3 V and 5 V boards, because a 5 V ATmega328P already treats anything above 3 V as HIGH. FT232RL modules also often have a jumper that selects the chip's I/O level (VCCIO).

If your adapter has no jumper and you need to connect a 5 V TX line to a 3.3 V input, a simple voltage divider does the job: with 1 kΩ between the TX line and the target's RX, and 2 kΩ between the target's RX and GND, 5 V drops to about 3.3 V. The full calculation is in voltage divider. The other direction, a 3.3 V TX into a 5 V input, is usually fine.

CH340 vs CP2102 vs FT232

For everyday hobby work there's practically no difference between the CH340 and the CP2102; both run flawlessly at 115200 baud and easily handle every speed the Arduino IDE uses. The CP2102's internal oscillator and stronger 3.3 V output give it a slight edge when powering small 3.3 V boards, while the CH340 is the cheapest and most common. The FT232RL is a reliable chip with detailed configuration options, but a large share of cheap FT232 modules on the market carry counterfeit chips. The CH9102 and CH343 you see on newer ESP32 boards are faster members of the same family and are used in exactly the same way.

Installing drivers: Windows, macOS and Linux

If, after plugging in the adapter on Windows, you see a USB2.0-Serial with a yellow exclamation mark under Other devices in Device Manager, the CH340 driver is missing; if you see CP2102 USB to UART Bridge Controller, the CP2102 driver is missing. Once the driver is installed, unplug the adapter, plug it back in and look at Tools > Port in the Arduino IDE: the new port that appears at that moment is the adapter's. If nothing shows up at all, change the cable first; charging cables have no data wires. The full list of port, driver and permission problems is in Arduino code won't upload.

Loopback test: is the adapter working?

1. Remove every wire from the adapter and plug it into the computer.
2. With a jumper wire, connect the adapter's own TXD and RXD pins together.
3. Select the adapter's port in the Arduino IDE and open the Serial Monitor; the speed doesn't matter for this test.
4. Type something and send it. If your text comes straight back, the chip, driver and cable are fine; the problem lies in the wiring or the target board.
5. If nothing comes back, check the port, the driver and the cable, and see whether the adapter's TX and RX LEDs flicker.

Programming an Arduino Pro Mini: auto-reset with DTR

When code is uploaded to an Arduino, the board is reset first; the bootloader, which runs for about a second after reset, checks whether a new program is arriving over the serial port. The Uno and Nano do this reset on their own: there's a 100 nF capacitor between the USB chip's DTR line and the processor's RESET pin. The moment the IDE opens the port, DTR drops from HIGH to LOW, the capacitor passes this sudden drop to the RESET pin as a short LOW pulse and the board resets. On the Pro Mini the same capacitor sits on the board and connects to the GRN (or DTR) pin on the header; when you connect the adapter's DTR pin there, uploading is as easy as on an Uno.

1. Find out your board's version from the marking on the back or on its crystal: boards with a 16 MHz crystal are the 5 V version, 8 MHz ones are the 3.3 V version.
2. Set the adapter's jumper to match the board version and wire it up according to the table.
3. In the Arduino IDE choose Tools > Board > Arduino AVR Boards > Arduino Pro or Pro Mini.
4. Under Tools > Processor, choose ATmega328P (5V, 16 MHz) or ATmega328P (3.3V, 8 MHz) to match your board.
5. Select the adapter's port and upload the test sketch below; with DTR connected you don't need to press any button.

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}

When the upload finishes, the LED on the board blinks every half second. Open the Serial Monitor at 9600 baud with New Line selected, type something, and the text comes back. The F_CPU line in the code catches a small but important trap: the bootloaders of both Pro Mini versions upload at 57600 baud, so code uploads even with the wrong Processor option. But if you choose 16 MHz for an 8 MHz board, everything runs at half speed, the LED changes once a second and you only see garbage in the Serial Monitor. If your adapter has no DTR pin, you can time the upload by hand: the moment the IDE finishes compiling and shows Uploading... in the output, press and release the Pro Mini's reset button.

Uploading code to the ESP-01 and ESP32-CAM

On the ESP8266 and ESP32 the bootloader is built into the chip and checks the GPIO 0 pin at boot: if GPIO 0 is LOW it enters download mode and waits for code, if it's HIGH it runs the program in flash. Development boards have an auto-upload circuit that connects the DTR and RTS lines to EN and GPIO 0 through two transistors; esptool toggles these lines in sequence to put the board into download mode by itself. A plain USB to TTL adapter doesn't have this circuit, so you do it by hand: connect GPIO 0 to GND, reset the board, upload the code, then remove the GPIO 0 connection and reset again.

The ESP-01 draws current peaks above 300 mA while connecting to Wi-Fi; the adapter's 3V3 pin can't supply that and the module keeps resetting. So use an AMS1117-3.3 regulator fed from the 5V pin. All of the ESP-01's connections and AT commands are in ESP-01 module, and the step-by-step ESP32-CAM upload is in How to use the ESP32-CAM. If you'd like a project that adds a PIR to the ESP32-CAM and sends the photo to your phone, have a look at ESP32-CAM photos to Telegram.

Reading serial logs: the USB to TTL as a second serial port

One of the adapter's least known yet most useful jobs is adding a second serial monitor to a board. While the board's own USB port is talking to a Python program, the Serial Plotter or another device, you can watch detailed debug messages on a separate port. The ESP32 has three hardware UARTs; the code below assigns UART2 to GPIO 16 and 17 and sends a log line to the adapter every second. Sending the letter r from the adapter resets the counter, so you can see that it works in both directions.

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}

To wire it up, set the adapter's jumper to 3.3 V and connect TXD to GPIO 16, RXD to GPIO 17 and GND to GND. Then, instead of opening a second Arduino IDE, you can use PuTTY, screen on macOS and Linux, or a small reader you write in Python; for the Python side see Arduino Python serial communication. On the Raspberry Pi Pico the same idea takes a few lines of MicroPython: UART0 is on GP0 (TX) and GP1 (RX), and the code both sends a log and echoes back the bytes it receives.

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)

The same method lets you listen to what a module is saying with no Arduino in between. Connect a NEO-6M GPS module straight to the adapter and open it at 9600 baud, and you'll see NMEA sentences streaming in; open an HC-05 module in AT mode at 38400 baud and you can change its name and PIN. Everything about the Serial Monitor's line ending and baud settings is in Arduino Serial Monitor.

Common problems and fixes

The USB to TTL adapter is one of the smallest tools in your drawer and one of the ones you'll use most: it programs boards without USB, lets your computer talk to modules and shows you line by line what's happening inside your projects. If you remember to cross TX and RX, choose the right logic level and keep GND common, almost every problem disappears. In the BlueGrays app you'll find serial communication between two Arduinos, phone control over Bluetooth and ESP32 Wi-Fi projects, with step-by-step wiring diagrams and ready-to-use code.