La simulation d’une interface cerveau-ordinateur (BCI) est un domaine fascinant qui combine des concepts de neurosciences, d’ingénierie biomédicale et d’intelligence artificielle. Cette interface permet de traduire les signaux cérébraux en commandes pour des dispositifs externes, offrant ainsi une voie de communication pour les personnes souffrant de paralysie ou d’autres handicaps moteurs.
Pour simuler une BCI, nous allons utiliser des signaux EEG (électroencéphalogramme) comme source de données. Nous allons générer des signaux EEG synthétiques, les filtrer et les classer pour simuler une tâche de contrôle d’un curseur sur un écran.
Voici un exemple de code Python pour simuler une telle interface :
« `python
import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import butter, filtfilt
# Paramètres de simulation
sampling_rate = 256 # Hz
duration = 5 # secondes
num_channels = 1 # Nombre de canaux EEG
# Génération de signaux EEG synthétiques
time = np.linspace(0, duration, int(sampling_rate duration), endpoint=False)
signal = np.sin(2 np.pi 10 time) + 0.5 np.sin(2 np.pi 15 time) + 0.1 np.random.randn(len(time))
# Filtre passe-bas pour simuler le filtrage des signaux EEG
def butter_lowpass(cutoff, fs, order=5):
nyquist = 0.5 fs
normal_cutoff = cutoff nyquist
b, a = butter(order, normal_cutoff, btype=’low’, analog=False)
return b, a
def butter_lowpass_filter(data, cutoff, fs, order=5):
b, a = butter_lowpass(cutoff, fs, order=order)
y = filtfilt(b, a, data)
return y
# Application du filtre passe-bas
filtered_signal = butter_lowpass_filter(signal, 30, sampling_rate)
# Classement des signaux en différentes classes (par exemple, mouvement vers la gauche ou la droite)
def classify_signal(signal, threshold=0.5):
classification = []
for i in range(1, len(signal)):
if signal[i] > threshold:
classification.append(1) # Mouvement vers la droite
elif signal[i] < -threshold:
classification.append(-1) # Mouvement vers la gauche
else:
classification.append(0) # Pas de mouvement
return classification
# Classification des signaux filtrés
classification = classify_signal(filtered_signal)
# Simulation du contrôle d'un curseur
cursor_position = 0
cursor_velocity = 0
for classification_value in classification:
if classification_value == 1:
cursor_velocity = 0.1 # Mouvement vers la droite
elif classification_value == -1:
cursor_velocity = -0.1 # Mouvement vers la gauche
else:
cursor_velocity = 0 # Pas de mouvement
cursor_position += cursor_velocity
print(f"Position du curseur : {cursor_position:.2f}")
# Visualisation des résultats
plt.figure(figsize=(12, 6))
plt.subplot(3, 1, 1)
plt.plot(time, signal)
plt.title('Signal EEG Synthétique')
plt.xlabel('Temps (s)')
plt.ylabel('Amplitude')
plt.subplot(3, 1, 2)
plt.plot(time, filtered_signal)
plt.title('Signal EEG Filtré')
plt.xlabel('Temps (s)')
plt.ylabel('Amplitude')
plt.subplot(3, 1, 3)
plt.plot(range(len(classification)), classification, 'o')
plt.title('Classification des Signaux')
plt.xlabel('Temps (échantillons)')
plt.ylabel('Classe')
plt.tight_layout()
plt.show()
```
### Explication du Code
1. Génération de Signaux EEG Synthétiques : Nous simulons des signaux EEG en utilisant des fonctions sinusoïdales et du bruit gaussien pour imiter les variations naturelles des signaux cérébraux.
2. Filtre Passe-Bas : Nous appliquons un filtre passe-bas pour éliminer les fréquences indésirables et améliorer la qualité des signaux.
3. Classification des Signaux : Nous classifions les signaux filtrés en trois catégories : mouvement vers la droite, mouvement vers la gauche, et absence de mouvement.
4. Simulation du Contrôle du Curseur : En fonction de la classification des signaux, nous ajustons la position d'un curseur simulé.
5. Visualisation : Nous utilisons Matplotlib pour visualiser les signaux EEG originaux, filtrés et classifiés.
Ce code fournit une simulation de base d'une interface cerveau-ordinateur, montrant comment les signaux cérébraux peuvent être traités et utilisés pour contrôler un dispositif externe.