Projet IMA3 P1, 2015/2016, TD1
Sommaire
Projet IMA3-SC 2015/2016 : Titre
Cahier des charges
Dans le cadre du projet IMA3, nous avons décidé de réaliser un afficheur qui ferait défiler une phrase saisie par le biais d'une application web. L'application enverrait cette phrase par le biais du port série à la carte électronique et aux afficheurs. Nous avons l'intention de réaliser cela grâce à des afficheurs 16 segments.
Le matériel nous paraissant indispensable est le suivant :
- huit afficheurs 16 segments
- une Nanoboard
- une Raspberry Pi
Séance 1
Partie électronique
Pour commencer cette partie du projet il a fallu réfléchir à comment et avec quoi nous allions le réaliser.
Préalablement nous avions réfléchi au multiplexage des afficheurs car nous savions que la Nanoboard ne possédait pas suffisamment de sorties pour pouvoir y connecter chaque pin des afficheurs, il aurait fallu 136 sorties (17 pins x 8 afficheurs). Nous avons pu, grâce au logiciel Logisim, tester le multiplexage d'afficheurs sept segments. On peut voir ci-dessous le résultat. Le multiplexage est réalisé par les sept multiplexeurs qui sont, en sortie liée à chaque segment des afficheurs (un multiplexeur par segment) et en entrées, on retrouve les valeurs de l'affichage pour chaque afficheur (quatre afficheurs donc quatre entrées). Les labels (A, B, etc.) en sortie des multiplexeurs représentent les pins de sortie de la Nanoboard. (Le reste du schéma ne sert que pour pouvoir afficher les valeurs sur le logiciel.)
Nous avons pu voir un des afficheurs que nous utiliserons et ainsi trouver sa datasheet sur internet.
Nous avons ainsi appris que les afficheurs étaient à anodes communes - pour les faire fonctionner il faut mettre l'alimentation (1 logique) sur le pin de l'anode (ici pins 6 et 18) et la masse (0 logique) sur les pins des segments à allumer. Pour sélectionner l'afficheur qui devra être éclairé il faudra mettre ses pins 6 et 18 à "1" et ceux des autres afficheurs à "0".
Nous avons terminé la séance en commençant à nous familiariser avec le logiciel AltiumDesigner pour pouvoir faire la programmation de la Nanoboard durant la séance suivante.
Partie informatique
Nous avons commencé à implémenter la partie réseau et à faire les tests à partir de l'arduino fournie .
Nous avons également découvert que le passage de la lettre ASCII en codage afficheur devait être implémenté dans le programme . Nous avons donc commencé à coder chaque lettre en binaire à partir de la disposition de chaque segment de nos afficheurs . Le codage réalisé est visible ci-dessous.
Nous avons également effectué la liaison série entre l'arduino et l'ordinateur.
Séance 2
Partie électronique
Lors de cette séance, nous avons réalisé le schéma logique qui sera implanté sur la Nanoboard avec AltiumDesigner.
Media : Schema_Altium_Alphabet.pdf
Pour pouvoir afficher les lettres à la vitesse que l'on souhaite sans dépendre de la liaison série, nous avons décidé de nous servir de registres afin de mémoriser le code de chaque lettre reçue sur le port série. Il faut 8 registres 16 bits pour pouvoir stocker la valeur de chaque segment par afficheur. Sur l'image qui suit, on peut voir le registre servant pour mémoire de l'afficheur 1. La sortie de la mémoire est décomposée par bit pour qu'ils soient envoyés vers le bon multiplexeur pour la suite. L'ordre des bits à été donné par la partie informatique.
Nous avons utilisé un compteur ainsi qu'un décodeur afin de sélectionner l'afficheur à allumer. Nous avons également utilisé des multiplexeurs gérés par le même compteur qui permettent de sélectionner la mémoire dans laquelle il faut aller lire. Il y a 16 multiplexeurs à 8 entrées car 16 segments sur les afficheurs et 8 afficheurs en tout.
Sur le pdf précédent et sur les deux images ci-dessous, nous pouvons voir que la sortie du compteur est reliée aux commandes des multiplexeurs et du décodeur (ce compteur compte de 0 à 7). C'est par le biais du décodeur qu'est sélectionné l'afficheur mis en marche. Les multiplexeurs permettent d'aller chercher les données dans la mémoire correspondante. Ex: Lorsque le compteur est à 0, les segments sont lus dans la mémoire 1 (pin 0 des multiplexeurs) et envoyés vers l'afficheur 1.
Pour pouvoir réaliser les premiers tests sans la réception des données par la liaison série, il faut placer en entrée des mémoires les valeurs à mémoriser. Pour ce test, nous avons décidé d'afficher les premières lettres de l'alphabet.
Dans le registre 1 (image ci-dessous) entre un bus de données initialisé avec des 0 (GND, segment éteint) et des 1 (VCC, segment éclairé) pour réaliser la lettre A.
Maintenant, pour pouvoir réaliser les tests, il faut que nous reliions les afficheurs et la Nanoboard. Une fois cela fait, il ne restera plus qu'à travailler la liaison série afin de récupérer et d'afficher les phrases envoyées depuis l'application web.
Partie informatique
Nous avons effectué des tests afin de connaitre le code binaire pour chaque segment de l'afficheur et avons découvert que les segments n’étaient pas dans l'ordre déterminé dans la séance 1 .
Nous avons repris la conversion faite dans la librairie de l'arduino tout en l'adaptant à notre projet.
implémentation de la conversion
En utilisant les websockets et la librairie jquery, nous avons ensuite implémenté la page web dans laquelle nous devons écrire la phrase à envoyer à l'afficheur par le biais de la liaison série. Nous avons testé avec un mot.
imprime écran de la page web
Dans la prochaine séance, nous essaierons de faire décaler les lettres de façon à ce qu'une phrase puisse défiler le long des afficheurs et d'implémenter le tout dans la Raspberry.
Séance 3
Partie électronique
Pendant cette séance, nous avons réalisé la carte PCB pour lier les afficheurs.
° La carte avait été préalablement routée avec le logiciel Kicad. Il a fallu créer le schéma des afficheurs dans la bibliothèque de composants du logiciel car il n'y était pas. Cela a été possible grâce aux informations données dans la datasheet du composant.
° La carte a ensuite été réalisée à l'aide d'une graveuse mécanique, ce qui a pris un certain temps.
° Une fois la gravure terminée, la soudure a pu commencer mais la forme des afficheurs étant particulière, il a fallu couper des supports en deux et enlever certains pins.
Cette partie du travail a été longue, elle a pris plus de 4h.
Nous nous sommes rendu compte à la fin que nous avions oublié de prévoir une place pour les résistances et finalement nous n'avons que trois afficheurs verts et un bleu (peut-être 4 bleus mais il faut que les trois manquants soit dessoudés ailleurs).
Lors de séances supplémentaires, il faudra souder des résistances et tester l'affichage.
Partie informatique
Séance supplémentaire 1 (30min)
Partie électronique
Soudure des résistances Les afficheurs n'étant pas tous de même couleur, les tensions d'alimentation ne sont pas non plus les mêmes. Ce qui est également le cas entre les petits et les grands segments. Il a donc fallu mettre des résistances différentes en fonction des segments et respecter les valeurs de tension de l'afficheur dont la tension max était la plus faible. On a ensuite allumé tous les segments du premier afficheur avec un Arduino en alimentation.
Séance supplémentaire 2 (2h)
Partie électronique
Affichage de l'alphabet Lors de cette séance, nous avons pu commencer à faire les tests avec la Nanoboard.
IMG_4278 :
Nous avons connecté trois sorties de la Nanoboard sur un appareil ce qui nous a permis de voir la mise en marche des trois premiers afficheurs. On voit bien que chaque afficheur est en marche 1/8 du temps et qu'ils fonctionnent bien les uns après les autres.
IMG_4280 :
imag9
Lors du test par lui-même, nous avons eu la mauvaise surprise de découvrir que la Nanoboard de génère pas suffisamment de courant pour faire fonctionner les afficheurs.
On peut voir sur la photo ci-dessous que seuls les petits segments s'éclairent.
Néanmoins, le test est concluant, lorsque l'on sait quelle lettre est écrite, on la reconnait bien sur l'afficheur.
imag10
Sur l'image qui suit, on peut voir qu'en affichant le signal d'une sortie branchée à un des grands segments, on retrouve bien les changements d'état en fonction de l'afficheur sélectionné. On sait donc ainsi que cette partie de notre projet est fonctionnelle.
imag11
Maintenant, il ne reste plus qu'à travailler sur la liaison série coté Nanoboard et lier les parties informatique et électronique ensemble.
