Comparatif des cartes de développement
Arduino, Raspberry Pi, BBC micro:bit, ESP32, STM32, Teensy, Orange Pi, BeagleBone — quelle carte choisir selon son projet, son niveau et son budget ?
Arduino
Raspberry Pi
BBC micro:bit
ESP32 / ESP8266
STM32 / Teensy
Orange Pi · BeagleBone · Pico
Positionnement indicatif — axe X : puissance/complexité, axe Y : accessibilité débutant
Les grandes familles de cartes
Arduino
AVR · ARM · 8 à 32 bits · 3–25 €
La référence du prototypage depuis 2005. Microcontrôleur sans OS, exécution déterministe, immense écosystème de bibliothèques et de shields.
- Uno R3 — ATmega328P, 16 MHz, 2 Ko RAM, 32 Ko Flash
- Nano — même MCU en format compact
- Mega 2560 — 54 GPIO, 8 Ko RAM
- Nano 33 IoT — SAMD21, WiFi, BLE
- Due — SAM3X8E ARM Cortex-M3, 84 MHz, 96 Ko RAM
Raspberry Pi
ARM Cortex-A · Linux · 6–95 €
Mini-ordinateur sous Linux. Pas un microcontrôleur : il fait tourner un OS complet avec bureau, Python, Node.js, Docker, etc.
- Pi 5 — BCM2712, 4× Cortex-A76 2,4 GHz, 4–8 Go RAM
- Pi 4 Model B — Cortex-A72, 1–8 Go RAM
- Pi Zero 2 W — Cortex-A53 quad, WiFi, format timbre
- Pico W — RP2040 Cortex-M0+, MicroPython, BLE
- Pi 400 — Pi 4 intégré dans un clavier
BBC micro:bit
ARM Cortex-M4 · Éducatif · ~12 €
Conçue pour l’enseignement, la micro:bit v2 embarque capteurs, LED, radio et Bluetooth. Programmable par blocs, Python ou C/C++.
- nRF52833 Cortex-M4, 64 MHz, 128 Ko RAM
- Matrice 5×5 LED, 2 boutons, boussole, accéléromètre
- Radio 2,4 GHz propriétaire + BLE 5.0
- Micro MEMS + haut-parleur intégrés (v2)
- MakeCode (blocs), MicroPython, C++ (Mbed)
ESP32 / ESP8266
Xtensa · WiFi + BLE · 3–12 €
Le champion du rapport qualité/prix pour les projets connectés. WiFi et Bluetooth intégrés, très grande communauté, compatible Arduino IDE.
- ESP8266 — 80 MHz, 80 Ko RAM, WiFi uniquement
- ESP32 — dual core 240 MHz, 520 Ko RAM, WiFi+BLE
- ESP32-S3 — USB natif, accélérateur IA
- ESP32-C6 — RISC-V, WiFi 6, Thread, Zigbee
- Programmable en Arduino C++, MicroPython, Lua
STM32 · Teensy
ARM Cortex-M · Temps réel · 3–35 €
Microcontrôleurs 32 bits hautes performances pour applications temps réel exigeantes : audio, SDR, contrôle moteur, protocoles radio.
- STM32F103 (Blue Pill) — 72 MHz, 20 Ko RAM, ~3 €
- STM32H743 — Cortex-M7, 480 MHz, 1 Mo RAM
- Teensy 4.1 — Cortex-M7, 600 MHz, 1 Mo RAM, audio
- STM32CubeIDE, Arduino, PlatformIO, Mbed
- USB natif, DAC, ADC 12–16 bits, I²S audio
Orange Pi · BeagleBone
Linux embarqué · 20–60 €
Alternatives au Raspberry Pi, souvent avec des avantages spécifiques : GPIO plus puissants, EMMC intégrée, connectivité étendue ou prix inférieur.
- Orange Pi 5 — RK3588S, 8× Cortex-A, 4–32 Go RAM
- BeagleBone Black — AM335x, PRU temps réel, 512 Mo RAM
- Rock Pi 4 — RK3399, NPU IA, M.2 NVMe
- Banana Pi M5 — Amlogic S905X3, 4 Go RAM
- Toutes sous Linux (Debian, Ubuntu, Armbian)
Tableau comparatif technique complet
| Critère | Arduino Uno R3 | Arduino Nano 33 | Raspberry Pi 4 | micro:bit v2 | ESP32 | STM32F103 | Teensy 4.1 | Orange Pi 5 |
|---|---|---|---|---|---|---|---|---|
| Processeur | ATmega328P 8 bits | SAMD21 Cortex-M0+ | BCM2711 Cortex-A72 | nRF52833 Cortex-M4 | Xtensa LX6 dual | Cortex-M3 | IMXRT1062 Cortex-M7 | RK3588S Cortex-A |
| Fréquence | 16 MHz | 48 MHz | 4× 1,8 GHz | 64 MHz | 2× 240 MHz | 72 MHz | 600 MHz | 8× 2,4 GHz |
| RAM | 2 Ko SRAM | 32 Ko | 1–8 Go LPDDR4 | 128 Ko | 520 Ko | 20 Ko | 1 Mo + 16 Mo PSRAM | 4–32 Go |
| Stockage | 32 Ko Flash | 256 Ko Flash | MicroSD / USB SSD | 512 Ko Flash | 4 Mo Flash SPI | 64–128 Ko Flash | 8 Mo Flash + SD | eMMC + MicroSD + NVMe |
| Système d’exploitation | Aucun | Aucun (RTOS possible) | Linux complet | Aucun | FreeRTOS, ESP-IDF | FreeRTOS, Mbed | FreeRTOS, ThreadX | Linux (Armbian, Ubuntu) |
| WiFi intégré | Non | Oui (Nina W102) | Oui (dual band) | Non | Oui (b/g/n) | Non | Non | Oui (WiFi 6) |
| Bluetooth | Non | BLE 4.2 | BLE 5.0 | BLE 5.0 | BLE 4.2 | Non | Non | BLE 5.0 |
| GPIO (nombre) | 14 num. + 6 analog. | 14 num. + 8 analog. | 40 (3,3 V, 16 mA) | 25 (via edge) | 38 (3,3 V, 40 mA) | 37 (5 V tolerant) | 55 + 5 V tolerant | 40 (3,3 V) |
| ADC résolution | 10 bits | 12 bits | Aucun natif | 10 bits | 12 bits (18 canaux) | 12 bits | 12 bits + 2 DAC | Aucun natif |
| I²C / SPI / UART | 1/1/1 | 2/1/2 | 2/6/5 | 1/1/1 | 2/4/3 | 2/2/3 | 3/4/8 | Via GPIO |
| USB | USB-B (programmation) | Micro USB | USB-C power + 4× USB-A | Micro USB | Micro/USB-C | USB (via PA11/12) | USB native host/device | USB-C + USB 3.0 |
| Alimentation | 5 V USB / 7–12 V Vin | 5 V USB | 5 V USB-C 3 A | 5 V USB / 3 V pile | 3,3–5 V | 3,3–5 V | 5 V USB | 5 V USB-C 4 A |
| Consommation repos | ~50 mA | ~10 mA | ~3 W (600 mA) | ~30 mA / 0,5 µA sommeil | ~10 mA / 10 µA deep sleep | ~20 mA | ~100 mA | ~5–10 W |
| Sortie vidéo | Non | Non | 2× HDMI 4K | Non | Non | Non | Non | HDMI 8K |
| IDE / Langage | Arduino C++ | Arduino C++ | Python, Node, C, Java… | MakeCode, MicroPython | Arduino C++, MicroPython | STM32CubeIDE, Arduino | Arduino C++, PlatformIO | Tout (Linux) |
| Facilité débutant | Excellente | Bonne | Bonne (Linux requis) | Excellente | Bonne | Difficile | Difficile | Moyenne |
| Prix indicatif | ~25 € (officiel) | ~20 € | ~55–95 € | ~12 € | ~5–12 € | ~3–5 € | ~30–35 € | ~55–120 € |
Scores par domaine d’utilisation
Accessibilité débutant
Puissance calcul
Autonomie / Faible consommation
Connectivité sans-fil native
Temps réel / Déterminisme
Rapport qualité / Prix
Comparatif pour applications radioamateur
Chaque famille de cartes se prête à des usages différents dans notre activité. Voici une synthèse pratique.
| Carte | Points forts radio | Projets typiques | Limites | Intérêt |
|---|---|---|---|---|
| Arduino Uno/Nano | Temps réel, ADC, PWM, I²C fiable, shields disponibles (LCD, GPS, relais) | Keyer CW, CAT control simple, decoder CTCSS, rotateur antenne, SWR-mètre | Pas de WiFi natif, RAM limitée (2 Ko), pas de floating point matériel | ★★★★ |
| Raspberry Pi 4/5 | Linux complet : WSPR, FT8 (WSJT-X), SDR (RTL-SDR), Node-RED, InfluxDB, Docker | Station SDR, serveur cluster DX, gateway APRS, SSTV, DMR dashboard, Allstar | Pas de temps réel, consommation élevée, pas d’ADC natif | ★★★★★ |
| BBC micro:bit | Capteurs intégrés, radio 2,4 GHz, BLE, éducatif, balise CW simple | Apprentissage Morse, chasse au renard, keyer éducatif, météo SOTA/POTA | RAM limitée, pas de WiFi, 2,4 GHz propriétaire (pas amateur) | ★★★ |
| ESP32 | WiFi + BLE, ADC 12 bits, faible coût, excellent pour IoT radio et télécommande | Télécommande PTZ antenne, gateway APRS/MQTT, S-mètre WiFi, relais EchoLink simplifié | ADC bruité en pratique, WiFi peut perturber les réceptions HF proches | ★★★★ |
| STM32 | DAC/ADC haute résolution, DSP FPU, USB audio, génération de signaux précis | SDR (récepteur direct conversion), modulateur/démodulateur PSK, keyer avancé, rotateur précis | Courbe d’apprentissage élevée, documentation technique dense | ★★★★ |
| Teensy 4.1 | Audio library, I²S, USB audio, 600 MHz — idéal DSP audio et modes numériques | Processeur audio FT8/PSK31/WSPR standalone, égaliseur, CODEC, SDR logiciel | Coût plus élevé, pas de WiFi natif | ★★★★★ |
| Orange Pi 5 | Puissance ARM A76, NPU IA, compatible Pi (GPIO), prix < Pi 5 à puissance égale | Station SDR haute performance, décodage multi-modes simultanés, serveur JT65/FT8 | Support communautaire moins mature que Pi, drivers parfois en retard | ★★★★ |
| Pico W (RP2040) | Très bas coût, WiFi, 2 cœurs, PIO (machine d’état programmable) pour protocoles série | Interface CAT Icom/Yaesu via WiFi, balise WSPR (Si5351 I²C), APRS tracker | Pas d’ADC haute résolution, support bibliothèques moins riche qu’Arduino | ★★★★ |
Combinaisons gagnantes pour radioamateurs
Station complète légère : Raspberry Pi Zero 2W + RTL-SDR + WSJT-X → réception FT8/WSPR portable, alimentation batterie possible.
Keyer/CAT avancé : Teensy 4.1 + codec audio WM8960 → DSP temps réel, side-tone qualité, interface CAT USB transparente.
IoT et domotique radio : ESP32 + broker MQTT → relais EchoLink, S-mètre web, rotateur commandé par smartphone.
Apprentissage : micro:bit → Morse, chasse au renard, mesures terrain SOTA/POTA sans aucune expérience préalable.
Même programme, 5 langages — clignoter une LED
Illustration concrète des différences syntaxiques entre les environnements.
Arduino (C++)
// Arduino Uno — LED sur broche 13 (LED intégrée)
void setup() {
pinMode(13, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);
delay(500);
digitalWrite(13, LOW);
delay(500);
}
Raspberry Pi (Python 3 + gpiozero)
# Raspberry Pi — GPIO 17 (broche 11)
from gpiozero import LED
from time import sleep
led = LED(17)
while True:
led.on()
sleep(0.5)
led.off()
sleep(0.5)
BBC micro:bit (MicroPython)
# micro:bit — LED sur P0 (ou matrice interne)
from microbit import *
while True:
pin0.write_digital(1)
sleep(500)
pin0.write_digital(0)
sleep(500)
ESP32 (Arduino C++)
// ESP32 — LED sur GPIO 2 (LED intégrée)
#define LED_PIN 2
void setup() { pinMode(LED_PIN, OUTPUT); }
void loop() {
digitalWrite(LED_PIN, HIGH); delay(500);
digitalWrite(LED_PIN, LOW); delay(500);
}
STM32 (HAL C)
/* STM32F103 — LED sur PC13 (Blue Pill) */
#include « stm32f1xx_hal.h »
int main(void) {
HAL_Init();
__HAL_RCC_GPIOC_CLK_ENABLE();
GPIO_InitTypeDef gpio = {GPIO_PIN_13, GPIO_MODE_OUTPUT_PP,
GPIO_NOPULL, GPIO_SPEED_FREQ_LOW};
HAL_GPIO_Init(GPIOC, &gpio);
while(1) {
HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
HAL_Delay(500);
}
}
Guide de choix rapide
Choisir micro:bit si…
- Débutant complet ou enfant
- Enseignement, atelier club
- Projet éducatif radioamateur
- Budget < 15 €
- Capteurs intégrés suffisants
Choisir Arduino si…
- Prototypage électronique
- Keyer, CAT, commande relais
- Temps réel important
- Large choix de shields
- Débutant en C/C++
Choisir Raspberry Pi si…
- Station SDR (WSJT-X, SDR++)
- Serveur APRS / cluster DX
- FT8 / WSPR automatique
- Docker, Node-RED, InfluxDB
- Interface web ou bureau requis
Choisir ESP32 si…
- Objet connecté WiFi/BLE
- Budget minimal (5 €)
- Gateway MQTT/APRS
- Télécommande par smartphone
- Déploiement en réseau
Choisir STM32 si…
- DSP, traitement audio précis
- ADC/DAC haute résolution
- Décodeur/modulateur PSK31
- Temps réel strict (ISR)
- Production / industriel
Choisir Teensy si…
- Audio HiFi : codec, I²S, USB
- SDR logiciel standalone
- FT8 / WSPR sans Pi
- Performance pure en C++
- USB audio / MIDI natif
