Convertitore USB-TTL: usare CH340 e CP2102 con Arduino

Un convertitore USB-TTL è una piccola scheda che traduce la porta USB del computer nel linguaggio seriale (UART) parlato dai microcontrollori. Ti serve per caricare codice su schede senza connettore USB come Arduino Pro Mini, ESP-01 ed ESP32-CAM, per leggere i messaggi seriali che escono da un modulo o per configurare moduli GPS e Bluetooth direttamente dal computer. In realtà ogni Arduino Uno e Nano ne ha già una copia a bordo; il convertitore la trasforma in un modulo separato e portatile.

In questa guida conoscerai i pin del convertitore, l'errore più comune in assoluto (il collegamento TX-RX), il jumper che sceglie il livello logico a 3,3 V o 5 V e l'installazione dei driver su Windows, macOS e Linux. Poi vedrai come programmare un Arduino Pro Mini senza premere pulsanti grazie al pin DTR, caricare codice su ESP-01 ed ESP32-CAM, usare il convertitore come secondo monitor seriale e in cosa differiscono i tre chip più diffusi: CH340, CP2102 e FT232.

Che cos'è un convertitore USB-TTL e a cosa serve?

Computer e microcontrollore parlano lingue diverse. L'USB è un protocollo complesso fatto di pacchetti, indirizzi e driver. La UART di un microcontrollore, invece, usa solo due linee: una invia i dati (TX), l'altra li riceve (RX), e ogni byte è composto da bit inviati uno dopo l'altro a una velocità concordata (baud). Il chip del convertitore appare al computer come una porta seriale virtuale (COM3 su Windows, /dev/cu.usbserial... su macOS, /dev/ttyUSB0 su Linux); ogni byte scritto su quella porta esce dal pin TX come segnale UART e ogni byte che arriva sul pin RX viene passato al computer. Il TTL nel nome indica che i segnali variano tra 0 V e 5 V, oppure tra 0 V e 3,3 V.

• Programmare schede senza USB: Arduino Pro Mini, LilyPad, ESP-01, ESP32-CAM e chip ATmega328P nudi con bootloader.
• Leggere log seriali: Seguire i messaggi di debug in una seconda finestra mentre la porta USB della scheda è occupata con altro.
• Parlare direttamente con i moduli: Inviare comandi AT a un ESP-01, leggere le frasi NMEA di un GPS, rinominare un modulo Bluetooth.
• Recuperare una scheda guasta: Programmare un Uno o un Nano con il chip USB bruciato tramite i pin D0 e D1.
• Collegarsi alla console di altri dispositivi: I pin della console seriale di router, schede di stampanti 3D o computer a scheda singola.

Pin dell'USB-TTL: GND, VCC, TXD, RXD, DTR e RTS

Collegamento incrociato di TX e RX

L'errore più comune è collegare TX con TX. La regola è semplice: la linea su cui un dispositivo parla deve andare alla linea su cui l'altro ascolta. Quindi il pin TXD del convertitore va al pin RX della scheda di destinazione e il pin RXD va al TX della destinazione. Alcune schede indicano la direzione direttamente nelle etichette per evitare confusione: sull'Arduino Pro Mini c'è scritto RXI (ingresso RX) e TXO (uscita TX), e le schede FTDI in stile SparkFun sono etichettate in modo che, innestandole direttamente, si ottenga l'incrocio corretto. Se non ti fidi delle etichette, prova una volta il collegamento al contrario; scambiare TX e RX non danneggia nulla, semplicemente non c'è comunicazione.

Il jumper 3,3 V / 5 V: come scegliere il livello logico

Arduino Uno, Nano e il Pro Mini a 5 V lavorano con logica a 5 V; ESP8266, ESP32 e Raspberry Pi Pico con logica a 3,3 V. Mandare un segnale a 5 V nel pin RX di un ESP sollecita i suoi diodi di protezione e col tempo può rovinare il pin. Per questo la maggior parte dei moduli CH340G ha un jumper a tre pin: sceglie la tensione di alimentazione del chip, e il livello dell'uscita TXD segue quella tensione. Il CP2102 lavora sempre con logica a 3,3 V ma i suoi ingressi tollerano i 5 V; perciò si intende senza problemi sia con le schede a 3,3 V sia con quelle a 5 V, perché un ATmega328P a 5 V considera già HIGH tutto ciò che supera i 3 V. Anche i moduli FT232RL hanno spesso un jumper che sceglie il livello di I/O del chip (VCCIO).

Se il tuo convertitore non ha il jumper e devi collegare una linea TX a 5 V a un ingresso a 3,3 V, basta un semplice partitore di tensione: con 1 kΩ tra la linea TX e l'RX della destinazione, e 2 kΩ tra l'RX della destinazione e GND, i 5 V scendono a circa 3,3 V. Il calcolo dettagliato è in partitore di tensione. Nella direzione opposta, un TX a 3,3 V verso un ingresso a 5 V, di solito non ci sono problemi.

Confronto: CH340, CP2102 e FT232

Per l'uso hobbistico di tutti i giorni tra CH340 e CP2102 non c'è differenza pratica; entrambi funzionano perfettamente a 115200 baud e reggono senza sforzo tutte le velocità usate dall'Arduino IDE. L'oscillatore interno e l'uscita a 3,3 V più robusta danno al CP2102 un leggero vantaggio quando deve alimentare piccole schede a 3,3 V, mentre il CH340 è il più economico e diffuso. L'FT232RL è un chip affidabile e molto configurabile, ma buona parte dei moduli FT232 economici in commercio monta chip contraffatti. I CH9102 e CH343 che trovi sulle schede ESP32 più recenti sono membri più veloci della stessa famiglia e si usano allo stesso modo.

Installare i driver: Windows, macOS e Linux

Se su Windows, dopo aver collegato il convertitore, in Gestione dispositivi vedi sotto Altri dispositivi un USB2.0-Serial con il punto esclamativo giallo, manca il driver del CH340; se vedi CP2102 USB to UART Bridge Controller, manca quello del CP2102. Dopo aver installato il driver, scollega e ricollega il convertitore e guarda Strumenti > Porta nell'Arduino IDE: la porta nuova che compare in quel momento è quella del convertitore. Se non compare nulla, cambia prima il cavo; i cavi di sola ricarica non hanno i fili dati. L'elenco completo dei problemi di porta, driver e permessi è in Arduino non carica lo sketch.

Test di loopback: il convertitore funziona?

1. Togli tutti i cavi dal convertitore e collegalo al computer.
2. Con un cavetto jumper unisci tra loro i pin TXD e RXD del convertitore stesso.
3. Seleziona la porta del convertitore nell'Arduino IDE e apri il Monitor seriale; per questo test la velocità non conta.
4. Scrivi qualcosa e invialo. Se il testo torna identico, chip, driver e cavo sono a posto; il problema sta nel collegamento o nella scheda di destinazione.
5. Se non torna nulla, controlla porta, driver e cavo, e guarda se i LED TX e RX del convertitore lampeggiano.

Programmare un Arduino Pro Mini: reset automatico con DTR

Durante il caricamento la scheda Arduino viene prima resettata; il bootloader, che gira per circa un secondo dopo il reset, controlla se dalla porta seriale arriva un nuovo programma. Uno e Nano fanno questo reset da soli: tra la linea DTR del chip USB e il pin RESET del processore c'è un condensatore da 100 nF. Appena l'IDE apre la porta, DTR passa da HIGH a LOW, il condensatore trasmette questo brusco calo al pin RESET come un breve impulso LOW e la scheda si riavvia. Sul Pro Mini lo stesso condensatore è sulla scheda ed è collegato al pin GRN (o DTR) del connettore; se colleghi lì il pin DTR del convertitore, caricare diventa facile come su un Uno.

1. Scopri la versione della scheda dalla serigrafia sul retro o dal quarzo: le schede con quarzo da 16 MHz sono la versione a 5 V, quelle da 8 MHz la versione a 3,3 V.
2. Imposta il jumper del convertitore in base alla versione della scheda e collega i fili secondo la tabella.
3. Nell'Arduino IDE scegli Strumenti > Scheda > Arduino AVR Boards > Arduino Pro or Pro Mini.
4. In Strumenti > Processor scegli ATmega328P (5V, 16 MHz) o ATmega328P (3.3V, 8 MHz) in base alla tua scheda.
5. Seleziona la porta del convertitore e carica lo sketch di prova qui sotto; con DTR collegato non serve premere alcun pulsante.

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}

Finito il caricamento, il LED sulla scheda lampeggia ogni mezzo secondo. Apri il Monitor seriale a 9600 baud con A capo (NL), scrivi qualcosa e il testo torna indietro. La riga F_CPU nel codice smaschera una trappola piccola ma importante: i bootloader di entrambe le versioni del Pro Mini caricano a 57600 baud, quindi il codice si carica anche con l'opzione Processor sbagliata. Ma se scegli 16 MHz per una scheda a 8 MHz, tutto gira a metà velocità, il LED cambia una volta al secondo e nel Monitor seriale vedi solo caratteri senza senso. Se il convertitore non ha il pin DTR puoi sincronizzare il caricamento a mano: appena l'IDE finisce di compilare e nell'output compare Uploading..., premi e rilascia il pulsante di reset del Pro Mini.

Caricare codice su ESP-01 ed ESP32-CAM

Su ESP8266 ed ESP32 il bootloader è integrato nel chip e all'avvio controlla il pin GPIO 0: se GPIO 0 è LOW entra in modalità download e attende il codice, se è HIGH esegue il programma in flash. Le schede di sviluppo hanno un circuito di caricamento automatico che collega le linee DTR e RTS a EN e GPIO 0 tramite due transistor; esptool muove queste linee in sequenza e porta da solo la scheda in modalità download. Un semplice convertitore USB-TTL non ha questo circuito, quindi lo fai a mano: colleghi GPIO 0 a GND, resetti la scheda, carichi il codice, poi togli il collegamento di GPIO 0 e resetti di nuovo.

L'ESP-01 assorbe picchi di corrente oltre i 300 mA quando si collega al Wi-Fi; il pin 3V3 del convertitore non li regge e il modulo si riavvia di continuo. Usa quindi un regolatore AMS1117-3.3 alimentato dal pin 5V. Tutti i collegamenti e i comandi AT dell'ESP-01 sono in Modulo ESP-01, mentre il caricamento passo passo della ESP32-CAM è in Come usare la ESP32-CAM. Se cerchi un progetto che aggiunga un PIR alla ESP32-CAM e ti mandi la foto sul telefono, dai un'occhiata a Foto dalla ESP32-CAM su Telegram.

Leggere i log seriali: l'USB-TTL come seconda porta seriale

Uno degli usi meno noti ma più utili del convertitore è dare a una scheda un secondo monitor seriale. Mentre la porta USB della scheda dialoga con un programma Python, con il Plotter seriale o con un altro dispositivo, tu segui i messaggi di debug dettagliati su una porta separata. L'ESP32 ha tre UART hardware; il codice seguente assegna la UART2 ai GPIO 16 e 17 e invia una riga di log al convertitore ogni secondo. La lettera r inviata dal convertitore azzera il contatore, così vedi che funziona in entrambe le direzioni.

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}

Per il collegamento imposta il jumper del convertitore su 3,3 V e collega TXD a GPIO 16, RXD a GPIO 17 e GND a GND. Poi, invece di aprire un secondo Arduino IDE, puoi usare PuTTY, screen su macOS e Linux oppure un piccolo lettore scritto in Python; per la parte Python vedi Comunicazione seriale tra Arduino e Python. Sul Raspberry Pi Pico la stessa idea richiede poche righe di MicroPython: la UART0 è su GP0 (TX) e GP1 (RX), e il codice invia un log e rimanda indietro i byte ricevuti.

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 lo stesso metodo puoi ascoltare cosa dice un modulo senza nessun Arduino in mezzo. Collega un modulo GPS NEO-6M direttamente al convertitore, aprilo a 9600 baud e vedrai scorrere le frasi NMEA; apri un modulo HC-05 in modalità AT a 38400 baud e potrai cambiarne nome e PIN. Tutto su fine riga e baud del Monitor seriale è in Monitor seriale di Arduino.

Errori comuni e soluzioni

Il convertitore USB-TTL è uno degli strumenti più piccoli del tuo cassetto e uno di quelli che userai di più: programma schede senza USB, fa parlare il computer con i moduli e ti mostra riga per riga cosa succede dentro i tuoi progetti. Se ricordi di incrociare TX e RX, di scegliere il livello logico giusto e di tenere GND in comune, quasi tutti i problemi spariscono. Nell'app BlueGrays trovi la comunicazione seriale tra due Arduino, il controllo dal telefono via Bluetooth e progetti Wi-Fi con ESP32, con schemi di collegamento e codice pronto passo passo.