Contrôle de matrice leds, 2013/2014, TD1 : Différence entre versions

De Wiki de Projets IMA
Ligne 1 : Ligne 1 :
−
Contrôle de matrice de LEDs
+
==Contrôle de matrice de LEDs==
 +
 
 +
===Présentation du projet===
 +
 
 +
==== Principe ====
 +
 
 +
Le projet consiste à allumer et éteindre des leds sur une matrice 8x8 de leds à partir d'un site web hébergé sur une Foxboard. Ainsi l'utilisateur peut créer l'image qu'il souhaite à travers son navigateur et ensuite l'envoyer sur la maquette d'essai, ici la Nanoboard, qui contrôlera la matrice de LEDS. Il a été réalisé par Colautti Kevin, Danel Thomas et Lefort Benjamin.
 +
 
 +
==== Eléments ====
 +
 
 +
Les éléments mis en oeuvre pour la réalisation du projets sont :
 +
**navigateur pour visualiser le site web
 +
**Foxboard hébergeant le serveur Web
 +
**module de communication série
 +
**Nanoboard contrôlant la matrice 8x8 de leds câblée en rouge
 +
**banc d'essai Arduino avec une matrice 16x16 de leds RGB
 +
 
 +
==== Modes ====
 +
 
 +
L'interface web permet de choisir la taille de la matrice et le type de LED (monocouleur ou RGB).
 +
 
 +
===Première séance===
 +
 
 +
====Partie info:====
  
−
partie info:
 
−
première séance :
 
 
création site web
 
création site web
 
page d'accueil permettant de choisir la taille de la matrice (n lignes et m colonnes)
 
page d'accueil permettant de choisir la taille de la matrice (n lignes et m colonnes)
Ligne 9 : Ligne 30 :
 
qui affiche cette matrice de LEDs qui pour l'instant sont vertes par défaut et deviennent rouge en cliquant dessus
 
qui affiche cette matrice de LEDs qui pour l'instant sont vertes par défaut et deviennent rouge en cliquant dessus
  
−
deuxième séance :
+
====Partie élec:====
 +
 
 +
Pendant cette première séance, nous nous sommes définis un cahier des charges restreint compte tenu de la difficulté du sujet. A savoir, nous ne traiterons dans la partie électronique que la matrice 8*8 en monocouleur. Nous avons alors étudié la documentation technique de la matrice de Leds pour savoir comment la commander. Nos TP de microprocesseurs nous ont alors servis à trouver l'astuce pour afficher toute la matrice. Notre idée est de stocker des mots de 8 bits dans un registre, pour chaque ligne. Ensuite, on envoie les bits un à un puis on affiche les colonnes une à une, en synchronisation avec l'envoi des bits (même clock).
 +
 
 +
Il nous faut donc en tout 16 sorties : 8 pour les colonnes et 8 autres pour les lignes. La prochaine étape serait de mettre ça au propre sous Altium, ce qu'on a commencé  à faire en fin de séance.
 +
 
 +
===Deuxième séance====
 +
 
 +
====Partie info:====
 +
 
 
essaie de la liaison série
 
essaie de la liaison série
  
Ligne 29 : Ligne 59 :
  
 
début du cgi-bin et en galère =D
 
début du cgi-bin et en galère =D
 +
 +
====Partie élec====
 +
 +
Cette séance fut riche en avancées pour la partie électronique : nous avons en effet pu mettre en place le circuit nécessaire à la réalisation de notre projet.
 +
 +
 +
==== Justification du choix des composants ====
 +
 +
 +
Transcrire le fonctionnement général ne fut pas chose aisée : en effet, nous devions trouver des composants  correspondant parfaitement à nos besoins. Tout d'abord, nous avons réfléchi à la manière dont nous pouvions stocker les "messages" qui nous parvenaient. Une petite révision dans nos cours de logique nous a rapidement conduit à prendre 8 bascules pouvant chacune stocker 8 bits d'information (une bascule stocke l'information d'une colonne). Il restait malgré tout à les sélectionner, pour que la bascule 1 stocke le message 1, la bascule 2 le message 2 etc. Sachant qu'une bascule est sélectionnée uniquement quand le bit de passage est à 1, nous avons rapidement compris que l'usage d'un démultiplexeur complémenté par un compteur était nécessaire. Le raisonnement fut similaire pour créer les 16 sorties de notre système : nous devions sélectionner les bascules à tour de rôle, mais assez rapidement pour que l’œil y voit un système fixe. Nous avons donc utilisé un multiplexeur et un démultiplexeur, accompagnés par un compteur.
 +
 +
                    [[Fichier:Capture15.jpg]]
 +
 +
==== Détails et explications approfondies ====
 +
 +
 +
''Un compteur 3 bits''
 +
 +
Les deux compteurs que nous avons choisis devaient sélectionner les 8 bascules, à tour de rôle. Nous avons donc choisi un compteur pouvant s’incrémenter de 0 à 7 pour les sélectionner. Or, pour compter sur cette plage, il suffit de 3 bits, ce qui justifie notre choix.
 +
 +
''Un multiplexeur 8 vers 1''
 +
 +
Comme dit précédemment, le multiplexeur a pour rôle de sélectionner à tour de rôle les bascules, et permettre d'afficher uniquement le message de celle qui a été sélectionnée. Nous avons donc choisi un multiplexeur 8 vers 1 : 8 bascules en entrée et 1 bus en sortie. Puis nous avons décomposé le bus de sortie en 8 bits, les 8 bits du message envoyé.
 +
 +
''Les démultiplexeurs 1 vers 8''
 +
 +
Les démultiplexeurs servant uniquement à envoyer des "1" sur les différents ports (les 8 bascules et les sorties), il s'est imposé de prendre des démultiplexeurs 1 vers 8, où l'entrée serait un "1" (VCC dans le schéma).
 +
 +
''Justification du choix sur les horloges et premiers problèmes''
 +
 +
Il était nécessaire de pouvoir régler l'horloge de sortie du système, afin de trouver une fréquence idéale à la réalisation de notre système.
 +
La Nanoboard dispose d'une horloge interne, réglable directement sur Altium. Nous avons donc décidé de l'utiliser pour notre projet, celle-ci répondant parfaitement à nos critères. De plus, la sélection des colonnes et l'envoi des informations devant se faire au même rythme, il fut aisé de comprendre que le multiplexeur et le démultiplexeur de sortie devaient être reliés à la même horloge.
 +
 +
Pour le multiplexeur d'entrée, la réflexion fut plus difficile et des problèmes apparurent lors des tout premiers tests.
 +
En effet à l'origine, nous avions relié le compteur d'entrée à la même horloge que celui de sortie. Mais notre groupe s'est rapidement aperçu que cela ne fonctionnait pas. Il fallait que le compteur soit coordonné avec la réception du mot. Il était clair alors qu'il fallait relier le bit de présence du mot avec l'horloge de notre compteur d'entrée, afin d'obtenir le résultat voulu.
 +
 +
==== Résultats des tests ====
 +
 +
 +
Après avoir fini et compilé le montage sur Altium, nous avons effectué des tests, afin de savoir si il était correct. Nous avons donc branché les ports de sortie de la Nanoboard sur un oscilloscope. Voici ce que nous avons observé :
 +
 +
[[Fichier:Capture16.jpg]]                                                       
 +
 +
----
 +
 +
 +
[[Fichier:Capture17.jpg]]
 +
 +
Nous avons envoyé 8 messages l'un après l'autre, puis observé les résultats. Sur les images ci-dessus, on voit bien que chaque message est rangé dans une colonne. Il nous restait maintenant à câbler notre matrice, et à faire de nouveau des tests sur celle-ci.
 +
 +
===Séance 3===
 +
----
 +
===Partie informatique===
 +
 +
====Configuration supplémentaire du CGI-BIN====
 +
 +
Pour pouvoir afficher quelque chose sur la matrice du banc Arduino, il faut modifier les droits dans le dossier /etc/group afin que l'utilisateur (www-data) en tapant ceci :
 +
chown www-data /dev/ttyUSB0
 +
 +
====Configuration Foxboard====
 +
 +
L'adresse de notre Foxboard est : 172.26.79.8. Chaque modification devra être suivie d'un reboot de la Foxboard afin que ces modifications soient prises en compte. Dans le fichier /etc/apt/sources.list, il faut changer l'adresse du serveur existant pour le remplacer par celui de Polytech'Lille.
 +
Pour configurer la carte Ethernet, il faut écrire les lignes suivantes dans le fichier /etc/network/interfaces : [[Fichier:avant.png|thumb|right|Avant]] [[Fichier:après.png|thumb|right|Après]]
 +
auto eth0                                               
 +
iface eth0 inet static
 +
  address 172.26.79.8
 +
  netmask 255.255.240.0
 +
  gateway 172.26.79.254
 +
  dns-nameservers 193.48.57.34
 +
 +
====Importation des fichiers sur la Foxboard====
 +
 +
Pour pouvoir mettre les différents fichiers nécessaires au projet, on se connecte en SSH en tant que root. On a placé dans le dossier /root les fichiers serial.h, serial.c et matrice.c et dans le répertoire /var/www les fichiers index.html, cercle.php, matrice.php, jquery.js. L'installation de php5-gd et de cgilib sera nécessaire. Nous avons inclus dans le fichier /etc/rc.local les utilitaires stty et sleep afin d'éviter de les réécrire à chaque compilation du CGI-BIN.
 +
 +
====Mise en forme de l'interface====
 +
 +
Pour rendre l'interface plus agréable à visionner nous avons créé un fichier style.css utilisé dans les fichiers index.html et matrice.php, nous avons également mis dans le répertoire du serveur local une image du logo de Polytech'Lille.
 +
 +
====Conclusion====
 +
 +
Voilà à présent une image récapitulant les différentes interactions entre les fichiers réalisés dans la partie informatique de ce projet.
 +
[[Fichier:interactivites.png]]
 +
 +
===Partie électronique===
 +
 +
 +
 +
==== Câblage de la matrice de leds ====
 +
 +
 +
Le circuit Altium étant terminé,  il ne manquait plus qu'à réaliser le câblage de notre matrice de led 8×8. Nous avions à notre disposition la datasheet de la matrice ainsi que tous les composants dont nous pourrions avoir éventuellement besoin.
 +
 +
==== Détermination du choix des résistances ====
 +
 +
 +
 +
À chaque couleur de notre matrice correspondait un voltage différent, soient des résistances différentes. Il a donc fallu choisir une seule couleur, qui pour notre groupe fut le bleu. Nous devions alors appliquer une tension de 3,2 V aux bornes des leds, alors que la Nanoboard fournissait en sortie une tension de 5V.
 +
 +
La datasheet fournie nous recommandait de prendre un ampérage de 20mA, mais sur conseil de Mr Boe nous en avons pris un plus faible, soit 7mA.
 +
Nous avons d'abord effectué le calcul pour une led :
 +
[[Fichier:loimaille.jpg]]
 +
 +
 +
En faisant la loi des mailles 5V-3,2-RI=0, on obtient rapidement R=250 ohm, et la seule résistance qui se rapprochait était 220 ohm.
 +
 +
Mais comme nous n'avions pas qu'une led, le professeur nous a conseillé d'en prendre une de 880 ohm.
 +
 +
==== Sélection des broches ====
 +
 +
Comme notre groupe avait choisi la couleur bleu, il fallait brancher la matrice de sorte à ce qu'elle affiche les leds en cette couleur. D'après la datasheet qui nous avait été fournie, seules certaines broches correspondaient à cette couleur, ce qui justifie les emplacements de nos fils et résistances.
 +
 +
[[Fichier:CablageElise.jpg|thumb|right|Elise en train de réaliser le câblage de la matrice]]
 +
 +
Voici le schéma complet du câblage de notre matrice :
 +
 +
[[Fichier:Cablage2.jpg]]
 +
 +
==== Derniers tests ====
 +
 +
Suite à ce branchement, nous avons pris la décision de le tester immédiatement. Nous avons donc branché la Nanoboard à notre montage, et envoyé des mots pour observer le résultat.
 +
[[Fichier:Capture52.jpg|thumb|right|Schéma final projet]]
 +
[[Fichier:Branchement.jpg|thumb|left|Branchements à la Nanoboard]]
 +
 +
 +
C'est lors de ce dernier test que nous avons remarqué deux problèmes :
 +
 +
- D'abord la matrice affichait l'inverse des mots envoyés. Nous avons rapidement compris que la matrice allumait une led lors du passage à 0 et non à 1. Il fut alors facile de mettre des inverseurs sur les 8 sorties du message de notre schéma Altium, afin de régler ce problème.
 +
 +
- Nous nous sommes également rendus compte qu'il y avait un décalage dans l'envoi des mots. En effet, la première colonne ne recevait que le huitième mot et non le premier. Celui-ci était reçu par la deuxième colonne. Ce problème nous surprit car lors des premiers tests, ni nous ni le professeur ne l'avions remarqué. Ce problème fut résolu lors des tests où les 2 systèmes, informatique et électronique, furent reliés. La résolution est expliquée dans la partie leur étant dédiée.
 +
 +
Vous pouvez apercevoir à droite le schéma final de notre projet, après que le professeur ait rajouté la liaison série, permettant de recevoir le mot et le bit de présence.
 +
 +
===Séance de tests et vidéo===
 +
----
 +
[[Fichier:capture_windows.png|thumb|right|Logo qui fait tout buguer =D]] [[Fichier:photo_windows.jpg|thumb|right|Visualisation sur le banc Arduino]] [[Fichier:Resulat.jpg|thumb|left|Résultats des tests]]
 +
 +
====Différents tests====
 +
 +
Durant la séance de test, nous avons pu constater qu'en branchant directement la Foxboard sur le banc Arduino, le mode 16x16 multicolore fonctionnait parfaitement. Cependant, le mode 8x8 monocolore n'était pas encore fonctionnel car nous n'avions pas encore modifié le CGI-BIN pour qu'il puisse également fonctionner dans ce mode. En effet, dans ce mode, chaque colonne de la matrice reçoit un octet (c'est-à-dire chaque led reçoit un bit pour signaler l'état allumée ou éteinte). Ayant choisi dans la partie électronique de colorier en bleu les leds de la matrice, nous avons également mis en bleu celles de l'interface Web.
 +
 +
Lorsque le mode 8x8 a fonctionné, nous avons commencé à brancher tout le système avec le module de communication série et la Nanoboard. Nous devions à présent corriger le problème de décalage rencontré à la dernière séance. Au départ, une solution informatique avait été envisagée. Mais il s'est avéré que recâbler les entrées des bascules D était plus rapide et fonctionnait également. Après avoir fait ceci, nous avons modifié la fréquence d'horloge de la Nanoboard pour que la persistance rétinienne nous permette de voir un signal fixe et pour que la luminosité des leds soit suffisante pour être bien visible.
 +
 +
====Vidéo====
 +
 +
Nous avons pu être filmés afin de montrer que notre système est fonctionnel en particulier le mode 8x8 monocolore et ainsi le mode 16x16 multicolore lorsque l'on branche directement la Foxboard sur le banc Arduino.
 +
 +
===Conclusion===
 +
 +
Pour conclure, nous avons, lors de ce projet, mis en place un système permettant à un utilisateur de créer l'image qu'il souhaite sur une matrice de leds à partir d'une interface web.
 +
Malgré les difficultés rencontrées que ce soit dans la partie informatique ou électronique, nous avons réussi à faire la relation entre les deux pour avoir un système fonctionnel.

Version du 3 juin 2014 à 12:03

Contrôle de matrice de LEDs

Présentation du projet

Principe

Le projet consiste à allumer et éteindre des leds sur une matrice 8x8 de leds à partir d'un site web hébergé sur une Foxboard. Ainsi l'utilisateur peut créer l'image qu'il souhaite à travers son navigateur et ensuite l'envoyer sur la maquette d'essai, ici la Nanoboard, qui contrôlera la matrice de LEDS. Il a été réalisé par Colautti Kevin, Danel Thomas et Lefort Benjamin.

Eléments

Les éléments mis en oeuvre pour la réalisation du projets sont :

    • navigateur pour visualiser le site web
    • Foxboard hébergeant le serveur Web
    • module de communication série
    • Nanoboard contrôlant la matrice 8x8 de leds câblée en rouge
    • banc d'essai Arduino avec une matrice 16x16 de leds RGB

Modes

L'interface web permet de choisir la taille de la matrice et le type de LED (monocouleur ou RGB).

Première séance

Partie info:

création site web page d'accueil permettant de choisir la taille de la matrice (n lignes et m colonnes) le type de LEDs (couleurs ou non) le formulaire envoie vers un php (matrice.php "a vérifier") qui affiche cette matrice de LEDs qui pour l'instant sont vertes par défaut et deviennent rouge en cliquant dessus

Partie élec:

Pendant cette première séance, nous nous sommes définis un cahier des charges restreint compte tenu de la difficulté du sujet. A savoir, nous ne traiterons dans la partie électronique que la matrice 8*8 en monocouleur. Nous avons alors étudié la documentation technique de la matrice de Leds pour savoir comment la commander. Nos TP de microprocesseurs nous ont alors servis à trouver l'astuce pour afficher toute la matrice. Notre idée est de stocker des mots de 8 bits dans un registre, pour chaque ligne. Ensuite, on envoie les bits un à un puis on affiche les colonnes une à une, en synchronisation avec l'envoi des bits (même clock).

Il nous faut donc en tout 16 sorties : 8 pour les colonnes et 8 autres pour les lignes. La prochaine étape serait de mettre ça au propre sous Altium, ce qu'on a commencé à faire en fin de séance.

Deuxième séance=

Partie info:

essaie de la liaison série

USB : pifou@zabeth15:/media/usb0/projet_SC$ stty -F /dev/ttyUSB0 9600 cs8 -hupcl -icrnl -ixon -opost -onlcr -isig -icanon -iexten -echo -echoe -echok -echoctl -echoke ignbrk pifou@zabeth15:/media/usb0/projet_SC$ sleep 9999d 3</dev/ttyUSB0 &[1] 8179

Programme : pifou@zabeth15:/media/usb0/projet_SC$ stty -F /dev/ttyUSB0 9600 cs8 -hupcl -icrnl -ixon -opost -onlcr -isig -icanon -iexten -echo -echoe -echok -echoctl -echoke ignbrk pifou@zabeth15:/media/usb0/projet_SC$ sleep 9999d 3</dev/ttyUSB0 &[1] 8179

c=0 ou 256 led éteinte c=1 bleu c=255 rouge

création matrice de 256 caractères reçu par matrice.php ces caractères correspondent aux couleurs B=bleu, R=rouge ... (recherche couleur finie ou pas selon les besoins juste une traduction de binaire à hexa) switch case pour traiter les infos de la matrice

début du cgi-bin et en galère =D

Partie élec

Cette séance fut riche en avancées pour la partie électronique : nous avons en effet pu mettre en place le circuit nécessaire à la réalisation de notre projet.


Justification du choix des composants

Transcrire le fonctionnement général ne fut pas chose aisée : en effet, nous devions trouver des composants correspondant parfaitement à nos besoins. Tout d'abord, nous avons réfléchi à la manière dont nous pouvions stocker les "messages" qui nous parvenaient. Une petite révision dans nos cours de logique nous a rapidement conduit à prendre 8 bascules pouvant chacune stocker 8 bits d'information (une bascule stocke l'information d'une colonne). Il restait malgré tout à les sélectionner, pour que la bascule 1 stocke le message 1, la bascule 2 le message 2 etc. Sachant qu'une bascule est sélectionnée uniquement quand le bit de passage est à 1, nous avons rapidement compris que l'usage d'un démultiplexeur complémenté par un compteur était nécessaire. Le raisonnement fut similaire pour créer les 16 sorties de notre système : nous devions sélectionner les bascules à tour de rôle, mais assez rapidement pour que l’œil y voit un système fixe. Nous avons donc utilisé un multiplexeur et un démultiplexeur, accompagnés par un compteur. 

                    Capture15.jpg

Détails et explications approfondies

Un compteur 3 bits

Les deux compteurs que nous avons choisis devaient sélectionner les 8 bascules, à tour de rôle. Nous avons donc choisi un compteur pouvant s’incrémenter de 0 à 7 pour les sélectionner. Or, pour compter sur cette plage, il suffit de 3 bits, ce qui justifie notre choix.

Un multiplexeur 8 vers 1

Comme dit précédemment, le multiplexeur a pour rôle de sélectionner à tour de rôle les bascules, et permettre d'afficher uniquement le message de celle qui a été sélectionnée. Nous avons donc choisi un multiplexeur 8 vers 1 : 8 bascules en entrée et 1 bus en sortie. Puis nous avons décomposé le bus de sortie en 8 bits, les 8 bits du message envoyé.

Les démultiplexeurs 1 vers 8

Les démultiplexeurs servant uniquement à envoyer des "1" sur les différents ports (les 8 bascules et les sorties), il s'est imposé de prendre des démultiplexeurs 1 vers 8, où l'entrée serait un "1" (VCC dans le schéma).

Justification du choix sur les horloges et premiers problèmes

Il était nécessaire de pouvoir régler l'horloge de sortie du système, afin de trouver une fréquence idéale à la réalisation de notre système. La Nanoboard dispose d'une horloge interne, réglable directement sur Altium. Nous avons donc décidé de l'utiliser pour notre projet, celle-ci répondant parfaitement à nos critères. De plus, la sélection des colonnes et l'envoi des informations devant se faire au même rythme, il fut aisé de comprendre que le multiplexeur et le démultiplexeur de sortie devaient être reliés à la même horloge.

Pour le multiplexeur d'entrée, la réflexion fut plus difficile et des problèmes apparurent lors des tout premiers tests. En effet à l'origine, nous avions relié le compteur d'entrée à la même horloge que celui de sortie. Mais notre groupe s'est rapidement aperçu que cela ne fonctionnait pas. Il fallait que le compteur soit coordonné avec la réception du mot. Il était clair alors qu'il fallait relier le bit de présence du mot avec l'horloge de notre compteur d'entrée, afin d'obtenir le résultat voulu.

Résultats des tests

Après avoir fini et compilé le montage sur Altium, nous avons effectué des tests, afin de savoir si il était correct. Nous avons donc branché les ports de sortie de la Nanoboard sur un oscilloscope. Voici ce que nous avons observé :

Capture16.jpg


Capture17.jpg

Nous avons envoyé 8 messages l'un après l'autre, puis observé les résultats. Sur les images ci-dessus, on voit bien que chaque message est rangé dans une colonne. Il nous restait maintenant à câbler notre matrice, et à faire de nouveau des tests sur celle-ci.

Séance 3

Partie informatique

Configuration supplémentaire du CGI-BIN

Pour pouvoir afficher quelque chose sur la matrice du banc Arduino, il faut modifier les droits dans le dossier /etc/group afin que l'utilisateur (www-data) en tapant ceci : 

chown www-data /dev/ttyUSB0

Configuration Foxboard

L'adresse de notre Foxboard est : 172.26.79.8. Chaque modification devra être suivie d'un reboot de la Foxboard afin que ces modifications soient prises en compte. Dans le fichier /etc/apt/sources.list, il faut changer l'adresse du serveur existant pour le remplacer par celui de Polytech'Lille.

Pour configurer la carte Ethernet, il faut écrire les lignes suivantes dans le fichier /etc/network/interfaces :
Avant
Après
auto eth0                                                
iface eth0 inet static
 address 172.26.79.8
 netmask 255.255.240.0
 gateway 172.26.79.254
 dns-nameservers 193.48.57.34

Importation des fichiers sur la Foxboard

Pour pouvoir mettre les différents fichiers nécessaires au projet, on se connecte en SSH en tant que root. On a placé dans le dossier /root les fichiers serial.h, serial.c et matrice.c et dans le répertoire /var/www les fichiers index.html, cercle.php, matrice.php, jquery.js. L'installation de php5-gd et de cgilib sera nécessaire. Nous avons inclus dans le fichier /etc/rc.local les utilitaires stty et sleep afin d'éviter de les réécrire à chaque compilation du CGI-BIN.

Mise en forme de l'interface

Pour rendre l'interface plus agréable à visionner nous avons créé un fichier style.css utilisé dans les fichiers index.html et matrice.php, nous avons également mis dans le répertoire du serveur local une image du logo de Polytech'Lille.

Conclusion

Voilà à présent une image récapitulant les différentes interactions entre les fichiers réalisés dans la partie informatique de ce projet. Interactivites.png

Partie électronique

Câblage de la matrice de leds

Le circuit Altium étant terminé, il ne manquait plus qu'à réaliser le câblage de notre matrice de led 8×8. Nous avions à notre disposition la datasheet de la matrice ainsi que tous les composants dont nous pourrions avoir éventuellement besoin.

Détermination du choix des résistances

À chaque couleur de notre matrice correspondait un voltage différent, soient des résistances différentes. Il a donc fallu choisir une seule couleur, qui pour notre groupe fut le bleu. Nous devions alors appliquer une tension de 3,2 V aux bornes des leds, alors que la Nanoboard fournissait en sortie une tension de 5V.

La datasheet fournie nous recommandait de prendre un ampérage de 20mA, mais sur conseil de Mr Boe nous en avons pris un plus faible, soit 7mA. Nous avons d'abord effectué le calcul pour une led : Loimaille.jpg


En faisant la loi des mailles 5V-3,2-RI=0, on obtient rapidement R=250 ohm, et la seule résistance qui se rapprochait était 220 ohm.

Mais comme nous n'avions pas qu'une led, le professeur nous a conseillé d'en prendre une de 880 ohm.

Sélection des broches

Comme notre groupe avait choisi la couleur bleu, il fallait brancher la matrice de sorte à ce qu'elle affiche les leds en cette couleur. D'après la datasheet qui nous avait été fournie, seules certaines broches correspondaient à cette couleur, ce qui justifie les emplacements de nos fils et résistances.

Elise en train de réaliser le câblage de la matrice

Voici le schéma complet du câblage de notre matrice :

Cablage2.jpg

Derniers tests

Suite à ce branchement, nous avons pris la décision de le tester immédiatement. Nous avons donc branché la Nanoboard à notre montage, et envoyé des mots pour observer le résultat.

Schéma final projet
Branchements à la Nanoboard


C'est lors de ce dernier test que nous avons remarqué deux problèmes :

- D'abord la matrice affichait l'inverse des mots envoyés. Nous avons rapidement compris que la matrice allumait une led lors du passage à 0 et non à 1. Il fut alors facile de mettre des inverseurs sur les 8 sorties du message de notre schéma Altium, afin de régler ce problème.

- Nous nous sommes également rendus compte qu'il y avait un décalage dans l'envoi des mots. En effet, la première colonne ne recevait que le huitième mot et non le premier. Celui-ci était reçu par la deuxième colonne. Ce problème nous surprit car lors des premiers tests, ni nous ni le professeur ne l'avions remarqué. Ce problème fut résolu lors des tests où les 2 systèmes, informatique et électronique, furent reliés. La résolution est expliquée dans la partie leur étant dédiée.

Vous pouvez apercevoir à droite le schéma final de notre projet, après que le professeur ait rajouté la liaison série, permettant de recevoir le mot et le bit de présence.

Séance de tests et vidéo

Logo qui fait tout buguer =D
Visualisation sur le banc Arduino
Résultats des tests

Différents tests

Durant la séance de test, nous avons pu constater qu'en branchant directement la Foxboard sur le banc Arduino, le mode 16x16 multicolore fonctionnait parfaitement. Cependant, le mode 8x8 monocolore n'était pas encore fonctionnel car nous n'avions pas encore modifié le CGI-BIN pour qu'il puisse également fonctionner dans ce mode. En effet, dans ce mode, chaque colonne de la matrice reçoit un octet (c'est-à-dire chaque led reçoit un bit pour signaler l'état allumée ou éteinte). Ayant choisi dans la partie électronique de colorier en bleu les leds de la matrice, nous avons également mis en bleu celles de l'interface Web.

Lorsque le mode 8x8 a fonctionné, nous avons commencé à brancher tout le système avec le module de communication série et la Nanoboard. Nous devions à présent corriger le problème de décalage rencontré à la dernière séance. Au départ, une solution informatique avait été envisagée. Mais il s'est avéré que recâbler les entrées des bascules D était plus rapide et fonctionnait également. Après avoir fait ceci, nous avons modifié la fréquence d'horloge de la Nanoboard pour que la persistance rétinienne nous permette de voir un signal fixe et pour que la luminosité des leds soit suffisante pour être bien visible.

Vidéo

Nous avons pu être filmés afin de montrer que notre système est fonctionnel en particulier le mode 8x8 monocolore et ainsi le mode 16x16 multicolore lorsque l'on branche directement la Foxboard sur le banc Arduino.

Conclusion

Pour conclure, nous avons, lors de ce projet, mis en place un système permettant à un utilisateur de créer l'image qu'il souhaite sur une matrice de leds à partir d'une interface web. Malgré les difficultés rencontrées que ce soit dans la partie informatique ou électronique, nous avons réussi à faire la relation entre les deux pour avoir un système fonctionnel.

Récupérée de « https://projets-ima.plil.fr/mediawiki/index.php?title=Contrôle_de_matrice_leds,_2013/2014,_TD1&oldid=13259 »