Conversor USB-TTL: cómo usar el CH340 y el CP2102 con Arduino

Un conversor USB-TTL es una pequeña placa que traduce el puerto USB de tu ordenador al idioma serie (UART) que hablan los microcontroladores. Lo necesitas para cargar código en placas sin conector USB como el Arduino Pro Mini, el ESP-01 y la ESP32-CAM, para leer los mensajes serie que salen de un módulo o para configurar módulos GPS y Bluetooth directamente desde el ordenador. De hecho, cada Arduino Uno y Nano ya lleva una copia de este circuito; el conversor lo convierte en un módulo separado y portátil.

En esta guía conocerás los pines del conversor, el error más frecuente de todos (la conexión TX-RX), el jumper que elige el nivel lógico de 3,3 V o 5 V y la instalación de drivers en Windows, macOS y Linux. Después verás cómo programar un Arduino Pro Mini sin pulsar ningún botón gracias al pin DTR, cargar código en el ESP-01 y la ESP32-CAM, usar el conversor como segundo monitor serie y en qué se diferencian los tres chips más comunes: CH340, CP2102 y FT232.

¿Qué es un conversor USB-TTL y para qué sirve?

El ordenador y el microcontrolador hablan idiomas distintos. USB es un protocolo complejo basado en paquetes, direcciones y drivers. La UART de un microcontrolador, en cambio, usa solo dos líneas: una envía datos (TX) y la otra los recibe (RX), y cada byte está formado por bits enviados uno tras otro a una velocidad acordada (baudios). El chip del conversor aparece en el ordenador como un puerto serie virtual (COM3 en Windows, /dev/cu.usbserial... en macOS, /dev/ttyUSB0 en Linux); cada byte que escribes en ese puerto sale por el pin TX como señal UART, y cada byte que llega al pin RX se pasa al ordenador. El TTL del nombre indica que las señales cambian entre 0 V y 5 V, o entre 0 V y 3,3 V.

• Programar placas sin USB: Arduino Pro Mini, LilyPad, ESP-01, ESP32-CAM y chips ATmega328P sueltos con bootloader.
• Leer logs serie: Ver mensajes de depuración en una segunda ventana mientras el USB propio de la placa está ocupado con otra cosa.
• Hablar directamente con módulos: Enviar comandos AT a un ESP-01, leer las sentencias NMEA de un GPS, cambiar el nombre de un módulo Bluetooth.
• Rescatar una placa averiada: Programar un Uno o un Nano con el chip USB quemado a través de sus pines D0 y D1.
• Conectarte a la consola de otros equipos: Los pines de consola serie de routers, placas de impresoras 3D u ordenadores de placa única.

Pines del USB-TTL: GND, VCC, TXD, RXD, DTR y RTS

Conexión cruzada de TX y RX

El error más común es conectar TX con TX. La regla es sencilla: la línea por la que un dispositivo habla debe ir a la línea por la que el otro escucha. Así, el pin TXD del conversor va al pin RX de la placa destino, y su pin RXD va al TX del destino. Algunas placas indican la dirección en la propia etiqueta para evitar confusiones: el Arduino Pro Mini pone RXI (entrada RX) y TXO (salida TX), y las placas FTDI estilo SparkFun están rotuladas de modo que, al enchufarlas directamente, se forma el cruce correcto. Si no te fías de las etiquetas, prueba una vez la conexión al revés; intercambiar TX y RX no daña nada, simplemente no hay comunicación.

El jumper de 3,3 V / 5 V: cómo elegir el nivel lógico

El Arduino Uno, el Nano y el Pro Mini de 5 V trabajan con lógica de 5 V; el ESP8266, el ESP32 y la Raspberry Pi Pico, con lógica de 3,3 V. Meter una señal de 5 V en el pin RX de un ESP fuerza sus diodos de protección y con el tiempo puede estropear el pin. Por eso la mayoría de módulos CH340G llevan un jumper de tres pines: elige la tensión de alimentación del chip, y el nivel de la salida TXD sigue esa tensión. El CP2102 trabaja siempre con lógica de 3,3 V, pero sus entradas toleran 5 V; por eso se entiende sin problemas con placas de 3,3 V y de 5 V, ya que un ATmega328P a 5 V considera HIGH todo lo que supera los 3 V. Los módulos FT232RL también suelen tener un jumper que elige el nivel de E/S del chip (VCCIO).

Si tu conversor no tiene jumper y necesitas conectar una línea TX de 5 V a una entrada de 3,3 V, basta con un simple divisor de tensión: con 1 kΩ entre la línea TX y el RX del destino, y 2 kΩ entre el RX del destino y GND, los 5 V bajan a unos 3,3 V. El cálculo detallado está en divisor de tensión. En sentido contrario, un TX de 3,3 V hacia una entrada de 5 V, normalmente no hay problema.

Comparativa: CH340, CP2102 y FT232

Para el trabajo diario de aficionado, entre el CH340 y el CP2102 no hay diferencia práctica; ambos funcionan perfectamente a 115200 baudios y manejan sin esfuerzo todas las velocidades que usa el Arduino IDE. El oscilador interno y la salida de 3,3 V más potente dan al CP2102 una ligera ventaja al alimentar placas pequeñas de 3,3 V, mientras que el CH340 es el más barato y extendido. El FT232RL es un chip fiable y muy configurable, pero buena parte de los módulos FT232 baratos del mercado llevan chips falsificados. Los CH9102 y CH343 que ves en las placas ESP32 más nuevas son miembros más rápidos de la misma familia y se usan igual.

Instalación de drivers: Windows, macOS y Linux

Si en Windows, al conectar el conversor, ves en el Administrador de dispositivos un USB2.0-Serial con un signo de exclamación amarillo bajo Otros dispositivos, falta el driver del CH340; si ves CP2102 USB to UART Bridge Controller, falta el del CP2102. Una vez instalado el driver, desconecta el conversor, vuelve a conectarlo y mira Herramientas > Puerto en el Arduino IDE: el puerto nuevo que aparece en ese momento es el del conversor. Si no aparece nada, cambia primero el cable; los cables de solo carga no tienen hilos de datos. La lista completa de problemas de puerto, driver y permisos está en Arduino no carga el código.

Prueba de loopback: ¿funciona el conversor?

1. Quita todos los cables del conversor y conéctalo al ordenador.
2. Con un cable jumper, une los pines TXD y RXD del propio conversor.
3. Elige el puerto del conversor en el Arduino IDE y abre el Monitor Serie; la velocidad no importa en esta prueba.
4. Escribe algo y envíalo. Si tu texto vuelve tal cual, el chip, el driver y el cable están bien; el problema está en la conexión o en la placa destino.
5. Si no vuelve nada, revisa el puerto, el driver y el cable, y fíjate en si parpadean los LED TX y RX del conversor.

Programar un Arduino Pro Mini: reset automático con DTR

Al cargar código en un Arduino, primero se resetea la placa; el bootloader, que funciona durante un segundo aproximadamente tras el reset, comprueba si llega un programa nuevo por el puerto serie. El Uno y el Nano hacen este reset solos: entre la línea DTR del chip USB y el pin RESET del procesador hay un condensador de 100 nF. En cuanto el IDE abre el puerto, DTR pasa de HIGH a LOW, el condensador transmite esa caída brusca al pin RESET como un breve pulso LOW y la placa se reinicia. En el Pro Mini el mismo condensador está en la placa y va al pin GRN (o DTR) de la tira; si conectas allí el pin DTR del conversor, cargar es tan fácil como en un Uno.

1. Averigua la versión de tu placa por la serigrafía de la parte trasera o del cristal: las de cristal de 16 MHz son la versión de 5 V y las de 8 MHz la de 3,3 V.
2. Pon el jumper del conversor según la versión de la placa y conecta los cables según la tabla.
3. En el Arduino IDE elige Herramientas > Placa > Arduino AVR Boards > Arduino Pro or Pro Mini.
4. En Herramientas > Processor elige ATmega328P (5V, 16 MHz) o ATmega328P (3.3V, 8 MHz) según tu placa.
5. Selecciona el puerto del conversor y carga el programa de prueba de abajo; con DTR conectado no hace falta pulsar ningún botón.

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}

Al terminar la carga, el LED de la placa parpadea cada medio segundo. Abre el Monitor Serie a 9600 baudios con Nueva línea, escribe algo y el texto vuelve. La línea F_CPU del código detecta una trampa pequeña pero importante: los bootloaders de las dos versiones del Pro Mini cargan a 57600 baudios, así que el código se carga incluso con la opción de Processor equivocada. Pero si eliges 16 MHz para una placa de 8 MHz, todo funciona a la mitad de velocidad, el LED cambia una vez por segundo y en el Monitor Serie solo ves caracteres sin sentido. Si tu conversor no tiene pin DTR, puedes sincronizar la carga a mano: en cuanto el IDE termine de compilar y muestre Uploading... en la salida, pulsa y suelta el botón de reset del Pro Mini.

Cargar código en el ESP-01 y la ESP32-CAM

En el ESP8266 y el ESP32 el bootloader está grabado en el chip y mira el pin GPIO 0 al arrancar: si GPIO 0 está en LOW entra en modo descarga y espera código; si está en HIGH, ejecuta el programa de la flash. Las placas de desarrollo tienen un circuito de carga automática que conecta las líneas DTR y RTS a EN y GPIO 0 mediante dos transistores; esptool mueve esas líneas en secuencia y pone la placa en modo descarga por sí solo. Un conversor USB-TTL sencillo no tiene ese circuito, así que lo haces a mano: conecta GPIO 0 a GND, resetea la placa, carga el código, luego quita la conexión de GPIO 0 y vuelve a resetear.

El ESP-01 consume picos de corriente de más de 300 mA al conectarse al Wi-Fi; el pin 3V3 del conversor no los aguanta y el módulo se reinicia una y otra vez. Por eso usa un regulador AMS1117-3.3 alimentado desde el pin 5V. Todas las conexiones y los comandos AT del ESP-01 están en Módulo ESP-01, y la carga paso a paso de la ESP32-CAM en Cómo usar la ESP32-CAM. Si quieres un proyecto que añada un PIR a la ESP32-CAM y te envíe la foto al móvil, echa un vistazo a Fotos de la ESP32-CAM por Telegram.

Leer logs serie: el USB-TTL como segundo puerto serie

Uno de los usos menos conocidos y más prácticos del conversor es dar a una placa un segundo monitor serie. Mientras el USB propio de la placa habla con un programa en Python, con el Serial Plotter o con otro dispositivo, tú puedes seguir los mensajes de depuración detallados por un puerto aparte. El ESP32 tiene tres UART por hardware; el código siguiente asigna la UART2 a los GPIO 16 y 17 y envía una línea de log al conversor cada segundo. La letra r enviada desde el conversor pone a cero el contador, así compruebas que funciona en los dos sentidos.

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}

Para conectarlo, pon el jumper del conversor en 3,3 V y une TXD con GPIO 16, RXD con GPIO 17 y GND con GND. Luego, en lugar de abrir un segundo Arduino IDE, puedes usar PuTTY, screen en macOS y Linux o un pequeño lector escrito en Python; para la parte de Python consulta Comunicación serie entre Arduino y Python. En la Raspberry Pi Pico la misma idea son unas pocas líneas de MicroPython: la UART0 está en GP0 (TX) y GP1 (RX), y el código envía un log y además devuelve los bytes que recibe.

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)

Con el mismo método puedes escuchar lo que dice un módulo sin ningún Arduino de por medio. Conecta un módulo GPS NEO-6M directamente al conversor, ábrelo a 9600 baudios y verás llegar las sentencias NMEA; abre un módulo HC-05 en modo AT a 38400 baudios y podrás cambiar su nombre y su PIN. Todo sobre el final de línea y los baudios del Monitor Serie está en Monitor Serie de Arduino.

Errores frecuentes y soluciones

El conversor USB-TTL es una de las herramientas más pequeñas de tu cajón y una de las que más usarás: programa placas sin USB, deja que el ordenador hable con los módulos y te muestra línea a línea lo que pasa dentro de tus proyectos. Si cruzas TX y RX, eliges el nivel lógico correcto y mantienes GND común, casi todos los problemas desaparecen. En la app BlueGrays encontrarás comunicación serie entre dos Arduino, control desde el móvil por Bluetooth y proyectos Wi-Fi con ESP32, con esquemas de conexión y código listo paso a paso.