Discussion :

[HagerFall]

Boujour à tous,

Voila avec mon groupe nous avons réalisé un échiquier qui a pour but d'acquérir les positions des pièces et de les retransmettre sur une interface graphique tel que tkinter à l'aide d'une carte Raspberry cependant le GPIO ne possède que 40 Pins donc nous y avons rajouté deux cartes d'extension 32 canaux IOPI PLUS qui, chacune nous permet de brancher 32 fils sur 2 bus donc nous avons 4 bus pour 64 fils avec une adresse que l'on peut définir avec des straps. Donc pour la partie acquisition le problème est réglé cependant la partie traitement des pièces nous pose problème, nous devons comparer les états de l'échiquier qui est une liste de liste (une liste de 8 listes possédant 8 chiffres 0 ou 1) afin de l'actualiser et de voir quelle pièce a bougé. Voila mon code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
# -*- coding: utf-8 -*-
 
# Nom :		Echiquier_03.py
# Role :	Lecture et affichage d'un echiquier (64 cases)
#			afin de visualiser la partie en direct sur un moniteur
 
#			implante sur une RPi
 
#**************************  bibliotheques  ****************************
 
from ABE_helpers import ABEHelpers
from ABE_IoPi import IoPi
import time
import os
from classe import *
i2c_helper = ABEHelpers()
i2c_bus = i2c_helper.get_smbus()
from tkinter import*
import tkinter
 
#****************************  fonctions  ******************************
 
def initPlateau():                          #  initialisation echiquier
 
	global plateau
	plateauAvant = [[1 for i in range (8)] for j in range(8)]
	for i in range(2,6):
		for j in range(8):
			plateauAvant[i][j] = 0
 
 
def affichage():                          #  affichage console du plateau
 
	global plateau_figure
	for i in range(8):
		for j in range(8):
			print(plateau_figure[i][j], end = '\t')
		print()
 
def lecturePlateau():
    global plateauAvant
    for i in range(4):                  # Pour chaque Bus des cartes IoPi Plus
        dx = 0
        for j in range(16):             # Lecture des 16 cases de ce Bus
            plateau[i+dx][j%8] = bus[i].read_pin(j+1)
            if j>7 :                    #Separation des 16Pin du Bus en 2 lignes
                dx = 1
 
def Actualisation():
    if plateauApres != plateauAvant:      # Si les deux plateaux sont differents
        for a in range (8):
            for b in range (8):
                # On cherche où se situe la difference sur le plateau
                if plateauApres[a][b] != plateauAvant[a][b]:
                    # On cherche ensuite la deuxième difference
                    # On cherche sur toute les lignes
                    for x in range (8):
                        # On cherche dans les colonnes avant b
                        for y in range (b):
                            if plateauApres[x][y] != plateauAvant[x][y]:
                        # Si on a trouvé la deuxieme difference alors on
                        # inverse les deux difference sur le plateau_figure
                        # La piece se retrouve à la place du zero et inversement
                                plateau_figure[x][y],plateau_figure[a][b]=plateau_figure[a][b],plateau_figure[x][y]
                                #Le plateau initial est actualisé
                                plateauAvant = plateauApres
                            else:
                                pass
                        # On cherche les colonnes apres b
                        for y in range (b+1,8):
                            if plateauApres[x][y] != plateauAvant[x][y]:
                                plateau_figure[x][y],plateau_figure[a][b]=plateau_figure[a][b],plateau_figure[x][y]
                                #Le plateau initial est actualisé
                                plateauAvant = plateauApres
                            else:
                                pass
                    # On cherche ensuite toutes les colonnes
                    for y in range (8):
                        # Mais seulement les lignes avant a
                        for x in range (a):
                            if plateauApres[x][y] != plateauAvant[x][y]:
                                plateau_figure[x][y],plateau_figure[a][b]=plateau_figure[a][b],plateau_figure[x][y]
                                #Le plateau initial est actualisé
                                plateauAvant = plateauApres
                            else:
                                pass
                        # On cherche ensuite toutes les lignes apres a
                        for x in range (a+1,8):
                            if plateauApres[x][y] != plateauAvant[x][y]:
                                plateau_figure[x][y],plateau_figure[a][b]=plateau_figure[a][b],plateau_figure[x][y]
                                #Le plateau initial est actualisé
                                plateauAvant = plateauApres
                            else:
                                pass
                else:
                    pass
    elif plateauApres == plateauAvant:   # Si les deux plateaux sont les memes
        time.sleep(1)                    # alors on attend 1s puis on recommence
 
 
#-------------------------------------declarations  ----------------------------
 
i2c_helper = ABEHelpers()
i2c_bus = i2c_helper.get_smbus()
 
bus = []                                # Liste contenant les differents Bus
 
#Carte Extension 1
bus.append(IoPi(i2c_bus, 0x27))         # attribution bus 1 et 2 : carte 1
bus.append(IoPi(i2c_bus, 0x26))
 
#Carte Extension 1
bus.append(IoPi(i2c_bus, 0x20))         # attribution bus 3 et 4 : carte 2
bus.append(IoPi(i2c_bus, 0x23))
 
 
for i in range(4):
        bus[i].set_port_direction(0, 0xFF)             # direction : 1 = sortie
        bus[i].set_port_direction(1, 0xFF)             # bus 16 bits = 2x8 bits
 
        bus[i].set_port_pullups(0, 0xFF)               # pull-up interne : 1
        bus[i].set_port_pullups(1, 0xFF)
 
 
plateauApres=[[1,1,1,1,1,1,1,1],
              [1,1,1,1,1,1,1,1],
              [1,1,1,1,1,1,1,1],
              [1,1,1,1,1,1,1,1],
              [1,1,1,1,1,1,1,1],
              [1,1,1,1,1,1,1,1],
              [1,1,1,1,1,1,1,1],
              [1,1,1,1,1,1,1,1]]
 
plateau_figure=[[tn1,cn1,fn1,roin,ren,fn2,cn2,tn2],     # t=tour
                 [pn1,pn2,pn3,pn4,pn5,pn6,pn7,pn8],     # c=cavalier
                 [ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ],     # f=fou
                 [ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ],     # roi
                 [ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ],     # re=reine
                 [ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ],     # p=pion
                 [pb1,pb2,pb3,pb4,pb5,pb6,pb7,pb8],     # n=noir et b=blanc
                 [tb1,cb1,fb1,roib,reb,fb2,cb2,tb2]]    # suivi du numéro
 
#*******************************  Main  ********************************
 
if __name__ == '__main__':
    plateauAvant = [[]*8]
    initPlateau()
    while True:
        lecturePlateau()
        actualisation()
        affichage()

Mon problème est donc pour la comparaison et l'actualisation du plateau, avez vous des conseils des solutions à me proposer ?
Merci de l'aide et de votre patience !

[wiztricks]

Salut,

Mon problème est donc pour la comparaison et l'actualisation du plateau, avez vous des conseils des solutions à me proposer ?

Si vous ne pouvez détecter que la présence/absence d'une pièce sans pouvoir l'identifier je ne vois pas trop comment vous allez pouvoir vous en sortir...
Comparez avant et après, si vous trouvez deux cases différentes, on peut imaginer conclure à un déplacement d'une pièce d'une case à l'autre... Mais si vous n'en trouvez qu'une est-ce que le joueur n'a pas encore joué sa pièce ou à réalisé une prise?
Tout çà pour dire que si on imagine pas comment çà va pouvoir fonctionner "sur le papier", coder est prématuré.

- W

[HagerFall]

Si vous ne pouvez détecter que la présence/absence d'une pièce sans pouvoir l'identifier je ne vois pas trop comment vous allez pouvoir vous en sortir...
- W

On a définit un plateau avec les différentes pièces donc quand on remarque une différence la pièce est déplacer.
Avez vous des conseils s'il vous plait car la vous ne m'encouragez pas trop sauf dire que ça ne marchera jamais.
Merci tout de même pour votre réponse.

[wiztricks]

On a définit un plateau avec les différentes pièces donc quand on remarque une différence la pièce est déplacer.

Trouver les indices (i, j) des cases différentes, c'est ce que vous commencez à faire ligne 51.
Après je ne comprends pas pourquoi vous partez à chercher l'autre différence au lieu de construire la liste des cases différentes et d'arbitrer en fonction de leur nombre/contenu/...

Avez vous des conseils s'il vous plait car la vous ne m'encouragez pas trop sauf dire que ça ne marchera jamais.

Moi ce que je dis c'est que je ne comprends pas comment çà va pouvoir marcher... C'est vous qui avez réfléchit vous devez donc avoir des idées... Et si vous ne les exposez pas, on ne va pas les inventer ni pouvoir vous aider à coder...

- W

[HagerFall]

Merci encore de me répondre.

Donc si j'ai compris il serait plus judicieux d'enregistrer les erreurs dans une liste de cette façon ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
erreur = []
def Actualisation():
    if plateauApres != plateauAvant:      # Si les deux plateaux sont differents
        for a in range (8):
            for b in range (8):
                # On cherche où se situe la difference sur le plateau
                if plateauApres[a][b] != plateauAvant[a][b]:
                    #On ajoute les coordonnées de l'erreur dans une liste de liste
                    erreur.append([a,b]) 
    elif plateauApres == plateauAvant:   # Si les deux plateaux sont les memes
        time.sleep(1)                    # alors on attend 1s puis on recommence

et donc que pouvons-nous faire suite à cela ?
On inverse les pièces en inverssant les coordonnées ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
x1,y1,x2,y2=erreur[0][0],erreur[0][1],erreur[1][0],erreur[1][1]
#On inverse le contenu des cases
plateau_figure[x1][y1],plateau_figure[x2][y2]=plateau_figure[x2][y2],plateau_figure[x1][y1]

Le plus gros problème étant que nous sommes débutants sur python et peu encadré donc nous avons beaucoup de difficultés dans l'organisation de notre code.

[wiztricks]

et donc que pouvons-nous faire suite à cela ?
On inverse les pièces en inverssant les coordonnées ?

Vous pouvez vérifier qu'une des cases est à 0 alors que l'autre est à 1 et déplacer la pièce pour refléter sa nouvelle position.

Le plus gros problème étant que nous sommes débutants sur python et peu encadré donc nous avons beaucoup de difficultés dans l'organisation de notre code.

Pour l'instant, vous ne posez pas de questions sur le code mais sur ce que vous devez faire dans différents cas de figures que vous devriez avoir travaillé sur une feuille de papier avant de coder.
Dit autrement, vous vous faites un monde sur le codage alors que vous ne vous en sortiriez pas si mal (comment coder) si vous saviez quoi coder.

- W

[HagerFall]

* Le déplacement d'une pièce

* Le "non déplacement" d'une pièce. Une pièce est levée puis reposée à sa place initiale.

* La prise d'une pièce. Une pièce 1 est levée puis une pièce 2 est levée. La pièce 1 est posée à la place de la pièce 2.

Exemple 1 : le déplacement d'une pièce



Cela nécessite de mémoriser 3 états successifs du plateau et donc de disposer de trois structures de données (liste de listes) pour stocker ces informations.

Exemple 2 : le non déplacement d'une pièce



Idem, cela nécessite de mémoriser 3 états successifs du plateau et donc de disposer de trois structures de données (liste de listes) pour stocker ces informations. La comparaison des structures 1 et 3 doit permettre de voir que finalement aucun mouvement n'a eu lieu.

Exemple 3 : la prise d'une pièce



Cette fois, cela nécessite de mémoriser 4 états successifs du plateau et donc de disposer de quatre structures de données (liste de listes) pour stocker ces informations.

Notre professeur nous a guider de cette façon.

[wiztricks]

Salut,

Ben à partir de la on peut supposer que le relevé de l'état des cases côté GPIO est suffisamment rapproché pour que la comparaison entre l'état T et l'état T + 1 sorte:

• pas de changement,
• une pièce à été retirée de la case (i, j)
• une pièce a été posée sur la case (i, j)

Donc çà serait peut être bien de commencer par écrire une sorte de fonction "get_change" qui ne retourne qu'après avoir constaté un changement un tuple de la forme 0/1, (i, j):
0 si la case à été libérée, 1 si une pièce a été posée et (i, j) les coordonnées de la case

Après c'est une machine à états finis:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
init -> retrait +-> pose -> init  // ce qui est un "déplacement".
                |
                +-> retrait -> pose -> init  // ce qui est une "prise".

assez simple à programmer en pseudo code avec des if-then-else:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
while True:
      etat, case = get_change()
      if etat != 0: çà buge car tout commence par un retrait.
      else:
            on mémorise la case et on récupère le changement suivant
            etat, case = get_change()
            if etat == 0: # çà s'oriente vers une prise
               on mémorise la case et on récupère le changement suivant
               etat, case = get_change()
               if etat != 1: BUG
               else:
                    on vérifie que la case est celle attendue et on traduit la prise.
            else: # çà s'oriente vers un déplacement
               on fait le déplacement si la case est différente.

tout çà pour dire que c'est pas si compliqué de faire un minimum de plan avant de coder.

- W