Adaptateur USB-TTL : utiliser le CH340 et le CP2102 (Arduino)

Un adaptateur USB-TTL est une petite carte qui traduit le port USB de ton ordinateur dans la langue série (UART) que parlent les microcontrôleurs. Il te faut pour téléverser du code sur des cartes sans prise USB comme l'Arduino Pro Mini, l'ESP-01 et l'ESP32-CAM, pour lire les messages série qui sortent d'un module ou pour configurer des modules GPS et Bluetooth directement depuis l'ordinateur. En réalité, chaque Arduino Uno et Nano en embarque déjà une copie ; l'adaptateur en fait un module séparé et transportable.

Dans ce guide, tu découvriras les broches de l'adaptateur, l'erreur la plus fréquente de toutes (le câblage TX-RX), le cavalier qui choisit le niveau logique 3,3 V ou 5 V et l'installation des pilotes sous Windows, macOS et Linux. Tu verras ensuite comment programmer un Arduino Pro Mini sans appuyer sur aucun bouton grâce à la broche DTR, téléverser du code sur l'ESP-01 et l'ESP32-CAM, utiliser l'adaptateur comme second moniteur série, et ce qui distingue les trois puces les plus courantes : CH340, CP2102 et FT232.

Qu'est-ce qu'un adaptateur USB-TTL et à quoi sert-il ?

L'ordinateur et le microcontrôleur ne parlent pas la même langue. L'USB est un protocole complexe fait de paquets, d'adresses et de pilotes. L'UART d'un microcontrôleur, elle, n'utilise que deux lignes : l'une envoie les données (TX), l'autre les reçoit (RX), et chaque octet est formé de bits envoyés les uns après les autres à une vitesse convenue (baud). La puce de l'adaptateur apparaît sur l'ordinateur comme un port série virtuel (COM3 sous Windows, /dev/cu.usbserial... sous macOS, /dev/ttyUSB0 sous Linux) ; chaque octet écrit sur ce port sort de la broche TX sous forme de signal UART, et chaque octet qui arrive sur la broche RX est transmis à l'ordinateur. Le TTL de son nom signifie que les signaux varient entre 0 V et 5 V, ou entre 0 V et 3,3 V.

• Programmer des cartes sans USB : Arduino Pro Mini, LilyPad, ESP-01, ESP32-CAM et puces ATmega328P nues avec bootloader.
• Lire des journaux série : Suivre les messages de débogage dans une seconde fenêtre pendant que l'USB de la carte est occupé ailleurs.
• Parler directement aux modules : Envoyer des commandes AT à un ESP-01, lire les trames NMEA d'un GPS, renommer un module Bluetooth.
• Sauver une carte en panne : Programmer un Uno ou un Nano dont la puce USB est morte via ses broches D0 et D1.
• Se brancher sur la console d'autres appareils : Les broches de console série des box, des cartes d'imprimante 3D ou des ordinateurs monocartes.

Broches de l'USB-TTL : GND, VCC, TXD, RXD, DTR et RTS

Câblage croisé de TX et RX

L'erreur la plus courante est de relier TX à TX. La règle est simple : la ligne sur laquelle un appareil parle doit aller sur la ligne où l'autre écoute. La broche TXD de l'adaptateur va donc sur la broche RX de la carte cible, et sa broche RXD sur le TX de la cible. Certaines cartes indiquent le sens dans leurs étiquettes pour éviter la confusion : l'Arduino Pro Mini porte RXI (entrée RX) et TXO (sortie TX), et les cartes FTDI de style SparkFun sont étiquetées de sorte qu'en les branchant directement l'une dans l'autre, le croisement soit correct. Si tu n'as pas confiance dans les étiquettes, essaie une fois le câblage dans l'autre sens ; inverser TX et RX n'abîme rien, il n'y a simplement pas de communication.

Le cavalier 3,3 V / 5 V : comment choisir le niveau logique

L'Arduino Uno, le Nano et le Pro Mini 5 V fonctionnent en logique 5 V ; l'ESP8266, l'ESP32 et la Raspberry Pi Pico en logique 3,3 V. Envoyer un signal de 5 V sur la broche RX d'un ESP sollicite ses diodes de protection et peut abîmer la broche avec le temps. C'est pourquoi la plupart des modules CH340G possèdent un cavalier à trois broches : il choisit la tension d'alimentation de la puce, et le niveau de la sortie TXD suit cette tension. Le CP2102 fonctionne toujours en logique 3,3 V, mais ses entrées tolèrent le 5 V ; il s'entend donc aussi bien avec les cartes 3,3 V qu'avec les cartes 5 V, car un ATmega328P en 5 V considère déjà comme HIGH tout ce qui dépasse 3 V. Les modules FT232RL ont souvent aussi un cavalier qui choisit le niveau d'E/S de la puce (VCCIO).

Si ton adaptateur n'a pas de cavalier et que tu dois relier une ligne TX en 5 V à une entrée 3,3 V, un simple pont diviseur suffit : avec 1 kΩ entre la ligne TX et le RX de la cible, et 2 kΩ entre le RX de la cible et GND, les 5 V tombent à environ 3,3 V. Le calcul détaillé est dans pont diviseur de tension. Dans l'autre sens, un TX en 3,3 V vers une entrée 5 V, cela ne pose généralement aucun problème.

Comparatif : CH340, CP2102 et FT232

Pour un usage amateur courant, il n'y a pratiquement aucune différence entre le CH340 et le CP2102 ; les deux fonctionnent parfaitement à 115200 bauds et gèrent sans peine toutes les vitesses de l'Arduino IDE. L'oscillateur interne et la sortie 3,3 V plus robuste du CP2102 lui donnent un léger avantage pour alimenter de petites cartes en 3,3 V, tandis que le CH340 est le moins cher et le plus répandu. Le FT232RL est une puce fiable et très configurable, mais une bonne partie des modules FT232 bon marché contiennent des puces contrefaites. Les CH9102 et CH343 présentes sur les cartes ESP32 récentes sont des membres plus rapides de la même famille et s'utilisent de la même manière.

Installer les pilotes : Windows, macOS et Linux

Si, sous Windows, après avoir branché l'adaptateur, tu vois dans le Gestionnaire de périphériques un USB2.0-Serial avec un point d'exclamation jaune sous Autres périphériques, il manque le pilote du CH340 ; si tu vois CP2102 USB to UART Bridge Controller, c'est celui du CP2102. Une fois le pilote installé, débranche puis rebranche l'adaptateur et regarde Outils > Port dans l'Arduino IDE : le nouveau port qui apparaît à cet instant est celui de l'adaptateur. Si rien n'apparaît, change d'abord de câble ; les câbles de charge seule n'ont pas de fils de données. La liste complète des problèmes de port, de pilote et de droits se trouve dans Arduino : le téléversement échoue.

Test de boucle (loopback) : l'adaptateur fonctionne-t-il ?

1. Retire tous les fils de l'adaptateur et branche-le sur l'ordinateur.
2. Avec un fil de liaison, relie entre elles les broches TXD et RXD de l'adaptateur lui-même.
3. Choisis le port de l'adaptateur dans l'Arduino IDE et ouvre le Moniteur série ; la vitesse n'a pas d'importance pour ce test.
4. Tape quelque chose et envoie-le. Si ton texte revient tel quel, la puce, le pilote et le câble sont bons ; le problème vient du câblage ou de la carte cible.
5. Si rien ne revient, vérifie le port, le pilote et le câble, et regarde si les LED TX et RX de l'adaptateur clignotent.

Programmer un Arduino Pro Mini : reset automatique par DTR

Lors d'un téléversement, l'Arduino est d'abord réinitialisé ; le bootloader, qui tourne environ une seconde après le reset, regarde si un nouveau programme arrive par le port série. L'Uno et le Nano font ce reset tout seuls : un condensateur de 100 nF relie la ligne DTR de la puce USB à la broche RESET du processeur. Dès que l'IDE ouvre le port, DTR passe de HIGH à LOW, le condensateur transmet cette chute brutale à RESET sous la forme d'une brève impulsion LOW et la carte redémarre. Sur le Pro Mini, ce même condensateur est sur la carte et relié à la broche GRN (ou DTR) du connecteur ; en y branchant la broche DTR de l'adaptateur, le téléversement devient aussi simple que sur un Uno.

1. Identifie la version de ta carte grâce au marquage au dos ou sur son quartz : les cartes à quartz de 16 MHz sont la version 5 V, celles à 8 MHz la version 3,3 V.
2. Règle le cavalier de l'adaptateur selon la version de la carte et câble le tout d'après le tableau.
3. Dans l'Arduino IDE, choisis Outils > Type de carte > Arduino AVR Boards > Arduino Pro or Pro Mini.
4. Dans Outils > Processor, choisis ATmega328P (5V, 16 MHz) ou ATmega328P (3.3V, 8 MHz) selon ta carte.
5. Sélectionne le port de l'adaptateur et téléverse le programme de test ci-dessous ; avec DTR branché, inutile d'appuyer sur un bouton.

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}

Une fois le téléversement terminé, la LED de la carte clignote toutes les demi-secondes. Ouvre le Moniteur série à 9600 bauds avec Nouvelle ligne, tape quelque chose et le texte revient. La ligne F_CPU du code met en évidence un piège petit mais important : les bootloaders des deux versions du Pro Mini téléversent à 57600 bauds, donc le code se charge même avec la mauvaise option Processor. Mais si tu choisis 16 MHz pour une carte à 8 MHz, tout tourne à moitié de la vitesse, la LED change une fois par seconde et le Moniteur série n'affiche que des caractères incompréhensibles. Si ton adaptateur n'a pas de broche DTR, tu peux synchroniser le téléversement à la main : dès que l'IDE a fini de compiler et affiche Uploading..., appuie brièvement sur le bouton reset du Pro Mini.

Téléverser du code sur l'ESP-01 et l'ESP32-CAM

Sur l'ESP8266 et l'ESP32, le bootloader est gravé dans la puce et lit la broche GPIO 0 au démarrage : si GPIO 0 est à LOW, il passe en mode téléchargement et attend du code ; si elle est à HIGH, il lance le programme en flash. Les cartes de développement ont un circuit de téléversement automatique qui relie DTR et RTS à EN et à GPIO 0 par deux transistors ; esptool actionne ces lignes dans l'ordre et met la carte en mode téléchargement tout seul. Un simple adaptateur USB-TTL n'a pas ce circuit, tu le fais donc à la main : relie GPIO 0 à GND, réinitialise la carte, téléverse le code, puis retire la liaison GPIO 0 et réinitialise à nouveau.

L'ESP-01 tire des pointes de courant de plus de 300 mA en se connectant au Wi-Fi ; la broche 3V3 de l'adaptateur ne suit pas et le module redémarre sans cesse. Utilise donc un régulateur AMS1117-3.3 alimenté par la broche 5V. Tous les branchements et commandes AT de l'ESP-01 sont dans Module ESP-01, et le téléversement pas à pas de l'ESP32-CAM dans Utiliser l'ESP32-CAM. Si tu veux un projet qui ajoute un PIR à l'ESP32-CAM et t'envoie la photo sur ton téléphone, jette un œil à Photos de l'ESP32-CAM sur Telegram.

Lire les journaux série : l'USB-TTL comme second port série

L'un des usages les moins connus mais les plus utiles de l'adaptateur est d'ajouter un second moniteur série à une carte. Pendant que le port USB de la carte dialogue avec un programme Python, le traceur série ou un autre appareil, tu suis les messages de débogage détaillés sur un port séparé. L'ESP32 a trois UART matérielles ; le code ci-dessous affecte l'UART2 aux GPIO 16 et 17 et envoie une ligne de journal à l'adaptateur chaque seconde. La lettre r envoyée depuis l'adaptateur remet le compteur à zéro, ce qui montre que cela fonctionne dans les deux sens.

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}

Pour le branchement, règle le cavalier de l'adaptateur sur 3,3 V et relie TXD à GPIO 16, RXD à GPIO 17 et GND à GND. Ensuite, au lieu d'ouvrir un second Arduino IDE, tu peux utiliser PuTTY, screen sous macOS et Linux ou un petit lecteur écrit en Python ; pour la partie Python, vois Communication série entre Arduino et Python. Sur la Raspberry Pi Pico, la même idée tient en quelques lignes de MicroPython : l'UART0 est sur GP0 (TX) et GP1 (RX), et le code envoie un journal tout en renvoyant les octets reçus.

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)

La même méthode permet d'écouter ce que dit un module sans aucun Arduino au milieu. Branche un module GPS NEO-6M directement sur l'adaptateur, ouvre-le à 9600 bauds et tu verras défiler les trames NMEA ; ouvre un module HC-05 en mode AT à 38400 bauds et tu pourras changer son nom et son code PIN. Tout sur la fin de ligne et les bauds du Moniteur série se trouve dans Moniteur série Arduino.

Erreurs fréquentes et solutions

L'adaptateur USB-TTL est l'un des plus petits outils de ton tiroir et l'un de ceux que tu utiliseras le plus : il programme les cartes sans USB, fait parler l'ordinateur avec les modules et te montre ligne par ligne ce qui se passe dans tes projets. Si tu penses à croiser TX et RX, à choisir le bon niveau logique et à garder une masse commune, presque tous les problèmes disparaissent. Dans l'application BlueGrays, tu trouveras la communication série entre deux Arduino, le pilotage depuis le téléphone en Bluetooth et des projets Wi-Fi avec l'ESP32, avec schémas de câblage et code prêt à l'emploi, étape par étape.