Arduino ou ESP32 : différences, comparatif et lequel choisir

Arduino ou ESP32 ? Voici la réponse courte : si ton projet a besoin du Wi-Fi, du Bluetooth, d'Internet ou d'une vraie puissance de calcul, choisis l'ESP32 ; si tu apprends les bases de l'électronique, veux utiliser des capteurs et modules 5 V sans souci et suivre chaque tutoriel à la lettre, choisis l'Arduino Uno. Les deux cartes se programment dans l'Arduino IDE avec les mêmes commandes digitalWrite, analogRead et Serial. La vraie différence est matérielle : vitesse, mémoire, tension de fonctionnement, broches et connexion sans fil.

Dans ce guide, nous comparons avec de vrais chiffres l'Arduino Uno R3 et la carte ESP32 la plus répandue, l'ESP32 DevKit (avec le module ESP-WROOM-32) : que changent concrètement le processeur et la mémoire, quels modules sont concernés par la différence entre 5 V et 3,3 V, comment évoluent la lecture analogique et le PWM, et combien d'heures chaque carte tient-elle sur batterie ? Ensuite, nous ferons tourner le même code sur les deux cartes, comparerons rapidement le Raspberry Pi Pico et résumerons dans un tableau quelle carte choisir selon le type de projet.

Réponse courte : laquelle et dans quel cas ?

Que sont l'Arduino Uno et l'ESP32 ?

L'Arduino Uno R3 est la carte la plus connue de la plateforme Arduino, née en Italie. Son cœur est le microcontrôleur 8 bits ATmega328P, cadencé à 16 MHz. La carte fonctionne en 5 V et son brochage n'a pas changé depuis des années ; des centaines de shields (cartes d'extension qui s'enfichent dessus), de livres et de cours sont donc compatibles. Sa conception simple te permet de voir exactement ce qui se passe : quand tu écris HIGH sur une broche, il y a vraiment 5 V dessus. Le nouvel Uno R4 embarque un processeur Arm 32 bits à 48 MHz et 32 Ko de RAM, et la version R4 WiFi ajoute un ESP32-S3 sur la carte pour le sans-fil ; dans cet article, « Uno » désigne le R3, toujours le plus répandu. Pour mieux connaître la plateforme, lis Qu'est-ce qu'Arduino ?.

L'ESP32, lui, est un système sur puce (SoC) 32 bits lancé par Espressif en 2016, avec le Wi-Fi et le Bluetooth sur la même puce. La carte que tu as en main est une carte de développement qui porte cette puce : elle comprend un convertisseur USB-série, un régulateur 3,3 V et les boutons EN et BOOT. Détail important : l'ESP32 n'est pas un Arduino, mais grâce au cœur Arduino fourni par Espressif, il se programme dans l'Arduino IDE exactement comme un Arduino. Pour l'installation et les premiers projets, Qu'est-ce que l'ESP32 ? est un bon point de départ.

Le grand tableau comparatif : Arduino Uno, ESP32 et Raspberry Pi Pico

Processeur et mémoire : que signifient les chiffres en pratique ?

Le processeur de l'Uno exécute environ 16 millions d'instructions par seconde et travaille sur des nombres de 8 bits à la fois ; une opération 32 bits sur un long ou un float demande des dizaines d'instructions, et il n'y a pas d'unité de calcul flottant (FPU) matérielle. L'ESP32 tourne à 240 MHz sur des nombres de 32 bits et possède une FPU simple précision. Dans un calcul riche en float, l'ESP32 peut donc être des dizaines, voire des centaines de fois plus rapide que l'Uno. Tu ne verras aucune différence pour faire clignoter une LED ou lire un capteur quelques fois par seconde, mais elle devient décisive pour le filtrage, le traitement audio, le chiffrement ou le calcul d'animations pour des centaines de LED. Petite astuce : la FPU de l'ESP32 ne gère que le type float ; les opérations en double se font en logiciel et sont nettement plus lentes.

La différence de mémoire, tu la rencontreras bien plus souvent. Les 2 Ko de RAM de l'Uno sont partagés entre tes variables, les tampons de Serial et l'espace réservé par les bibliothèques. Quand la RAM est pleine, le compilateur ne prévient presque jamais ; le programme se bloque au hasard ou se comporte bizarrement. Situations typiques où l'Uno manque vite de RAM :

• Écran OLED : le seul tampon d'image d'un écran SSD1306 128×64 occupe 1 Ko, soit la moitié de la RAM (voir Écran OLED).
• LED adressables : chaque LED WS2812B occupe 3 octets ; un ruban de 300 LED demande 900 octets (voir WS2812B NeoPixel).
• Données d'Internet : le JSON renvoyé par un service météo peut peser plusieurs Ko ; il ne tient pas dans l'Uno mais l'ESP32 le traite sans peine.
• Concaténation de String : des objets String qui grossissent dans une boucle fragmentent la petite RAM et peuvent provoquer un plantage des heures plus tard.
• Carte SD : la bibliothèque SD réserve un tampon de secteur de 512 octets ; avec les bibliothèques d'écran et de capteurs, on atteint vite la limite.

La différence de tension : 5 V et 3,3 V

C'est la différence la plus souvent oubliée. Les broches de l'Uno fonctionnent en logique 5 V : une sortie HIGH vaut 5 V et les entrées au-dessus de 3 V sont lues comme HIGH. Les broches de l'ESP32 fonctionnent en logique 3,3 V et ne tolèrent pas le 5 V. Appliquer 5 V sur une broche ne tue peut-être pas l'ESP32 tout de suite, mais cela force les diodes de protection internes et peut détruire la puce à la longue ou d'un coup. Dans l'autre sens, c'est moins grave : le HIGH de 3,3 V de l'ESP32 dépasse de justesse le seuil de 3 V de l'Uno et il est donc généralement lu comme HIGH, mais ce n'est pas non plus une conception sûre. Voici comment se comportent les modules courants avec chaque carte :

Broches, lecture analogique et PWM

Sur l'Uno, les 20 broches se comportent à peu près de la même façon : chacune peut être une entrée ou une sortie, fournit sans problème jusqu'à 20 mA et n'influence pas le démarrage. L'ESP32 DevKit a plus de broches sur le papier, mais elles ne se valent pas : les GPIO 6–11 sont reliés à la flash interne et inutilisables, les GPIO 34–39 sont uniquement des entrées, et les GPIO 0, 2, 5, 12 et 15 doivent avoir certains niveaux au démarrage. En pratique, tu peux utiliser confortablement 20 à 25 broches. Le brochage de ta carte est disponible dans l'outil Brochage.

En lecture analogique, l'ADC 10 bits de l'Uno découpe la plage 0–5 V en 1024 pas ; chaque pas vaut environ 4,9 mV et la mesure est assez linéaire. L'ADC 12 bits de l'ESP32 donne 4096 pas, mais avec le réglage par défaut il ne distingue pas les valeurs sous environ 0,15 V ni au-dessus de 3,1 V, il est bruité et les broches ADC2 ne fonctionnent pas du tout quand le Wi-Fi est actif. Pour une tension précise sur l'ESP32, utilise analogReadMilliVolts() et branche le capteur sur les broches ADC1 (GPIO 32–39). Côté PWM, l'ESP32 prend l'avantage : l'Uno ne propose du PWM 8 bits que sur 6 broches à 490 ou 980 Hz, alors que l'ESP32 peut diriger 16 canaux à fréquence et résolution réglables vers presque n'importe quelle broche de sortie. Il possède aussi 2 DAC (GPIO 25 et 26) qui produisent une vraie tension analogique. Pour les bases du PWM, lis Qu'est-ce que le PWM ?.

Le même code sur les deux cartes : qu'est-ce qui change ?

Bonne nouvelle : tout ce que tu as appris sur Arduino vaut aussi pour l'ESP32. Le code ci-dessous lit un potentiomètre, affiche la tension dans le Moniteur série et allume la LED de la carte quand la valeur dépasse la moitié. La ligne #if defined(ESP32) détecte pour quelle carte le code est compilé et ne change que le numéro de broche, la tension de référence et la résolution de l'ADC. Relie les bornes extrêmes du potentiomètre à 5V et GND sur l'Uno, ou à 3V3 et GND sur l'ESP32 ; branche le curseur sur A0 pour l'Uno ou sur GPIO 34 pour l'ESP32, puis ouvre le Moniteur série à 115200 bauds. Les principales différences hors du code sont dans le tableau.

1// Aynı kod Uno ve ESP32'de çalışır / The same sketch runs on Uno and ESP32
2#if defined(ESP32)
3const int LED_PIN = 2;        // DevKit dahili LED / DevKit onboard LED
4const int POT_PIN = 34;       // ADC1 pini, Wi-Fi ile de çalışır / ADC1 pin, works with Wi-Fi too
5const float VREF = 3.3;       // ESP32 pinleri 3,3 V / ESP32 pins are 3.3 V
6const int ADC_MAX = 4095;     // 12 bit
7#else
8const int LED_PIN = 13;       // Uno dahili LED / Uno onboard LED
9const int POT_PIN = A0;
10const float VREF = 5.0;       // Uno referansı 5 V / Uno reference is 5 V
11const int ADC_MAX = 1023;     // 10 bit
12#endif
13
14void setup() {
15  Serial.begin(115200);
16  pinMode(LED_PIN, OUTPUT);
17}
18
19void loop() {
20  int raw = analogRead(POT_PIN);
21  float volts = raw * VREF / ADC_MAX;
22  Serial.print("Ham / raw: ");
23  Serial.print(raw);
24  Serial.print("  Gerilim / voltage: ");
25  Serial.println(volts, 2);
26  digitalWrite(LED_PIN, raw > ADC_MAX / 2 ? HIGH : LOW);   // yarıdan fazlaysa LED yanar / LED on above half
27  delay(250);
28}

Wi-Fi, Bluetooth et Internet

Ce qui distingue vraiment l'ESP32, c'est la connexion sans fil. La carte rejoint les réseaux Wi-Fi 2,4 GHz, peut créer son propre point d'accès, fait tourner un serveur web, envoie des données à une installation domotique via MQTT, récupère l'heure sur Internet par NTP et peut mettre à jour son firmware sans fil (OTA). Côté Bluetooth, le Bluetooth classique (profil port série) et le BLE basse consommation sont pris en charge, et avec ESP-NOW plusieurs ESP32 peuvent dialoguer sans box. Rien de tout cela n'est intégré à l'Uno : pour le Bluetooth il faut un module comme le HC-05, et pour le Wi-Fi une puce séparée comme l'ESP-01 avec des commandes AT. Le code ci-dessous lit le même potentiomètre, cette fois par Wi-Fi : ouvre l'adresse affichée dans le Moniteur série dans le navigateur d'un téléphone connecté au même réseau et tu verras la tension en millivolts ; la page se rafraîchit toute seule toutes les deux secondes.

1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* ssid = "AgAdi";          // Wi-Fi adın / your Wi-Fi name
5const char* password = "Sifre123";   // Wi-Fi şifren / your Wi-Fi password
6const int POT_PIN = 34;              // ADC1 pini / ADC1 pin
7
8WebServer server(80);
9
10void handleRoot() {
11  uint32_t mv = analogReadMilliVolts(POT_PIN);   // kalibre edilmiş mV / calibrated mV
12  String html = "<meta name='viewport' content='width=device-width'>"
13                "<meta http-equiv='refresh' content='2'>"
14                "<h1>ESP32</h1><p>Pot: ";
15  html += mv;
16  html += " mV</p>";
17  server.send(200, "text/html", html);
18}
19
20void setup() {
21  Serial.begin(115200);
22  WiFi.begin(ssid, password);
23  while (WiFi.status() != WL_CONNECTED) delay(500);
24  Serial.print("Telefonda aç / open on your phone: http://");
25  Serial.println(WiFi.localIP());
26  server.on("/", handleRoot);
27  server.begin();
28}
29
30void loop() {
31  server.handleClient();
32}

Consommation et fonctionnement sur batterie

Sur le papier, l'ESP32 est à la fois la carte la plus gourmande et la plus sobre. Quand il envoie des données en Wi-Fi, il tire des pics jusqu'à 240 mA ; c'est pourquoi il redémarre avec l'erreur « Brownout detector was triggered » sur un port USB faible. En sommeil profond, en revanche, la puce ne consomme qu'environ 10 µA. La carte Uno consomme environ 45 mA sans rien faire ; même avec l'ATmega328P endormi, la puce USB-série, le régulateur et la LED d'alimentation continuent de tirer environ 30 mA. Prenons un exemple : une batterie de 2000 mAh alimente un Uno qui tourne en continu pendant environ 2000 / 45 ≈ 44 heures. Un ESP32 avec le Wi-Fi toujours actif (100 mA en moyenne) tient environ 20 heures. Mais si l'ESP32 se réveille toutes les 10 minutes pendant 3 secondes, envoie une mesure à 120 mA et dort à 10 µA pendant les 597 secondes restantes, le courant moyen vaut (3 × 120 + 597 × 0,01) / 600 ≈ 0,61 mA et la même batterie tient en théorie plus de 3000 heures, soit plus de quatre mois. Il faut pour cela une carte basse consommation ou un module nu ; le régulateur et la puce USB des DevKit classiques consomment quelques mA même en veille. Tu peux calculer ton propre scénario avec l'outil Autonomie batterie.

Et le Raspberry Pi Pico dans tout ça ?

La troisième option sérieuse est le Raspberry Pi Pico. Sa puce RP2040 possède deux cœurs Cortex-M0+ à 133 MHz, 264 Ko de RAM et 2 Mo de flash, pour environ 4 dollars. Comme l'ESP32, il fonctionne en 3,3 V et offre 26 GPIO, mais seulement 3 entrées analogiques. Ses gros atouts : une prise en charge de MicroPython très mûre, un chargement du firmware très simple puisqu'il apparaît sur l'ordinateur comme une clé USB, et les blocs PIO, qui génèrent des protocoles au timing précis sans charger le processeur. Si tu veux du sans-fil, prends le Pico W (Wi-Fi et Bluetooth) ; pour plus de puissance, le Pico 2 avec la puce RP2350. Plus de détails dans Qu'est-ce que le Raspberry Pi Pico ?. La même lecture de potentiomètre s'écrit ainsi sur le Pico en MicroPython (curseur sur GP26, bornes extrêmes sur 3V3 et GND) :

1from machine import ADC, Pin
2import time
3
4pot = ADC(26)                  # GP26 = ADC0, potansiyometre orta ucu / pot wiper
5led = Pin("LED", Pin.OUT)      # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
6
7while True:
8    raw = pot.read_u16()                   # 0–65535 (12 bit ölçüm ölçeklenir / 12-bit reading, scaled)
9    volts = raw * 3.3 / 65535
10    print("Ham / raw:", raw, " Gerilim / voltage: {:.2f}".format(volts))
11    led.value(raw > 32767)                 # yarıdan fazlaysa yanar / on above half
12    time.sleep(0.25)

Prix et facilité d'apprentissage

Le prix seul tranche rarement. Un Uno R3 original coûte environ 25–30 $, tandis que les clones à puce USB CH340 se trouvent à 5–10 $ ; les ESP32 DevKit clones coûtent 4–8 $ et le Pico 4 $. Entre un ESP32 et un clone d'Uno, l'écart de prix est donc quasi nul ; le vrai coût se cache dans les à-côtés : utiliser des modules 5 V avec l'ESP32 demande quelques résistances ou un convertisseur de niveau à 1–2 $, et ajouter le Wi-Fi à l'Uno demande un module séparé. Côté apprentissage, l'Uno garde l'avantage : tu choisis la carte et cliques sur Téléverser, les messages d'erreur et les exemples sont les mêmes depuis des années, et il n'y a aucun problème de niveaux avec les modules 5 V. Avec l'ESP32, tu dois d'abord installer le paquet de cartes d'Espressif et, si besoin, le pilote de la puce USB (CP2102 ou CH340), choisir le bon modèle de carte et, sur certaines cartes, maintenir le bouton BOOT pendant le téléversement ; de plus, une partie des exemples en ligne a été écrite pour d'anciennes versions du cœur et peut ne pas compiler (dans le cœur 3.x, par exemple, ledcAttach remplace ledcSetup). Ces obstacles se franchissent en quelques heures, mais si tu montes tes premiers circuits, il est plus facile sur l'Uno de savoir si un problème vient du code ou du câblage.

Quelle carte pour quel projet ?

Erreurs fréquentes et idées reçues

• « L'ESP32 est toujours meilleur » : il est plus puissant, mais ses broches 3,3 V, ses broches sensibles au démarrage, le bouton BOOT et les chutes de tension peuvent décourager un débutant. Pour apprendre les bases, l'Uno réserve moins de surprises.
• Brancher un capteur 5 V directement sur l'ESP32 : relier sans pont diviseur des signaux 5 V, comme la sortie ECHO du HC-SR04, peut endommager la broche.
• Lire une broche ADC2 avec le Wi-Fi actif : les GPIO 0, 2, 4, 12–15 et 25–27 ne lisent rien en analogique pendant que le Wi-Fi tourne ; déplace le capteur sur GPIO 32–39.
• Oublier la RAM de l'Uno : si le code compile mais que la carte se fige au hasard, la RAM est peut-être pleine ; mets les textes fixes dans F("...") et évite de concaténer des String dans une boucle.
• Alimenter l'ESP32 par un USB faible : si la carte redémarre au lancement du Wi-Fi, utilise un bon câble de données et un adaptateur d'au moins 1 A.
• Confondre Pico et Pico W : le Pico simple n'a pas de Wi-Fi ; pour un projet sans fil, achète le modèle avec un W dans son nom.

En résumé, l'Arduino Uno est la carte pour apprendre, l'ESP32 la carte pour se connecter et le Raspberry Pi Pico la carte pour expérimenter avec Python. Si tu te demandes quel modèle de la famille Arduino te convient, jette un œil à Quel Arduino acheter ?. Dans l'application BlueGrays, tu trouveras des dizaines de projets pour Arduino, ESP32 et Pico, de la LED qui clignote au serveur web Wi-Fi et de l'horloge NTP à l'écran météo, chacun avec son schéma et son code pas à pas.