Labomedia Ressources

Outils pour utilisateurs

Outils du site

Piste :
jeu_de_la_vie

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentesRévision précédente
Prochaine révision		Révision précédente
Prochaine révisionLes deux révisions suivantes
jeu_de_la_vie [2019/10/18 14:50] – [Logiciel] Camillejeu_de_la_vie [2019/10/21 09:26] – Camille
Ligne 30: Ligne 30:
 L'écran choisi a une taille de ____ et de résolution ____; c'est un écran qui s'interface au micro-ordinateur en HDMI.\\ L'écran choisi a une taille de ____ et de résolution ____; c'est un écran qui s'interface au micro-ordinateur en HDMI.\\
 Il était initialement question de pions qui se poseraient dans les trous du plateau de jeu. Le choix s'est porté sur des capteurs de pression (Force Sensing Resistance) pour la détection des pions. \\ Il était initialement question de pions qui se poseraient dans les trous du plateau de jeu. Le choix s'est porté sur des capteurs de pression (Force Sensing Resistance) pour la détection des pions. \\
-Un bouton pour amorcer le jeu et le faire et évoluer et un bouton pour revenir à la configuration initiale ont été ajoutés sur les GPIO du micro-iordinateur. \\ +Un bouton pour amorcer le jeu et le faire et évoluer et un bouton pour revenir à la configuration initiale ont été ajoutés sur les GPIO du micro-ordinateur. \\ 
-Enfin, un bouton marche/arrêt du jeu a été intégré. Il est nécessaire d'effectuer un arrêt du +Enfin, un bouton marche/arrêt du jeu a été intégré. Il est nécessaire d'effectuer un arrêt du micro-ordinateur pour éviter une corruption de la carte SD. 
  
 Montage des capteurs dans le plateau de jeu: Montage des capteurs dans le plateau de jeu:
Ligne 74: Ligne 74:
 ======================================================= =======================================================
  
 +<code python>
 + import pygame, sys
 + from pygame.locals import *
 + import random
 + import RPi.GPIO as GPIO
 + from time import sleep
  
-'' + GPIOCasesInit = {17:(9,4), 27:(10,4), 22:(11,4), 5:(12,4), 6:(9,5), 13:(10,5), 19:(11,5), 26:(12,5), 18:(9,6), 24:(10,6),   23:(11,6), 25:(12,6), 12:(9,7), 16:(10,7), 20:(11,7), 21:(12,7)} 
-import pygame, sys\\ + # vérification du nombre de capteurs définis 
-from pygame.locals import *\\ + assert len(GPIOCasesInit)==16 
-import random\\ + assert len(set(GPIOCasesInit.values()))==16 
-import RPi.GPIO as GPIO\\ + GPIO.setmode(GPIO.BCM) 
-from time import sleep\\ +# les broches sur lesquelles se trouvent les capteurs, ainsi que les broches 14 et 15, sont configurées en entrée. 
-'' +# Par défaut, les broches des capteurs sont à l'état bas (niveau électrique 0V) 
-'' +# Les broches 14 et 15 (sur lesquelles sont câblés des boutons) sont au niveau électrique haut par défaut 
-GPIOCasesInit = {17:(9,4), 27:(10,4), 22:(11,4), 5:(12,4), 6:(9,5), 13:(10,5), 19:(11,5), 26:(12,5), 18:(9,6), 24:(10,6), 23:(11,6), 25:(12,6), 12:(9,7), 16:(10,7), 20:(11,7), 21:(12,7)}\\ + for n in GPIOCasesInit:  
-assert len(GPIOCasesInit)==16\\ +     GPIO.setup(n, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) 
-assert len(set(GPIOCasesInit.values()))==16\\ +     GPIO.setup(14, GPIO.IN, pull_up_down=GPIO.PUD_UP) 
-GPIO.setmode(GPIO.BCM)\\ +     GPIO.setup(15, GPIO.IN, pull_up_down=GPIO.PUD_UP) 
-'' + # les broches 14 et 15 détecteront un front descendant  
-'' + GPIO.add_event_detect(14, GPIO.FALLING) 
-for n in GPIOCasesInit: + GPIO.add_event_detect(15, GPIO.FALLING) 
-    GPIO.setup(n, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) + #nombre d'images par seconde 
-    GPIO.setup(14, GPIO.IN, pull_up_down=GPIO.PUD_UP) + FPS = 10
-    GPIO.setup(15, GPIO.IN, pull_up_down=GPIO.PUD_UP) +
-'' +
-'' +
-GPIO.add_event_detect(14, GPIO.FALLING)\\ +
-GPIO.add_event_detect(15, GPIO.FALLING)\\ +
-#Number of frames per second\\ +
-FPS = 10\\+
  
-###Sets size of grid\\ + ###configure la taille de la grille 
-WINDOWWIDTH = 1920\\ + WINDOWWIDTH = 1920 
-WINDOWHEIGHT = 1080\\ + WINDOWHEIGHT = 1080 
-CELLSIZE = 40\\+ CELLSIZE = 40
  
-#Check to see if the width and height are multiples of the cell size.\\ + #les dimensions de la grille sont-elles des multiples du nombre de cellules 
-assert WINDOWWIDTH % CELLSIZE == 0, "Window width must be a multiple of cell size"\\ + assert WINDOWWIDTH % CELLSIZE == 0, "la largeur des cellules doit être un multiple de la taille des cellules" 
-assert WINDOWHEIGHT % CELLSIZE == 0, "Window height must be a multiple of cell size"\\+ assert WINDOWHEIGHT % CELLSIZE == 0, "la hauteur des cellules doit être un multiple de la taille des cellules"
  
-#Determine number of cells in horizonatl and vertical plane\\ + #Determine le nombre de cellules sur l'axe vertical et l'axe horizontal\\ 
-CELLWIDTH = WINDOWWIDTH / CELLSIZE # number of cells wide\\ + CELLWIDTH = WINDOWWIDTH / CELLSIZE # nombre de cellules en largeur 
-CELLHEIGHT = WINDOWHEIGHT / CELLSIZE # Number of cells high\\+ CELLHEIGHT = WINDOWHEIGHT / CELLSIZE # nombre de cellules en hauteur
  
-# set up the colours\\ + # fabrication des couleurs 
-BLACK =    (0,  0,  0)\\ + BLACK =    (0,  0,  0) 
-WHITE =    (255,255,255)\\ + WHITE =    (255,255,255) 
-DARKGRAY = (40, 40, 40)\\ + DARKGRAY = (40, 40, 40) 
-GREEN =    (50,255,100)\\ + GREEN =    (50,255,100) 
-RED =  (255, 0, 100)\\+ RED =  (255, 0, 100)
  
-BoxExample = {1:(3,10), 2:(15,10), 3:(2,11), 4:(4,11), 5:(10,11), 6:(14,11), 7:(16,11), 8:(3,12), 9:(9,12), 10:(10,12), 11:(11,12), 12:(14,12), 13:(16,12), 14:(15,13), 15:(4,16), 16:(9,16), 17:(10,16), 18:(14,16), 19:(16,16), 20:(17,16), 21:(5,17), 22:(8,17), 23:(11,17), 24:(14,17), 25:(15,17), 26:(17,17), 27:(3,18), 28:(4,18), 29:(5,18), 30:(9,18), 31:(11,18), 32:(10,19), 33:(25,17),34:(25,18),35:(26,18)}\\+ BoxExample = {1:(3,10), 2:(15,10), 3:(2,11), 4:(4,11), 5:(10,11), 6:(14,11), 7:(16,11), 8:(3,12), 9:(9,12), 10:(10,12),  11:(11,12), 12:(14,12), 13:(16,12), 14:(15,13), 15:(4,16), 16:(9,16), 17:(10,16), 18:(14,16), 19:(16,16), 20:(17,16), 21:(5,17), 22:(8,17), 23:(11,17), 24:(14,17), 25:(15,17), 26:(17,17), 27:(3,18), 28:(4,18), 29:(5,18), 30:(9,18), 31:(11,18), 32:(10,19), 33:(25,17),34:(25,18),35:(26,18)}
  
-def text_objects(text, font): \\ + def text_objects(text, font):  
-    textSurface = font.render(text, True, DARKGRAY)\\ +     textSurface = font.render(text, True, DARKGRAY) 
-    return textSurface, textSurface.get_rect()\\+     return textSurface, textSurface.get_rect() 
  
-def afficheInit(text, x, y):\\ + def afficheInit(text, x, y): 
-    largeText = pygame.font.Font('freesansbold.ttf',75)\\ +     largeText = pygame.font.Font('freesansbold.ttf',75) 
-    TextSurf, TextRect = text_objects(text, largeText)\\ +     TextSurf, TextRect = text_objects(text, largeText) 
-    TextRect.center = (x,y)\\ +     TextRect.center = (x,y) 
-    DISPLAYSURF.blit(TextSurf, TextRect)\\ +     DISPLAYSURF.blit(TextSurf, TextRect) 
-    pygame.display.update()\\ +     pygame.display.update()
-    #time.sleep(2)\\+
  
-#Draws the grid lines\\ + #Dessin de la grille 
-def drawGrid():\\ + def drawGrid(): 
-    for x in range(0, WINDOWWIDTH, CELLSIZE): # draw vertical lines\\ +     for x in range(0, WINDOWWIDTH, CELLSIZE): # trace des lignes verticales 
-        pygame.draw.line(DISPLAYSURF, DARKGRAY, (x,0),(x,WINDOWHEIGHT))\\ +         pygame.draw.line(DISPLAYSURF, DARKGRAY, (x,0),(x,WINDOWHEIGHT)) 
-    for y in range (0, WINDOWHEIGHT, CELLSIZE): # draw horizontal lines\\ +     for y in range (0, WINDOWHEIGHT, CELLSIZE): # trace des lignes horizontales 
-        pygame.draw.line(DISPLAYSURF, DARKGRAY, (0,y), (WINDOWWIDTH, y))\\+         pygame.draw.line(DISPLAYSURF, DARKGRAY, (0,y), (WINDOWWIDTH, y))
  
  
-def drawGridExample():\\ + def drawGridExample(): 
-    for n in BoxExample:\\ +     for n in BoxExample: 
-     pygame.draw.rect(DISPLAYSURF, RED, (BoxExample[n][0]*CELLSIZE, BoxExample[n][1]*CELLSIZE, CELLSIZE, CELLSIZE))\\+     pygame.draw.rect(DISPLAYSURF, RED, (BoxExample[n][0]*CELLSIZE, BoxExample[n][1]*CELLSIZE, CELLSIZE, CELLSIZE))
  
-#Colours the cells green for life and white for no life\\ + #Colore en vert les cellules vivantes et en blancs les "non-vivantes" 
-def colourGrid(item, lifeDict):\\ + def colourGrid(item, lifeDict): 
-    x = item[0]\\ +     x = item[0] 
-    y = item[1]\\ +     y = item[1] 
-    y = y * CELLSIZE # translates array into grid size\\ +     y = y * CELLSIZE # transforme le tableau de dimension de la grille 
-    x = x * CELLSIZE # translates array into grid size\\ +     x = x * CELLSIZE # transforme le tableau de dimension de la grille 
-    if lifeDict[item] == 0:\\ +     if lifeDict[item] == 0: 
-        pygame.draw.rect(DISPLAYSURF, WHITE, (x, y, CELLSIZE, CELLSIZE))\\ +         pygame.draw.rect(DISPLAYSURF, WHITE, (x, y, CELLSIZE, CELLSIZE)) 
-    if lifeDict[item] == 1:\\ +     if lifeDict[item] == 1: 
-        pygame.draw.rect(DISPLAYSURF, GREEN, (x, y, CELLSIZE, CELLSIZE))\\ +         pygame.draw.rect(DISPLAYSURF, GREEN, (x, y, CELLSIZE, CELLSIZE)) 
- #   pygame.draw.rect(DISPLAYSURF, BLACK, (8*CELLSIZE, 3*CELLSIZE, CELLSIZE, CELLSIZE))\\ +     return lifeDict[item]\\
-    return lifeDict[item]\\+
  
-#Creation un dictionnaire de l'ensemble des cellules\\ + #Creation un dictionnaire de l'ensemble des cellules 
-#Toutes les cellules sont "mortes" (valeur 0)\\ + #Toutes les cellules sont "mortes" (valeur 0) 
-def blankGrid():\\ + def blankGrid(): 
-    gridDict = {}\\ +     gridDict = {} 
-    #Creation d un dictionnaire pour toutes les cellules de la grille\\ +     #Creation d un dictionnaire pour toutes les cellules de la grille 
-    for y in range (CELLHEIGHT):\\ +     for y in range (CELLHEIGHT): 
-        for x in range (CELLWIDTH):\\ +         for x in range (CELLWIDTH): 
-            gridDict[x,y] = 0 #Toutes les cellules sont "mortes"\\  +             gridDict[x,y] = 0 #Toutes les cellules sont "mortes"  
-    return gridDict\\+     return gridDict 
  
-def startingGridInit(lifeDict, GPIOCasesInit):\\ + def startingGridInit(lifeDict, GPIOCasesInit): 
-    for ncapt in GPIOCasesInit:\\ +     for ncapt in GPIOCasesInit: 
- if(GPIO.input(ncapt)!=0):\\ +  if(GPIO.input(ncapt)!=0): 
-     lifeDict[GPIOCasesInit[ncapt]] = 1\\ +     lifeDict[GPIOCasesInit[ncapt]] = 1 
- # print('pion')\\ +     return lifeDict 
- # print(ncapt)\\ +
-    return lifeDict\\+
  
-#Determines how many alive neighbours there are around each cell\\ + #Calcul du nombre de voisins vivants autour de chaque cellule 
-def getNeighbours(item,lifeDict):\\ + def getNeighbours(item,lifeDict): 
-    neighbours = 0\\ +     neighbours = 0 
-    for x in range (-1,2):\\ +     for x in range (-1,2): 
-        for y in range (-1,2):\\ +         for y in range (-1,2): 
-            checkCell = (item[0]+x,item[1]+y)\\ +             checkCell = (item[0]+x,item[1]+y) 
-            if checkCell[0] < CELLWIDTH  and checkCell[0] >=0:\\ +             if checkCell[0] < CELLWIDTH  and checkCell[0] >=0: 
-                if checkCell [1] < CELLHEIGHT and checkCell[1]>= 0:\\ +                 if checkCell [1] < CELLHEIGHT and checkCell[1]>= 0: 
-                    if lifeDict[checkCell] == 1:\\ +                     if lifeDict[checkCell] == 1: 
-                        if x == 0 and y == 0: # negate the central cell\\ +                         if x == 0 and y == 0: # la cellule centrale n'est pas prise en compte 
-                            neighbours += 0\\ +                             neighbours += 0 
-                        else:\\ +                         else: 
-                            neighbours += 1\\ +                             neighbours += 1 
-    return neighbours\\+     return neighbours 
 +      #Calcul de la nouvelle génération par appel à la fonction 'tick' 
 + def tick(lifeDict): 
 +     newTick = {} 
 +     for item in lifeDict: 
 +         #Obtention du nombre de voisins pour cet élément 
 +         numberNeighbours = getNeighbours(item, lifeDict) 
 +         if lifeDict[item] == 1: # Pour les cellules encore vivantes 
 +             if numberNeighbours < 2: # mort par sous-population 
 +                 newTick[item] = 0 
 +             elif numberNeighbours > 3: #mort par surpopulation 
 +                 newTick[item] = 0 
 +             else:\\ 
 +                 newTick[item] = 1 # ne rien faire (cellule vivante) 
 +         elif lifeDict[item] == 0: 
 +             if numberNeighbours == 3: # naissance d'une cellule 
 +                 newTick[item] = 1 
 +             else: 
 +                 newTick[item] = 0 # ne rien faire (cellule morte) 
 +     return newTick
  
-#determines the next generation by running a 'tick'\\ + #fonction princpale 
-def tick(lifeDict):\\ + def main(): 
-    newTick = {}\\ +     etat=0 
-    for item in lifeDict:\\ +     FLAG_PUSH = 0 
-        #get number of neighbours for that item\\ +     pygame.init() 
-        numberNeighbours = getNeighbours(item, lifeDict)\\ +     global DISPLAYSURF 
-        if lifeDict[item] == 1: # For those cells already alive\\ +     FPSCLOCK = pygame.time.Clock() 
-            if numberNeighbours < 2: # kill under-population\\ +     DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH,WINDOWHEIGHT), pygame.FULLSCREEN) 
-                newTick[item] = 0\\ +     pygame.display.set_caption('Game of Life') 
-            elif numberNeighbours > 3: #kill over-population\\ +     DISPLAYSURF.fill(WHITE)
-                newTick[item] = 0\\ +
-            else:\\ +
-                newTick[item] = 1 # keep status quo (life)\\ +
-        elif lifeDict[item] == 0:\\ +
-            if numberNeighbours == 3: # cell reproduces\\ +
-                newTick[item] = 1\\ +
-            else:\\ +
-                newTick[item] = 0 # keep status quo (death)\\ +
-    return newTick\\+
  
-#main function\\ +     lifeDict = blankGrid() #Creation un dictionnaire de cellules, initialisation a zero
-def main():\\+
  
-    ps14=0\\ +     #Coloration des cellules vivantes 
-    ps15=0\\ +     for item in lifeDict: 
-    cs14=0\\ +         colourGrid(item, lifeDict) 
-    cs15=0\\ +     drawGrid() 
-#    GPIOCasesInit = {17:(9,4), 27:(10,4), 22:(11,4), 5:(12,4), 6:(9,5), 13:(10,5), 19:(11,5), 26:(12,5), 12:(9,6), 23:(11,6), 25:(12,6), 21:(9,7), 16:(10,7), 20:(11,7)}\\ +     pygame.display.update() 
-    etat=0\\ +     while True: #main game loop 
-    FLAG_PUSH = 0\\ +         for event in pygame.event.get(): 
-    pygame.init()\\ +         if event.type == QUIT: 
-    global DISPLAYSURF\\ +                 pygame.quit() 
-    FPSCLOCK = pygame.time.Clock()\\ +                 sys.exit() 
-    DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH,WINDOWHEIGHT), pygame.FULLSCREEN)\\ +                 #Indispensable: prévoir de pouvoir quitter le mode plein écran  
-    pygame.display.set_caption('Game of Life')\\ +  if event.type == pygame.KEYUP: 
-    DISPLAYSURF.fill(WHITE)\\ +  DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH,WINDOWHEIGHT), pygame.RESIZABLE) 
-#    GPIOCasesInit=valCaptInit()\\ +  cs14=GPIO.input(14) 
-    lifeDict = blankGrid() #Creation un dictionnaire de cellules, initialisation a zero\\ +  cs15=GPIO.input(15) 
-    #lifeDict = startingGridInit(lifeDict,GPIOCasesInit) # Remplissage du dictionnaire de depart\\ +  if ps14!=cs14:  
-    #Colours the live cells, blanks the dead\\ +  print('ps14', ps14) 
-    for item in lifeDict:\\ +  print('cs14', cs14) 
-        colourGrid(item, lifeDict)\\ +  if(etat==0): 
-    drawGrid()\\ +  afficheInit('Disposez les pions sur le plateau', WINDOWWIDTH/2, WINDOWHEIGHT/2-300) 
-    pygame.display.update()\\ +  afficheInit('et appuyez sur SUIVANT', WINDOWWIDTH/2, (WINDOWHEIGHT/2-200))  
-    while True: #main game loop\\ +  afficheInit('Quelques exemples:', WINDOWWIDTH/2, WINDOWHEIGHT/2-100) 
-       for event in pygame.event.get():\\ +  drawGridExample() 
-         if event.type == QUIT:\\ +  pygame.display.update() 
-                 pygame.quit()\\ +  #passage a etat suivant 
-                 sys.exit()\\ +  if(ps14==1 and  cs14==0): 
- if event.type == pygame.KEYUP:\\ +  doit_demarrer=False 
- DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH,WINDOWHEIGHT), pygame.RESIZABLE)\\ +  nb_viv=0 
- cs14=GPIO.input(14)\\ +  for elem in GPIOCasesInit: 
- cs15=GPIO.input(15)\\ +  if(GPIO.input(elem)): 
- if ps14!=cs14: \\ + doit_demarrer = True 
- print('ps14', ps14)\\ + nb_viv+=1 
- print('cs14', cs14)\\ + print(GPIOCasesInit[elem]) 
- if(etat==0):\\ + print('nb_viv', nb_viv) 
- afficheInit('Disposez les pions sur le plateau', WINDOWWIDTH/2, WINDOWHEIGHT/2-300)\\ + if doit_demarrer:  
- afficheInit('et appuyez sur SUIVANT', WINDOWWIDTH/2, (WINDOWHEIGHT/2-200)) \\ + etat=1 
- afficheInit('Quelques exemples:', WINDOWWIDTH/2, WINDOWHEIGHT/2-100)\\ + lifeDict = startingGridInit(lifeDict, GPIOCasesInit) 
- drawGridExample()\\ + else: 
- pygame.display.update()\\ + etat=0 
- #passage a etat suivant\\ + elif(etat==1): 
-# if GPIO.event_detected(14):\\ + if(ps15==1 and cs15==0):
- if(ps14==1 and  cs14==0):\\ +
- doit_demarrer=False\\ +
- nb_viv=0\\ +
- for elem in GPIOCasesInit:\\ +
- if(GPIO.input(elem)):\\ +
- doit_demarrer = True\\ +
- nb_viv+=1\\ +
- print(GPIOCasesInit[elem])\\ +
- print('nb_viv', nb_viv)\\ +
- if doit_demarrer: \\  +
- etat=1\\ +
- lifeDict = startingGridInit(lifeDict, GPIOCasesInit)\\ +
- +
- else:\\ +
- etat=0\\ +
- elif(etat==1):\\ +
- if(ps15==1 and cs15==0):\\ +
-# if GPIO.event_detected(15):+
  etat=0  etat=0
  lifeDict=blankGrid()  lifeDict=blankGrid()
  if(ps14==1 and cs14==0):  if(ps14==1 and cs14==0):
-# if GPIO.event_detected(14): +        #Calcul de l'état suivant
-        #runs a tick+
  nb_viv=0  nb_viv=0
  lifeDict = tick(lifeDict)  lifeDict = tick(lifeDict)
Ligne 294: Ligne 279:
  drawGrid()  drawGrid()
         pygame.display.update()          pygame.display.update() 
- #if(nb_viv==0): 
- # etat=0   
  ps14=cs14  ps14=cs14
  ps15=cs15  ps15=cs15
Ligne 304: Ligne 287:
     main()     main()
  
- +</code>
-''+
 ======================================================= =======================================================
  
Ligne 315: Ligne 297:
  
 =====Retour d'expérience===== =====Retour d'expérience=====
 +
 +Il semble qu'il ne soit pas nécessaire de protéger la carte SD d'une extinction intempestive, au moins pour plusieurs cycles d'extinction/allumage.
 +
 +Par précaution, il faut réaliser un clone (une image disque) de la carte finale, comportant non seulement une copie du système mais aussi de tous les réglages et des codes.
 +
 +Ce clone servira à graver une nouvelles carte SD si celle employée ne fonctionne plus.
 +
 +
 FSR: FSR:
  
jeu_de_la_vie.txt · Dernière modification : 2020/10/29 14:03 de serge