L’image ci dessus montre un graphique d’intensité sonore en fonction du temps. Comment faisons nous pour déterminer les différentes fréquences qui composent ce graphique? Tout d’abord, nous devons comprendre comment la superposition d’ondes sonores fonctionne. En effet, c’est beaucoup plus simple que vous le pensez!

Comme vous pouvez observer, le graphique ci-dessus (pression en fonction du temps) nous montre deux fréquences différentes (Mauve = 294Hz || Jaune = 440Hz). Le graphique de couleur verte est la superposition des deux ondes. Nous pouvons observer qu’à certains endroits l’amplitude est très grande puisque c’est un temps qui coincide avec l’amplitude maximale des deux droites. À d’autres endroits l’addition des amplitudes s’annulent et crée une pression nulle. Comme nous pouvons voir, c’est simple de construire des graphiques à plusieurs fréquences. La question que nous nous posons ici c’est comment déduire les fréquences qui ont composé un graphique?

Pour arriver à déduire la fréquence d’une onde complexe nous devons comprendre comment y arriver avec une onde prédéterminé. L’image ci-dessus nous montre une onde de 3Hz qui est divisé en 2 secondes. Un tour de cercle corresponds à deux secondes dans le graphique. Le centre du cercle corresponds à une intensité nulle et plus on s’éloigne du centre du cercle plus l’intensité est grande. Nous ne travaillons pas dans le négatif, puisque le centre du cercle ne correspondra plus au bas de l’onde.

Quand nous changeons la valeur d’un tour de cercle (Le temps qui corresponds à un tour) le graphique résultant change aussi. (Afin de continuer les explications nous allons appeller la valeur d’un tour de cercle gamma.) Dans la deuxième image, nous observons une forme hors du commun puisque la valeur de gamma équivaut à la fréquence de l’onde. Hélas! Nous devons nous questionner sur cet effet.

Avec le graphique et les informations que nous avons trouvé nous pouvons maintenant déduire la fréquence de l’onde. Pour ce faire, nous devons trouver le centre de la masse du graphique gamma. Pourquoi? Quand la valeur de gamma est égale à la valeur de la fréquence de l’onde, la valeur en X du centre de masse est grande. Pour déduire la fréquence, il suffit d’observer le graphique de la coordonnée en X et trouver ou il y a un pic!

Comme vous l’avez deviné, la somme de deux ondes de différentes fréquences fonctionne similairement! C’est à dire, dans le graphique de la coordonnée en X du centre de masse il y a deux pics. Chaque pic est égale à une fréquence qui compose l’onde.

Pour trouver le point du centre de masse plus précisément nous devons faire une intégrale d’un infinité de points sur la forme obtenue. Voici la fonction finale qui est utilisé afin de calculer les différentes fréquences sur le spectromètre.

Comme vous l’avez deviné, la voix humaine est une composition de différentes fréquences. Pour déterminer quelle fréquences est la plus dominante, nous devons analyser d’avantage le graphique d’intensité en fonction de la fréquence. Par la suite nous prenons la valeur maximale d’intensité afin de déterminer la fréquence qui est la plus dominante. J’ai choisi de faire cette partie en processing puisqu’il existe une libraire qui utilise la transformation de fourrier. Voici comment déterminer la fréquence dominante :

Nous parcourons les bandes données par la transformation de fourrier afin de trouver elle qui à l’intensité la plus grande. Par la suite, afin de déterminer la fréquence de celle-ci nous devons trouver la vitesse à laquelle nous prenons les données et le diviser par le nombres de bandes que nous avons.

Lors des premiers essaies, nous avons déterminé que la fréquence obtenue est grandement influencé par le bruit ambiant. Nous nous sommes penché fortement sur ce sujet afin de comprendre comment éliminer le bruit ambiant et calculer la fréquence plus précisément. Pour ce faire, nous avons décidé de faire une moyenne en décibels du bruit ambiant. Quand nous avons un bruit qui nettement supérieur à la fréquence ambiante nous calculons la fréquence de celui-ci!

C’est assez simple comme fonction! La fonction CalculPower() envoie un chiffre entre 0 et 3 inclus au port serial dépendant de la fréquence déterminée. Le arduino comprends ces chiffres et fait avancer / reculer l’automobile en fonction du chiffre obtenue.

Suite à la commande du casque capteur d’ondes cérébrales, le produit s’est avéré être défectueux. Par conséquent une alternative permettant de faire avancer l’automobile téléguidée doit être pensée. La solution : un micro détectant les fréquences de la voix et tout dépendant la fréquence captée, l’automobile téléguidée avancera ou reculera.

Comment s’y prendre?

Pour commencer nos tests, nous avons utilisé l’automobile téléguidée d’un groupe d’étudiants dans une année antérieur.

Comme vous pouvez observer, il manque un pneu sur deux des roues de l’automobile! C’est simplement pour faire en sorte que l’automobile tourne sur place en faisant tourner les moteurs en sens opposé. Le graphique ci-dessous nous informe dans quel sens on doit

Afin de pouvoir envoyer des commandes à l’automobile nous avons resoudé les points de contact sur la télécommande puisqu’elles étaient désuets.

Le code pour obtenir l’angle d’inclinaison du senseur maintenant fait, il s’agit de traduire cette récupération de données qui est l’angle, dans un environnment graphique.

Voici la fonction draw() :

Premièrement, on doit dessiner le volant :

La fonction rotate permet de rotationner la forme complète qui est dessinée. L’angle change à chaque fois qu’on bouge le mpu6050.

Comme on peut voir ci-dessus, on lit la valeur transmise par le mpu et on la soumet à des critères pour l’accepter ou pas. Ainsi, on diminue la charge d’information dans le serial port. Au tout début, lorsqu’on ne faisait que prendre la valeur du mpu et la transmettre pour faire bouger le volant il y avait beaucoup de lag. On a donc dû ajouter des barrières pour bloquer les surplus, comme expliqué dans le code ci-dessus.

Voici la fonction setup()

Ici, on commnuique avec le serial port pour obtenir les informations recueillies par le mpu6050 à travers le arduino.

Voici une vidéo du résultat :

Après réflexions et recherches sur le mpu6050, la meilleure façon de contrôler l’auto à l’aide du senseur serait de calculer l’angle d’inclinaison que nous créerions à l’aide du senseur pour faire tourner l’auto. En effet, il est possible avec le mpu6050 de déterminer la force gravitationelle exercée sur chacun des axes. Ainsi, on peut utiliser la force en x et en z pour calculer l’angle d’inclinaison avec une simple astuce trigonométrique. J’expliquerai donc le code que nous avons fait pour permettre de recueillir l’information nécessaire, c’est-à-dire l’angle d’inclinaison du mpu6050.

Tout d’abord, il est important de mentionner que le mpu6050 sera à utiliser à plat, dans le sens où l’on peut lire les lettres à l’endroit comme ci-dessous.

CODE :

Donc, la première étape est d’établir la communication avec le mpu6050, chose que l’on fait dans la fonction setupMPU() :

On doit d’abord accéder à l’adresse du mpu qui est : 0b1101000. Le x qu’on peut voir dans la description ci-dessous est un 0 car dans le circuit nous avons connecté la pin AD0 au ground, donc il s’agit de AD0 low.

Ensuite, parce que le mpu6050 est en sleep mode par défaut, nous voulons désactiver le sleep mode en accédant au registre SLEEP (6B) et le mettre à zéro pour pouvoir recevoir des données sans arrêt. On doit ensuite accéder au registre de l’accéléromètre pour le configurer. On le configure ici à la sensibilité la plus basse, car il n’y aura pas de mouvement extrêmement rapide durant la conduite de l’auto et cela nous permettra d’avoir des données plus stable.

Maintenant qu’on a accédé à l’accéléromètre et qu’il est configuré, on veut aller chercher les données brutes pour les placer dans nos variables, puis les traiter pour les transformer sous forme de force g.

Le calcul s’explique par cela :

En effet, la sensibilité de l’accéléromètre à +/-16g est de 2048 LSB/g, ce qui explique la division par 2048 pour trouver la force g.

Pour calculer l’angle, on utilise la formule trigonométrique tan(x) = opp/adj, où x est l’angle en radian, opp est la force g en X et adj la force g en Z. Puisque nous voulons trouver l’angle, on isole x et donc x = arctan(gForceX/gForceZ).

Cette article résume donc le code arduino pour récupérer l’angle d’inclinaison créer par l’utilisateur, qui servira à orienter l’automobile téléguidée.

Voici une vidéo du résultat :

Lorsqu’on penche vers la gauche, on constate que l’angle affichée se rend environ à 1.57 degrés radian ce qui équivaut à 90 degrés et que lorsqu’on penche vers la droite l’angle affichée se rend environ à -1.57 degrés radian ce qui équivaut à -90 degrés.

Le but de ce programme est de trouver une norme de valeurs de concentration afin de cerner ou pourrait être le seuil de concentration.

Voici un petit sketch à quoi devrait ressembler mon graphique. Mon but est de le graduer par 10 points sur 100 à chaque ligne. De plus, chaque point va avoir sa valeur indiqué au dessus de lui (x = Méditation ; y = Concentration).

Voici à quoi va ressembler la construction des lignes du graphique:

Pour y arriver je vais faire une boucle for qui va parcourir 10 données (0-9). La première donnée indiquera le point (0,0) dans le graphique. Voici à quoi ressemble le code :

Voici à quoi ressemble mon graphique :

Afin de mieux comprendre mes données je vais créer deux fichiers .txt qui vont sauver toutes les valeurs reçus de l’electroencephalogram. Un fichier sera pour les valeurs de méditation et l’autre sera pour les valeurs de concentration. Par la suite je vais prendre les données récoltées dans les fichiers et l’importer dans excel afin de mieux pouvoir jouer avec les données expérimentales.

Avec ce bout de code, les informations seront sauvées dans le fichier .txt correspondant.

Pendant ma semaine de relâche j’ai fortement pensé à mon projet. Afin de déterminer qu’elle sera la valeur du niveau d’attention qui déterminera quand l’automobile avancera j’ai décidé de faire un graphique qui aura tous les points reçu par l’electroencephalogram.

En premier lieu, je dois créer mon environnement processing avec le graphique. Je vais m’inspirer du graphique ci-dessus! Pour l’instant mon intention est de donner l’option à la personne qui porte le casque de sélectionner les options suivantes : (Concentrer (rouge), Relaxer(Vert), Rien (Aucun point)). Voici ma classe qui va créer le point dans le graphique:

Il reste seulement à créer des variables et des boutons qui vont activer certaines couleurs:

Afin de savoir quel bouton le sujet essaie de peser je dois vérifier la position de la sourie sur l’écran:

Afin de pouvoir découper le message du arduino j’ai copié la fonction que j’ai fait dans mon programme graphique.

C’est dans ma fonction draw() qui déterminera quel sera la couleur du cercle. J’ai seulement activé ou désactivé des booléens dépendamment du choix de l’utilisateur:

J’ai fini le programme, il reste seulement à essailler avec les données de l’electroencephalogram.

En premier lieu, afin voir si mon code fonctionnait j’ai recréer à quoi peux ressembler le ouput serial avec un potentiomêtre brancé dans le Arduino. J’ai réussi à faire varier la varaible qui représente le niveau de concentration (0-100) à l’aide du potentiomètre. Voici le code que j’ai importer dans le arduino :

Comme nous pouvons observer, je fait varier la variable value(entre les deux virgules) qui elle représente un chiffre donné par le potentiomètre, et ce toujours entre 0 et 100.

Après avois compilé le programme dans le arduino, voici à quoi ressemble le port Serial 9600 baud (vitesse que j’ai défini afin de transmettre l’information):

Dans mon code processing, je dois lire chaque ligne serial et voir lesquelles commencent par #EEG. Cette méthode sert à définir les informations qui sont dédiés au graphique de l’electroencephalogram de celle qui sont dédiés au graphique du gyroscope.

Le premier problème que j’ai rencontrer était que je n’avais pas de manière afin de déterminer qu’une ligne serial était null. Par conséquent, il y avait des lignes qui étaients vides et donnait l’erreur : ArrayOutOfBoundsException. Avec ce bout de code, je peux vérifier que aucune ligne qui est envoyé sera == null.

Le second problème que j’ai encontré c’est que mon graphique ne répondait pas rapidement. C’est à dire que je modifiais la valeur d’attention et la sphère changeait de grosseur que quelques disaines de secondes après. Afin de régler ce problème, j’ai du réduire le nombre de données que mon programme décryptait afin de l’alléger.

Comme nous pouvons observer, j’ai mis un protocole qui autorise le changement de la variable “Niveauattention” si seulement elle est différente de sa variable précédente. De plus, afin d’éviter mon programme de prendre des données qui ne sont pas bonnes, j’ai mis un restriction de pouvoir jouer avec les lignes qui contiennent seulement trois valeurs. J’ai fait cela puisqu’il y avait certains cas ou mon code processing lisait la ligne plus vite que la vitesse que mon arduino. Cela faisait en sorte qu’il y avait des lignes qui n’avaient pas les 3 variables nécessaires au fonctionnement du programme.

J’ai aussi ajouté cette condition puisque le niveau d’attention passait de 80 à 0 pendant une miliseconde et retournait à sa valeur d’orginine. Cela faisait en sorte que la sphère nous parraissait très sacadé puisqu’elle faisait cette action plus d’une fois par seconde. Ce bout de code à règler le problème en enlevant complètlement le 0 de l’échelle des valeurs.

Afin de tester et de se familiariser avec le fonctionnement du capteur mpu-6050, nous avons, à partir d’une vidéo Youtube, construit un modèle de représentation graphique en 3 dimensions qui imite les mouvements du capteur sous l’image d’un avion. Il s’agit de la démonstration Teapot.

Voici quelques photos de notre expérience.

Comme on peut voir dans les images, il s’agit d’un ancien projet que nous avons utiliser juste pour démontrer le fonctionnent du mpu-6050. On peut voir que lorsque nous bougeons l’objet équipé du capteur, l’image dans la représentation graphique bouge également.