Fabriquer un enregistreur audio (avec un Raspberry)

Avec ce dossier, on va fabriquer un enregistreur audio basé sur Raspberry Pi, en Python 3, avec une carte son USB (un Raspberry Pi n’a pas d’entrée micro).

Dans le même style, je vous ai déjà proposé différents dossiers plus simples pour réaliser des boîtes à sons avec un “DF Player”, avec un “Arduino” + “DF Player”, et avec un Raspberry Pi.

Comme toujours, si vous avez la moindre question, n’hésitez pas à me contacter !

Présentation

Le Raspberry Pi est un micro-ordinateur bon marché et très pratique pour l’audio. Mais il y a un point à comprendre dès le départ : le Raspberry Pi n’a pas d’entrée audio analogique. Il sait sortir du son, mais pas enregistrer un micro “en jack” tout seul. Donc, pour enregistrer, il vous faut soit :

• un micro USB (le plus simple),
• ou une carte son USB avec entrée micro/line (souvent plus robuste et plus qualitative).

L’avantage d’une carte son USB, c’est que ça se branche, ça se remplace facilement, et ça vous laisse la liberté de choisir le micro. N’importe quelle interface audio USB peut convenir, du petit dongle à 10€ jusqu’à une vraie interface studio.

Cependant, les mini “cartes son USB” très basiques (les dongles à 2€ à 10€) fonctionnent, mais sont parfois bruitées, avec un gain micro médiocre. Si votre projet doit être propre, prévoyez une interface correcte ou un micro USB de qualité.

Côté logiciel, on va s’appuyer sur ALSA (le système audio Linux) et un script Python qui enregistre en WAV, avec un nom de fichier automatique (date/heure). On verra aussi comment lancer le script au démarrage, et comment déclencher l’enregistrement avec un bouton sur le GPIO.

Votre projet

Une idée d'installation : mon Sonomaton

D’ailleurs, fabriquer un enregistreur audio avec un Raspberry Pi est la base technique de mon installation sonore "Sonomaton" : Comme un traditionnel photomaton, le "Sonomaton" offre un espace d'expression libre, mais sonore. Car, au lieu de capturer les trombines, il enregistre les voix. Il fait partie de mes nombreuses installations sonores.

Concrètement, il s’agit d’un combiné téléphonique dont le haut-parleur et le micro sont reliés à une carte son, elle-même reliée en USB à un Raspberry Pi. Le choix du combiné téléphonique est pratique dans mon cas : il oblige les gens à écouter les consignes et impose une distance constante vis-à-vis du microphone. C’est plus difficile à garantir avec un micro + casque “libres”.

Les gens décrochent et entendent un fichier d’intro leur proposant de réagir à l’un des trois thèmes (A, B ou C). Ils appuient sur l’un des trois boutons : le bouton s’illumine en rouge pour signifier que l’enregistrement a démarré. Une voix décrit ensuite la question en détail et invite à parler. Ils peuvent changer de bouton/thème ou raccrocher. Au raccrochage du combiné, l’enregistrement s’arrête. J’ai poussé les détails assez loin, dont l’ajout d’un voyant “ON AIR” qui s’allume au décrochage du combiné, à l’extérieur de la cabine, pour indiquer qu’elle est occupée.

Une fois le Sonomaton utilisé, il ne me reste plus qu’à récupérer les fichiers dans les dossiers /A/, /B/ et /C/.

Étape par étape

1. Préparation

Installez Raspberry Pi OS avec “Raspberry Pi Imager” (Windows, Mac, Linux) : page officielle.

Si vous débutez, installez une version avec interface graphique. Vous gagnerez du temps (et vous éviterez 90% des galères liées à une configuration au clavier).

2. Branchement et vérification de la carte son USB

Branchez votre micro USB ou votre carte son USB, puis ouvrez un terminal. Listez les périphériques d’enregistrement :

arecord -l
arecord --list-pcms

Ces commandes permettent d’identifier la carte et le périphérique utilisés par ALSA.

3. Installation des outils (et la question “pip” sur Raspberry Pi OS)

Mettez le système à jour :

sudo apt update
sudo apt full-upgrade -y

Installez ce qu’il faut pour enregistrer en Python (dont PortAudio) :

sudo apt install -y python3-venv python3-pip portaudio19-dev libsndfile1

Le paquet portaudio19-dev est une dépendance classique pour les bibliothèques audio Python (sounddevice, pyaudio, etc.).

Important : depuis Raspberry Pi OS “Bookworm”, évitez d’installer des bibliothèques avec pip dans le Python système. Utilisez un environnement virtuel (venv).

Créez un dossier de projet, puis un venv :

mkdir -p /home/LOGIN/sonomaton-rec
cd /home/LOGIN/sonomaton-rec
python3 -m venv .venv
source .venv/bin/activate

Installez les bibliothèques Python :

pip install sounddevice soundfile

4. Test rapide en ligne de commande (avant Python)

Avant d’accuser Python, testez déjà que l’enregistrement fonctionne au niveau Linux. Exemple, 10 secondes en WAV stéréo :

arecord -d 10 -c 2 -r 48000 -f S16_LE test.wav

C’est volontairement simple : si ça échoue ici, votre problème est la carte son, le micro, ou ALSA.

5. Programmation : un enregistreur WAV en Python

Ouvrez Thonny (ou un éditeur), et créez rec.py dans /home/LOGIN/sonomaton-rec.

import os
from datetime import datetime

import sounddevice as sd
import soundfile as sf

# Dossier de sortie
OUT_DIR = "/home/LOGIN/sonomaton-rec/records"

# Réglages audio (à adapter)
SAMPLE_RATE = 48000
CHANNELS = 1          # 1 = mono, 2 = stéréo
DURATION_S = 10       # durée d’enregistrement en secondes

# Optionnel : choisir un device précis
# Laissez à None pour le device par défaut ALSA
INPUT_DEVICE = None   # exemple: 2 (index sounddevice)

def ensure_out_dir():
    os.makedirs(OUT_DIR, exist_ok=True)

def filename():
    ts = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
    return os.path.join(OUT_DIR, f"rec_{ts}.wav")

def record_once():
    ensure_out_dir()
    path = filename()

    print("Périphériques audio disponibles :")
    print(sd.query_devices())

    print(f"Enregistrement {DURATION_S}s -> {path}")
    audio = sd.rec(
        int(DURATION_S * SAMPLE_RATE),
        samplerate=SAMPLE_RATE,
        channels=CHANNELS,
        device=INPUT_DEVICE,
        dtype="int16",
    )
    sd.wait()

    sf.write(path, audio, SAMPLE_RATE, subtype="PCM_16")
    print("Terminé.")

if __name__ == "__main__":
    record_once()

Ce script fait exactement ce qu’on veut : un enregistrement WAV propre, horodaté, dans un dossier dédié.

N’oubliez pas de remplacer LOGIN par votre nom d’utilisateur Raspberry.

6. Déclenchement avec un bouton GPIO (optionnel, mais très utile)

Si vous voulez une logique “installation” (un bouton, un enregistrement), le GPIO est parfait. Voici une version simple : un appui lance un enregistrement (et ignore les appuis pendant l’enregistrement).

import os
from datetime import datetime
import threading

import sounddevice as sd
import soundfile as sf
from gpiozero import Button, LED

OUT_DIR = "/home/LOGIN/sonomaton-rec/records"
SAMPLE_RATE = 48000
CHANNELS = 1
DURATION_S = 10
INPUT_DEVICE = None

btn = Button(17, pull_up=True)  # bouton entre GPIO17 et GND
led = LED(27)                   # LED sur GPIO27 (avec résistance)
busy = False

def ensure_out_dir():
    os.makedirs(OUT_DIR, exist_ok=True)

def filename():
    ts = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
    return os.path.join(OUT_DIR, f"rec_{ts}.wav")

def do_record():
    global busy
    if busy:
        return
    busy = True
    led.on()

    ensure_out_dir()
    path = filename()

    audio = sd.rec(
        int(DURATION_S * SAMPLE_RATE),
        samplerate=SAMPLE_RATE,
        channels=CHANNELS,
        device=INPUT_DEVICE,
        dtype="int16",
    )
    sd.wait()
    sf.write(path, audio, SAMPLE_RATE, subtype="PCM_16")

    led.off()
    busy = False
    print(f"OK: {path}")

def on_press():
    threading.Thread(target=do_record, daemon=True).start()

btn.when_pressed = on_press

print("Prêt. Appuyez sur le bouton pour enregistrer.")
while True:
    pass

Vous avez maintenant un “magnétophone” minimal : bouton, LED, fichiers WAV horodatés. C’est typiquement le genre de base qui sert ensuite à construire une installation comme Sonomaton.

7. Autostart propre au démarrage (recommandé : systemd)

Pour une installation, vous ne voulez pas “ouvrir Thonny et cliquer Run”. Utilisez un service systemd, c’est fait pour ça.

Créez un fichier de service :

sudo nano /etc/systemd/system/sonomaton-rec.service

Collez (en adaptant LOGIN et le nom du script) :

[Unit]
Description=Sonomaton Recorder
After=network.target sound.target

[Service]
Type=simple
User=LOGIN
WorkingDirectory=/home/LOGIN/sonomaton-rec
ExecStart=/home/LOGIN/sonomaton-rec/.venv/bin/python /home/LOGIN/sonomaton-rec/rec_gpio.py
Restart=on-failure

[Install]
WantedBy=multi-user.target

Activez et démarrez :

sudo systemctl daemon-reload
sudo systemctl enable sonomaton-rec.service
sudo systemctl start sonomaton-rec.service

Idées supplémentaires

• durée variable : enregistrer tant que le bouton est appuyé (start/stop) au lieu d’une durée fixe.
• détection de niveau : déclencher automatiquement si le son dépasse un seuil (pratique en ambiance).
• compression mp3 : enregistrer en WAV, puis convertir en MP3 avec ffmpeg (plus léger, mais ce n’est plus “brut”).
• nommage métier : plutôt qu’une date, un compteur de prise, un nom de visiteur, un identifiant de session, etc.
• double flux : enregistrer, puis jouer immédiatement (ou envoyer vers un serveur) selon le principe de votre installation.

Conclusion

Vous avez maintenant un enregistreur audio autonome basé sur Raspberry Pi : une entrée micro via USB, un script Python, des fichiers WAV propres, et une option bouton/LED + lancement automatique au démarrage. C’est le socle technique qui permet ensuite de monter une installation comme Sonomaton.

Si vous voulez rester sur des systèmes plus simples orientés lecture (et non enregistrement), relisez aussi mes dossiers : DF Player, Arduino + DF Player, et Raspberry Pi.

Et si ça coince (son absent, mauvais périphérique, volume trop faible, souffle), ne perdez pas une journée à bricoler au hasard : commencez par valider arecord, puis seulement après Python. Si vous avez la moindre question, contactez-moi.