Différence entre Raspberry Pi et Arduino : lequel choisir ?

La différence entre Raspberry Pi et Arduino tient en une phrase : le Raspberry Pi est un ordinateur de la taille d'une carte bancaire qui fait tourner un système Linux, tandis que l'Arduino est une carte à microcontrôleur qui exécute en boucle le seul programme que tu lui téléverses. Sur un Pi, tu peux brancher clavier, souris et écran, naviguer sur internet, traiter les images d'une caméra en Python ou héberger un petit serveur chez toi. L'Arduino, lui, démarre dès qu'il est alimenté, lit des capteurs à la microseconde près, pilote moteurs et LED sans le moindre à-coup et tient plusieurs jours sur piles.

En bref, le Raspberry Pi est le meilleur choix pour les projets qui demandent une caméra, du traitement d'image, une interface graphique ou des services réseau, tandis que l'Arduino l'emporte dès qu'il faut des capteurs, des moteurs, une temporisation précise et une faible consommation. Dans ce guide, nous comparons les deux plateformes avec de vrais chiffres : temps de démarrage, consommation, GPIO et entrées analogiques, langage de programmation, temps réel et prix. Ensuite, nous te montrons dans un tableau laquelle choisir pour chaque projet, nous te donnons un exemple de code qui fait travailler les deux ensemble via un câble USB et nous expliquons la place du Raspberry Pi Pico qui, malgré son nom, ressemble bien plus à un Arduino.

Qu'est-ce qu'un Raspberry Pi, qu'est-ce qu'un Arduino ?

Le Raspberry Pi est un ordinateur monocarte (SBC) conçu par la Raspberry Pi Foundation au Royaume-Uni. Le Raspberry Pi 5 embarque un processeur Arm Cortex-A76 quadricœur à 2,4 GHz, de 1 à 16 Go de RAM, deux sorties HDMI 4K, de l'USB 3.0, l'Ethernet Gigabit, le Wi-Fi et le Bluetooth. Au lieu d'un disque dur, il utilise une carte microSD (ou un SSD NVMe via une carte d'extension) sur laquelle on installe Raspberry Pi OS, basé sur Debian. Tu as donc devant toi le petit frère, compact et bon marché, de ton ordinateur de bureau ; la seule différence est le connecteur GPIO de 40 broches sur son bord, qui permet de brancher directement LED, boutons et capteurs.

L'Arduino, lui, est une plateforme de microcontrôleurs open source née en Italie. Sa carte la plus répandue, l'Arduino Uno R3, repose sur un ATmega328P 8 bits cadencé à 16 MHz : le processeur, 2 Ko de RAM, 32 Ko de mémoire programme et le convertisseur analogique-numérique sont réunis dans une seule petite puce. Il n'y a ni système d'exploitation, ni système de fichiers, ni sortie vidéo. Le code que tu écris dans l'Arduino IDE sur ton ordinateur est compilé puis stocké dans la mémoire flash de la carte ; à chaque mise sous tension, setup() s'exécute une fois, puis loop() tourne indéfiniment. Pour mieux connaître la plateforme, lis Qu'est-ce qu'Arduino ?.

Réponse rapide : laquelle pour quelle situation ?

Tableau comparatif : Raspberry Pi 5, Arduino Uno et Raspberry Pi Pico

Petite remarque sur les prix : comme le coût des puces mémoire LPDDR4 utilisées dans les Raspberry Pi 4 et 5 a flambé sous l'effet de la demande des centres de données d'IA, Raspberry Pi a augmenté ses tarifs plusieurs fois depuis décembre 2025 ; en octobre 2026, le Pi 5 de 2 Go est affiché à 77,50 $. Le Pi Zero 2 W, qui utilise une mémoire plus ancienne, est resté à 15 $. En plus, un Pi a besoin d'une carte microSD, d'une alimentation USB-C de 27 W et idéalement d'un dissipateur, ce qui ajoute encore 20 à 30 $ au total. Un Arduino Uno ou un Pico se contentent d'un câble USB.

La différence fondamentale entre un ordinateur Linux et un microcontrôleur

Sur un Raspberry Pi, le programme Python que tu écris n'est qu'un des centaines de processus que Linux gère en même temps. Le noyau (kernel) attribue tour à tour le processeur à la connexion réseau, à l'affichage, aux périphériques USB, aux services en arrière-plan et à ton programme. C'est une organisation très puissante : tu peux enregistrer des journaux dans des fichiers, faire tourner en même temps un serveur web et un flux vidéo, et modifier ton code en SSH depuis une autre pièce. Sur un Arduino, en revanche, la seule chose qui tourne sur le processeur, c'est ton code. Sans système d'exploitation entre les deux, l'instruction digitalWrite change l'état de la broche en quelques microsecondes, et toujours dans le même délai. Concrètement, cette différence a les conséquences suivantes :

• Multitâche : le Pi fait tourner en même temps un navigateur, un script Python et une base de données ; l'Arduino fonctionne avec une seule loop(), et c'est toi qui organises plusieurs tâches avec millis().
• Stockage : sur un Pi, tu peux conserver des gigaoctets de photos, de journaux et de bases de données ; sur un Uno, ton programme doit tenir dans 32 Ko et tes variables dans 2 Ko de RAM.
• Réseau : le Pi se connecte à internet en Wi-Fi et en Ethernet dès la sortie de la boîte ; l'Uno n'a aucune connexion réseau, il te faut un ESP32 ou un module supplémentaire.
• Maintenance : comme le Pi est un ordinateur, il demande des mises à jour, un mot de passe utilisateur et un minimum de sécurité ; tu téléverses ton code une fois sur l'Arduino et il fonctionne de la même façon pendant des années.
• En cas de problème : si un programme plante sur le Pi, le système reste debout et tu peux lire le message d'erreur ; si le code se bloque sur l'Arduino, la carte s'arrête sans rien dire, mais un chien de garde (watchdog) peut la redémarrer automatiquement.

Temps de démarrage et coupures de courant

Dès que tu alimentes un Arduino, ton programme démarre en moins d'une seconde ; même après un appui sur le bouton reset, le bootloader n'attend qu'un instant. Le Raspberry Pi charge d'abord son bootloader, puis le noyau Linux et les services ; selon le modèle et la vitesse de la carte SD, il lui faut 15 à 40 secondes pour afficher le bureau. Cela compte pour les appareils qui doivent fonctionner tout de suite après une coupure de courant, comme une sonnette, une alarme ou un arrosage automatique. L'extinction est encore plus délicate : Linux écrit en permanence sur la carte SD, et si le courant est coupé au milieu d'une écriture, le système de fichiers peut être corrompu au point que le Pi ne redémarre plus. Comme le programme de l'Arduino reste figé dans la mémoire flash, tu peux le débrancher quand tu veux.

Consommation et fonctionnement sur batterie

Côté consommation, l'écart va de 10 à 30 fois. Un Raspberry Pi 5 consomme environ 3 W au repos et 7 à 8 W processeur à fond, et davantage encore avec un disque USB et une caméra. Un Arduino Uno tire environ 50 mA, soit 0,25 W sous 5 V, et un Pico autour de 0,1 W. Le tableau ci-dessous donne les autonomies approximatives avec une batterie externe de 10 000 mAh. Le calcul est le suivant : les 10 000 mAh de l'étiquette concernent des cellules de 3,7 V, soit environ 37 Wh ; après les pertes de conversion vers 5 V, il reste environ 30 Wh utilisables. Il suffit de diviser cette valeur par la consommation de la carte en watts. Pour ton propre circuit, utilise le calculateur d'autonomie de batterie.

Broches GPIO et entrées analogiques

Le connecteur 40 broches du Raspberry Pi compte 28 GPIO ; GPIO 0 et 1 sont réservées à l'EEPROM d'identification des cartes HAT et ne servent généralement pas. Ces broches fonctionnent en 3,3 V, ne tolèrent pas le 5 V et ne fournissent que quelques milliampères par broche (environ 16 mA au maximum) ; tu peux allumer une LED avec une résistance en série, mais pas piloter directement la bobine d'un relais ou un moteur. Le plus gros manque, c'est l'absence d'entrées analogiques : il n'existe pas d'équivalent à analogRead sur le Pi, donc pour lire un capteur analogique comme un potentiomètre, une photorésistance (LDR) ou un capteur d'humidité du sol, il faut une puce ADC externe. L'Arduino Uno possède 6 entrées analogiques et presque tous les capteurs 5 V s'y branchent directement.

Il y a deux façons de brancher un capteur analogique sur un Pi. La première consiste à utiliser un module ADC comme le MCP3008 8 canaux 10 bits en SPI ou l'ADS1115 4 canaux 16 bits en I2C ; la bibliothèque gpiozero prend en charge le MCP3008 nativement. La seconde consiste à brancher les capteurs sur un Arduino ou un Pico et à envoyer les mesures au Pi par USB ; tu trouveras le code plus bas. Le fonctionnement de la lecture analogique est expliqué dans Qu'est-ce qu'un ADC ?, et les brochages des cartes dans l'outil Pinout.

Langage de programmation et environnement de développement

L'Arduino se programme dans le langage Arduino, basé sur le C/C++ : tu écris le code dans l'Arduino IDE sur ton ordinateur, il est compilé puis téléversé sur la carte par USB. Sur le Raspberry Pi, le code s'écrit et s'exécute directement sur le Pi, sans étape de téléversement. Le langage le plus utilisé est Python, et Raspberry Pi OS est livré avec l'éditeur Thonny et la bibliothèque gpiozero. Tu peux aussi utiliser n'importe quel langage qui tourne sous Linux, comme le C, le C++, Node.js, Go ou Java. Voici à quoi ressemble en Python sur le Pi un programme « la LED s'allume tant que le bouton est appuyé » :

1from gpiozero import LED, Button
2from signal import pause
3
4led = LED(17)       # GPIO17 = fiziksel pin 11 / GPIO17 = physical pin 11
5buton = Button(27)  # GPIO27 = fiziksel pin 13, dahili pull-up açık / physical pin 13, internal pull-up on
6
7buton.when_pressed = led.on    # Basınca LED yanar / LED on when pressed
8buton.when_released = led.off  # Bırakınca söner / LED off when released
9
10pause()  # Programı açık tut, olayları bekle / keep running and wait for events

Branche le bouton entre GPIO27 et GND, et la LED sur GPIO17 avec une résistance de 220 Ω ; la classe Button active d'elle-même la résistance de pull-up interne. Enregistre le fichier sous le nom buton_led.py et lance-le en tapant python3 buton_led.py dans le terminal. Attention : sur le Raspberry Pi 5, les GPIO passent par la nouvelle puce RP1, si bien que l'ancienne bibliothèque RPi.GPIO ne fonctionne plus et échoue avec « RuntimeError: Cannot determine SOC peripheral base address » ; utilise gpiozero pour tes nouveaux projets. Si, sur un Raspberry Pi OS récent, pip install renvoie l'erreur « externally-managed-environment », installe le paquet avec sudo apt install python3-... ou crée un environnement virtuel (venv). Sur le Raspberry Pi Pico, tu réutilises les mêmes connaissances Python avec MicroPython.

Temps réel : pourquoi l'Arduino pour les moteurs et les capteurs ?

Comme Linux partage le processeur entre les programmes, ton code Python peut être mis en pause quelques millisecondes de temps en temps, sans que tu puisses prévoir quand. Pour une page web, c'est sans importance, mais pour du matériel qui dépend de la temporisation, c'est un vrai problème. Quelques exemples concrets :

• Capteur de distance HC-SR04 : le son met environ 58 µs pour faire l'aller-retour par centimètre de distance. Si un retard de 100 µs se glisse pendant la mesure de l'écho, le résultat est faux de 1,7 cm ; sur le Pi, ce genre d'écart est fréquent.
• Servomoteur : un servo se positionne grâce à une impulsion de 1 à 2 ms dans un signal à 50 Hz, et 1 degré correspond à environ 5,5 µs. Un servo piloté en PWM logicielle par le Pi tremble ; avec l'Arduino, il reste immobile.
• Ruban LED WS2812B : chaque bit dure 1,25 µs et la temporisation exige une précision de 0,15 µs ; le Pi n'y arrive qu'avec le matériel SPI ou PWM et le DMA, alors que l'Arduino et le Pico le pilotent directement.
• Moteurs pas à pas et encodeurs : des milliers d'impulsions par seconde ou les signaux rapides d'un encodeur sont captés sans en manquer un seul sur l'Arduino grâce aux interruptions.

Quelle carte pour quel projet ?

La caméra et le traitement d'image sont le grand point fort du Raspberry Pi. La Camera Module 3 de 12 Mpx à mise au point automatique se branche sur le connecteur caméra avec une nappe ; tu peux prendre une photo avec rpicam-still -o photo.jpg et, avec les bibliothèques Picamera2 et OpenCV, faire en Python de la détection de mouvement, du suivi de couleur, de la lecture de QR codes ou de la reconnaissance faciale. Pour des modèles d'IA plus lourds, il existe des cartes accélératrices comme l'AI HAT+ ou l'AI Camera, qui traite l'image directement dans la caméra. Les connecteurs caméra du Raspberry Pi 5 sont plus petits (22 broches) que sur les anciens modèles, il faut donc un câble adaptateur pour les anciennes caméras. Les 2 Ko de RAM de l'Arduino Uno, eux, ne suffisent même pas pour une petite photo ; si tu veux seulement prendre des photos et les envoyer sur Telegram, l'ESP32-CAM bon marché est un bon compromis.

Pour les capteurs et les moteurs, en revanche, l'Arduino n'a pratiquement pas de concurrent. Comme il fonctionne en 5 V, la plupart des modules du marché, comme le HC-SR04, les modules relais, le driver de moteurs L298N ou les écrans LCD à caractères, se branchent sans circuit supplémentaire, et les shields moteurs, relais et capteurs s'enfichent directement sur la carte. Dans une voiture robot, l'Arduino lit le capteur de distance des dizaines de fois par seconde et arrête les moteurs dès qu'il voit un obstacle ; ce temps de réaction ne dépend jamais de la charge d'un système d'exploitation. Pour la même raison, les servomoteurs et les moteurs pas à pas tournent parfaitement sur Arduino.

Utiliser les deux ensemble : Raspberry Pi + Arduino

Dans la plupart des projets avancés, la meilleure solution consiste à combiner les deux. Pense au corps humain : le Raspberry Pi est le cerveau ; il traite la caméra, se connecte à internet, enregistre les données et prend les décisions. L'Arduino est la moelle épinière et les muscles ; il lit les capteurs, pilote les moteurs et, en cas d'urgence, réagit par réflexe sans demander l'avis du Pi. Dans une voiture robot avec caméra, par exemple, le Pi repère la ligne dans l'image et envoie la commande « tourne à gauche » ; l'Arduino la traduit en vitesses de moteur et s'arrête de lui-même si un obstacle apparaît. Les façons courantes de relier les deux cartes sont :

1. Téléverse sur la carte le code Arduino ci-dessous depuis ton ordinateur (tu peux aussi le faire depuis le Pi avec arduino-cli).
2. Relie l'Arduino au Pi avec un câble USB et trouve le nom du port en tapant ls /dev/ttyACM* /dev/ttyUSB* dans le terminal. Un Uno d'origine apparaît généralement comme /dev/ttyACM0, les clones à puce CH340 comme /dev/ttyUSB0.
3. Si la bibliothèque pyserial n'est pas installée, installe-la avec sudo apt install python3-serial.
4. Si ton utilisateur n'a pas accès au port série, tape sudo usermod -a -G dialout $USER, puis déconnecte-toi et reconnecte-toi.
5. Enregistre le code Python sous le nom pi_arduino.py et lance-le avec python3 pi_arduino.py ; si le moniteur série de l'Arduino IDE est ouvert, ferme-le d'abord.

1// Arduino Uno: A0 değerini Pi'ye gönderir, Pi'den gelen komutla LED'i yönetir
2// Arduino Uno: sends the A0 reading to the Pi and drives the LED on the Pi's command
3const int SENSOR_PIN = A0;      // LDR ya da potansiyometre / LDR or potentiometer
4const int LED_PIN = 13;         // Dahili LED / built-in LED
5unsigned long sonGonderim = 0;  // Son gönderim zamanı / time of the last send
6
7void setup() {
8  Serial.begin(115200);         // Pi tarafıyla aynı hız / same baud rate as the Pi
9  pinMode(LED_PIN, OUTPUT);
10}
11
12void loop() {
13  // Pi'den komut geldi mi? / has a command arrived from the Pi?
14  if (Serial.available()) {
15    String komut = Serial.readStringUntil('\n');  // Satır sonuna kadar oku / read up to the newline
16    komut.trim();                                  // Boşluk ve \r karakterlerini sil / strip spaces and \r
17    if (komut == "LED1") digitalWrite(LED_PIN, HIGH);
18    else if (komut == "LED0") digitalWrite(LED_PIN, LOW);
19  }
20
21  // 500 ms'de bir ölçüm gönder, loop'u bekletmeden / send a reading every 500 ms without blocking
22  if (millis() - sonGonderim >= 500) {
23    sonGonderim = millis();
24    int deger = analogRead(SENSOR_PIN);  // 0-1023
25    Serial.print("A0:");
26    Serial.println(deger);               // Örnek: A0:512 / example: A0:512
27  }
28}

1import time
2import serial  # sudo apt install python3-serial
3
4# Orijinal Uno: /dev/ttyACM0, CH340'lı klon: /dev/ttyUSB0 / genuine Uno: /dev/ttyACM0, CH340 clone: /dev/ttyUSB0
5ser = serial.Serial("/dev/ttyACM0", 115200, timeout=1)
6time.sleep(2)             # Port açılınca Arduino yeniden başlar / opening the port resets the Arduino
7ser.reset_input_buffer()  # Eski verileri temizle / drop stale data
8
9ESIK = 300                # Karanlık eşiği, sensörüne göre ayarla / darkness threshold, tune it for your sensor
10led_durum = None
11
12while True:
13    satir = ser.readline().decode("utf-8", errors="ignore").strip()
14    if not satir.startswith("A0:") or not satir[3:].isdigit():
15        continue          # Boş ya da yarım satırı atla / skip empty or partial lines
16    deger = int(satir[3:])
17    print("Sensor:", deger)
18
19    yeni = "LED1" if deger < ESIK else "LED0"  # Karanlıkta LED'i yak / LED on in the dark
20    if yeni != led_durum:                      # Yalnız değişince gönder / send only on change
21        ser.write((yeni + "\n").encode())
22        led_durum = yeni

Toutes les 500 ms, l'Arduino envoie une ligne du type « A0:512 » et écoute les commandes « LED1 » ou « LED0 » terminées par un retour à la ligne ; comme il utilise millis(), l'attente des commandes ne retarde jamais les mesures. Côté Python, la ligne time.sleep(2) est importante : quand le Pi ouvre le port série, l'Arduino redémarre automatiquement et tout ce qui est envoyé pendant les deux premières secondes est perdu. Adapte le seuil de 300 à ton capteur ; selon le sens de branchement de la LDR, la valeur peut monter ou descendre dans l'obscurité. Pour aller plus loin sur la communication série, consulte Communication série entre Arduino et Python et Qu'est-ce que l'UART ?.

La place du Raspberry Pi Pico : Raspberry Pi par le nom, microcontrôleur par nature

C'est la source de confusion la plus fréquente. Bien qu'il soit fabriqué par Raspberry Pi, le Raspberry Pi Pico n'est pas un ordinateur mais une carte à microcontrôleur comme l'Arduino : pas de système d'exploitation, démarrage instantané, environ 0,1 W de consommation et fonctionnement en temps réel. Il est construit autour de la puce double cœur RP2040 conçue par Raspberry Pi elle-même (le Pico 2 utilise le RP2350 à 150 MHz). Par rapport à l'Arduino Uno, il a beaucoup plus de RAM (264 Ko), un ADC 12 bits et des blocs PIO pour les tâches de temporisation, et il se programme en MicroPython, en C/C++ ou avec l'Arduino IDE. À 4 $, il coûte moins cher qu'un Arduino Uno, mais comme il fonctionne en 3,3 V, il faut faire attention aux modules 5 V. Pour en savoir plus, lis Qu'est-ce que le Raspberry Pi Pico ?.

Le plus gros avantage du Pico dans cette comparaison, c'est qu'il fonctionne au même niveau de 3,3 V que le Raspberry Pi : tu peux relier ses broches UART directement au Pi sans convertisseur de niveau, ou le brancher en USB et l'utiliser exactement comme un Arduino. Le code MicroPython ci-dessous envoie des données au même format « A0:valeur » que le code Arduino précédent et écoute les mêmes commandes de LED, si bien que le script Python du Pi fonctionne sans la moindre modification. Enregistre le code sur le Pico sous le nom main.py avec Thonny, puis ferme Thonny pour libérer le port série pour le script du Pi.

1import sys, select, time
2from machine import ADC, Pin
3
4sensor = ADC(26)        # GP26 = ADC0 (fiziksel pin 31) / GP26 = ADC0 (physical pin 31)
5led = Pin(25, Pin.OUT)  # Pico dahili LED; Pico W'de Pin("LED") / onboard LED; use Pin("LED") on Pico W
6poll = select.poll()
7poll.register(sys.stdin, select.POLLIN)  # USB'den gelen veriyi dinle / listen for data over USB
8son = time.ticks_ms()
9
10while True:
11    # Pi'den komut var mı? / is there a command from the Pi?
12    if poll.poll(0):
13        komut = sys.stdin.readline().strip()
14        if komut == "LED1":
15            led.on()
16        elif komut == "LED0":
17            led.off()
18
19    # 500 ms'de bir, Arduino ile aynı biçimde gönder / every 500 ms, same format as the Arduino
20    if time.ticks_diff(time.ticks_ms(), son) >= 500:
21        son = time.ticks_ms()
22        deger = sensor.read_u16() >> 6  # 0-65535 -> 0-1023
23        print("A0:" + str(deger))

Les frontières sont d'ailleurs de plus en plus floues. En 2025, Arduino a présenté l'Arduino UNO Q, qui réunit les deux mondes sur une seule carte : cette carte au format Uno associe un processeur Qualcomm quadricœur sous Debian Linux à un microcontrôleur STM32U585 qui exécute les sketches Arduino en temps réel. Autrement dit, l'architecture « Pi + Arduino » tient désormais sur une seule carte. La logique reste pourtant la même : la partie Linux gère le réseau, l'image et l'application, la partie microcontrôleur gère les broches et la temporisation. Quiconque a compris les différences présentées ici tirera bien meilleur parti de ces cartes hybrides.

Erreurs fréquentes et idées reçues

• « Le Raspberry Pi Pico est un petit Raspberry Pi » : faux ; il ne fait pas tourner Linux et n'a pas de sortie HDMI. Le Pico est un microcontrôleur, de la même famille que l'Arduino.
• Brancher un signal 5 V sur le Pi : si la broche ECHO du HC-SR04 ou la ligne TX de l'Arduino arrive directement sur un GPIO, la broche, voire le processeur, peut être détruite définitivement ; utilise un pont diviseur.
• Chercher analogRead sur le Pi : le Raspberry Pi n'a pas d'entrées analogiques ; utilise un MCP3008, un ADS1115 ou un Arduino ou un Pico en renfort.
• Éteindre en débranchant : c'est le moyen le plus rapide de corrompre une carte SD ; utilise sudo poweroff à chaque fois.
• Alimenter un Pi 5 avec un chargeur de téléphone : avec une alimentation incapable de fournir 5 V 5 A, le Pi 5 limite le courant total des ports USB à 600 mA et peut redémarrer en charge.
• L'erreur « Permission denied: '/dev/ttyACM0' » : ton utilisateur n'appartient pas au groupe dialout ; lance la commande usermod et reconnecte-toi. Avec « Device or resource busy », un autre programme (le moniteur série ou Thonny) occupe le port.
• Penser que « l'Arduino est dépassé, il y a le Pi maintenant » : ce ne sont pas des rivaux mais des outils pour des tâches différentes ; la plupart des appareils, du lave-linge à la voiture, fonctionnent encore aujourd'hui avec des microcontrôleurs.

En résumé, le Raspberry Pi est un ordinateur qui réfléchit et qui voit, et l'Arduino un contrôleur qui transforme instantanément ce qu'il perçoit en action ; un bon projet combine souvent les forces des deux. Dans l'application BlueGrays, tu trouveras des dizaines de projets avec Arduino, ESP32 et Raspberry Pi Pico, des LED et capteurs jusqu'aux robots et aux montages Wi-Fi, chacun avec son schéma de câblage pas à pas et son code prêt à l'emploi, et tu peux commencer par les projets gratuits.