Contrôle de matrice leds, 2011/2012, TD3

Evaluation informatique et électronique

Gestion de projet / rédaction Wiki

Rédaction correcte mais sans plus; quelques coquilles, un formattage un peu déroutant. Des éléments de gestion de projet donnés dans le Wiki. La gestion de projet en elle même est très satisfaisante puisque que le projet a abouti.

Note 75%.

Test fonctionnels

• Sous-système : Le système de gestion de matrice de LED est un succès (constaté le 24/05/2012, vidéo à venir), interconnexion FoxBoard / Altium effectuée. Note 120%.
• Système : Un système a été réalisé en l'espèce d'un jeu de type "snake". Système à priori fonctionnel (la confirmation se fera via la vidéo). Note 100% (à confirmer).

Qualité de la réalisation

• Informatique. Note
  • procédure de test : Pas de README sur la FoxBoard, banc d'essai avec un cable arraché, tentative de test de snake14 à la main sans vraiment de succès (la gestion des boutons est aléatoire). Note en l'état 50%.
  • pages HTML et Javascript : Non applicable.
  • scripts PHP ou programmes C : Un vrai code C, structuré en fonction, du code mort et un formattage un peu limite. Note 90%
  • installation sur FoxBoard : Les exécutables y sont, tentative de démarrage automatique. Note 80%
• Electronique :
  • qualité de la réalisation :
  • tests autonomes :

Bilan

Tous les points principaux ont un poids équivalent (sauf "système" qui est un bonus).

Note finale :

Introduction

Dans l'optique du projet systèmes communicants, nous avons choisi de mettre en place l'antique (mais non dépassé) jeu SNAKE et de l'appliquer sur les matrices de LEDs fournies. Il est intéressant de rappeler que ce jeu a été vu pour la première fois en 1970 et est devenu populaire pour sa simplicité et sa disponibilité sur tout type de plate-formes. Pour le projet, nous avons donc décidé de réaliser ce jeu entièrement grâce au langage informatique C et les outils électronique de base. Il est évident que deux parties se détachent dans la réalisation de ce projet. Dans ce compte rendu, nous allons vous montrer l'évolution en parallèle de la partie informatique et de la partie électronique. Enfin, nous mettrons en avant la réunion des deux parties pour former le jeu.

Développement par séances

Séance 1 20/04/2012

Après avoir choisi le sujet de notre projet, il a été clair qu'un cahier des charges devait être mis sur papier. Nous avons décidé que :

• l'utilisateur aura 4 boutons pour diriger le serpent.
• deux afficheurs 7 segments présenteront le score.
• pour la matrice de LEDs, 8 mots de 8 bits seront envoyés ainsi qu'un bit d'écriture
• Un bouton reset sera mis en place pour rafraîchir la matrice avant le début du jeu.

Ensuite,nous avons scindé notre trinôme en deux. Le premier groupe est parti sur le logiciel de conception assisté de circuit électronique afin de concevoir le contrôle de la matrice LEDs. Le second groupe a pris en main la maquette de matrice LEDs et esquissé une interface web de contrôle d'allumage. A la fin de la séance, le groupe s'est remis ensemble pour la mise en commun des idées. Au final, au niveau électronique,un circuit basé sur nos expériences en microprocesseur a été édité et sera testé à la prochaine séance. Au niveau informatique, la maquette de LEDs a été pleinement comprise et la programmation du jeu en langage C est prévue pour la séance prochaine.

==>Prévisions pour la séance du 11/05/2012

• Programmation du jeu SNAKE
• Test du circuit électronique
• Recherche sur la transmission des données
• Mise en place du tableau des scores du jeu
• Ajouter des points au cahier des charges

Séance 2 11/05/2012

Avant la séance, en travail personnel, l’algorithme du jeu Snake a été entièrement écrit et est fonctionnel pour jouer dans un terminal. L'objectif de la séance est donc d'adapter cet algorithme à notre projet. Le groupe est tout d'abord resté en partie informatique pour mettre au point le jeu du point de vue strictement informatique. Nous avons adapté notre programme afin d'utiliser la maquette arduino donnée par le professeur. Après avoir ébauché les grandes lignes du jeu, le trinôme s'est encore scindé pour pouvoir compléter la partie électronique. Rappelons que le schéma altium avait été déjà testé avec l'oscilloscope et qu il fonctionnait. Il restait donc normalement qu'à câbler une matrice de LEDs. En pratique,le schéma se révéla incomplet.Nous dûmes donc l'améliorer pour qu'il prenne en compte l'affichage croissant des colonnes.

Séance 3 21/05/2012

==> Partie Informatique

Le code du Jeu est enfin terminé. Dés l'or que l'on compile, un message apparait obligeant l'utilisateur à appuyer sur une touche pour démarrer. Ensuite,les touches directionnelles dirigent le serpent vers la direction choisi. Le jeu se termine quand le serpent se mort la queue ou lorsque le serpent atteint les zones limites.

Media:snake.c.txt

==> Partie Électronique La partie Informatique étant fini, nous sommes tous retournés sur altium pour terminer le schéma et le compiler sur la nanoBoard. A la fin de la séance, le schéma marchait, et ressemblait à ceci:

Media:sch.pdf

Nous avons donc fait quelques tests supplémentaires sur oscilloscope pour vérifier que les sorties répondait correctement à nos attentes.

Suite à cela , nous avions besoin de câbler la matrice de LEDs en suivant son schéma

[1]

==> Réunion des deux parties

======>Configuration de la Foxboard

Dans la Foxboard, il faut changer les paramêtres de l'interface afin de pouvoir se connecter et travailler en SSH.

AVANT MODIFICATIONS

                  auto eth0
                    iface eth0 inet static
                    address 172.26.79.X
                    netmask 255.255.255.0
                    gateway 172.26.79.254
                    dns-nameservers 193.48.57.34

APRES MODIFICATIONS

                  auto eth0
                    iface eth0 inet static
                    address 172.26.79.07
                    netmask 255.255.255.0
                    gateway 172.26.79.254
                    dns-nameservers 193.48.57.34

Par la suite, il faut donc se connecter en SSH sur la foxboard ( commande: ssh 172.26.79.07) et copier le programme dans la mémoire du petit appareil et compiler le programme(scp -r snake.c root@172.26.79.07:/root/rep/).

======>Initialisation du port émission RS 232

A défaut de pouvoir mettre en place le protocole d'émission par nous même, nous avons utilisé un bloc fait par un des professeurs Ce bloc a pour but d'activié le port RS 232 de la NanoBoard afin de pouvoir brancher la Foxboard. En clair, ce bloc est le passage de la frontière entre le programme informatique C et la partie électronique active sur la NanoBoard.

Explication de la partie Electronique

Fichier:Sch.pdf

Dans cette partie nous allons détailler, la partie électronique compilé sur la NanoBoard.

La partie électronique consiste en l'implantation d'un système alliant logique séquentielle et combinatoire sur un FPGA (carte "fille" de la Nanoboard). Un FPGA est un ensemble de portes et de bascules logiques pouvant être connectée physiquement entres elles par programmation (ici nous avons utilisé le logiciel Altium Designer pour le schéma).

Afin de répondre au cahier des charges du Snake nous avons implanté 2 systèmes indépendants sur le même FPGA.

==> 1 – Réception et commande de la matrice

le module de réception RS232 (fournit par les professeurs) stock dans un registre 8 bits parallèle le mot reçu par l’interface série et génère un bit de validation une fois l’octet entièrement reçu.

Ce bit de validation permet d’incrémenter un compteur 3 bits qui va commander un démultiplexeur (3 vers 8 dont l’entrée est toujours à 1) afin de sélectionner (en écriture) tour à tour l’un des 8 registres correspondant aux 8 colonnes de la matrice et y stocké le mot courant. Ainsi le décalage se fait automatiquement et il n’y a pas de risque d’aller écrire au mauvais endroit.

Pour l’affichage c’est le processus inverse. Pour aller relire les registres on utilise un compteur (3 bits toujours) qui commande un multiplexeur qui va venir récupérer l’octet enregistré dans l’un des 8 registres précédents. Ces données seront envoyées sur les lignes de la matrice de façon synchrone avec l’activation de la colonne correspondante. Pour l’activation des colonnes c’est encore une fois la combinaison d’un compteur et d’un démultiplexeur (dont l’entrée est toujours à 1) qui est utilisée. La combinaison des sorties des registres et l’activation des colonnes de façon synchrone constitue la commande de la matrice. Pour la partie synchrone on utilise une subdivision de l’horloge principale réglée à 500 Hz (minimum nécessaire pour jouer sur la persistance rétinienne)

==> 2 – Emission du code des touches de la Nanoboard

On utilise ici un 2ème module fourni permettant d’émettre sur le port RS232 dans la Nanoboard. Ce module a besoin qu’on lui précise le mot de 8 bits à envoyer, cette fonction est remplie par la combinaison des 4 premiers boutons sur le schéma correspondant aux codes « 1 », « 2 », « 4 » et « 8 ». Il a aussi besoin d’un bit pour valider l’envoi des donné, cette broche a donc été relié à une horloge réglée à 1Hz (par exemple) pour pouvoir envoyer le code « 0 » toute les secondes (cela permet d’acquitter une phase de lecture dans la partie informatique).

Remarque : le 5ème bouton permet de remettre à zero en même temps tout les compteurs du montage.

Explication de la partie Informatique.

La partie informatique s'articule autour de deux programmes en C. Un démon de gestion du port série et un programme principal : le jeu snake. Les deux programmes sont compilés sur la Foxboard qui est paramétré pour se lancer automatiquement à son démarrage.

==>1-Le démon de gestion du port série.

Le démon est paramétré pour utiliser un port USB comme port série. C'est lui gui gère l'envoi et la réception de donné de la Foxboard. Les données transférées sont des caractères 8 bit.

En pratique ce démon est toujours lancé et il permet l'utilisation de fonction dans le programme principal qui a besoin de communiquer. Ils sont utilisé de la façon suivante :

   #define SOCKET_ECRITURE "/tmp/serial.send"
   #define SOCKET_LECTURE "/tmp/serial.recv"
   int se=connexionServeur(SOCKET_ECRITURE);
   int sl=connexionServeur(SOCKET_LECTURE);
   write(se,&col,1);
   read(sl,&d,1);

En effet les fonctions read et write permettent d'envoyer et recevoir les données.

==>2-Le programme principal : Snake.

Ce programme s'occupe la gestion du jeu Snake. Il récupère la valeur des touches envoyée depuis la Nanoboard, puis il applique les modifications nécéssaires (mouvement du snake, mort du snake, apparition d'un objectif). Une fois les modifications effectuées il envoi à la Nanoboard les nouvelles valeurs des LEDs pour un rafraichissement de l'image. Nous avons accordé une attention particulière aux performances pour un jeu fluide.

Voici la boucle principale qui résume les actions effectué par ce programme :

   while (alive) {
   lire(&direction, sl); //lecture des touches
   checkNext (&kaa,Matrice,&mouse,&score,&alive,direction,&etat); //analyse du coup suivant
   move (&kaa,Matrice,direction); //mouvement
   draw(Matrice, se); //affichage
   }

Ainsi la Foxboard s'occupe de la gestion du jeu en communiquant avec la Nanoboard via le port série. Pour plus de détails se rapporter au programme en lui même qui comporte de nombreux commentaires.

Conclusion

Le système que nous avons choisi est le mythique jeu Snake.Nous avons spliter le sujet en deux parties, l'une informatique et l'autre électronique. La partie électronique s'est axé autour du logiciel Altium et la Nanoboard.Après des essais théorique fructueux et des essais sur matrice encourageantes, nous avons décidé de reformer le trinôme afin de compléter la partie informatique. La partie informatique a été très rapide au niveau du codage du jeu. Après avoir réussi à configurer le daemon et la FoxBoard, nous avons pu voir le jeu fonctionner sous maquette Arduino. Après quelques essais et grâce à beaucoup de détermination, nous avons finalement pu faire revivre cet ancien jeu sous FoxBoard et Nano Board. Voici la vidéo de notre projet: [2] Et le lien de l'upload [3]