Master Braz

Victor BRAZ
Laurent MANEVILLE
Christophe PERSON
Projet de fin d'études
INTERFACE CERVEAU-MACHINE
Tuteurs : Valérie Louis-Dorr, Radu Ranta
Année universitaire 2007/2008

Remerciements
Nous tenons à remercier toutes les personnes qui nous ont apporté leur aide dans ce projet.
Nous remercions tout d'abord nos tuteurs, Valérie Louis-Dorr et Radu Ranta, pour leur
disponibilité et pour avoir su nous conseiller tout au long de l'avancement de ce projet.
Nous remercions également le docteur Louis Maillard ainsi que les membres de son
équipe du service de neurologie de l'Hôpital Central de Nancy pour nous avoir permis de réaliser
des mesures grâce à leurs équipements.
Résumé
Depuis plusieurs années, de nombreuses équipes de recherche dans le monde s’intéressent à la

réalisation d’une interface cerveau – ordinateur. Les applications possibles sont nombreuses : cela va
de l’aide aux personnes lourdement handicapées, aux jeux vidéo, à la réalité virtuelle et au contrôle
d’objets réels.
L’électroencéphalogramme (EEG) est le moyen le plus utilisé pour constituer le premier

élément de la chaîne de mesure et de traitement d’une interface cerveau – ordinateur. Ce signal
électrophysiologique, obtenu à l’aide d'électrodes placées sur le crâne, est capable d’enregistrer les
changements d’activité électrique cérébrale en temps réel.
Ce projet vise à créer, détecter et utiliser des événements particuliers dans le signal EEG. La
plupart des méthodes actuelles provoquent des événements (appelés potentiels évoqués) par des
stimuli extérieurs (son, image, flash, toucher). D’autres méthodes demandent au volontaire de créer
lui-même l’événement à détecter (contraction musculaire, mouvement des yeux ou des paupières,
voire même un mouvement imaginaire). L'objectif de ce projet est de tester la réponse de l’EEG à ces
différents types de stimuli connus des neurologues.
Abstract
Last several years, numerous research teams in the world have been interested in the
realization of brain – computer interfaces (BCI). The possible applications are various like
helping the heavily handicapped persons or video games. It can also be used in virtual reality or
to control real objects.
The electroencephalogram (EEG) is the most used means to constitute the first element of
the system of measure and treatment of a brain – computer interface. This electrophysiological
signal, obtained thanks to electrodes placed on the head, is able to record the changes of cerebral
electric activity in real-time.
This project's purpose is to create, detect and use particular events in the EEG signal.
Most of the current methods provoke events (called potential evoked) while using outside stimuli
(sound, image, flash, touch). With other methods the volunteer is asked to create the event to be
detected (muscular contraction, movement of eyes or eyelids, even imaginary movements). The
objective of this project is to test EEG'S answer to these various types of stimuli known by
neurologists.
Sommaire
1. Introduction.........................................................................................................3
1.1. Contexte............................................................................................................................. 3
1.2. Objectifs.............................................................................................................................3
2. Présentation des BCI...........................................................................................5
2.1. Les applications médicales................................................................................................ 5

2.1.1. Un fauteuil roulant commandé par la pensée..............................................................5
2.1.2. Une machine à écrire mentale.....................................................................................6
2.1.3. Un navigateur web...................................................................................................... 6
2.1.4. Contrôle d'un bras robotisé......................................................................................... 7
2.2. Les jeux vidéo....................................................................................................................7
2.2.1. Le ping-pong cérébral.................................................................................................7
2.2.2. La réalité virtuelle....................................................................................................... 8
2.2.3. La transmission de sensations par Sony..................................................................... 8
3. L'acquisition des EEG.........................................................................................9
3.1. Utilisation des EEG........................................................................................................... 9

3.1.1. Présentation des EEG..................................................................................................9
3.1.2. La mesure des signaux EEG..................................................................................... 10
3.1.3. Les dispositifs d'acquisition...................................................................................... 11
3.2. Les évènements détectables dans les EEG...................................................................... 13
3.2.1. Les potentiels évoqués.............................................................................................. 13
3.2.2. Les stimuli intérieurs................................................................................................ 14
3.3. Chaîne d'acquisition des signaux EEG ........................................................................... 15
3.4. Mesures de signaux EEG.................................................................................................17
3.4.1. Protocoles utilisés..................................................................................................... 17
3.4.2. Résultats des acquisitions EEG.................................................................................18
4. Traitement des signaux..................................................................................... 19
4.1. Le prétraitement des signaux........................................................................................... 19

4.1.1. Filtrage...................................................................................................................... 19
4.1.2. Elimination des artefacts...........................................................................................20
4.2. Caractéristiques des signaux............................................................................................ 21
4.3. Discrimination des signaux..............................................................................................21
4.3.1. Les classificateurs linéaires...................................................................................... 21
4.3.2. Les classificateurs non-linéaires............................................................................... 25
4.3.3. Les réseaux de neurones........................................................................................... 25
4.3.4. Système d'inférence flou...........................................................................................27
4.4. Etude expérimentale........................................................................................................ 27
4.4.1. Approximation fonctionnelle d'un clignement d'oeil ...............................................27
4.4.2. Détection par seuil ................................................................................................ 30
4.4.3. Analyse discriminante linéaire..................................................................................30
Projet de fin d'études 1 Interface cerveau-machine

5. Interface graphique........................................................................................... 35
5.1. Présentation......................................................................................................................35
5.2. Choix du matériel utilisé..................................................................................................36
5.2.1 Choix du système d'exploitation................................................................................ 36
5.2.2 Choix du langage de programmation.........................................................................36
5.2.3 Choix de la librairie graphique.................................................................................. 37
5.3. La communication avec Matlab.......................................................................................38
5.4. Les programmes réalisés..................................................................................................40
5.4.1 Mise en place de la SDL............................................................................................ 40
5.4.2 Programme de prise de mesures................................................................................ 43
5.4.3 Programme de tracé de signaux................................................................................. 44
6. Conclusion........................................................................................................ 48
7. Bibliographie.....................................................................................................49
ANNEXE.............................................................................................................. 52
Les parties 1 à 3 ont été rédigées par Christophe Person, la partie 4 par Victor Braz, et la
partie 5 par Laurent Maneville.

1. Introduction
1.1. Contexte
Ces dernières années, les interfaces cerveau-machine, ou BCI (Brain-Computer

Interface), ont été l’objet de nombreuses recherches dans le monde. Elles consistent à contrôler
des ordinateurs ou des objets en utilisant uniquement l’activité cérébrale d’un individu. Cette
activité est mesurée à l’aide d’un casque à électrodes, voire à l'aide d'électrodes intra-
crâniennes qui permettent l'acquisition de signaux nettement moins bruités. Nous nous
intéresserons plus particulièrement aux BCI non invasifs, ne nécessitant pas la pose
d'électrodes dans le cerveau, avec tous les risques de rejets correspondants.
Les applications possibles des BCI sont variées. Les recherches concernent avant tout le
domaine médical et visent principalement à redonner de l'autonomie à des patients souffrant de
lourds handicaps, c'est-à-dire de tétraplégie, ou de dysfonctionnements du système nerveux,
par exemple. Les enjeux sont donc de taille, et les premiers succès ont permis de manœuvrer
une chaise roulante par la pensée ou encore d’écrire des mots avec une machine à écrire
mentale. Pour de nombreux individus dans le monde, les BCI constituent le seul espoir de
communiquer avec l’extérieur.
Une autre application trouve sa place dans le domaine des jeux vidéo. Les enjeux
financiers de ce secteur expliquent l'intérêt de nombreuses équipes de chercheurs, qui ont
réalisé des progrès remarquables, en parvenant à concevoir par exemple des jeux de ping-pong
cérébraux. Le domaine de la réalité virtuelle profite lui-aussi des avancées des BCI puisque des
interfaces permettent de se déplacer par la pensée dans des environnements virtuels.
1.2. Objectifs
Le but de ce projet est de créer des évènements particuliers dans
l’électroencéphalogramme (EEG), de les détecter et de les utiliser dans le but d’interagir avec
un ordinateur.
Ce projet est mené en équipe de 3 étudiants, qui sont chargés de l’acquisition de
l’activité cérébrale, du traitement du signal, et de la mise en œuvre d’une interface graphique.
Un diagramme montrant l'organisation de ces différentes parties est représenté sur la figure 1
de la page suivante.
Nous chercherons les événements caractéristiques et détectables dans les EEG, afin de
décider s'il est préférable de provoquer des événements au moyen de stimuli extérieurs (des
images défilant rapidement sur un écran par exemple), appelés potentiels évoqués, ou s'il est
plus intéressant que le sujet provoque lui-même les évènements à détecter (par contraction
d’un muscle).
Un objectif important sera de parvenir à différencier plusieurs événements : par
exemple, on pourrait tenter de distinguer des événements selon qu’ils proviennent de
l’hémisphère gauche ou de l’hémisphère droit du cerveau.
Il faudrait aussi s’interroger sur l’interface graphique à réaliser : une version simple
serait d’allumer une LED rouge lorsqu’un événement a été détecté dans la partie gauche du
cerveau, et d’allumer une LED verte lorsqu’il a été détecté dans la partie droite.

figure 1 : Organisation des différentes parties du projet

2. Présentation des BCI
2.1. Les applications médicales

Pour les personnes lourdement handicapées, les BCI peuvent être un moyen de pallier
leur handicap, afin de leur permettre de se déplacer par exemple. Les patients dont les capacités
de communication ont été altérées peuvent bénéficier de la technologie des BCI pour
s'exprimer. Les BCI peuvent aussi apporter beaucoup dans le domaine de la neuroprosthétique
: des bras robotisés peuvent déjà être contrôlés par la pensée.
2.1.1. Un fauteuil roulant commandé par la pensée
Des scientifiques espagnols de l’université de Saragosse travaillent sur une nouvelle

interface cerveau-ordinateur : il s'agit d'un fauteuil roulant capable de transformer les pensées
de son occupant en commandes que le fauteuil exécutera. Ce projet consiste à concevoir un
système mobile (qui peut être installé sur le fauteuil) et non invasif, pour apporter un nouveau
degré de mobilité et à des gens ayant des capacités motrices très réduites.
Le premier prototype intégrant un système BCI est attendu pour fin 2008, et les
difficultés majeures consistent pour l’instant à miniaturiser l’équipement. Il faudra une petite
semaine d’entraînement à la personne pour arriver à utiliser des commandes simples comme
droite, gauche, en avant, ou stop. L’équipe espagnole travaille à une combinaison de systèmes
mêlant pensées et logiciel de cartographie, ce qui permettrait au système de comprendre des
injonctions plus compliquées comme “va à la cuisine”.
figure 2 : Fauteuil roulant

commandé par la pensée
[FIEVET C.]

2.1.2. Une machine à écrire mentale
Les chercheurs de l'institut Fraunhofer de Berlin ont conçu un système utilisant 128
électrodes afin de traduire les pensées de l'utilisateur en mouvements de curseur sur un écran
d’ordinateur. Le système doit encore être amélioré, la durée nécessaire pour saisir une simple
phrase pouvant atteindre plusieurs minutes. La mise en place des électrodes est également très
complexe. Mais les scientifiques comptent développer un casque sans contact qui remplacera
toutes ces électrodes. Le logiciel apprend en même temps que l’utilisateur, ce qui permet aux
personnes totalement handicapées, mais dont le cerveau est intact, de retranscrire leurs pensées
sur un écran d’ordinateur, comme par télépathie.
Pour déplacer le curseur sur les différentes lettres à l'écran, il faut imaginer des
mouvements de mains ou de pieds. Cela ne demande qu'une vingtaine de minutes
d'entraînement pour parvenir à configurer un nouveau profil, puis on peut parvenir à écrire 5 à
7 mots à la minute.
On est donc encore loin de pouvoir écrire directement un texte sur son ordinateur
simplement en pensant aux mots que l'on voudrait voir s'afficher, puisqu'il faut épeler chaque
mot, même s'il existe des programmes de reconnaissance de mots qui permettent d'accélérer
légèrement l'écriture.
D'autres chercheurs, de l'université de l'Illinois, utilisent les ondes P300 pour écrire des
mots. Un clavier virtuel en forme de tableau est présent à l'écran, les lignes et les colonnes
clignotant successivement. Lorsque la lettre à sélectionner par l'utilisateur apparaît au
croisement de la ligne et de la colonne clignotantes, le simple fait de vouloir la sélectionner
entraîne un pic d'activité 300 millisecondes après l'évènement qui devient donc facilement
détectable. Ce procédé permet actuellement de saisir 8 lettres par minute et demande beaucoup
d'entraînement, suite auquel on peut parvenir à saisir les lettres plus rapidement.
2.1.3. Un navigateur web
Cela fait déjà plusieurs années que la société IBVA (Interactive Brainwave Visual
Analyzer) travaille sur un système permettant de contrôler différents appareils par la pensée,
comme une télévision ou un lecteur CD par exemple. Ils sont aussi parvenus à envoyer des
messages par internet en contrôlant un ordinateur par des ondes cérébrales.
Un navigateur web a même été réalisé à l'université de Georgie, permettant de surfer

sur internet par la pensée, sans souris ni clavier : il s'agit de BrainBrowser qui permet à un
utilisateur de passer d'une page web à une autre en cliquant par la pensée.
Ces technologies ont elles aussi pour principal objectif de venir en aide à des personnes
handicapées, en leur apportant des outils permettant de pallier leur handicap.

2.1.4. Contrôle d'un bras robotisé
A l’université de Pittsburgh, des chercheurs ont mis au point un bras robotisé contrôlé
par la pensée. Ce bras reproduirait les gestes d’un humain grâce à un système de sondes et de
capteurs directement insérés dans le cerveau. Lors d’une expérience menée sur des singes, le
bras robotisé suit les directives imposées par la pensée ou la volonté du singe.
Une autre équipe de scientifiques du CHU de Duke (en Caroline du Nord) a entraîné
des singes à manœuvrer un bras mécanique par la pensée. Elle a annoncé en 2005 que les
premiers tests sur 11 personnes atteintes de la maladie de Parkinson prouvaient la viabilité de
ce protocole d’utilisation d’une BCI sur les humains. Des électrodes implantées dans le
cerveau transforment les impulsions en signaux capables de télécommander les mouvements
d’une prothèse robotisée ou d’un fauteuil électrique. Les espoirs sont très grands, notamment
chez les amputés et les tétraplégiques.
figure 3 : Bras robotisé

[JACQUEMIN C.]
2.2. Les jeux vidéo

2.2.1. Le ping-pong cérébral
La société autrichienne g.tec (Guger Technologie) a réalisé un casque qui analyse les
ondes émises par le cerveau et les retransmet à un PC. Ce système permet par exemple de
déplacer un curseur dans des jeux simples comme « Pong ».
figure 4 : Ping-pong cérébral

[WOLKAM]

Plusieurs autres équipes de scientifiques sont elles aussi parvenues à mettre en œuvre
des jeux similaires de ping-pong cérébral, cette application nécessitant uniquement la détection
de deux évènements correspondant à un déplacement vers le haut ou vers le bas du curseur. Le
ping-pong cérébral représente donc l'application la plus connue et la plus fréquente des BCI
aux jeux vidéo.
D'autre part, g.tec a sorti un Pocket BCI : il s'agit de la première interface cerveau-
machine commercialisée. Le Pocket BCI est constitué d'un casque, et d'un récepteur qui se
connecte sur un ordinateur par une prise USB. La version actuelle du Pocket BCI permet
d'épeler des mots et de jouer à « Pong », mais d'autres fonctionnalités sont en cours de
développement.
2.2.2. La réalité virtuelle
Combiner un BCI non invasif avec les technologies de réalité virtuelle offre la
possibilité de réaliser une interface «naturelle» pour se déplacer par la pensée (en imaginant
des mouvements) et en temps réel dans un environnement virtuel. Dans ce cadre, une étape très
importante a été présentée en 2004 par un groupe de scientifiques travaillant avec la société
autrichienne g.tec (Guger Technologies).
Le participant, assis sur un siège et la tête recouverte d'un casque (EEG) et de lunettes
spéciales est placé dans un environnement virtuel, lui donnant l'illusion d'être physiquement
dans une rue. Il lui suffit d'imaginer mentalement le mouvement de ses pieds, pour progresser
en avant ou en arrière dans cet environnement, et le mouvement de sa main droite pour arrêter
la progression.
figure 5: Environnement virtuel

[JACQUEMIN C.]
2.2.3. La transmission de sensations par Sony
Sony a déposé un brevet en 2005 pour une technologie visant à transmettre directement
des informations sensorielles au cerveau. Aucune chirurgie invasive n'est nécessaire et cette
technologie pourrait être utilisée pour créer des jeux vidéo dans lesquels il deviendrait possible
de sentir ou de goûter. Des pulsations ultrasoniques sont envoyées à des zones spécifiques du
cerveau afin d'induire des expériences sensorielles telles que des odeurs, des sons ou des
images. On pourrait alors même espérer ouvrir de nouvelles voies pour aider les sourds ou les
aveugles, le spécialiste en neurologie à l'université de Tübingen en Allemagne Niels Birbaumer
ayant estimé ce brevet plausible.

3. L'acquisition des EEG
3.1. Utilisation des EEG
3.1.1. Présentation des EEG
L’EEG est le moyen le plus utilisé pour la réalisation d’une BCI. Ce signal est la
mesure de l’activité bioélectrique cérébrale ; il est obtenu à l’aide d’électrodes placées sur le
cuir chevelu, les électrodes étant soit autocollantes et à usage unique, soit fixées sur un casque.
Les courants recueillis sont surtout ceux générés au niveau des dendrites des neurones
pyramidaux que l'on retrouve massivement dans le cortex et qui ont une orientation parallèle,
ce qui amplifie le signal de leur activité commune. Le développement de l’EEG en clinique
date de l’apparition des amplificateurs différentiels au début des années 1960. Les EEG sont
actuellement utilisés afin de diagnostiquer des foyers épileptiques, des tumeurs cérébrales, des
lésions. Ils permettent aussi de trouver l'origine de migraines, de problèmes d'étourdissements,
ou encore de somnolence.
L’activité bioélectrique cérébrale correspond à des différences de potentiel électrique
entre deux électrodes. Un montage EEG correspond donc à une combinaison de couples
d’électrodes. Il existe des montages bipolaires et des montages référentiels (ou monopolaires).
Dans un montage bipolaire, le signal mesuré est la différence entre un pôle positif et un pôle
négatif, alors que dans un montage référentiel, le signal mesuré ne provient que d'un pôle, le
pôle opposé étant commun à tous les couples d'électrodes. En fait, cette électrode neutre n’est
jamais véritablement nulle et il existe donc plusieurs choix possibles pour l’origine des
potentiels.
L’emplacement des électrodes est standardisé par une nomenclature internationale
appelée système 10/20. Chaque électrode porte un nom précis (F : frontale, P : pariétale, Fp :
Fronto-pariétale, T : temporale, O : occipitale, C : centrale), les électrodes de la ligne médiane
reçoivent le suffixe « z » pour zéro, les chiffres pairs indiquent le côté droit et les chiffres
impairs le côté gauche.
figure 6: La nomenclature 10/20

[BILLARD V.]

Les fréquences des ondes cérébrales s'étendent de 0,25 Hz à environ 60 Hz, l'état de
conscience de la personne (éveil, sommeil, ou rêve) ayant une importance déterminante sur la
fréquence de l'électroencéphalogramme. On peut distinguer plusieurs profils de fréquences
s'apparentant à différentes activités :
– les ondes DELTA, correspondant à un état de sommeil profond ou de coma, sont
inférieures à 4 Hz,
– les ondes THETA, correspondant à une activité limbique (mémoire et émotions), sont
comprises entre 4 et 8 Hz,
– les ondes ALPHA, qui sont émises par un sujet alerte, sans traitement actif de
l'information, c'est-à-dire par exemple chez un individu ayant les yeux fermés, sont
comprises entre 8 et 12 Hz,
– les ondes BETA, qui sont émises par un sujet alerte traitant activement de l'information,
sont comprises entre 13 et 30 Hz,
– les ondes GAMMA, qui pourraient être reliées à la conscience, sont comprises entre 30 et
35 Hz.
3.1.2. La mesure des signaux EEG
Plusieurs difficultés existent lors de l'acquisition d'un signal EEG avec des électrodes
de surface :
 la faible amplitude du signal mesuré (de 10 à 100 μV),
 le bruit de mesure, dû à l’éloignement des sources ; la qualité du signal EEG recueilli
est testée en mesurant l'impédance de l'ensemble constitué par chaque électrode et son
câble, qui doit être inférieure à 10 kΩ, voire à 5 kΩ pour que les signaux soient
interprétables.
 la présence d’artefacts :
 ils peuvent être d’origine corporelle, c'est-à-dire dus à des mouvements
oculaires, aux activités musculaire, respiratoire et cardiaque, au mâchonnement,
à la déglutition, à la toux…
De plus, il ne faut pas oublier qu’il existe des pensées parasites qu’il est difficile
de contrôler.
 Les artefacts peuvent aussi être d’origine extra-corporelle ; ils peuvent être
induits par l'environnement immédiat, dépendre de l'isolement électrique…
Dans le cas des techniques non invasives, le problème d'une mauvaise résolution du
signal à cause de son atténuation par les tissus et os crâniens a souvent été souligné. La forme
ronde du crâne vient également entraîner une dispersion et un brouillage des ondes
électromagnétiques créées par les neurones. Ainsi, même si les ondes peuvent tout de même
être détectées, il est plus difficile, par rapport aux méthodes invasives, de déterminer le secteur
du cerveau qui les a créées ou les actions générées par différents neurones, d’autant plus que
plusieurs régions différentes du cerveau peuvent réagir au même événement. Par ailleurs, la
méthode non invasive nécessite un entraînement intensif du sujet à la maîtrise de cette
technologie.

L’acquisition d’un signal EEG comporte plusieurs étapes :
– la mesure de l’activité bioélectrique au moyen d’un casque à électrodes
– l’amplification du signal (par un facteur 1000 au moins), le signal initial étant
de l’ordre du μV, afin d’obtenir des mV, voire des V.
– le filtrage du signal (filtrage passe-bas avec fréquence de coupure à 100 Hz)
– la conversion analogique-numérique dans le but de traiter le signal
figure 7 : Acquisition d'un signal EEG
3.1.3. Les dispositifs d'acquisition
Il existe de multiples systèmes d'acquisition EEG se différenciant par le nombre

d'électrodes utilisées, par le traitement des signaux, ou encore par le moyen de connexion à un
ordinateur qui enregistre et traite les données.
Parmi les distributeurs de tels dispositifs d'acquisition EEG, on peut citer la société
russe Neurosoft qui propose le « Neurospectrum » dont la particularité est qu'il se connecte au
port USB d'un ordinateur. Il s'agit donc d'un système relativement simple d'utilisation,
comportant tout l'équipement d'acquisition de signaux EEG, d'autant plus qu'il est livré avec un
logiciel complet d'acquisition et d'analyse, pour un prix abordable (environ 10 000 € pour le
modèle à 16 électrodes). Cependant, le « Neurospectrum » semble davantage destiné à une
utilisation clinique plutôt que du domaine de la recherche scientifique.
Il existe plusieurs versions du « Neurospectrum » qui comportent soit 16 électrodes,

soit 19, 21, 28, ou encore 41. Le « Neurospectrum 2 », constitué de 16 entrées, comporte les
caractéristiques suivantes :
Fréquence d'échantillonnage par canal jusqu'à 5000 Hz

Sensibilité 1 – 500 µV/mm
Echelle signal d'entrée 13 mV
Filtre passe bas 0.05 – 2 Hz
Filtre passe haut 15, 30, 75, 100, 200 Hz

Capacité de conversion 16 bits
Taux de réjection (à 10 Hz) 110 dB
Réjecteur 50 Hz 40 dB
Niveau de bruit sur charge de 10 KΩ 0.8 µV
Impédance d'entrée > 100 MΩ
Damping inter canaux 60 dB
Calibration auto
Contrôle d'impédance oui
Contrôle électrode de terre oui
Le « Neurospectrum » comporte une boîte d'entrée facile d'utilisation, ainsi que divers
accessoires personnalisables de stimulations auditives ou visuelles :
figure 8 : Le Neurospectrum
[NEUROSOFT]
La société autrichienne g.tec propose elle-aussi plusieurs systèmes robustes et faciles

d'utilisation exploitant les EEG. Leurs casques à électrodes permettent de choisir 34, 64, 72 ou
encore 111 positions pour placer les électrodes, les positions les plus exploitables étant les
suivantes :
figure 9 : Positionnement des électrodes

[GTEC]

3.2. Les évènements détectables dans les EEG
3.2.1. Les potentiels évoqués
Lorsqu’on s’intéresse aux événements caractéristiques et détectables dans les EEG, une
première solution consiste à provoquer des événements au moyen de stimuli extérieurs (des
images défilant rapidement par exemple) : il s'agit des potentiels évoqués (PE) que l'on peut
définir comme des réponses électrophysiologiques à des stimulations sensorielles. Nous nous
intéresserons plus particulièrement aux PE visuels qui sont plus amples, donc plus faciles à
extraire.
Il existe plusieurs types de PE, par exemple l’onde « P300 » qui est une onde positive
qui survient lorsqu’un sujet a détecté un stimulus attendu et imprévisible. Le « P » signifie que
le signal est positif et « 300 » précise que le pic est obtenu 300 ms après l’événement. De
même on utilise la lettre « N » pour des pics négatifs.
La MMN, ou négativité de discordance (mismatch negativity), est observée lorsqu'un
stimulus déviant est inséré au sein d'une série régulière de stimuli identiques.
La N400 est liée au traitement linguistique, au contenu ou représentation sémantique.
Elle reflète la force de l'association à laquelle un concept est relié dans un contexte sémantique.
L’onde P300 est souvent utilisée dans les BCI pour détecter des événements. Il s’agit
d’un signal électrique produit par le cerveau en réponse à une stimulation ; plus
particulièrement, le fait qu'il s’agisse d’un potentiel positif culminant à 300 ms après la
stimulation la rend facilement détectable. Le montage C de la figure 9 précédente est utilisé
pour mesurer ces P300.
On présente à l’utilisateur plusieurs choix (par exemple plusieurs images), et lorsque
celui qui lui convient apparaît, le simple fait de vouloir le sélectionner augmente la tension
électrique du cerveau d’une manière plus facilement mesurable que son activité habituelle ne le
permet.
figure 10 : Exemple d'onde P300

[GLOVER]

3.2.2. Les stimuli intérieurs
Le sujet peut provoquer lui-même les évènements à détecter (par contraction d’un
muscle, ou par mouvements imaginaires). L'intérêt des stimuli intérieurs est que le sujet va
pouvoir agir par lui-même et à tout moment sur une commande, contrairement aux potentiels
évoqués où il ne fait que réagir à un stimulus.
Les contractions musculaires provoquent des variations d'amplitude assez importantes

pour être facilement détectées. On peut donc imaginer utiliser les contractions de différents
muscles, chacune correspondant à une commande différente. Chaque contraction pourrait être
identifiée en observant les signaux EEG provenant des électrodes situées aux endroits où la
contraction a provoqué une variation d'amplitude. Ainsi, la connaissance des voies sur
lesquelles un événement a été détecté permettrait d'identifier le muscle contracté, et donc la
commande demandée.
Par exemple, on peut considérer 2 événements :

● L'événement 1 consistant à la stimulation de l’hémisphère droit du cerveau, par
mouvement de la partie gauche de son corps par exemple.
● L'événement 2 consistant à la stimulation de l’hémisphère gauche du cerveau, par
mouvement de la partie droite de son corps.
Alors on peut imaginer pouvoir déplacer un curseur sur un écran, l’événement 1
déplaçant le curseur vers la gauche, le 2 vers la droite, et la combinaison simultanée des 2
événements permettant de cliquer.
Une difficulté dans l'utilisation des stimuli intérieurs est de différencier plusieurs
évènements : il est difficile de contracter un seul muscle en relâchant tous les autres, et la
réalisation d'un mouvement sollicite en général plusieurs muscles. Le simple fait de se tenir
assis ou de maintenir sa tête droite entraîne la contraction de multiples muscles. De plus, de
nombreux artefacts oculaires dégradent le signal, étant donné qu'il est très difficile, voire
impossible de contrôler ses clignements des yeux.
Il faut donc utiliser des mouvements relativement simples afin d'espérer pouvoir les
détecter. Il est aussi possible de travailler avec des mouvements imaginaires, ce qui peut être
intéressant pour l'utilisation par des personnes handicapées. Cela demande beaucoup
d'entraînement, mais des résultats encourageants ont déjà été obtenus, en particulier par la
société autrichienne g.tec.
Les stimuli intérieurs semblent donc être un moyen efficace pour détecter plusieurs
évènements différents, c'est pourquoi nous avons choisi de les exploiter dans nos mesures
expérimentales.

3.3. Chaîne d'acquisition des signaux EEG
Afin d'acquérir des signaux EEG exploitables, le signal provenant des électrodes doit
être filtré et amplifié. L'amplification est une étape cruciale de la chaîne d'acquisition, puisqu'il
s'agit d'amplifier un signal très faible, c'est-à-dire de l'ordre du μV. Pour cela, on utilise un
amplificateur différentiel de grande précision : le « AD524 » de « Analog Devices ».
Sa structure est celle d'un amplificateur d'instrumentation. Les amplificateurs A1 et A2

de la figure suivante étant supposés idéaux, les résistances R1 et R2 sont parcourues par le
même courant I et la tension aux bornes de R2 est V1 – V2 = R2.I.
V1−V2
On en déduit la différence de potentiels VA – VB= 2 R1R2. I =2 R1R2. .
R2
V1−V2
Ainsi, on a en sortie : Vs=α VA−VB=α . 2 R1R2.
R2
Les valeurs de α, de R1 et de R2 permettent de modifier la valeur du gain entre Vs et la
différence (V1 – V2).
figure 11 : Principe d'un amplificateur d'instrumentation
Les deux amplificateurs opérationnels A1 et A2 permettent d'effectuer une adaptation

d'impédance.
En utilisant des résistances d'une extrême précision et en ajoutant à cette structure

plusieurs transistors afin d'améliorer le rapport signal sur bruit qui devient alors excellent, on
obtient le montage de l'amplificateur AD524. Celui-ci permet d'obtenir un gain réglable
pouvant atteindre 105. Le gain est réglé en utilisant soit les entrées 11, 12 ou 13 de
l'amplificateur correspondant respectivement à des gains de 1000, 100 ou 10, soit en utilisant
une résistance entre les entrées 3 et 16 afin d'obtenir un gain d'une autre valeur ; la résistance
utilisée doit évidemment être elle-aussi de grande précision, afin de ne pas dégrader les
performances de l'amplificateur AD524. Plusieurs interrupteurs sont utilisés pour modifier les
entrées de l'amplificateur afin de régler le gain.

figure 12 : Circuit simplifié de l'amplificateur AD524
[ANALOG]
Après amplification, on utilise un filtrage passe-haut de fréquence de coupure de 5 Hz

afin d'éliminer toute composante continue du signal. Il s'agit d'un filtrage passif, afin de ne pas
trop dégrader le signal, ce qui serait le cas si l'on utilisait des amplificateurs opérationnels.
Le signal est ensuite à nouveau amplifié, le gain étant réglable et ayant une valeur
comprise entre 1 et 10. Le gain total peut donc atteindre 10 6 en considérant les deux
amplifications ; à partir d'un signal de quelques μV, on obtient donc un signal de l'ordre du
Volt.
Un filtrage passe-bas, servant aussi de filtre anti-repliement, est finalement utilisé afin
d'obtenir un signal qui pourra être utilisé en entrée d'un convertisseur analogique-numérique.
Le montage complet permettant d'acquérir des signaux EEG, constitué d'un

amplificateur différentiel, d'un filtre passe-haut, d'un gain réglable et d'un filtre passe-bas, est
donc le suivant :
figure 13 : Schéma de la chaîne d'acquisition d'un signal EEG

3.4. Mesures de signaux EEG
Le service de neurologie de l'Hôpital Central de Nancy nous a permis de réaliser nos
propres enregistrements EEG en mettant un casque ainsi qu'une chambre à notre disposition.
Nous avons ainsi pu utiliser nos propres protocoles afin de tenter de détecter des évènements.
3.4.1. Protocoles utilisés
Nous avons commencé par tenter de détecter des mouvements, c'est-à-dire d'utiliser des
stimuli intérieurs. Pour cela, nous avons utilisé un programme en langage C qui affichait des
instructions à l'écran d'un ordinateur, et qui écrivait dans un fichier l'instant auquel l'instruction
avait été donnée.
Les instructions étaient de cligner de l'œil gauche, de l'œil droit, de bouger le bras droit,
puis le gauche. Ces différentes instructions étaient tout d'abord répétées dans un ordre défini,
puis elles étaient données aléatoirement.
On pouvait ainsi espérer détecter des évènements dans l'hémisphère droit du cerveau
lorsque l'on demandait un mouvement de la partie gauche du corps, et inversement.
D'autre part, afin d'obtenir des enregistrements exploitables, il a fallu limiter au

maximum les mouvements parasites. Pour cela, il fallait rester immobile pendant
l'enregistrement et ne solliciter que le minimum de muscles nécessaires à l'exécution du
mouvement demandé. De plus, nous avons constaté que le simple fait de fermer les yeux
permettait d'améliorer la qualité des tracés, puisque cela limitait les pensées parasites. Nous
avons donc opté pour un enregistrement au cours duquel il fallait fermer les yeux, et les
instructions demandant de bouger le bras gauche ou le droit étaient dictées par une autre
personne. Finalement, nous avons effectué un enregistrement pour lequel les instructions
étaient de bouger la main gauche, ou la droite, afin de solliciter le moins de muscles possibles.
figure 14 : Prise de mesures EEG
Nous avons ensuite tenté d'exploiter des potentiels évoqués. L'expérience consistait à
afficher aléatoirement différentes lettres à l'écran, et il fallait compter le nombre d'apparitions
d'une lettre cible. On espérait ainsi observer un phénomène comparable aux P300.

3.4.2. Résultats des acquisitions EEG
La première difficulté pour exploiter nos enregistrements EEG a été de les synchroniser
avec les instructions données. Ainsi, au début de chaque acquisition, on demande de cligner
trois fois des yeux, ce qui a pour effet de produire un événement facilement détectable sur la
plupart des voies :
150
100
50
-5 0
1.4 1 .6 1 .8 2 2.2 2 .4 2.6 2 .8 3 3 .2
figure 15 : Trois clignements des yeux consécutifs
Les données obtenues sont sous forme ASCII, donc facilement exploitables avec
MATLAB. Nos mesures ont été effectuées avec une fréquence d'échantillonnage de 256 Hz,
avec un montage référentiel constitué de 19 voies (la vingtième voie étant utilisée comme
référence).
Le fichier contenant les données comportait l'heure d'enregistrement au début des lignes
correspondant à chaque nouvelle seconde, soit toutes les 256 lignes. Afin de pouvoir exploiter
ce fichier avec MATLAB, il a fallu supprimer ces affichages d'heures pour obtenir un fichier
ne contenant que les données, sans aucune autre information. Nous avons donc écrit un
programme en langage C uniquement afin de générer un fichier directement exploitable avec
MATLAB, puisqu'il aurait été extrêmement laborieux de modifier nous-mêmes le fichier
manuellement. En effet, ces fichiers de données sont relativement volumineux, puisqu'un
enregistrement de deux minutes correspond à environ 7 Mo (il faut donc utiliser des disques
durs de grande capacité si l'on souhaite stocker des enregistrements EEG, ce qui est le cas à
l'hôpital).

4. Traitement des signaux
Les signaux EEG utilisés dans les interfaces cerveau-machine sont traités dans deux
parties différentes. La première est la partie « hors ligne » qui consiste à traiter les signaux afin
de trouver des caractéristiques qui puissent déterminer au mieux les évènements que l'on
souhaite détecter dans l'EEG. La seconde partie est celle qui se passe « en ligne » où l'on
compare les caractéristiques des signaux à une base de données afin de choisir l'événement
auquel le signal se rapporte le mieux.
Dans les différentes études sur les BCI, plusieurs méthodes ont été utilisées pour
réaliser ces deux parties que ce soit dans le domaine du prétraitement du signal ou dans les
algorithmes de classification des événements.
4.1. Le prétraitement des signaux

Les signaux EEG acquis à partir de méthodes non-invasives sont très bruités, de plus ils
contiennent des artefacts, notamment ceux dus aux clignements des yeux qui augmentent
l'amplitude du signal. Afin d'extraire des caractéristiques intéressantes des signaux, il faut donc
mettre au point des méthodes qui permettent de réduire leur influence.
4.1.1. Filtrage
Pour éliminer le bruit, la méthode la plus utilisée est un filtre passe-bande dont les
fréquences de coupures sont déterminées selon les domaines de fréquence de l'activité
cérébrale. Les filtres linéaires sont aussi utilisés, notamment la moyenne glissante où
l'échantillon n du signal est remplacé par la moyenne de ses points voisins permettant ainsi de
lisser le signal.
figure 16 : Exemple de signaux filtrés

Une fois le signal filtré, il est en général rééchantillonné en accord avec la fréquence de
coupure du filtre afin de diminuer la taille des signaux.
4.1.2. Elimination des artefacts
Les mouvements des yeux ou des muscles peuvent provoquer des larges amplitudes du
signal EEG, afin de réduire l'effet de ces artefacts, on peut placer des bornes supérieures et
inférieures au signal, toute valeur au-dessus (resp. en-dessous) de la borne supérieure (resp.
inférieure) sera remplacée par la valeur de la borne. Les bornes sont déterminées à partir des
échantillons, on prend les valeurs telles que 10% des échantillons soient en dessous et 90% des
échantillons soient au-dessus. [HOFFMAN]
D'autres méthodes telles que l'analyse en composantes principales(ACP) et l'analyse en

composantes indépendantes (ACI) sont aussi utilisées pour éliminer les artefacts. En
considérant que les différentes activités du cerveau sont décrites par des signaux indépendants
entre eux, on peut retrouver ces signaux sources à l'aide de ces deux méthodes dans le signal
EEG qui est la représentation du mélange de ces différentes activités cérébrales.
L'ACP cherche à séparer le signal en sources non corrélées(en utilisant des statistiques
du deuxième ordre). Cette méthode utilise la matrice d'observation X (n*p) ,que l'on a centrée
et réduite afin de s'affranchir de l'hétérogénéité des variables tant en moyenne qu'en dispersion,
pour déterminer les composantes principales définies par C=XtV où V est la matrice des
vecteurs propres de XXt (matrice de corrélation entre les variables). Ces composantes
principales peuvent être considérées comme de nouvelles variables non corrélées entre elles.
L'ACI cherche à séparer le signal en sources indépendantes (en utilisant des statistiques
d'ordre supérieur). A partir de la matrice d'observation X, on cherche la matrice de mélange des
signaux A de façon à avoir X=A*Y et où les lignes de la matrice Y représentent les signaux qui
doivent être indépendants entre eux. Plusieurs algorithmes existent pour réaliser l'ACI,
notamment le fastICA qui après un blanchiment des données, maximise un contraste basé sur
la néguentropie et extrait les composantes indépendantes une à une
([KACHENOURA],[UNGUREANU]). La néguentropie est définie par la différence entre
l'entropie d'un vecteur x et de l'entropie d'un vecteur gaussien ayant la même matrice de
corrélation que x.[LAFAYE DE MICHEAUX]
J(x)=H(xgauss) – H(x) avec H(x)= −∫ px  x logpx  x dx
L'ACI est peu utilisée pour le moment dans les BCI, mais les quelques applications qui
en ont été faites, ont permis d'améliorer le taux de classification des évènements.
D'autres méthodes de traitement des signaux EEG existent pour détecter les activités
cérébrales, notamment pour les protocoles de détection des P300 où l'on peut utiliser la
connaissance des instants des stimuli qui engendrent les potentiels évoqués pour réhausser le
signal des P300 et estimer un sous-espace des signaux P300. [RIVET]

4.2. Caractéristiques des signaux
Un problème des BCI est de trouver des caractéristiques qui puissent déterminer le
mieux possible les évènements que l'on souhaite détecter. De plus, étant donné que l'on veut
réaliser la classification et la prise de décision de commande pour l'interface en temps réel, il
ne faut pas faire de choix regroupant trop de caractéristiques qui pourraient entraîner de trop
longs calculs et donc un décalage progressif du retour de la commande.
Par ailleurs, la quantité de données nécessaires pour décrire les différentes classes
d'évènements augmente rapidement avec la taille des vecteurs de caractéristiques, et il est
difficile d'avoir une quantité importante de données dans le domaine de la recherche sur les
BCI compte tenu du temps que cela demande pour les personnes. Il s'agit là d'un des problèmes
majeurs concernant les BCI du domaine de la recherche connu sous le nom de « malédiction de
la dimension » (« curse-of-dimensionality »). [LOTTE]
De nombreuses applications utilisent directement les données EEG pour réaliser leurs
classifications, notamment pour les systèmes P300 speller où pour diminuer la taille des
données on limite le nombre de voies du casque EEG utilisées (les électrodes les plus utilisées
se trouvant dans la zone pariétale ou centrale : Pz, Cz, ...).
4.3. Discrimination des signaux

Pour déterminer à quel type d'évènement le signal correspond, on utilise généralement
des algorithmes de classifications qui en utilisant des signaux de sessions d'apprentissage dans
la partie « hors ligne » créent des classes pour chaque évènement et qui dans la partie « en
ligne » déterminent un coefficient d'appartenance aux différentes classes selon les données
qu'on lui présente en entrée. De nombreux types de classifications sont utilisés dans la
recherche sur les BCI que l'on peut regrouper en différentes catégories : les classificateurs
linéaires, les classificateurs non-linéaires, les réseaux de neurones. [LOTTE]
4.3.1. Les classificateurs linéaires
Les classificateurs linéaires sont les algorithmes les plus utilisés pour les BCI, ils
permettent de distinguer des classes en utilisant des fonctions linéaires.
4.3.1.1. L'analyse discriminante linéaire (LDA)
L'analyse discriminante linéaire doit permettre de déterminer à quelle classe appartient

un évènement à partir d'une mesure, il s'agit donc de trouver les probabilités conditionnelles :
P(Y=i | X= x 0 ) avec i∈[1, g ] où g est le nombre de classes
En utilisant le théorème de Bayes :
P(A|B)=P(B|A)P(A)/P(B),
on obtient :
f  x 0⋮y=i P Y =i
P(Y=i | X= x 0 )= i∈[1, g ]
f  x0 

−1 t −1
exp  x −mi  . K . x−mi 
où 2
f  x 0⋮y=i=
 2∗ pin /2 . det  K  x ∈ℝn
La probabilité P(Y=i) est la probabilité a priori de la classe i. Les moyennes mi et la

matrice de covariance K symétrique sont estimées à partir des données par :
1 où n i est le nombre d'observations de la classe i

mi = ∑X
ni j ∈ I j
I l'ensemble des numéros d'observations qui sont dans la classe i
g
1
K= ∑ ∑
n i =1 j∈ I
 X j−mi X j−mit
La discrimination à une classe est donnée par :
argmax i∈[1, g ] P Y =i⋮X =x 0 
Et les droites séparant les classes sont déterminées par les relations d'égalités entre les
probabilités conditionnelles :
P(Y=i | X= x 0 )= P(Y=j | X= x 0 )
Cette méthode d'analyse discriminante est basée sur les différences entre les moyennes
et les variances des classes. Pour avoir de bons résultats, il faut que les lois que suivent les
données des différentes classes aient des paramètres distincts, sinon les probabilités
conditionnelles P(Y=i | X= x 0 ) auraient sensiblement la même valeur, d'autant plus que les
probabilités a priori des différentes classes P(Y=i) sont généralement égales.
figure 17 : Hyperplan séparant deux classes

[LOTTE]

En pratique, dans les BCI, on utilise un algorithme qui détermine le vecteur qui sépare
les classes en maximisant la distance entre les moyennes des deux classes et en minimisant leur
variance. On cherche à maximiser le critère suivant :
wt S b w
J w=
wt S w w
où S b=m1−m2 m1−m2t représente la distance entre les moyennes

2
S w =∑ ∑  x j −mi  x j−mi t représente la dispersion des données
i =1 j∈ I
1
mi = ∑X
ni j ∈ I j
La solution optimale à ce problème est donnée par :
w=S −1
w  m1−m 2 
Un des problèmes de cette méthode est que si le nombre de caractéristiques devient plus
important que le nombre d'échantillons utilisés pour l'apprentissage, la matrice Sw n'est plus
régulière et donc son inverse n'est plus définie, il faut alors la remplacer par sa pseudo-inverse.
[HOFFMAN]
Lorsque l'hyperplan qui sépare les classes est déterminé, on peut faire la classification
des données en regardant le signe du produit scalaire entre w et le vecteur de données. Lorsque
l'on utilise cette méthode pour des BCI multiclasses, on applique la stratégie « One Versus the
Rest »(OVR) pour déterminer chaque hyperplan séparant une classe de toutes les autres.
Pour améliorer les performances des LDA, on peut introduire un paramètre de

régularisation C qui pourra permettre d'autoriser ou de pénaliser les erreurs de classifications
sur la base d'apprentissage rendant la méthode plus robuste aux artefacts.
La méthode d'analyse discriminante linéaire est utilisée dans de nombreuses

applications de BCI car elle est simple à mettre en œuvre et elle donne de bons résultats, de
plus, elle nécessite peu de ressources informatiques ce qui la rend intéressante pour les
systèmes en ligne.
4.3.1.2. Séparateurs à vastes marges (Support Vector Machines)
Tout comme l'analyse discriminante linéaire, les séparateurs à vastes marges cherchent
un hyperplan séparant les classes, mais ici, cet hyperplan doit aussi maximiser la distance avec
les points les plus proches de chaque classe.

figure 18 : Hyperplan optimal à l'aide d'un SVM
[LOTTE]
On peut par exemple chercher un hyperplan tel que :
min |<w;x> -  | =1 pour x appartenant à la base d'apprentissage
On a alors la plus petite disance d'un point x k à l'hyperplan d'équation :

<w;x> - lambda=0 est définie par 1/||w||; et si l'on prend comme marqueur des deux classes
y k =±1 , on a la relation suivante : yk (< w ; xk > −  ) ≥ +1, ∀k ∈ {1, . . . , n} qui
détermine la position par rapport à l'hyperplan selon la classe.
On doit alors maximiser la marge 1/||w||, ce qui revient à minimiser ||w||^2/2 sous la
contrainte : yk (< w ; xk > −0) ≥ +1, ∀k ∈ {1, . . . , n}. On doit alors chercher un point selle du
n
Lagrangien : L(w,  ,  )=||w||^2/2- ∑ k  y k 〈 w∣x k 〉 − −1 où alpha représente les
k =1
coefficients de Lagrange.
Après résolution, on a l'équation de l'hyperplan [ABDALLAH] :

n
〈 w∣ x 〉−= ∑ k y k 〈 x∣x k 〉−
k =1
Cette méthode est valable lorsque les classes sont linéairement séparables, si ce n'est
pas le cas, on peut utiliser les SVM non linéaires en employant une fonction Φ qui transforme
les données afin de pouvoir appliquer les méthodes linéaires. On a alors :
〈 x∣x k 〉 〈  x ∣ x k 〉=K  x , x k 
où K  x , x k  est un noyau reproduisant (kernel function).
Pour les SVM non linéaires utilisés dans le domaine des BCI, on emploie généralement
un kernel gaussien : K(x,y)=exp(-||x-y||^2/(2*sigma)) .
Comme pour l'analyse discriminante linéaire, on utilise la stratégie OVR pour les
applications multiclasses. Les séparateurs à vastes marges sont eux aussi fortement utilisés
pour les BCI avec de bons résultats.

Pour améliorer les performances des SVM, on peut aussi introduire un paramètre de
régularisation comme dans les LDA, de plus les SVM sont moins sensibles que d'autres
méthodes au problème de la « malédiction de la dimension ». [LOTTE]
4.3.2. Les classificateurs non-linéaires
4.3.2.1. La distance de Mahalanobis
La distance de Mahalanobis est un classificateur qui détermine les paramètres ( i ,

 i ) de la distribution gaussienne de chaque classe i pour en faire un « modèle ». Ensuite, on
fait la discrimination du vecteur X de caractéristique de l'évènement en cherchant le modèle le
plus proche selon la distance de Mahalanobis qui est définie par :
d i  X =  X −i  −1
i  X − i 
t
La distance de Mahalanobis convient bien pour les problèmes multiclasses et elle donne
de bons résultats, cependant elle est peu utilisée dans les applications sur les BCI.
4.3.2.2. Les k-plus proches voisins
Cette méthode consiste à déterminer dans la base d'apprentissage les k vecteurs les plus
proches du vecteur X de caractéristiques que l'on souhaite classer en calculant les distances
entre eux, puis lorsque ces k éléments sont trouvés, on affecte le vecteur X à une classe en
fonction de l'appartenance de ces k points.
Cette technique est peu utilisée dans la recherche sur les BCI car elle est sensible au
problème de la « malédiction de la dimension », mais elle est efficace pour les vecteurs de
caractéristiques de faible dimension [LOTTE].
4.3.3. Les réseaux de neurones
Les réseaux de neurones sont des outils qui sont fréquemment utilisés dans le domaine
de la classification automatique. Un neurone réalise une fonction de transfert entre ses entrées
et la sortie dont la valeur dépend de paramètres appelés poids. Les réseaux de neurones se
caractérisent par leur architecture : nombre de neurones, nombres de couches, agencement des
neurones les uns par rapport aux autres, ainsi que par les fonctions utilisées.
x1
a1
x2 a2
S n F y
a3
x3
b
figure 19 : Neurone à entrées multiples

Un neurone à entrées multiples transfert les informations d'entrée x i au travers d'un
sommateur S et d'une fonction F linéaire ou non. Le paramètre b est le biais permettant de
décaler le signal n. La sortie y est alors définie par :
3
y=F  ∑ a i x ib 
1
A partir de neurones, on peut construire des réseaux mono-couche qui comportent

plusieurs neurones qui sont reliés aux mêmes entrées; ou des réseaux multicouches où les
neurones sont reliés à la sortie des neurones de la couche précédente.
S F y1
b21
x1 S F
S F y2
x2 b11
x3 S b22
F
S F y3
b12
b23
figure 20 : Réseau de neurones multi-couches
Pour faire de la classification à l'aide des réseaux de neurones, il faut déterminer les
paramètres A et b afin d'optimiser le critère :
N
=∑  y m , k − y k 2
k=1
où ym,k est la k-ième composante de la sortie mesurée,

yk est la k-ième sortie du réseau et est fonction de F,A,b et des entrées xi
Pour les BCI, les x i représentent les vecteurs de caractéristiques et les y m ,k

correspondent aux numéros de la classe. Les sessions d'apprentissage « hors ligne » permettent
de déterminer les poids A et b, puis lors de la partie « en ligne », la présentation d'un vecteur de
caractéristique en entrée du réseau de neurones va donner en sortie la classe à laquelle il se
rapporte.
Les différences des réseaux de neurones proviennent des fonctions F choisies. Les
réseaux les plus répandus dans le domaine des BCI sont les MultiLayer Perceptron (MLP) où
un perceptron est un neurone multi-entrées dans lequel on utilise une fonction à commutation:
y=0 si AX+b<0 ou y=1 si AX+b>=0

Un perceptron seul est équivalent à faire une discrimination linéaire.
Parmi les autres réseaux de neurones que l'on peut trouver dans les BCI, il y a ceux
utilisant des fonctions de discrimination gaussienne ainsi que d'autres architectures de réseaux
dont l'utilisation dans ce domaine est plus rare [LOTTE].
4.3.4. Système d'inférence flou
Les algorithmes de classification dans les BCI sont dominés par les méthodes utilisant
les LDA, les SVM ou les MLP et chacun de ces procédés marche bien. Mais des techniques
pas utilisées ou très peu apparaissent pour la conception des interfaces cerveau-machines,
notamment les systèmes à inférence floue qui consistent à déterminer des règles d'appartenance
« si-alors » floues. Le principe est de diviser les données de chaque classe en paquets
(« clusters »), puis pour chacun de ces groupes, on génère la règle floue :
Si X1 est Aj1 et si X2 est Aj2 et ... alors la classe est Ci
où Xk est la k-ième composante du vecteur de caractéristiques et Ajk est une fonction
d'appartenance floue gaussienne décrivant la forme du groupe :
−1 X k − x jk
2
A jk  X k =exp   
2  jk
avec xjk le k-ième élément représentant le centre du groupe et σjk une constante positive
Les paramètres de cette fonction d'appartenance sont ensuite optimisés à l'aide d'une
méthode de la descente du gradient sur une mesure de l'erreur de classification.[OPEN VIBE]
Dans certaines études des BCI, des combinaisons de classifications sont utilisées afin
d'essayer d'améliorer le taux d'éléments bien classés. On considère qu'une méthode donne de
bons résultats si son taux de bien classés atteint les 80%.
4.4. Etude expérimentale

Au travers des différentes mesures EEG que nous avons effectuées, nous avons essayé
de détecter des évènements dans les signaux, notamment ceux dus aux clignements des yeux.
Pour cela, nous avons utilisé plusieurs méthodes.
4.4.1. Approximation fonctionnelle d'un clignement d'oeil
Le signal dû à un clignement d'oeil est facilement repérable dans les mesure EEG, donc
on peut isoler cette partie du signal et en faire un modèle pour ensuite repérer tous les autres
signaux similaires par corrélation au modèle.
Pour cela, on cherche à approximer le vecteur des données s correspondant à un clignement
n
P t k =∑ ai .t k
i
d'oeil par un polynôme P de degré n :
i =0

Notons A le vecteur contenant les coefficients ai du polynôme P et X la matrice définie par :
[ ]
1 t 1 t 12 ⋯ t 1 n
1 t 2 t 22 t 2n
X= ⋮ ⋮ , les valeurs de s ayant été mesurées aux instants t1, t2,..., tP.
⋮ ⋮
1 t P tP ⋯ tPn
2
On cherche donc à écrire P = X.A.
Notons E le vecteur des différences : E = s – X.A.

L'estimation de A est obtenue en minimisant, par rapport à A, le critère des moindres carrés
1 1 1 1
J = .∣∣s−X.A∣ ∣2= . E T . E= . s – X.AT . s – X.A= . s sT −s T XA−AT X T s AT X T XA
2 2 2 2
dJ dJ 1 T T
Le minimum de J correspond donc à =0 , soit = .−2 X s2 X XA=0
dA dA 2
d'où : X T s=X T XA , c'est-à-dire A= X T X −1 X T s
On en déduit finalement le modèle polynomial prédit : P= X A= X  X T X −1 X T s
figure 21 : Approximation par un polynôme
On utilise ensuite ce modèle polynomial pour calculer la corrélation avec les différentes
voies en se plaçant sur plusieurs échelles temporelles. Une corrélation importante indiquera
qu'un clignement d'oeil a eu lieu sur l'échelle temporelle correspondante.

150
100
50
-5 0
1 .4 1 .6 1 .8 2 2 .2 2 .4 2 .6 2 .8 3 3 .2
figure 22 : Signal représentant les trois clignements des yeux
En effectuant des tests sur le signal avec 3 clignements d'oeil, on a les résultats suivant :
voie Fp2 F4 C4 P4 O2 F8 T4 T6 Fz Cz Pz Fp1 F3 C3 P3 O1 F7 T3 T5

n° 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
Sur une recherche d'une corrélation supérieure à 0,98 :

On détecte le pic 1 sur les voies 1, 3, 4, 5, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19.
On détecte le pic 2 sur les voies 1, 2, 9.
Aucune fausse détection.
Sur une recherche d'une corrélation supérieure à 0,95 :

On détecte le pic 1 sur toutes les voies sauf la 6.
On détecte le pic 2 sur toutes les voies sauf la 6 et la 17.
On détecte le pic 3 sur les voies 1, 9, 12, 13.
On a aussi la détection d'artefacts : 8 artefacts sur la voie 1,
1 sur les 2, 5, 13, 16 et 18,
2 sur les 3, 4, 8, 9, 11, 15 et 19 ,
3 sur les 10 et 14,
4 sur la 12
La méthode qui consiste à corréler les mesures des électrodes à un modèle n'est pas
utilisée dans le domaine de la BCI, car généralement, on cherche à détecter d'autres
évènements que les clignements des yeux, et déterminer un modèle de P300 par exemple est
très difficile compte tenu du fait que ce type de potentiel peut varier selon le temps et la
concentration de la personne qui effectue l'expérience.

4.4.2. Détection par seuil
Le signal dû aux clignements des yeux est généralement de plus forte amplitude que les
signaux dus à d'autres activités. De ce fait, on peut mettre en place un programme qui compare
la valeur de l'amplitude du signal à un seuil que l'on a fixé à partir de l'observation de mesures
de clignement d'oeil.
En plaçant un seuil à 100 μV sur le même signal que la partie précédente, on arrive à
détecter les trois pics des clignements sur plusieurs voies, et on n'a aucune fausse détection.
On détecte le pic 1 sur les voies 1, 3, 4, 5, 7, 8, 10, 11, 12, 14, 15, 18, 19.
On détecte le pic 2 sur les voies 1, 5, 7, 8, 7, 8, 11, 18, 19.
On détecte le pic 3 sur les voies 1, 3, 4, 5, 7, 8, 10, 11, 12, 15, 18, 19.
Cette technique de seuil est aussi peu utilisée dans les interfaces cerveau-machines car
les potentiels que l'on cherche à extraire ont généralement une faible amplitude qui peut varier
selon les sessions d'acquisition des signaux et selon la présence du bruit dans le signal. Cette
méthode donnerait donc pour des signaux autres que les clignements des yeux (qui ont une
forte amplitude) de nombreuses fausses et/ou non détections.
4.4.3. Analyse discriminante linéaire
Une autre méthode que nous avons utilisé pour détecter le clignement des yeux est
l'analyse discriminante linéaire, une méthode qui est largement utilisée dans le domaine des
BCI. A partir d'une base d'apprentissage composée de dix clignements des yeux, nous avons
déterminé les échantillons correspondant aux différents évènements que l'on voulait détecter.
Puis, à l'aide du logiciel Matlab, nous avons fait la classification d'une session de mesures ( qui
doit aussi comporter dix clignements des yeux ) à partir des données de la base d'apprentissage.
figure 23 : Signal de la base d'apprentissage

On s'aperçoit que l'on a bien détecté les dix clignements des yeux, cependant, nous avons aussi
quatre fausses détections qui se traduisent par un pic rouge de plus faible largeur que les
bonnes détections.
figure 24 : Détection des clignements des yeux
L'analyse discriminante linéaire utilise les caractéristiques telles que la moyenne et la

variance pour faire la classification d'un échantillon. Donc, si l'amplitude du signal que l'on
cherche à classer est modifiée, on risque de ne pas détecter les évènements ou de faire des
fausses détections.
figure 25 : Influence de l'amplitude du signal (a)

On s'aperçoit que le signal multiplié par un facteur 1,2 présente plus de fausses
détections. Si on diminue le facteur, on commence à faire disparaître les fausses détections,
puis on perd la détectabilité des évènements de plus petite amplitude et enfin on ne détecte plus
aucun événement.
figure 26 : Influence de l'amplitude du signal (b)
Ce problème de facteur d'échelle de l'amplitude dépend aussi du signal de la base

d'apprentissage.
L'un des problèmes des signaux EEG qui peut affecter la qualité de détection des
évènements est le bruit. Plus le rapport signal sur bruit diminue, plus le nombre de fausses
détections augmente.
figure 27 : Détection dans un signal bruité

Durant ce projet, nous avons aussi essayé de mettre en place des algorithmes de
classification pour détecter des P300. Pour réaliser cela, nous avons utilisé un protocole qui
demandait au patient de compter les lettres C qui apparaîssaient à l'écran. Après avoir fait un
moyennage sur l'ensemble des fenêtres d'observations (d'une durée d'environ 600 ms ) prises
après le déclenchement d'un stimulus cible (apparition de la lettre C) et un autre moyennage
sur l'ensemble des fenêtres suivant un stimulus non cible, nous avons essayé de voir si nous
pouvions extraire quelques caractéristiques différentes entre les deux moyennes.
Nous avons pu voir que pour les échantillons se situant aux alentours de 300 ms après
le stimulus, les valeurs des amplitudes des signaux sur certaines électrodes étaient différentes,
notamment sur Cz, Pz, P3, P4, C3, C4. Cependant, lorsque nous avons essayé d'utiliser ces
points pour faire des algorithmes de classifications tels que des réseaux de neurones ou des
méthodes d'analyse discriminante linéaire, nous avons eu de mauvais résultats. Sur un
ensemble de cent stimuli dont seize étaient cibles, nous avons eu très peu de bonnes détections
et beaucoup de fausses détections. La cause de ces mauvais résultats est notamment due au fait
que le signal de chaque fenêtre d'observation d'un stimulus cible ou non est bruité, qu'il
contient des artefacts et qu'il varie entre deux fenêtres d'observation. Ainsi, les caractéristiques
que l'on a choisies sur les moyennes peuvent fortement varier selon les différentes périodes
d'observations.
figure 28 : Moyenne des stimuli cibles (bleu) et moyenne des stimuli non cibles (rouge) sur la
voie P4

figure 29 : Moyenne des stimuli cibles (bleu) avec les signaux des deux premiers stimuli cibles
sur la voie P4
On voit donc que faire une classification des potentiels P300 à l'aide d'une seule fenêtre
d'observation ne donnera que très peu de bons résultats compte tenu de la différence entre les
caractéristiques des signaux. Il faudrait plutôt utiliser une moyenne de plusieurs fenêtres
d'observations afin d'enlever le bruit en faisant un moyennage, ce qui permettrait de faire une
meilleure classification, comme c'est le cas dans certaines BCI utilisant le protocole du « P300
speller » qui atteignent un taux de bien classé de 100% après 4,5 ou 6 répétitions du stimulus
cible [LOTTE].Cependant, pour cela il faut une plus grande quantité de signaux résultants des
stimuli cibles que celle dont nous disposons.

5. Interface graphique
5.1. Présentation
Une fois que l'on sait récupérer un signal EEG et l'analyser, il reste à l'utiliser pour créer
toutes les applications voulues. J'ai été chargé d'étudier la mise en œuvre d'une interface
graphique qui interagit avec l'utilisateur en réceptionnant les signaux de son cerveau et en lui
retournant des informations à l'écran.
Le programme gérant l'interface graphique doit pouvoir récupérer le signal traité par
Matlab et réagir à ce signal. Il doit également gérer le temps en se synchronisant avec la prise
de mesures. Pour des applications qui doivent réagir rapidement aux signaux de l'utilisateur
telles qu'une machine à écrire virtuelle, cette gestion du temps est primordiale au bon
fonctionnement du programme. Dans l'idéal, la prise de mesures, le traitement de celles-ci et
leur utilisation doivent se faire en temps réel. Dans un premier temps et pour des raisons de
simplicité, il est possible d'effectuer du temps décalé en stockant les mesures dans un buffer.
Cela ne sera pas visible pour l'utilisateur et permettra tout de même de détecter les événements
à temps : si la période d'échantillonnage est faible (4ms), l'apparition d'un signal est plus lente
(par exemple un P300 survient 300ms après un stimulus visuel). Ceci nous offre une plus
grande souplesse vis à vis du temps.
Les programmes que nous pouvons réaliser sont variés et peuvent soit invoquer des
potentiels évoqués (par exemple un logiciel d'écriture de texte) ou des stimuli intérieurs (par
exemple un jeu de ping pong). Il est également possible de créer des programmes uniquement
destinés à étudier les signaux EEG mais qui ne les utilisent pas à proprement parler. On peut si
besoin écrire dans un fichier les actions réalisées durant le déroulement du programme.
Nous avons décidé de ne pas nous soucier du temps réel dans le projet (mais en
n'excluant pas son utilisation à terme). De plus, nos applications ne pouvaient être testées
durant une prise de mesures. Elles ont donc été réalisées dans le but d'utiliser des signaux
enregistrés dans un fichier ASCII. Nous avons cependant essayé de faire en sorte que les
programmes puissent facilement être modifiés pour être utilisés en direct. La principale
difficulté restante est la communication avec Matlab. Nous verrons plus loin comment cette
communication peut être réalisée.
Le schéma suivant montre les liens entre le programme gérant l'interface graphique et
les différentes parties du système dans le cas ou le programme appelle la machine Matlab :
Utilisateur Acquisition Stocke Buffers
Lit Ecrit dans des fichiers

Appelle
Synchronise Programme Matlab
Renvoie
Met en place
Interface
graphique
figure 30 : Diagramme du programme gérant l'interface graphique

5.2. Choix du matériel utilisé
5.2.1 Choix du système d'exploitation
Le choix de l'OS est très important lorsque les applications à réaliser ont des contraintes
de temps. Ainsi, si l'on souhaite effectuer du temps réel, il faudrait utiliser un OS temps réel tel
que QNX.
Cependant, nous avions convenu de laisser de coté cette partie et de se limiter à du temps
différé. Nous avons donc plus de souplesse au niveau de l'OS. Le choix s'est donc porté sur un
linux tel que Ubuntu, ou sur Windows. Bien que les performances puissent être meilleures sur
un linux, nous avons choisi d'utiliser Windows que nous connaissons plus et qui est déjà
installé sur nos machines personnelles.
5.2.2 Choix du langage de programmation
De nombreux langages permettant de réaliser une interface graphique sont disponibles.
Matlab : Il est possible de réaliser une interface graphique en Matlab. L’avantage serait
alors de pouvoir effectuer le traitement des données et l’interface graphique dans le même
langage. Cependant les possibilités offertes par cette interface sont limitées. On ne pourra
réaliser de clavier virtuel avec ce langage par exemple.
Intouch : on pourrait utiliser un logiciel de supervision comme Intouch pour récupérer

les données et réaliser une interface. Mais cette option empêche le traitement des données par
Matlab (incompatibilité des licences). Il faudrait alors utiliser un autre langage pour traiter le
signal.
Java : Java est un langage de haut niveau puissant. De plus il est très simple de réaliser
des interfaces graphiques évoluées grâce aux composants swing. Cette option est donc la plus
facile à mettre en œuvre. Cependant, il est possible que Java devienne trop limité lorsqu’il
s’agira de prendre les mesures en temps réel.
C : Le C est un langage de bas niveau, il permet de tout faire au prix d’une

programmation plus compliquée. Il gère notamment le temps réel et permet de réaliser une
interface graphique grâce à des librairies graphiques. Cependant ces interfaces graphiques sont
généralement de bas niveau et toutes les fonctions désirées doivent être créées par le
programmeur.
C++ : Le langage C++ est une amélioration du C. Ce langage est aussi puissant que le C
avec en plus les avantages de la programmation orientée objet comme Java. Il existe en C++
des librairies graphiques offrant les même possibilités qu’en Java et donc simple à mettre en
œuvre que le C.

Même si dans un premier temps nous ne réaliserons pas de prises de mesures en temps
réel, j’ai choisi de programmer mes interfaces graphiques en C pour permettre de pouvoir
passer plus facilement à un programme temps réel par la suite. De plus le C étant un langage
que je souhaite maîtriser, ce choix me permettra de me performer dans ce langage. Etant encore
en apprentissage du langage C, j’ai choisi de ne pas développer le programme en C++ qui
nécessite la connaissance du C.
Le choix du langage C implique que je devrai entièrement coder mon interface
graphique grâce à une bibliothèque graphique choisie parmi toutes celles existantes.
5.2.3 Choix de la librairie graphique
Après avoir choisi le langage C, j’ai dû sélectionner une bibliothèque me permettant de

réaliser des interfaces graphiques adaptées au projet. De nombreuses bibliothèques graphiques
sont proposées mais la plupart exigent de programmer en C++. Il reste peu de bibliothèques
destinées au C gratuites et performantes. Parmi-elles nous avons :
-GTK+ et l’API win32 : ces bibliothèques performantes permettent de réaliser les

fenêtres usuelles avec par exemple des boutons, des zones de textes ou des menus. Elles
possèdent donc des fonctions de haut niveau qui les rendent faciles à utiliser. Mais cela les
rend moins polyvalentes. De plus l’API win32 n’est utilisable que sur windows.
-SDL : cette bibliothèque est de bas niveau, d’un point de vue graphique elle permet de
modifier la valeur d’un pixel, de tracer des rectangles et d’y inclure des images ! Il faut ensuite
programmer les fonctions plus élaborées. Mais la SDL n’est pas que graphique, elle permet
entre autre de gérer les événements (clavier et souris par exemple) ou des timers. Elle reste
simple d’utilisation.
-openGL et direct X : ces bibliothèques de bas niveau sont les plus performantes, elles
sont optimisées pour les cartes graphiques et permettent de gérer efficacement la 3D. Elles sont
peut être trop élaborées pour l’interface graphique que j’ai à réaliser. Direct X, comme l’API
win32, n’est utilisable que sur windows.
J’ai choisi d’utiliser la SDL qui est une bibliothèque de bas niveau (donc plus
polyvalente et plus rapide) simple et suffisamment complète pour réaliser mes interfaces
graphiques. Elle est également portable et les programmes pourront alors facilement être
adaptés sous un système UNIX. Les fichiers nécessaires au fonctionnement de la SDL peuvent
être téléchargés sur Internet [LIBSDL] et de nombreux tutoriels existent [TUTO,
DEVELOPPEZ]

5.3. La communication avec Matlab
Un des points importants de l’interface graphique est de pouvoir communiquer avec le
programme Matlab pour prendre dans l’idéal les données traitées en temps réel.
Il existe plusieurs moyens de réaliser cette communication. Matlab propose en effet
plusieurs fonctions pour communiquer avec du C. J’ai cependant eu de nombreux problèmes
pour parvenir à les faire fonctionner.
A défaut de parvenir rapidement à communiquer avec Matlab, j’ai dans un premier lieu
opté pour une méthode simple mais peu efficace : la communication par fichiers. Matlab écrit
ses résultats dans un fichier que le programme C lit. Cette solution s’est révélée suffisante pour
les premières applications mais ne pourrait être utilisée en direct lors d’une prise de mesures
puisque le programme C ne peut lire le fichier quand Matlab y écrit. On pourrait contourner le
problème en demandant à Matlab de sauvegarder les mesures par séquences d’une dizaine de
points avant de changer de fichier. Le programme C pourrait alors lire les fichiers un à un en
décalé. Cette solution reste assez lourde et limitée. Il faut donc se pencher sur les autres
moyens de communication que propose Matlab.
Il est possible d’utiliser le compilateur Matlab mcc pour compiler le code Matlab
directement en code C. L’avantage serait alors de pouvoir tout effectuer (traitement et
affichage) dans un seul et unique programme en C. Je n’ai cependant pas réussi à réaliser cette
fonction malgré l’aide de Matlab.
Il est également possible d’appeler la machine Matlab depuis C grâce à l’outil mex.
Cette option est simple d’utilisation (une fois celle-ci assimilée !) et est performante.
La principale utilisation de l’outil mex est de créer des MEX-files à partir de routines
écrites en C ou fortran. Les MEX-files permettent d’appeler du code C dans Matlab. Mais mex
permet aussi de réaliser l’inverse : compiler un programme C qui appelle la machine Matlab.
Mex n’est pas en lui-même un compilateur. Il appelle un compilateur qui par défaut est lcc
sous windows. Il faut indiquer à l’outil mex quelle action réaliser avec quel compilateur. Pour
cela on utilise un fichier .bat. On trouve ces fichiers dans le répertoire
‘$MATLAB\bin\win32\mexopts\’.
Pour indiquer que l’on veut compiler un programme C appelant Matlab avec le
compilateur lcc il faut donner le fichier ‘lccengmatopts.bat’. On compile alors sous Matlab
grâce à la commande :
mex -f $MATLAB\bin\win32\mexopts\lccengmatopts.bat programme.c
Pour pouvoir appeler la machine Matlab, le programme C doit avoir une forme
spécifique. Tout d’abord, il faut penser à définir les includes suivants au préprocesseur :
- ''engine.h'' pour manipuler la machine Matlab elle-même.
- <windows.h> pour l’utiliser sous windows.
Sous Windows, il faut également changer la fonction main en WinMain qui a la forme
suivante :

int PASCAL WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpszCmdLine, int nCmdShow){ //le programme}
La machine Matlab doit être déclarée comme une variable de type Engine (On déclare
en fait un pointeur 'ep' vers cette variable).
L’ouverture de la machine se fait par la fonction : ep = engOpen(NULL); qui renvoie 0
en cas de problème.
On ferme la machine grâce à la fonction : engClose(ep);
Il existe ensuite plusieurs fonctions que l’on peut utiliser pour communiquer entre C et
la machine Matlab. Citons entre autres :
-engPutVariable(ep, "T", t);=> met la variable t du programme C dans la variable T de
la machine Matlab
-engEvalString(ep, "commande Matlab;"); => exécute la commande dans la machine
Matlab
-t =engGetVariable(ep,"T"); prend la variable T de la machine Matlab.
Pour manipuler les variables dans le programme C, il faut déclarer des variables dédiées
à la communication avec Matlab par exemple de type mxArray pour un tableau et utiliser les
fonctions mx comme :
-mxCreateDoubleMatrix => crée une matrice renvoyée dans un mxArray.
-mxGetPr(T); =>renvoie la partie réelle de T dans un double ou tableau de double.
On utilise la fonction memcpy() ; pour remplir les valeurs d’un mxArray à partir d’un
tableau d’entiers.
On peut maintenant facilement créer un mxArray de 10 points par exemple, l’envoyer à

la machine Matlab pour traitement, et tracer dans le programme C le résultat obtenu. Reste à
savoir de combien de points l’algorithme Matlab a besoin pour être efficace.
Il reste cependant un problème de taille sachant que nous voulons créer une interface
graphique : peut-on lancer la SDL en même temps que la machine Matlab ? A priori il suffit de
rassembler les deux dans le même programme C, et d’ajouter les bibliothèques de la SDL à la
commande mex.
Malheureusement, cela ne fonctionne pas ! Il m’a fallu de nombreux essais pour me
convaincre que le problème venait du compilateur lcc utilisé par Matlab. En effet sur le site de
la SDL il n’existe pour Windows que des bibliothèques pour le compilateur de Visual C++ et
de mingw (utilisé par mon IDE Code::Blocs). J’ai donc cherché à utiliser le compilateur
mingw mais Matlab ne le prend pas en charge !
Par chance il existe un logiciel libre : gnumex [GNUMEX], qui permet de créer des
fichiers .bat à entrer en option de l’outil mex. J’ai donc pu créer un fichier 'mexmingwopts.bat'
qui demande à l’outil mex de compiler grâce à mingw des programmes C appelant la machine
Matlab. Il suffit maintenant d’ajouter les bibliothèques de la SDL pour le compilateur mingw
et la compilation fonctionne !

On utilise alors la commande :
mex -f mexmingwopts.bat test3.c libSDLmain.a libSDL.dll.a SDL_ttf.lib
Il est maintenant possible de créer des interfaces graphiques appelant la machine

Matlab.
5.4. Les programmes réalisés

5.4.1 Mise en place de la SDL
La SDL est une librairie graphique de bas niveau, c'est-à-dire qu’elle ne possède pas de
fonctions élaborées telles que tracer un graphe. Il faudra donc coder les fonctionnalités
recherchées à partir des fonctions de bases. Par exemple pour réaliser un graphe il faut tracer
une droite entre tous les points consécutifs du graphe, et pour tracer une droite, modifier un à
un tous les pixels entre les deux points.
Nous utiliserons également d’autres fonctions de la SDL pour gérer les événements
souris et clavier et pour gérer les temps grâce à des timers. Nous utiliserons également une
extension de la bibliothèque permettant d’écrire du texte pour donner les valeurs maximales et
minimales des graphes par exemple.
Nous allons maintenant voir les points importants pour utiliser la SDL et réaliser notre
programme. Avant toute chose nous réalisons les includes suivants au préprocesseur :
#include <SDL/SDL.h> // contient les fonctions SDL
#include <SDL/SDL_ttf.h> //contient les fonctions texte
Création de la fenêtre :
On commence par charger la SDL en sélectionnant les options dont nous aurons besoin.
Ici nous chargeons les systèmes d’affichage et de timers :
SDL_Init(SDL_INIT_VIDEO| SDL_INIT_TIMER);
Il faudra à la fin du programme quitter la SDL par la fonction : SDL_Quit();
Pour Créer la fenêtre on va ensuite utiliser une surface SDL qui correspondra à l'écran
de fond du programme.
Pour cela on déclare un pointeur sur une surface : SDL_Surface *ecran;
Il est possible d'effectuer cette déclaration publiquement dans un fichier .h pour pouvoir
utiliser cet écran dans toutes les fonctions qui utilisent notre interface.
On peut ensuite choisir le mode vidéo de notre fenêtre en donnant : sa taille en pixels, le
nombre de bits par pixels pour les couleurs ainsi que différentes options. Ici nous indiquons
que nous chargeons les données dans une mémoire plus rapide, nous améliorons l’effet visuel
de l’affichage grâce au Double Buffering et nous mettons la fenêtre en plein écran :

ecran = SDL_SetVideoMode(1024, 768, 32, SDL_HWSURFACE| SDL_DOUBLEBUF|
SDL_FULLSCREEN );
Il faut ensuite colorier la fenêtre à la couleur désirée. Ici du blanc :

SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
Pour finir on met à jour l’affichage à l’écran. En effet toutes les modifications
précédentes ont été effectuées en mémoire uniquement. Il faut maintenant les afficher. Il faudra
faire la même opération à chaque modification de la fenêtre : SDL_Flip(ecran);
Création d’une surface :

Pour créer une surface supplémentaire il faut déclarer cette surface de la même façon
que ‘ecran’ : SDL_Surface *curseur=NULL;
On peut ensuite soit charger une image dans la surface :
curseur=SDL_LoadBMP("curseur.bmp");
Soit donner une couleur unie à la surface. Pour cela il faut allouer la surface en
mémoire en donnant l’option de gestion de la mémoire (rapide ou lente mais plus importante)
sa taille et le nombre de bits par pixels pour les couleurs.
surface=SDL_CreateRGBSurface(SDL_HWSURFACE, 220, 180, 32, 0, 0, 0, 0);
On colorie ensuite la surface comme pour l’écran avec SDL_FillRect
Pour donner la position de la surface dans l’écran, on définit une variable de type
SDL_Rect qui contient l’abscisse et l’ordonnée de la surface :
SDL_Rect position_curseur;
position_curseur.x=470;
position_curseur.y=50;
On peut alors coller la surface sur ‘ecran’:
SDL_BlitSurface(curseur, NULL, ecran, &position_curseur);

Et pour finir on actualise l’affichage : SDL_Flip(ecran);
En terminant le programme, il ne faut pas oublier de libérer la mémoire :

SDL_FreeSurface(curseur);

Ecrire du texte :
Pour écrire du texte on utilise l’extension ttf de la SDL. Cette extension doit être
chargée au début du programme : TTF_Init(); et arrêtée à la fin : TTF_Quit();
Il faut ensuite charger une police. Pour cela on crée une variable : TTF_Font* police;
Puis on alloue la police désirée et sa taille : police = TTF_OpenFont("times.ttf", 20);
Il faudra penser à fermer cette police à la fin du programme : TTF_CloseFont(police);
On peut ensuite associer un texte contenu dans une chaîne de caractères à une surface grâce à
la fonction : text_min = TTF_RenderText_Solid(police,chaine, couleur_noire); où couleur
noire est définie ainsi : SDL_Color couleur_noire= {0, 0, 0};
Gestion des événements :
La SDL est capable de gérer les signaux d’entrée tels que l’appui sur une touche du
clavier ou le déplacement de la souris.
Pour cela, il faut d'abord créer une variable de type SDL_Event : SDL_Event event;
On entre ensuite dans une boucle qui ne se terminera que lorsque l'on souhaitera quitter
le programme. Cette boucle attend à chaque fois un événement grâce à la fonction :
SDL_WaitEvent(&event); (reste bloquée tant qu’il n’y a pas d’événement) ou
SDL_PollEvent(&event);
Lorsqu'un événement est apparu, la sous-variable event.type contient le type

d’événement correspondant. Il suffit donc de faire un switch selon l'événement. On peut ainsi
détecter un appui sur une touche de clavier par exemple si event.type=SDL_KEYDOWN. Dans
ce cas, on peut récupérer la touche pressée grâce à la sous-variable event.key.keysym.sym qui
correspond en général au code ASCII de la touche pressée. On fait ensuite un switch sur la
variable event.key.keysym.sym pour coder l’action réalisée par une touche.
Gestion du temps :
Pour réaliser les programmes d’interfaçage graphique, un point essentiel est de pouvoir
gérer le temps. La SDL permet cela grâce à plusieurs fonctions. La première est une fonction
très simple (SDL_GetTicks();) qui ne fait rien d’autre que renvoyer le nombre de millisecondes
passées depuis le début du programme. Il suffit de faire la différence entre deux commandes
SDL_GetTicks() pour obtenir le temps qui s’est écoulé.
Une autre fonctionnalité importante et plus complexe est la gestion des timers : un timer
est un système qui va appeler une fonction de manière périodique.
Il faut d’abord déclarer le timer : SDL_TimerID timer;

On alloue ensuite le timer grâce à la commande suivante qui donne le délai du timer
(variable de type Uint32), la fonction lancée et un pointeur vers une structure passée en
paramètre :
timer = SDL_AddTimer(40, tracer, &graphique);
Remarque : on ne peut passer qu’un unique paramètre. Si l’on souhaite en passer plus,
il faut nécessairement créer une structure contenant tous les paramètres.
La fonction lancée par le timer doit avoir un format type. Elle doit prendre en entrée le
délai du timer et un pointeur de type void. Elle renvoie la valeur du délai. Le prototype de la
fonction est donc le suivant : Uint32 tracer(Uint32 intervalle, void *parametre);
Pour récupérer le paramètre on crée un nouveau pointeur vers le type voulu :
Graphique* graphe = parametre;
On peut alors directement modifier notre structure passée en paramètre. On accède aux
sous-variables de la structure grâce à graphe->sous_variable qui correspond à
(*graphe).sous_variable.
Il ne faut pas oublier de retourner le délai du timer à la fin de la fonction : return intervalle;
Pour stopper le timer et donc l’appel périodique à la fonction il suffit de faire :

SDL_RemoveTimer(timer);
5.4.2 Programme de prise de mesures
Ce programme est plus destiné à l’étude des signaux EEG qu’à leur application. En
effet, dans le cadre d’une visite au centre hospitalier de Nancy, nous avons voulu définir des
protocoles de prises de mesures. Le but de ce programme est de mettre en œuvre ces protocoles
en demandant à un utilisateur muni d’un casque d’effectuer divers exercices comme lever un
bras ou compter le nombre d’apparitions d’une lettre. Le programme note dans un fichier les
opérations demandées et la date de la demande. On pourra ainsi caler le fichier eeg avec les
exercices réalisés.
La réalisation du programme reste assez simple. Il s’agit juste d’afficher des phrases à
tour de rôle, soit de manière définie soit aléatoire. Il n’y a pas besoin de communiquer avec
Matlab puisque le traitement se fait après coup. Il n’y a pas non plus besoin d’effectuer du
temps réel. La SDL permet ici d’améliorer l’affichage des actions à réaliser pour que celles-ci
soient écrites en plus gros et plus lisible qu’en ligne de commande. Cela est important car
l’utilisateur ne doit pas avoir à trop se forcer pour lire. Surtout qu’il n’est pas forcément bien
installé pour cela.
Le programme étant simple, il ne contient qu’une seule classe. Presque tout le

programme se déroule dans la fonction main. Mis à part une fonction permettant de mettre le
programme en pause en attendant un clic de l’utilisateur et une fonction contenant une liste de
chaînes de caractères auxquelles sont attachées un nombre. La fonction prend en entrée un
pointeur vers une chaîne de caractères et un entier. Elle remplit ensuite la chaîne de caractères

en paramètre par la phrase correspondante à l’entier. Il est ainsi plus simple de modifier le
programme pour changer de protocole. C’est aussi important si l’on veut afficher des exercices
au hasard. Il suffit d’obtenir un entier aléatoire et de prendre la phrase correspondante.
Le même programme nous a permis de réaliser différentes prises de mesures impliquant

des stimuli intérieurs ou des potentiels évoqués en modifiant simplement les commandes à
chaque fois. Nous avons décidé de démarrer chaque prise de mesures par 3 clignements des
yeux que nous sommes sûrs de déceler sur le signal EEG. Cela pour mieux se synchroniser lors
de l’étude des signaux. Les séquences d’exercices se doivent d’être répétitives pour pouvoir
effectuer ensuite des moyennages durant le traitement.
5.4.3 Programme de tracé de signaux
J’ai choisi de réaliser un programme qui va simplement tracer des signaux en fonction
du temps. Ce programme nous permet de tracer les signaux EEG ainsi que les différentes
étapes du traitement. C’est une bonne introduction avec la bibliothèque SDL et nécessite la
recherche d’un moyen pour récupérer les données Matlab. Ce programme doit également
prouver qu’on a réussi à détecter un événement.
L’idéal serait de tracer les signaux en temps réel, cependant, nous avons décidé de
commencer par traiter le signal et de le tracer a posteriori. Pour cela le programme Matlab
enregistre les signaux dans un fichier que le programme doit lire.
Plutôt que de tracer directement l’ensemble du fichier j’ai choisi de simuler le temps en
lisant un point du fichier toutes les 4ms (période d’échantillonnage du signal) et en traçant
l’ensemble des points déjà lus toutes les 40ms (25 images par seconde). Ceci pour permettre
une meilleure adaptation future à une exécution en direct. Le programme utilise donc des
timers pour actualiser le graphe toutes les 40ms et pour lire une valeur d’un fichier toutes les
4ms.
L’interface contient 4 graphiques permettant de tracer différents signaux, par exemple
un signal non traité, débruité, après traitement par une fonction de corrélation et une détection
d’événement. Un disque rouge permet de montrer que l’on a détecté un événement. Soit en
s’allumant, soit en se déplaçant à droite ou à gauche.

figure 31 : Le programme en fonctionnement
Réalisation d’un graphique :
Les graphiques sont destinés à tracer différents signaux en fonction du temps.
Un graphique est défini par de nombreux attributs comme sa taille, sa position,

l’ensemble des points à tracer, … Il doit aussi contenir différentes surfaces SDL pour dessiner
le graphique.
Il faut donc créer une structure graphique contenant toutes les variables nécessaires à
son utilisation. Il est ensuite possible de créer une variable de type graphique et d’envoyer son
adresse en paramètre d’une fonction pour directement la modifier. On crée alors une classe
graphique.c contenant les fonctions permettant de modifier les variables de type Graphique.
On peut alors voir Graphique comme un objet Java avec ses attributs définis dans la structure
et ses méthodes dans la classe graphique.c
La structure Graphique a pour sous-variables :
-Le fichier depuis lequel on récupère la fonction à tracer
-Un tableau stockant les valeurs à tracer en fonction du temps
-La taille de ce tableau
-Les valeurs minimales et maximales de ce tableau

-Ses position et taille
-Des surfaces SDL pour : tracer le cadre du graphique, le fond et pour écrire les valeurs
minimales et maximales
Pour permettre de tracer un graphique, j’ai réalisé une fonction ‘tracer_graphe’. Celle-
ci prend en entier la position, la taille, les valeurs max et min, le nombre de points et un tableau
de mesures à tracer. La fonction calcule l’échelle des ordonnées en fonction de la hauteur du
graphe et des valeurs maximale et minimale. L’échelle des abscisses est calculée pour pouvoir
positionner 800 points dans toute la largeur du graphique. S’il y a plus de points à tracer seuls
les 800 derniers le seront. Cela entraînera un défilement du signal avec le temps.
On entre ensuite dans une boucle qui parcourt tous les points à tracer et calcule
l’ordonnée et l’abscisse d’un point et de son suivant par rapport à la fenêtre principale grâce à
la position du graphe, sa taille et les échelles en abscisse et ordonnée. On trace alors une ligne
entre les deux points et on recommence pour tous les points.
Tracer une ligne en SDL n’est pas si simple qu’il n’y parait. Il faut en fait modifier un à
un tous les pixels entre les deux extrémités. Cependant, vu l’importance d’une telle fonction,
de nombreux sites offrent le code permettant de la réaliser. J’ai donc pu récupérer une fonction
qui trace une ligne [DEVELOPPEZ LIGNE]. Cette fonction ligne prend en entrée l’abscisse et
l’ordonnée des deux points à relier ainsi que la couleur de la ligne. Elle utilise les fonctions
‘SetPixel’ définies dans la documentation de la SDL et ‘echangerEntier’ qui permet
d’intervertir les deux points en entrée. Toutes ces fonctions, de même que ‘tracer_graphe’ ont
été placées dans la classe tracer_graphe.c pour plus de clarté.
J'ai attaché à la touche entrée (SDLK_RETURN) le début du tracé, à la touche espace

(SDLK_SPACE) la pause, et à la touche echap (SDLK_ESCAPE) la sortie de la boucle donc la
fin du programme.
Améliorations du programme :
En testant le programme il semble fonctionner correctement : les signaux sont tracés et

on arrive à détecter un événement. Cependant, on constate que le tracé du signal prend environ
deux fois plus de temps qu’en réalité. Pour voir d’où vient ce problème j’ai demandé au
programme d’écrire le temps (grâce à la fonction ‘SDL_GetTicks();’) dans un fichier à chaque
fois qu’une fonction est lancée par un timer.
On peut alors constater un retard dans le lancement de chaque fonction. Ce retard est dû
à deux phénomènes distincts :
-le premier, et aussi le plus prévisible est dû au temps pris pour tracer les graphiques. Celui-ci
est compris entre 5 et 10 ms. Cela laisse une marge de temps très réduite pour tracer 4 graphes
actualisés toutes les 40ms mais cela reste suffisant. Il s’ensuit que le tracé des graphes se fait
en décalé. Mais cela ne devrait pas ralentir le tracé en lui-même.
-la deuxième raison est plus subtile. Elle provient d’un non respect de la période des timers de
lecture de valeurs (4ms). En effet cette lecture est faite toutes les 10ms! Et si l’on fixe la
période à 11ms, elle est en réalité à 20ms! La période doit donc être arrondie à la dizaine de
ms.
Comment dans ce cas simuler une période d’échantillonnage de 4ms?

L’idée est de prendre les données 10 par 10 toutes les 40ms. On simule ainsi du pseudo
temps réel décalé en considérant un buffer de 10 valeurs. J’ai alors pu diminuer le nombre de
timers en rassemblant la prise de mesure et le tracé en un seul timer.
On obtient maintenant un programme fonctionnel sans retard. Le principal problème

reste qu’il doit être lancé une fois que Matlab a terminé son travail. Pour pallier ce problème,
on pourrait demander à Matlab d’écrire un nombre limité de mesures par fichier avant d’écrire
dans un autre. Le programme C pourra alors lire les données fichier par fichier en temps
différé.
Nous avons cependant préféré utiliser l'application pour s'essayer à la communication C

– Matlab. Après avoir réussi à appeler la machine Matlab sur des exemples simples, j'ai
modifié mon programme pour pouvoir réaliser cette fonctionnalité. Il a fallu d'abord ajouter à
l'objet graphique un tableau de 100 points. Ce buffer contiendra toujours les 100 dernières
mesures d'un signal. Il sera envoyé tous les 10 points à la machine Matlab. Ceci permettra
d'alléger le traitement tout en laissant suffisamment de points pour qu'il soit efficace.
J'ai donc dû réaliser une nouvelle fonction pour actualiser les graphes. Le déroulement
est le suivant : le programme lit 10 points dans un fichier et les mets dans le buffer en décalant
à chaque fois les valeurs de celui-ci dans le but d'enlever les plus anciennes. Le buffer est
ensuite envoyé à Matlab et les 10 dernières valeurs sont ensuite mises dans le tableau contenant
les valeurs à tracer.
Pour pouvoir utiliser la machine Matlab dans différentes fonctions, celle-ci doit être
déclarée de façon publique dans un fichier .h. De plus la fonction ep = engOpen(NULL); doit
être lancée dans toutes les fonctions qui l'utilisent.

6. Conclusion
Nous avons donc maintenant à notre disposition un programme permettant de

visionner les signaux EEG et de communiquer avec Matlab. Il reste à faire fonctionner ce
programme en même temps que l'enregistrement. Une fois cela réalisé, les principales
difficultés liées à l'interface graphique seraient réglées. Il suffirait de reprendre les mêmes
concepts pour de nouvelles applications. Reste à parvenir à déceler les signaux nécessaires au
fonctionnement de ces applications.
Compte tenu des faibles rapports signal sur bruit des différentes applications d'interface
cerveau-machine, le domaine de recherche sur les BCI est un secteur qui regroupe de
nombreuses techniques de traitement du signal et le développement des activités et des études
sur les ondes cérébrales va demander un apport encore plus important de méthodes.
Ce projet nous a permis de découvrir un domaine de recherche florissant, cependant le

manque de moyens pour acquérir un casque, et la difficulté de détecter les événements perdus
dans le bruit ou mélangés à d'autres activités cérébrales, nous ont empêché de mener notre
projet au point où nous l'aurions souhaité. Toutefois, même si nous ne nous attendions pas à
réaliser un système complet, nous avons tout de même établi des bases permettant d'avancer
dans le domaine des BCI.

7. Bibliographie
ABDALLAH,F. Les Support Vector Machines.Cours. Université de Technologie de
Compiègne.
BILLARD V., Surveillance de la profondeur de l'anesthésie générale, EMC - Anesthésie-

Réanimation, Volume 2, Issue 1, février 2005, pages 23-45
EDLINGER G., GUGER C., The Brain-Computer Interface, [en ligne], janvier 2006, [consulté
le 16 octobre 2007],
< http://www.mathworks.com/company/newsletters/news_notes/jan06/brain.html >
FIEVET C., Le contrôle par la pensée, l'interface ultime ?, [en ligne], mars 2005, [consulté le
7 novembre 2007], < http://www.internetactu.net/?p=5854 >
GARNERO L., Localisation de sources en MEG/EEG, [en ligne], [consulté le 15 janvier

2008], < http://www.labos.upmc.fr/center-meg/media/ecp2001/Meg21.pdf >
GLOVER John R., JANSEN Ben H., Brain-wave Analysis, [en ligne], 2008, [consulté le 15
mars 2008], < http://www.egr.uh.edu/cnecs/research/?e=brainwaveanalysis >
GUILLEMAUD R., Vers des interfaces BCI intégrées et implantables, [en ligne], mai 2007,
[consulté le 30 novembre 2007], < www-bci.univ-lille1.fr/more/journee-ifrath-2007/regis-
guillemaud.pdf >
HOFFMAN.U, VESIN.J-M, EBRAHIMI.T, DISERENS.K. An efficient P300-based brain-

computer interface for disabled subjects.Journal of Neuroscience Methods, vol. 167, num. 1,
2008, p. 115-125
JACQUEMIN C., Les Interfaces cerveau/ordinateur ont le vent en poupe, [en ligne] , janvier
2007, [consulté le 16 octobre 2007],
< http://www.automatesintelligents.com/labo/2007/jan/bci.html >
KACHENOURA.A, ALBERA.L, SENHADJI.L, COMON.P. L’ACI : un outil pour les

Interfaces Cerveau-Machine.Actes du XXI Colloque GRETSI - 21ème Colloque sur le
Traitement du Signal
LAFAYE DE MICHEAUX.P .Méthodes statistiques multivariées en IRMF.

Rapport.Sciences.2007. INP Grenoble.
LOTTE.F, CONGEDO.M, LECUYER.F, ARNALDI.B. A Review of Classification Algorithms

for EEG-based Brain-Computer Interfaces.Journal of Neural Engineering 4.2007.
MCFARLAND D.J., SARNACKI W.A., Brain-computer interface (BCI) operation :

optimizing information transfer rates, Biological Psychology, Volume 63, Issue 3, juillet 2003,
pages 237-251
RIVET.B, SOULOUMIAC.A. Extraction de potentiels évoqués P300 pour les interfaces

cerveau-machine.Colloque GRETSI. Septembre 2007. Troyes.

SELLERS E.W., KRUSIENSKI D.J., A P300 event-related potential brain-computer interface
(BCI) : The effects of matrix size and inter stimulus interval on performance, Biological
Psychology, Volume 73, Issue 3, octobre 2006, pages 242-252
UNGUREANU.M, BIGAN.C, STRUNGARU.R, LAZARESCU.V. Independent Component

Analysis Applied in Biomedical Signal Processing.MEASUREMENT SCIENCE REVIEW,
Volume 4, Section 2, 2004 Independent
WOLKAM, SecondLife, pour mieux se comprendre, [en ligne], mars 2007, [consulté le 22
février 2008], < http://secondworld.wordpress.com/2007/03/20/secondlife-pour-mieux-se-
comprendre >
Sites Internet :
[WIKI BRAIN] http://en.wikipedia.org/w/index.php?title=Brain-

computer_interface&oldid=130305011, [en ligne], consulté le 7 novembre 2007
[WIKI CORTEX]
http://fr.wikipedia.org/wiki/Cortex_sensoriel_et_plasticit%C3%A9_c%C3%A9r%C3%A9bral
e, [en ligne], consulté le 25 janvier 2008
[WIKI INTERFACE] http://fr.wikipedia.org/wiki/Interface_neuronale_directe, [en ligne],

consultée le 7 novembre 2007
[MEDPHAR] http://medphar.univ-poitiers.fr/DU_alzheimer/
EEG_et_demences_DU_ALZ_2005.pps, [en ligne], consulté le 7 décembre 2007
[TPE] http://tpe.goutcouleur.free.fr/plan/, [en ligne], consulté le 15 janvier 2008
[ALTIVIS] http://www.altivis.fr/-Neuropuces-et-neuroprotheses-.html, [en ligne], consulté le

16 novembre 2007
[ANALOG] http://www.analog.com/UploadedFiles/Data_Sheets/AD524.pdf, [en ligne],

consulté le 19 mars 2008
[CORTECHSOLUTIONS] http://www.cortechsolutions.com/Data_Acquisition.htm, [en ligne],

consulté le 31 octobre 2007
[ELECTRODESALES] http://www.electrodesales.com/electrode-accessories-eeg-electrode-
cap.html, [en ligne], consulté le 19 octobre 2007
[GIZMODO] http://www.gizmodo.fr/2006/03/08/la_machine_a_ecrire_mentale_pr.html, [en

ligne], consulté le 22 février 2008
[GTEC] http://www.gtec.at/index.htm, [en ligne], consulté le 16 octobre 2007
[NEUROSOFT] http://www.neurosoft.ru/fra/product/index.aspx#group_eeg, [en ligne],


[LIBSDL] http://www.libsdl.org, [en ligne], consulté le 20 octobre 2007
[DEVELOPPEZ] http://loka.developpez.com/tutoriel/sdl, [en ligne], consulté le 15 novembre

2007
[TUTO] http://www.siteduzero.com/tuto-3-8-0-apprenez-a-programmer-en-c.html, [en ligne],

[DEVELOPPEZ LIGNE] http://anomaly.developpez.com/tutoriel/sdl/partie2, [en ligne],

consulté le 20 novembre 2007
[GNUMEX] http://gnumex.sourceforge.net, [en ligne], consulté le 16 mars 2008
[OPEN VIBE] http ://www.irisa.fr/siames/OpenViBE, [en ligne]

ANNEXE
Compiler un programme C utilisant la SDL et appelant la machine Matlab.
Installation de mingw :
On télécharge par exemple sur :

http://www.zdnet.fr/telecharger/windows/fiche/0,39021313,11010878s,00.htm
On crée par exemple un répertoire C:\mingw pour y mettre les fichiers.
Installation de la SDL :
Sur le site http://www.libsdl.org/download-1.2.php, on télécharge dans developement

libraries pour Win32 : SDL-devel-1.2.13-mingw32.tar.gz.
Il faut mettre les fichiers .h dans le répertoire C:\mingw\include\SDL. Les fichiers .a et

.dll doivent se placer dans le répertoire du programme.
Création d’un fichier .bat : (méthode expliquée sur http://gnumex.sourceforge.net/)
Il faut installer gnumex sur le site : https://sourceforge.net/projects/gnumex et placer les

fichiers par exemple dans le répertoire C:\gnumex. Il faut placer ce répertoire et C:\gnumex\src
dans le Matlab Path : File – Set Path … - Add Folder … .
Dans Matlab on place le répertoire de travail à C:\gnumex et on tape ‘gnumex’ en

commande. On remplit ensuite la fenêtre de la façon suivante :

Mettre le fichier .bat dans le répertoire de travail. On peut ensuite compiler grâce à ce
fichier. Par exemple pour compiler le programme de tracé de graphiques on utilise la
commande :
mex -f mexmingwopts.bat main.c fonctions_utiles.c tracer_graphe.c graphique.c libSDLmain.a
libSDL.dll.a SDL_ttf.lib
On lance ensuite le fichier main.exe

Master Braz

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Master Braz

Diunggah oleh

Hak Cipta:

Format Tersedia

Victor BRAZ

Projet de fin d'études

Tuteurs : Valérie Louis-Dorr, Radu Ranta

Année universitaire 2007/2008

Depuis plusieurs années, de nombreuses équipes de recherche dans le monde s’intéressent à la

L’électroencéphalogramme (EEG) est le moyen le plus utilisé pour constituer le premier

2. Présentation des BCI...........................................................................................5

2.1. Les applications médicales................................................................................................ 5

3. L'acquisition des EEG.........................................................................................9

3.1. Utilisation des EEG........................................................................................................... 9

4. Traitement des signaux..................................................................................... 19

4.1. Le prétraitement des signaux........................................................................................... 19

Projet de fin d'études 1 Interface cerveau-machine

Projet de fin d'études 2 Interface cerveau-machine

Ces dernières années, les interfaces cerveau-machine, ou BCI (Brain-Computer

Projet de fin d'études 3 Interface cerveau-machine

Projet de fin d'études 4 Interface cerveau-machine

2.1. Les applications médicales

2.1.1. Un fauteuil roulant commandé par la pensée

Des scientifiques espagnols de l’université de Saragosse travaillent sur une nouvelle

figure 2 : Fauteuil roulant

Projet de fin d'études 5 Interface cerveau-machine

2.1.3. Un navigateur web

Un navigateur web a même été réalisé à l'université de Georgie, permettant de surfer

Projet de fin d'études 6 Interface cerveau-machine

figure 3 : Bras robotisé

2.2. Les jeux vidéo

figure 4 : Ping-pong cérébral

Projet de fin d'études 7 Interface cerveau-machine

2.2.2. La réalité virtuelle

figure 5: Environnement virtuel

2.2.3. La transmission de sensations par Sony

Projet de fin d'études 8 Interface cerveau-machine

figure 6: La nomenclature 10/20

Projet de fin d'études 9 Interface cerveau-machine

3.1.2. La mesure des signaux EEG

Projet de fin d'études 10 Interface cerveau-machine

figure 7 : Acquisition d'un signal EEG

3.1.3. Les dispositifs d'acquisition

Il existe de multiples systèmes d'acquisition EEG se différenciant par le nombre

Il existe plusieurs versions du « Neurospectrum » qui comportent soit 16 électrodes,

Fréquence d'échantillonnage par canal jusqu'à 5000 Hz

Projet de fin d'études 11 Interface cerveau-machine

La société autrichienne g.tec propose elle-aussi plusieurs systèmes robustes et faciles

figure 9 : Positionnement des électrodes

Projet de fin d'études 12 Interface cerveau-machine

figure 10 : Exemple d'onde P300

Projet de fin d'études 13 Interface cerveau-machine

Les contractions musculaires provoquent des variations d'amplitude assez importantes

Par exemple, on peut considérer 2 événements :

Projet de fin d'études 14 Interface cerveau-machine

Sa structure est celle d'un amplificateur d'instrumentation. Les amplificateurs A1 et A2

figure 11 : Principe d'un amplificateur d'instrumentation

Les deux amplificateurs opérationnels A1 et A2 permettent d'effectuer une adaptation

En utilisant des résistances d'une extrême précision et en ajoutant à cette structure

Projet de fin d'études 15 Interface cerveau-machine

Après amplification, on utilise un filtrage passe-haut de fréquence de coupure de 5 Hz

Le montage complet permettant d'acquérir des signaux EEG, constitué d'un

figure 13 : Schéma de la chaîne d'acquisition d'un signal EEG

Projet de fin d'études 16 Interface cerveau-machine

3.4.1. Protocoles utilisés

D'autre part, afin d'obtenir des enregistrements exploitables, il a fallu limiter au

figure 14 : Prise de mesures EEG