Art Sciences 2025/2026 E17

Présentation du projet

Le Masque de Pouvoir des Enfants Sauvages est une installation sonore interactive qui explore la voix comme un outil de contrôle et de transformation. Le projet ne traite pas du sens du langage, mais de ses paramètres physiques : intensité, durée et répétition.

Le dispositif se compose d’une structure noire semi-fermée équipée d’un microphone à haute sensibilité. La voix du spectateur active et interrompt la projection vidéo. L’intensité sonore module l’ambiance audio, tandis que la durée de la projection dépend directement du temps de parole.

Trois masques d’animaux — renard, lapin et chat — sont suspendus autour de la structure. En plaçant sa tête dans un masque, le spectateur déclenche une réponse sonore animale spécifique. Plus la voix est forte ou prolongée, plus la réaction devient envahissante et difficile à maîtriser.

Les masques, fabriqués en matériaux textiles et en fourrure, laissent apparaître une partie du visage humain. Cette ambiguïté maintient le spectateur dans un état intermédiaire, entre identification et perte de contrôle.

L’installation met en tension la volonté de maîtriser sa voix et les mécanismes qui la transforment. La parole devient effort, souffle et épuisement, révélant les processus de domestication à l’œuvre dans l’usage de la voix.

Partie technique

1. Matériels nécessaires

Nous avons besoin d’une carte de développement Arduino Uno, d’un module microphone, ainsi que d’un ordinateur et d’une tablette.

carte arduino uno

microphone max9814

Ordinateur portable

Tablette

2. Description de la structure du système

Le système adopte une architecture modulaire, composée principalement d’un module d’acquisition et de traitement du son, d’un module de communication, d’un module de contrôle multimédia et d’un module d’affichage. L’Arduino uno et le microphone max9814 constituent le module d’acquisition et de traitement du son : ils assurent l’échantillonnage en temps réel des sons ambiants et l’extraction de l’intensité sonore ainsi que de l’état de durée de la parole. Les informations traitées sont ensuite transmises à l’ordinateur via le port série USB. Côté ordinateur, un programme Python analyse les instructions de commande envoyées par l’Arduino et pilote la lecture, l’arrêt et le volume de la vidéo. La tablette sert uniquement de terminal d’affichage pour présenter le résultat de la lecture vidéo, sans participer au traitement des données ni à la logique de contrôle. L’affichage est assuré par un partage d’écran entre l’ordinateur et la tablette à l’aide du logiciel LetsView.

Organigramme

letsview

3. Codage d'arduino et de python

Le programme Arduino permet de détecter la présence de la parole à partir du signal d’un microphone.

Le signal sonore est échantillonné sur une fenêtre temporelle fixe, puis l’amplitude crête-à-crête est calculée afin d’estimer l’intensité du son.

Lorsque la tension mesurée dépasse un seuil prédéfini, le système considère que la parole a commencé et envoie une commande de démarrage accompagnée d’une information de volume via la communication série.

Tant que la parole est détectée, le programme surveille le niveau sonore. Lorsque le signal reste en dessous du seuil pendant un certain nombre de fenêtres consécutives, la fin de la parole est détectée et une commande d’arrêt est envoyée, incluant la durée de la prise de parole. voici le code d'arduino.

/****************************************

Commande vidéo déclenchée par le son

Arduino + Microphone (MAX9814 / KY-038)

Avec affichage en temps réel de la tension

****************************************/

const int micPin = A0;

// ===== Paramètres réglables =====

const int sampleWindow = 500;       // Fenêtre d’échantillonnage (ms)

const float thresholdVolts = 1.7;   // Seuil de détection de la parole (V)

const int silenceLimit = 3;         // Nombre de fenêtres silencieuses avant arrêt

// ===== Variables =====

bool speaking = false;

unsigned long startTime = 0;

int silenceCount = 0;

float startVolts = 0.0;

void setup() {

  Serial.begin(115200);

}

void loop() {

  // ----------- Acquisition du signal sonore -----------

  unsigned long startMillis = millis();

  unsigned int signalMax = 0;

  unsigned int signalMin = 1023;

  while (millis() - startMillis < sampleWindow) {

    int sample = analogRead(micPin);

    if (sample < 1024) {

      if (sample > signalMax) signalMax = sample;

      if (sample < signalMin) signalMin = sample;

    }

  }

  unsigned int peakToPeak = signalMax - signalMin;

  float volts = (peakToPeak * 5.0) / 1024.0;

  // ----------- Affichage en temps réel de la tension -----------

  Serial.print("VOLT:");

  Serial.println(volts, 2);   // Affichage avec 2 décimales

  // ----------- Détection du début de la parole -----------

  if (volts >= thresholdVolts && !speaking) {

    speaking = true;

    startTime = millis();

    silenceCount = 0;

    // Mémorisation de l’intensité sonore initiale

    startVolts = volts;

    int videoVolume = map(

      constrain(startVolts * 100, 160, 250),

      160, 250,

      30, 100

    );

    Serial.print("START,VOL:");

    Serial.println(videoVolume);

  }

  // ----------- Pendant la parole -----------

  if (speaking) {

    if (volts < thresholdVolts) {

      silenceCount++;

    } else {

      silenceCount = 0;

    }

    // ----------- Détection de la fin de la parole -----------

    if (silenceCount >= silenceLimit) {

      speaking = false;

      unsigned long duration = millis() - startTime;

      Serial.print("STOP,DUR:");

      Serial.println(duration);

    }

  }

}

Et puis, le programme Python assure la communication entre l’Arduino et le système de lecture vidéo.

Il lit en temps réel les messages envoyés par l’Arduino via la liaison série et interprète les commandes de démarrage et d’arrêt de la lecture vidéo.

Lorsqu’une commande de démarrage est reçue, le programme lance la lecture de la vidéo en mode plein écran. Lorsque la commande d’arrêt est reçue, la lecture est interrompue.

Tant que la parole est détectée, l’état du lecteur vidéo est surveillé afin de relancer automatiquement la vidéo lorsqu’elle arrive à la fin, garantissant ainsi une lecture continue pendant la prise de parole. Voici le code de python.

import serial

import vlc

import time

# ===== À modifier ici =====

SERIAL_PORT = 'COM3'       # À adapter selon le port série de l’Arduino

VIDEO_PATH = 'test.mp4'

# ==========================

BAUD_RATE = 115200

speaking = False

# Port série

ser = serial.Serial(SERIAL_PORT, BAUD_RATE, timeout=1)

# VLC (désactivation de Direct3D11 pour éviter les erreurs d’affichage)

instance = vlc.Instance('--vout=directx')

player = instance.media_player_new()

media = instance.media_new(VIDEO_PATH)

player.set_media(media)

player.set_fullscreen(True)

print("Système démarré, en attente des signaux Arduino...")

while True:

    # -------- Traitement des données série --------

    if ser.in_waiting:

        line = ser.readline().decode(errors='ignore').strip()

        print("Reçu :", line)

        if line.startswith("VOLT"):

            pass  # Affichage de la tension uniquement (pas de traitement)

        elif line.startswith("START"):

            if not speaking:

                speaking = True

                player.stop()

                time.sleep(0.05)

                player.play()

        elif line.startswith("STOP"):

            speaking = False

            player.stop()

    # -------- Détection de la fin de la vidéo --------

    if speaking:

        state = player.get_state()

        # Ended = fin de lecture de la vidéo

        if state == vlc.State.Ended:

            player.stop()

            time.sleep(0.05)

            player.play()

    time.sleep(0.02)  # Limitation de l’utilisation du processeur