Version actuelle datée du 26 mai 2011 à 10:37

Objectifs

Le but de ce projet est de créer un système permettant à partir de 4 micros d'afficher automatiquement le temps de paroles de plusieurs personnes qui ne sont pas nécessairement devant un micro. Ce temps de parole sera matérialisé sur une dalle composé de 9 sous-matrices de LED 8*8.

Préparation du projet

Matériel Requis

• 9 matrices de LED à commandes SPI (https://www.sparkfun.com/products/760) -> disponibles en F004 ;
• 4 microphones:
  • selectronic (possibilité de commander par 10)
  • ou alors microphone des casques du labo de langue (déjà 2 de disponible)
• Condensateurs et resistances pour alimentation et récupération du signal : R1=4K7 C1=10u

[[1]]

• 1 foxboard -> disponibles en F004.
• Des cables de liaison ( voir avec Thierry)
  • 2 "nappes" de 6 fils de 50cm
  • 1 fil male-femelle de 50cm

Avancement du projet

Vous pouvez suivre l'avancement de notre projet sur le lien suivant Avancement du projet : Schéma GANTT

Première Etape

Recherches préalables sur le sujet, Definition du cahier des charges.

Recherche sur le sujet

Projet de l'EPFL : Table de conversation Reflect

Un projet similaire au notre a été réalisé à l'EPFL. Il serait donc interessant d'étudier ce projet, afin de trouver des idées de réalisation.

Voici une vidéo de démonstration du projet TABLE DE CONVERSATION REFLECT de l'EPFL : Vidéo de démonstration du projet EPFL
Idées retenues :

• réalisation d'un jeu type Snake guidé par la voix;
• visualisation de l'implication des personnes dans la conversation par le nombre de LED allumées;
• attribution d'une couleur de LED à chaque personne.

Technologies utilisées et caractéristiques de la parole

Caractéristique de la parole : La parole

Cahier des charges

• Commande du matériel
• Assemblage des matrices de LED
• test des exemples de code fournis pour l'allumage des LED via liaison Série
• Réalisation du modéle Altium
• Connexion de la maquette Altium en entrée de l'arduino
• Analyse et traitement des signaux issus des microphones
• Developpement du programme de récupération des données provenant de la carte Altium (intensité sonore de chaque micro, type d'affichage à réaliser)
• Réaliser affichage des informations issue de la carte Altium
• Paramétrage de la foxboard

Bilan de fin de Séances

Séance n°1

• Taches réalisées :
  • Connexion des matrices entres elles ( 3 par 3)
  • Connexion d'une matrice au dispositif arduino
  • Test d'un exemple de code pour l'allumage des LED de la matrice Test
  • Prise en main de la matrice par des tests persos

• Objectifs pour la séance suivante :
  • Determiner le matériel à commander ( micro et cables de connexion entre les matrices)
  • Test sur une matrice et sur 2 matrices

Jeudi 04 mars 2011

Objectif: faire la liste la plus exhaustive possible du matériel nécessaire

Séance n°2

• Taches réalisées :
  • Test de mise en chaine de toutes les matrices
    1 matrice est defecteuse.
  • Définition de la liste de matériel à commander ( voir section Matériel )
  • modification du cahier des charges, mise à jour du GANTT

• Objectifs pour la seance n°3:
  • Prise en main de altium : Réalisation d'un modèle de test sans micro
  • Controle du contenu de chaque matrice
  • Definition du contenu des matrices en fonction des entrées ( ex: on connecte un bouton et en fonction de son etat on colore les matrices Bouton/LED)
  • Se renseigner sur les cables pour lier les matrices

Séance n°3 & 4

• Tache rélisées :
  • Réalisation du modèle sous altium ( shématic)
  • Etude d'un exemple de traitement sonore sous altium
  • Changement de l'affichage de la matrice en fonction de l'appuie sur 2 boutons
  • Tests sur les matrices afin de les chainer et de les dissocier les unes des autres ( en cours)
  • Recherche de solutions pour chainer les matrices avec des cables. Solution : prendre des cables assez long ( commande en cours auprés de Monsieur Thierry ???)

• Objectifs pour la séance 5
  • Etude de l'exemple sous altium ( code C)
  • Réalisation d'un code C simple sous altium
  • Tests sur les matrices afin de les chainer et de les dissocier les unes des autres
    • [Code à tester]
    • [Autre code avec 4 matrices]
  • Mise à jour du GANTT et Réalisation d'un schéma de fonctionnement

Séance 5

• Tâches réalisées :
  • Configuration des matrices en mode chaîne
  • Premiers affichages sur 4 matrices chaînées
  • Realisation du code C sous Altium (en cours de debbuguage)

• Objectifs séance 6 :
  • Tester avec une chaîne de 8 matrices
  • Commencer à voir la gestion des 9 matrices (sachant que l'on peut uniquement les chaîner par 8)
  • Voir pour la gestion de l'affichage du temps de parole
  • Modifier un code Altium donné en exemple pour essayer d'enregistrer le son issu du micro et de lire les données numérisées

Séance 6 et 7

• Tâches réalisées :
  • Mise a jour du schéma GANTT
  • Réalisation schéma de fonctionnement global [Schéma de fonctionnement]
  • Travail sous altium : Récupération des données numériques issues du microphone
  • Confection d'un cable pour relier 2 séries de 3 matrices
  • Création du code permettant de gérer 3 ou 6 matrices pour l'affichage final

• Objectif Séance 8 :
  • Etudier les données issues du microphone
  • Traiter les données issues du microphone et envoyer le resultat pour Arduino
  • Tester une[liaison série] entre les 2 arduinos pour partager les 4 entiers correspondants aux "temps" de parole 4 micro
  • Tester l'alimentation des arduinos par alimentation externe.

• Objectif à venir :
  • Brancher 2 microphones

Séance 8

• Tâches réalisées :
  • Allumage des LED quand la parole est detecté par le micro
  • MAJ Gantt
  • Liaison série basique entre 2 arduino
  • Test de positionnement des matrices et arduinos sur une plaque plexiglas.

• Objectif seance 9 :
  • Envoyer sur les ports de sortie l'information sur ce qui est detecter dans le micro
  • Connecter les ports de sortie sur arduino et tester le dispositif avec 1 seul micro

Séance 9

• Tâches réalisées :
  • Allumages d'un certain nombre de LED en fonction de l'intensité de la voix sur la nanoboard.

• Objectifs séance 10:
  • Installer l'IDE arduino sur un PC de la salle Altium.
  • Voir Mr Flamman pour connecter 2 micros à la nano board.
  • Tester la connexion entre la nanoboard et arduino.
  • améliorer la liaison série entre les 2 arduinos.
  • fixer les matrices sur le plexiglas

Séance 10

• Tâches réalisées :
  • Réalisation du connecteur pour pouvoir connecter 2 micros sur une seule entrée jack (stereo) (Merci à Monsieur Thierry Flammand ;) )
  • Preparation de la plaque de plexiglas pour fixer les matrices de LED
  • Réflexion sur les modélisations à réaliser pour visualiser le temps de parole

• Objectifs pour la séance 11:
  • Observer les valeurs échantillonnées obtenues des 2 micros connecter sur l'entrée jack.
  • Comparer les signaux des 2 micros et designer le micro detectant de la parole pour l'envoyer ensuite à l'arduino
  • Percer la plaque de plexiglas
  • Réaliser une modélisation du temps de parole pour 2 micros

• Objectifs à venir :
  • Connecter l'ensemble du dispositif ( Micro -> Altium -> Arduino -> Matrice de LEDs)
  • Etudier les différentes possibilités offertes à nous pour connecter 4 micros ( 2 nanoboards ou utiliser l'entrée LINE IN)

Séance 11 & 12

affichage de nombres

• Tâches réalisées :
  • Test sous altium pour récupérer les echantillons correspondant à chacun des micros sur chacune des voies stéréo ( en cours)
  • Réalisation de l'assemblage des matrices de LED sur une plaque (avec les conseils de Thierry Flammand)
  • Création d'un fonction d'affichage "scalable" de nombres pour afficher les pourcentages et pour les tests de laison série.

• Objectif pour les séances 13 & 14
  • Dissocier les voies stéréos sous altium
  • Envoyer les données vers la nanoboard

Séance 13 & 14

• Tâches réalisées :
  • Affichage du pourcentage de temps de parole pour 2 micros (simulés) sur un seul arduino (et donc 6 matrices).
  • Test de liaison série entre les 2 arduinos (en cours)
  • Test de connexion directe d'une entrée (ici un bouton) simultanéement sur les 2 arduinos pour éviter la liason série. Résultat : comme "prévu" il y a un un décalage d'incrémentation entre les 2 arduinos, cette méthode n'est donc pas précise.

• Objectif pour les séances 15 & 16
  • Finir la liaison série
  • Imlémenter différentes fonctions d'affichage avec un nombre de micro différents (typiquement 2 ou 4).

Séance 15 & 16

Affichage type "quart de cercle"

Affichage type "Points Aléatoires"

• Tâches réalisées :
  • Test Stereo sur 8 bits, 12 bits (en cours)
  • Liaison série entre les 2 arduinos ok.
  • Création de 3 types d'affichage : "nombre pourcentage", "quart de cercle" et "point aléatoire".
  • Ajout d'un bouton pour switcher entre les différents affichages : quelques soucis de synchronisation, notamment via la liaison série.

• Objectif pour les séances 17
  • Comprendre la façon dont sont stockées les données issues des micros dans le buffer par Altium
  • Refaire un beau cablage des Arduinos car les projet de réseau seront finis
  • Améliorer la gestion des modes d'affichage

Séance 17 & 18

• Tâches réalisées :
  • Amélioration du code Arduino pour resoudre les soucis de transmission.
  • Création des nappes pour relier les arduinos aux matrices
  • Realisation d'une version du projet altium fonctionnant avec un micro (avec envoi de l'information sur les User Header). Ainsi nous pourrons réaliser une première version du projet en utilisant 2 nanoboards
  • Travail sur la stéréo ( affichage de tous les bits stockés dans le buffer -> aucune logique relevée...)

• Objectif pour les séances 19 et séances altium suppplémentaire
  • optimiser le programme Arduino et tester plus le code.
  • fixer les Arduinos sur une plaque plexiglas
  • tester la connexion entre Arduino et la Nanoboard
  • rechercher encore comment fonctionne la stereo ( forum, modification taille buffer, etc)
  • essayer de faire passer le signal du deuxième micro sur l'entrée LINE IN de la nanoboard et non plus en utilisant l'embout "jack-2jack" créé.

Séance supplémentaire

• Tâches réalisées:
  • Etude du fonctionnement des analogue input.
  • Creation d'un embout pour pouvoir connecter un microphone sur ANALOGUE IN sans avoir a dénuder les cables
  • Creation d'un projet Altium pour récupérer le signal issu des ANALOGUE IN ( sans resultat)
  • Mise en place d'un "interrupteur" 3 positions pour la selection du mode.
  • Sytème d'optimisation de la liaison série

• Bilan de la partie du projet sur Altium :

Nous avons étudié 3 solutions différentes pour connecter et traiter les signaux issues de 2 microphones sur 1 Nanoboard :

• • Connecter 2 micros sur l'entrée MIC en utilisant la stéréo
  • Utiliser l'entrée LINE IN pour connecter le 2nd micro
  • Utiliser les entrées ANALOGUE IN pour connecter le 2nd micro

Malheureusement, aucune de ces solutions n'a pu fonctionner sous la plateforme Altium. Etant donné le peu de temps restant pour terminer le projet, nous utiliserons donc 2 nanoboard pour faire une représentation finale correcte de notre projet.

Objectifs complémentaires

• Voir pour la possibilité de faire fondre un composant à partir du code Altium pour se passer du FPGA, et voir aussi pour ses composants electroniques.

Résultat

Nous en sommes arrivé a un système fonctionnel, notemment pour faire une vidéo de présentation, avec 2 micros et 3 modes d'affichage. Nous avons ainsi connecté un micro par nanoboard et, en mettant toutes les masses communes, avons directement connecté les huser header utilisés sur les entrées digital de l'arduino maitre. Ce dernier gére le pourcentage de parole de chaque participant et envoit les pourcentages associés à l'arduino esclave par liaison série.

Montage final

Améliorations possibles

• Faire plus de recherches sur la stéreo sous altium pour avoir au moins 2 micro par nanoboard.
• Voir les différentes entrée proposées sur les nanoboard pour augmenter le nombre de micro à 4 par nanoboard
• Gérer ces 4 micros sur arduino
• Améliorer le selecteur de mode d'affichage
• Ajouter un bouton de mise à zero
• Implémenter de nouveau modes d'affichage
• Liaison sans fil entre les nanoboard et les arduinos pour pouvoir deporter l'affichage de la prise de son.

Ressources

• Code source Arduino
• Sources projet Altium