Version actuelle datée du 31 décembre 2016 à 23:25

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.)

schéma réalisé sur logisim

Nous avons pu voir un des afficheurs que nous utiliserons et ainsi trouver sa datasheet sur internet.

Media:datasheet.pdf

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é par la réalisation de la liaison série. Pour notre projet, nous allons enregistrer une phrase qui sera écrite sur la page web. Cette phrase n'est rien d'autre qu'une séquence de caractères qui se termine par un caractère spécial. La séquence sera convertie en code ASCII (code binaire relatif à chaque caractère) et envoyée à l'Arduino (qui pour le moment remplace la carte électronique qui est en cours de réalisation) qui se chargera de reconvertir le code ASCII en une suite de caractères qui pourra être envoyée aux afficheurs.

La liaison série sera donc l'outil qui permettra d'envoyer le code ASCII de l'ordinateur à l'Arduino. Pour ce faire, nous avons utilisé un outil de gestion de liaison série que Posix met à disposition. Cet outil permet d'ouvrir un canal de communication entre l'ordinateur et l'Arduino par le biais d'un câble USB.

Pour gérer la conversion des caractères en code binaire, nous avons utilisé le même code qui figure dans la librairie de l'Arduino. Nous stockons la phrase dans une variable, puis nous récupérons sa longueur. Ensuite nous convertissions chaque caractère, du début de la phrase jusqu'à la fin et nous l’envoyons. Pour s'assurer du fonctionnement, nous avons testé avec un message envoyé dans le code (et non à partir de la page web puisque nous ne l'avions pas encore fait).

Le code réalisé est visible ici :Média:code_seance1.pdf

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.

registre memoire

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.

compteur et décodeur

multiplexeur

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.

afin réaliser les tests sans la liaison série, il faut entrer à la mains les valeurs à mémorisées, ici 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

Durant cette séance, nous avons commencé à réaliser la page web. Nous voulons envoyer la phrase, écrite dans le navigateur web, à notre programme qui se chargera de l'envoyer à l'Arduino. Pour cela, nous devons instaurer une communication entre les deux. A cette fin, nous allons utiliser un web socket. Nous allons ouvrir une communication au niveau de notre programme et nous mettre en attente de recevoir notre phrase venant du browser.

Ensuite, nous avons créé une page HTML dans laquelle nous avons mis un champ où l'on pourra saisir la phrase à envoyer aux afficheurs. Cette page doit pouvoir stocker et envoyer la phrase au programme. Pour ce faire, on insère dans la page, du code JavaScript qui permettra d'ouvrir une communication grâce au web socket et envoyer ainsi les données. Le code réalisé fonctionne mais l'afficheur ne fait pas défiler la phrase, il ne l'affiche qu'une seule fois. La prochaine étape sera de faire en sorte que la phrase parcourt les afficheurs continuellement.

Après l'implémentation, nous avons testé le programme.

page web

Code du programme : Media : code_seance2.pdf

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

Après avoir corrigé et réajusté notre application en donnant la possibilité à l'utilisateur d'augmenter ou de diminuer la vitesse de défilement des lettres sur les afficheurs, nous avons commencé à configurer la Raspberry pour y mettre toute l'application. Nous avons revérifié le tout à partir de la Raspberry et nous nous sommes assurées que tout fonctionnait comme avant.

Code Raspberry : Media : code_final.pdf

Code page web : Media : code_page.pdf

Video : Media : video_info.mp4

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.

câblage de la carte à afficheurs vers la Nanoboard

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.

câblage des sorties de la Nanoboard vers l'appareil de mesure

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.

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.

Maintenant, il ne reste plus qu'à travailler sur la liaison série coté Nanoboard et lier les parties informatique et électronique ensemble.

Séance supplémentaire 3 (2h)

Pour cette dernière séance, nous avons préparé la liaison série avec AltiumDesigner. On nous a donné le programme qui réalise la liaison pour recevoir 8 bits, mais comme pour notre application nous avons besoins de recevoir les 16 bits composant une lettre il a fallu le modifier.

Nouveau programme de réception sur la liaison série : Media: Reception.pdf

Schéma Altium : Media:Schema_Altium_Avec_Liaison.pdf

raspberry utilisée lors de la séance

écran de l'ordinateur lors du test

Lors de cette séance, nous avons pus voir que la liaison série fonctionnait correctement . Malheureusement, bien que sur l'ordinateur nous pouvions voir la phrase défilée, nous ne pouvions pas le vérifier grâce à la partie électronique car les afficheurs n’étaient pas assez lumineux .En effet nous voyons bien que des mots défilent bien mais nous ne pouvons pas vérifier qu'il s'agit des bonnes lettres étant données que la luminosité très faible de certain segments.

Video : Media : Affichage_Phrase.avi

Conclusion

Lors de ce projet, nous avons réalisé une série d'afficheur qui fait défiler une phrase saisie par le biais d'une application web. Malheureusement, biens que notre travail semble réussit nous ne pourrons jamais être certain de son succès car la luminosité des afficheurs n'est pas suffisante afin de vérifier que la phrase envoyé par le biais de l'application web est bien celle qui défile.

Pour que le projet soit parfait il aurait fallu ajouter une carte de puissance entre les broches des afficheurs et la sortie de la nanoboard. Nous savons néanmoins que la donnée envoyée par la raspberry est la bonne et que les afficheurs reçoivent correctement une phrase qui est affichée et défile correctement.

La difficulté principal rencontrée lors de la réalisation de la partie informatique a été de se familiariser à des technologies que nous n'avions jusqu'alors jamais vu (Websocket, Raspberry ). Mais nous avons néanmoins réussi à réaliser le projet notamment en faisant le lien entre l’envoie de donnée et l'application Web .

En conclusion, nous somme satisfait du résultat de notre projet qui nous a beaucoup appris. Ce premier projet "système communiquant" nous a permis de mettre en application les connaissances acquisent lors de la formation. Il nous a également permis d'avoir une première idée sur le travail de réalisation d'un projet à partir d'un cahier des charges que nous avons nous même établit. Ce projet nous a donné l’opportunité d’acquérir de nombreuse compétences en manipulant des outils auquel nous n'avions jamais eu accès jusqu’à maintenant.