Projet IMA3 P6, 2017/2018, TD2, SEEGA

Projet IMA3-SC 2017-2018 : Projet SEEGA

Description du projet

Le projet consiste en un jeu de plateau connecté. Il permettrait à 2 personnes de jouer l'une contre l'autre (le joueur 1 sur le vrai plateau et le joueur 2 sur ordinateur).

Pour faire une partie de Seega, il faut un plateau de 5x5 cases, 12 pions pour le joueur 1, 12 pions pour le joueur 2. Le but du jeu est de capturer le maximum de pions de l'adversaire.

>Au début de la partie, chaque joueur dispose à tour de rôle 2 de ses pions sur le plateau sur les cases de son choix, sauf case centrale.
>Une fois les 24 pions placés, les joueurs bougent à tour de rôle un de leurs pions respectifs sur le plateau. Chaque pièce peut être déplacée verticalement ou horizontalement et obligatoirement sur une case contiguë.
>Un joueur capture un pion adverse lorsqu'il parvient à l'encadrer avec 2 de ses pions suite à un déplacement. Le pion est donc éliminé du plateau. Cependant, un pion positionné sur la case centrale ne peut pas être capturé.
>La partie se termine quand l'un des joueurs n'a plus de pions ou lorsque les 2 séries de pions forment des barrières qui empêchent d'être capturés. Le gagnant est alors celui à qui il reste le plus de pièces sur le plateau.

Cahier des charges

Titre du sujet

Projet SEEGA

Description du système

Nous avons comme objectif de détecter les pions du joueur 1 grâce à un capteur de ligne (pour transmettre leurs positions à l'ordinateur) et de simuler les pions du joueur 2 par des leds sous le plateau en plexiglas, allumées aux cases en question.

Matériel nécessaire

• 1 Arduino
• 3 registres à décalage
• 25 leds blanches
• 25 capteurs de ligne
• 1 plaque de plexiglass 30*30cm de 3mm d'épaisseur
• 1 plaque de contreplaqué de 5mm usinable pour la découpe du coffre du plateau et des pions
• 12 pions noirs circulaires environ 4 cm de diamètre (découpeuse laser)
• Papier aluminium
• 25 résistances 180 Ohm
• 2 résistance de 220Ohm
• 1 Led rouge, 1 led verte
• 4 entretoises 30mm

Séance 1

Pendant cette première séance, nous avons choisi notre sujet et défini les besoins électroniques et informatiques. Nous nous sommes tout de suite mis d'accord pour réaliser un jeu de société entre un ordinateur et un plateau de jeu réel.
Nous avons alors séparé les tâches et partagé le travail à effectuer.

-Du côté informatique lors de la première séance, on nous donne une Raspberry prête à l’utilisation. On commence par lui installer un système d’exploitation adapté pour fonctionner sur Raspberry : on choisit Raspbian sans interface graphique. On a rencontré quelques problèmes qui n’étaient pas prévus par le tutoriel que nous suivions. A la fin de l’installation, on commence alors la configuration de la Raspberry (en port série puis hot-spot wi-fi etc). On sera stoppé par le temps au moment d'entamer la configuration en hot-spot wi-fi.

Schéma de l'exemple à réaliser sur Altium

-Du côté électronique, nous avons principalement dédié cette séance à la découverte du FPGA. Au travers d'un tutoriel, nous avons créé un compteur sur Altium et dont la valeur s'affiche sur des LED. Nous nous somme alors familiarisé avec cette carte électronique et avec son fonctionnement.

Durant la dernière heure, nous nous sommes intéressés à nos capteurs de ligne QRE1113 [1]:

Capteur de ligne QRE1113

N'ayant pas trouvé de suite la datasheet, nous avons alors effectué différents tests afin de déterminer les caractéristiques et le fonctionnement de ces modules. Chaque composant est alors alimenté sous une tension de 5V, une led infrarouge émet un rayonnement qui revient vers un capteur si une surface réfléchissante est présente. Le capteur peut alors renvoyer entre 0V et 5V: 0V quand il y a réflexion totale et 5V s'il n'y a aucun obstacle. Afin de maximiser l'efficacité du capteur il nous faut donc une surface la plus réfléchissante possible à disposer sous nos pions. La distance optimale entre récepteur et la surface réfléchissante est de 1mm. Il nous faudra donc un plexiglas peu épais. Pour la surface réfléchissante nous utiliserons du papier aluminium qui permet une réflexion convenable de la lumière.

Séance 2

Entre les deux premières séances, nous avons imaginé le circuit électronique et codé en Javascript le jeu de Seega, en y ajoutant un affichage graphique. Nous l'avons d'abord fait en C avant de se rendre compte que notre jeu devait être en html pour fonctionner via la Raspberry. Nous avons alors repris notre code cette fois-ci en Javascript (dans un fichier html). Pour l'affichage graphique, on est passé par un canvas qu'on a soigneusement découpé en 25 cases de mêmes tailles. Ce sera notre plateau de jeu. On récupère les clics qu'on stockent dans des variables, ce sont les choix de déplacements de l'utilisateur sur ordi. On code les différentes fonctions permettant de jouer dans les règles comme la fonction deplacement_possible qui parle d'elle même etc. On décide de simplifier la mise ne place de départ (car fastidieuse). Ainsi, la partie commence le plateau de jeu est vide et chaque joueur place à son tour 2 pions (sauf sur la case du milieu). Le jeu peut ensuite commencer.

-Du côté informatique, nous avons continué et finalisé la configuration de la Raspberry Pi. On peut désormais s'y connecter via ssh. On arrive aussi à lancer le redémarrage de la Raspberry depuis la page web (programme très simple donné dans le tutoriel).

-Du côté électronique, dans un premier temps nous nous sommes intéressés à réaliser une matrice de led. Nous avons trouvé 2 solutions permettant de la concevoir:

Schéma solution 1 Matrice Leds

> La première solution nécessite 5 résistances, 25 leds et occupe 10 pins de l'arduino. 5 pins servent à contrôler chaque ligne (en rose sur l'image), et les 5 autres les colonnes (en bleu). Pour allumer une seule led, par exemple la première il suffit donc de mettre tous les pins "ligne" à l'état LOW sauf la celui de la première ligne en HIGH. A cette étape toute la ligne s'allume, pour palier à cela on laisse notre pin "colonne" correspondant à l'état LOW, et les autre en HIGH. Maintenant pour allumer plusieurs led, on utilisera la persistance rétinienne. C'est à dire que l'on va allumer et éteindre chaque led de manière très rapide. L’œil lui ne va pas percevoir ce clignotement et verra les leds allumées.

Schéma 74HC595

> La deuxième solution consiste à utiliser les registres à décalage 74HC595 qui n'occupent que 3 pin de l'arduino.
Vcc : alimentation 6V Max.
QA à QH: sorties Shift Register.
QH': renvoie la même valeur que QH.
SER (Serial): entrée pour le prochain pin qui sera déplacé.
SRCLK (Serial Clock): déplace le registre d'un rang à droite lorsqu’il est mis à 1.
RCLK (Register Clock): mettre à 1 pour valider les modfications.
SRCLR (Serial Clear): le passage de 1 à 0 vide le registre.
OE (Output Enable): ce pin permet d’activer la sortie lorsqu’il est sur la masse et la désactive lorsqu’il est en High.

Schéma principe registre à décalage

Le composant 74HC595 dispose de 8 pins de sortie (Qa, Qb, Qc, Qd, Qe, Qf, Qg, Qh) qui peuvent soit avoir la valeur 0 (Low) soit la valeur 1 (High). Lorsque l’on met le pin SRCLK (Serial Clock) en valeur 1, alors les 8 pins de sorties se décalent vers la droite et le premier pin Qa prend la valeur appliquée à SER. La valeur anciennement appliquée à Qh est alors écrasée. Ainsi en 8 étapes nous pouvons enregistrer l'état des 8 leds à contrôler puis valider les modifications en passant RCLK à l'état HIGH.

Registres à décalages chainés

A présent nous voulons contrôler non pas 8 mais 16 led. Nous allons donc chaîner 2 registres à décalage. Pour cela il suffit de relier le QH' du premier 74HC595 au SER du second. Ainsi le dernier bit, au lieu d'être écrasé, est récupéré par le deuxième registre. Ainsi nous pouvons facilement chaîner plusieurs 74HC595 comme présenté sur l'image.

Nous retenons donc cette solutions moins gourmande en pins de l'arduino. 3 Shift Registers permettront de contrôler 3*8=24 leds. La 25ème led sera directement contrôlée par un 4ème pin.

Cependant nous gardons tout de même la première méthode en tête afin de l'adapter aux capteurs de lignes pour détecter les pions sur les cases. En effet l'arduino uno ne possédant que 6 ports analogique, nous branchons alors les sorties de chaque colonne de capteurs sur une entrée analogiques. Les bornes négatives sont reliées directement à la masse et les bornes positives de chaque lignes de capteurs sont reliées à une sortie digitale. Ainsi pour lire la valeur du capteur de la première ligne et première colonne il suffit d'allumer les capteur de la ligne correspondante et lire la valeur l'entrée analogique de la colonne correspondante. Pour scanner toute la grilles on allumera les lignes successivements en laissant un intervalle de temps suffisant pour la mesure.

Nous avons aussi commencé à réaliser la partie du montage électronique à faire sur Altium.

Séance 3

Schéma de la partie FPGA

Partie électronique:

• FPGA:

Nous avons essayé de corriger certains problèmes concernant le schéma sur Altium. En effet, les ports de sortie et le multiplexeur empêchaient la compilation. Nous n'avons malheureusement pas réussi à les résoudre.

Schéma du circuit électronique sur Frizing

• PCB:

Cette séance a été dédiée à la conception du circuit électronique du plateau de jeu afin de rendre les branchements plus faciles. Pour cela nous avons utilisé le logiciel frizing qui permet d'un côté de réaliser un schéma du montage, et d'un autre de dessiner la carte. La tâche s'est avérée plus complexe que nous ne le pensions au vu de la disposition et du nombre de composants en jeu. Il a fallu recommencer plusieurs fois et continuer le travail à la maison pour en arriver au résultat final et envoyer la carte électronique en fabrication.

Partie informatique:

Ajout du fichier html contenant le jeu sur la Raspberry Pi. On peut désormais y jouer via internet en se connectant en wifi à la Raspberry (adresse : robot.projetseega.org). Divers essais pour permettre la communication entre la Raspberry et l'Arduino mais sans réussite. On a perdu du temps à cause de certaines intructions du tutoriel qui n'étaient plus valables non plus. On ne baisse pas les bras et on continue d'avancer.

Logo de notre version du Seega

Partie maquette:

Avant la séance nous avons réfléchi et créé le logo pour notre projet. Nous avons alors réservé la découpeuse laser dans le but de graver et de fabriquer les jetons pour notre plateau.

Séances complémentaires

Afin de finaliser notre travail, nous nous sommes servis des machines du Fabricarium pour découper le plateau de jeu en bois ainsi que la grille en plexiglas. Nous avons également soudé nos capteurs de ligne et nos diodes qui indiquent les positions des pions du joueur sur ordinateur.

Nous sommes revenus en salle informatique pour réussir à faire communiquer la Raspberry à l'Arduino en utilisant un serveur : le websocket. Après plusieurs heures, ils réussissent à s’échanger des signaux correctement et le jeu peut alors prendre forme. C'était une étape compliquée puisque les nombreux exemples disponibles sur internet étaient codés en python or nous utilisons Javascript pour la gestion du serveur et du jeu.

Transmission des données

La transmission des données entre l'arduino et la Raspberry est un point clé dans le bon fonctionnement du projet. Afin d'optimiser la liaison et d'éviter au maximum la perte de données, nous tentons de coder les information à transmettre sous la forme d'un seul octet.

- Première partie: positionnement des pions: Arduino vers Raspberry.
Ici nous devons ici transmettre le caractère 's' pour marquer le début de la transmission, puis la colonne de la case sur laquelle le pion est positionné ainsi que la ligne. Nous pouvons encoder la colonne (nombre entre 0 et 4) sur 3 bits, de même pour la ligne. Il nous reste 1 bit pour coder le 's'. Nous l'encodons alors par '11'.
Nous pouvons alors effectuer les commandes suivantes:

     Encoder:  (0b11<<6)|(ligne<<3)|colonne

     Décoder:  ligne = (reçu & 0b00111000)>>2

               colonne = (reçu & 0b00000111)

- Deuxième partie : mouvement des pions: Arduino vers Raspberry.
Ici nous devons transmettre à la Raspberry quel point a été déplacé sur quelle case il a été positionné. Pour encoder cela sur 1 octet nous enverrons le numéro de la case du pion déplacé (nombre entre 0 et 24 encodé sur les 5 derniers bits). Il nous reste alors 3 bits. Le premier mis à 0 sera un signal de 'start' puis les 2 bits suivants correspondront à la direction prise par le pion (haut ='0b00', bas ='0b01', gauche ='0b10', droite='0b11').
Nous pouvons alors effectuer la commande suivante:

     (0b0<<7)|(direction<<5)|case

Ainsi le bit de poids fort permettra de faire la différence entre les 2 phases ( 1 pour la première et 0 pour la seconde).

- Envoie des cases de la Raspberry vers l’Arduino.
Ici nous procédons de la même manière que pour la première partie mais les 2 premiers bit permettrons au lieu de définir un start, d'encoder le type de pion sur la case. Ainsi vide = '0b00', blanc = '0b01' et noir ='0b10'.
La commande devient alors:

      (type_pion<<6)|(ligne<<3)|colonne. 

L'arduino peut maintenant recevoir les modifications de grille calculées par la raspberry.