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 15:08] – Mushussujeu_de_la_vie [2020/04/06 07:30] – [Matériel] serge
Ligne 28: Ligne 28:
 Les choix techniques ont été les suivants:\\ Les choix techniques ont été les suivants:\\
 la contrainte d'encombrement réduit et de puissance de calcul suffisant a conduit au choix d'une micro-ordinateur pour la partie unité de traitement.\\ la contrainte d'encombrement réduit et de puissance de calcul suffisant a conduit au choix d'une micro-ordinateur pour la partie unité de traitement.\\
-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 1920 par 1080 pixels; 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. \\ + 
-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. \\ + 
-Enfin, un bouton marche/arrêt du jeu a été intégré. Il est nécessaire d'effectuer un arrêt du +\\ 
 +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.  
 + 
 +{{:fsr.jpg?400|}} 
 +\\ 
 +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 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 50: Ligne 56:
  
 16 capteurs FSR pour la détection des billes: Fournisseur Pololu, dimensions 0,2 pouces de diamètre (ce qui correspond à 0,5 cm de diamètre)\\ 16 capteurs FSR pour la détection des billes: Fournisseur Pololu, dimensions 0,2 pouces de diamètre (ce qui correspond à 0,5 cm de diamètre)\\
 +https://www.pololu.com/product/1695\\
 Deux boutons d'interaction: démarrage et avance du jeu, retour à zéro\\ Deux boutons d'interaction: démarrage et avance du jeu, retour à zéro\\
  
 Un bouton marche/arrêt\\ Un bouton marche/arrêt\\
-Une RaspberryPi pour la gestion des événements et l'affichage\\ +Une RaspberryPi pour la gestion des événements et l'affichage: [[https://www.kubii.fr/les-cartes-raspberry-pi/1628-raspberry-pi-3-modele-b-1-gb-kubii-640522710850.html|kubii.fr]]\\ 
-Un écran Waveshare 1920x1080 pixels+Un écran Waveshare 1920x1080 pixels: https://www.waveshare.com/15.6inch-HDMI-LCD-H-with-case.htm
  
 =====Logiciel===== =====Logiciel=====
Ligne 66: Ligne 73:
 -copie sur une autre carte SD\\ -copie sur une autre carte SD\\
 Liste exhaustive du matériel:\\ Liste exhaustive du matériel:\\
 +
 +écran Waveshare:\\
 +https://www.waveshare.com/15.6inch-HDMI-LCD-H-with-case.htm
 +
 +capteurs de pression:\\
 +
 +
 Photos\\ Photos\\
 Codes\\ Codes\\
Ligne 75: Ligne 89:
  
 <code python> <code python>
-'' + import pygame, sys 
-import pygame, sys\\ + from pygame.locals import * 
-from pygame.locals import *\\ + import random 
-import random\\ + import RPi.GPIO as GPIO 
-import RPi.GPIO as GPIO\\ + from time import sleep
-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)}\\ +
-assert len(GPIOCasesInit)==16\\ +
-assert len(set(GPIOCasesInit.values()))==16\\ +
-GPIO.setmode(GPIO.BCM)\\ +
-'' +
-'' +
-for n in GPIOCasesInit: +
-    GPIO.setup(n, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) +
-    GPIO.setup(14, GPIO.IN, pull_up_down=GPIO.PUD_UP) +
-    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\\ + 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)} 
-WINDOWWIDTH = 1920\\ + # vérification du nombre de capteurs définis 
-WINDOWHEIGHT = 1080\\ + assert len(GPIOCasesInit)==16 
-CELLSIZE = 40\\+ assert len(set(GPIOCasesInit.values()))==16 
 + GPIO.setmode(GPIO.BCM) 
 +# 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 
 + for n in GPIOCasesInit:  
 +     GPIO.setup(n, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) 
 +     GPIO.setup(14, GPIO.IN, pull_up_down=GPIO.PUD_UP) 
 +     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) 
 + GPIO.add_event_detect(15, GPIO.FALLING) 
 + #nombre d'images par seconde 
 + FPS = 10
  
-#Check to see if the width and height are multiples of the cell size.\\ + ###configure la taille de la grille 
-assert WINDOWWIDTH % CELLSIZE == 0, "Window width must be a multiple of cell size"\\ + WINDOWWIDTH = 1920 
-assert WINDOWHEIGHT % CELLSIZE == 0, "Window height must be a multiple of cell size"\\+ WINDOWHEIGHT = 1080 
 + CELLSIZE = 40
  
-#Determine number of cells in horizonatl and vertical plane\\ + #les dimensions de la grille sont-elles des multiples du nombre de cellules 
-CELLWIDTH = WINDOWWIDTH / CELLSIZE # number of cells wide\\ + assert WINDOWWIDTH % CELLSIZE == 0, "la largeur des cellules doit être un multiple de la taille des cellules" 
-CELLHEIGHT = WINDOWHEIGHT / CELLSIZE # Number of cells high\\+ assert WINDOWHEIGHT % CELLSIZE == 0, "la hauteur des cellules doit être un multiple de la taille des cellules"
  
-# set up the colours\\ + #Determine le nombre de cellules sur l'axe vertical et l'axe horizontal\\ 
-BLACK =    (0,  0,  0)\\ + CELLWIDTH = WINDOWWIDTH / CELLSIZE # nombre de cellules en largeur 
-WHITE =    (255,255,255)\\ + CELLHEIGHT = WINDOWHEIGHT / CELLSIZE # nombre de cellules en hauteur
-DARKGRAY = (40, 40, 40)\\ +
-GREEN =    (50,255,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)}\\+ # fabrication des couleurs 
 + BLACK =    (0,  0,  0) 
 + WHITE =    (255,255,255) 
 + DARKGRAY = (40, 40, 40) 
 + GREEN =    (50,255,100) 
 + RED =  (255, 0, 100)
  
-def text_objects(text, font): \\ + 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)}
-    textSurface = font.render(text, True, DARKGRAY)\\ +
-    return textSurface, textSurface.get_rect()\\+
  
-def afficheInit(text, x, y):\\ + def text_objects(text, font):  
-    largeText = pygame.font.Font('freesansbold.ttf',75)\\ +     textSurface = font.render(text, True, DARKGRAY) 
-    TextSurf, TextRect = text_objects(text, largeText)\\ +     return textSurface, textSurface.get_rect() 
-    TextRect.center = (x,y)\\ +
-    DISPLAYSURF.blit(TextSurf, TextRect)\\ +
-    pygame.display.update()\\ +
-    #time.sleep(2)\\+
  
-#Draws the grid lines\\ + def afficheInit(text, x, y): 
-def drawGrid():\\ +     largeText = pygame.font.Font('freesansbold.ttf',75) 
-    for x in range(0, WINDOWWIDTH, CELLSIZE): # draw vertical lines\\ +     TextSurf, TextRect = text_objects(text, largeText) 
-        pygame.draw.line(DISPLAYSURF, DARKGRAY, (x,0),(x,WINDOWHEIGHT))\\ +     TextRect.center = (x,y) 
-    for y in range (0, WINDOWHEIGHT, CELLSIZE): # draw horizontal lines\\ +     DISPLAYSURF.blit(TextSurf, TextRect) 
-        pygame.draw.line(DISPLAYSURF, DARKGRAY, (0,y), (WINDOWWIDTH, y))\\+     pygame.display.update()
  
 + #Dessin de la grille
 + def drawGrid():
 +     for x in range(0, WINDOWWIDTH, CELLSIZE): # trace des lignes verticales
 +         pygame.draw.line(DISPLAYSURF, DARKGRAY, (x,0),(x,WINDOWHEIGHT))
 +     for y in range (0, WINDOWHEIGHT, CELLSIZE): # trace des lignes horizontales
 +         pygame.draw.line(DISPLAYSURF, DARKGRAY, (0,y), (WINDOWWIDTH, y))
  
-def drawGridExample():\\ 
-    for n in BoxExample:\\ 
-    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\\ + def drawGridExample(): 
-def colourGrid(item, lifeDict):\\ +     for n in BoxExample: 
-    x = item[0]\\ +     pygame.draw.rect(DISPLAYSURF, RED, (BoxExample[n][0]*CELLSIZE, BoxExample[n][1]*CELLSIZE, CELLSIZE, CELLSIZE))
-    y = item[1]\\ +
-    y = y * CELLSIZE # translates array into grid size\\ +
-    x = x * CELLSIZE # translates array into grid size\\ +
-    if lifeDict[item] == 0:\\ +
-        pygame.draw.rect(DISPLAYSURF, WHITE, (x, y, CELLSIZE, CELLSIZE))\\ +
-    if lifeDict[item] == 1:\\ +
-        pygame.draw.rect(DISPLAYSURF, GREEN, (x, y, CELLSIZE, CELLSIZE))\\ +
- #   pygame.draw.rect(DISPLAYSURF, BLACK, (8*CELLSIZE, 3*CELLSIZE, CELLSIZE, CELLSIZE))\\ +
-    return lifeDict[item]\\+
  
-#Creation un dictionnaire de l'ensemble des cellules\\ + #Colore en vert les cellules vivantes et en blancs les "non-vivantes" 
-#Toutes les cellules sont "mortes" (valeur 0)\\ + def colourGrid(item, lifeDict): 
-def blankGrid():\\ +     x = item[0] 
-    gridDict = {}\\ +     y = item[1] 
-    #Creation d un dictionnaire pour toutes les cellules de la grille\\ +     y = y * CELLSIZE # transforme le tableau de dimension de la grille 
-    for y in range (CELLHEIGHT):\\ +     x = x * CELLSIZE # transforme le tableau de dimension de la grille 
-        for x in range (CELLWIDTH):\\ +     if lifeDict[item] == 0: 
-            gridDict[x,y] = 0 #Toutes les cellules sont "mortes"\\  +         pygame.draw.rect(DISPLAYSURF, WHITE, (x, y, CELLSIZE, CELLSIZE)) 
-    return gridDict\\+     if lifeDict[item] == 1: 
 +         pygame.draw.rect(DISPLAYSURF, GREEN, (x, y, CELLSIZE, CELLSIZE)) 
 +     return lifeDict[item]\\
  
-def startingGridInit(lifeDict, GPIOCasesInit):\\ + #Creation un dictionnaire de l'ensemble des cellules 
-    for ncapt in GPIOCasesInit:\\ + #Toutes les cellules sont "mortes" (valeur 0) 
- if(GPIO.input(ncapt)!=0):\\ + def blankGrid(): 
-     lifeDict[GPIOCasesInit[ncapt]] = 1\\ +     gridDict = {} 
- # print('pion')\\ +     #Creation d un dictionnaire pour toutes les cellules de la grille 
- # print(ncapt)\\ +     for y in range (CELLHEIGHT): 
-    return lifeDict\\+         for x in range (CELLWIDTH): 
 +             gridDict[x,y] = 0 #Toutes les cellules sont "mortes"  
 +     return gridDict 
  
-#Determines how many alive neighbours there are around each cell\\ + def startingGridInit(lifeDict, GPIOCasesInit): 
-def getNeighbours(item,lifeDict):\\ +     for ncapt in GPIOCasesInit: 
-    neighbours = 0\\ +  if(GPIO.input(ncapt)!=0): 
-    for x in range (-1,2):\\ +     lifeDict[GPIOCasesInit[ncapt]] = 1 
-        for y in range (-1,2):\\ +     return lifeDict 
-            checkCell = (item[0]+x,item[1]+y)\\ +
-            if checkCell[0] < CELLWIDTH  and checkCell[0] >=0:\\ +
-                if checkCell [1] < CELLHEIGHT and checkCell[1]>= 0:\\ +
-                    if lifeDict[checkCell] == 1:\\ +
-                        if x == 0 and y == 0: # negate the central cell\\ +
-                            neighbours += 0\\ +
-                        else:\\ +
-                            neighbours += 1\\ +
-    return neighbours\\+
  
-#determines the next generation by running a 'tick'\\ + #Calcul du nombre de voisins vivants autour de chaque cellule 
-def tick(lifeDict):\\ + def getNeighbours(item,lifeDict): 
-    newTick = {}\\ +     neighbours = 0 
-    for item in lifeDict:\\ +     for x in range (-1,2): 
-        #get number of neighbours for that item\\ +         for y in range (-1,2): 
-        numberNeighbours = getNeighbours(item, lifeDict)\\ +             checkCell = (item[0]+x,item[1]+y) 
-        if lifeDict[item] == 1: # For those cells already alive\\ +             if checkCell[0] < CELLWIDTH  and checkCell[0] >=0: 
-            if numberNeighbours < 2: # kill under-population\\ +                 if checkCell [1] < CELLHEIGHT and checkCell[1]>= 0: 
-                newTick[item] = 0\\ +                     if lifeDict[checkCell] == 1: 
-            elif numberNeighbours > 3: #kill over-population\\ +                         if x == 0 and y == 0: # la cellule centrale n'est pas prise en compte 
-                newTick[item] = 0\\ +                             neighbours += 0 
-            else:\\ +                         else: 
-                newTick[item] = 1 # keep status quo (life)\\ +                             neighbours += 1 
-        elif lifeDict[item] == 0:\\ +     return neighbours 
-            if numberNeighbours == 3: # cell reproduces\\ +      #Calcul de la nouvelle génération par appel à la fonction 'tick' 
-                newTick[item] = 1\\ + def tick(lifeDict): 
-            else:\\ +     newTick = {} 
-                newTick[item] = 0 # keep status quo (death)\\ +     for item in lifeDict: 
-    return newTick\\+         #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
  
-#main function\\ + #fonction princpale 
-def main():\\+ def main(): 
 +     etat=0 
 +     FLAG_PUSH = 0 
 +     pygame.init() 
 +     global DISPLAYSURF 
 +     FPSCLOCK = pygame.time.Clock() 
 +     DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH,WINDOWHEIGHT), pygame.FULLSCREEN) 
 +     pygame.display.set_caption('Game of Life') 
 +     DISPLAYSURF.fill(WHITE)
  
-    ps14=0\\ +     lifeDict = blankGrid() #Creation un dictionnaire de cellules, initialisation a zero
-    ps15=0\\ +
-    cs14=0\\ +
-    cs15=0\\ +
-#    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)}\\ +
-    etat=0\\ +
-    FLAG_PUSH = 0\\ +
-    pygame.init()\\ +
-    global DISPLAYSURF\\ +
-    FPSCLOCK = pygame.time.Clock()\\ +
-    DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH,WINDOWHEIGHT), pygame.FULLSCREEN)\\ +
-    pygame.display.set_caption('Game of Life')\\ +
-    DISPLAYSURF.fill(WHITE)\\ +
-#    GPIOCasesInit=valCaptInit()\\ +
-    lifeDict = blankGrid() #Creation un dictionnaire de cellules, initialisation a zero\\ +
-    #lifeDict = startingGridInit(lifeDict,GPIOCasesInit) # Remplissage du dictionnaire de depart\\ +
-    #Colours the live cells, blanks the dead\\ +
-    for item in lifeDict:\\ +
-        colourGrid(item, lifeDict)\\ +
-    drawGrid()\\ +
-    pygame.display.update()\\ +
-    while True: #main game loop\\ +
-        for event in pygame.event.get():\\ +
-        if event.type == QUIT:\\ +
-                pygame.quit()\\ +
-                sys.exit()\\ +
- if event.type == pygame.KEYUP:\\ +
- DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH,WINDOWHEIGHT), pygame.RESIZABLE)\\ +
- cs14=GPIO.input(14)\\ +
- cs15=GPIO.input(15)\\ +
- if ps14!=cs14: \\ +
- print('ps14', ps14)\\ +
- print('cs14', cs14)\\ +
- if(etat==0):\\ +
- afficheInit('Disposez les pions sur le plateau', WINDOWWIDTH/2, WINDOWHEIGHT/2-300)\\ +
- afficheInit('et appuyez sur SUIVANT', WINDOWWIDTH/2, (WINDOWHEIGHT/2-200)) \\ +
- afficheInit('Quelques exemples:', WINDOWWIDTH/2, WINDOWHEIGHT/2-100)\\ +
- drawGridExample()\\ +
- pygame.display.update()\\ +
- #passage a etat suivant\\ +
-# if GPIO.event_detected(14):\\ +
- 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:\\ +     #Coloration des cellules vivantes 
- etat=0\\ +     for item in lifeDict: 
- elif(etat==1):\\ +         colourGrid(item, lifeDict) 
- if(ps15==1 and cs15==0):\\ +     drawGrid() 
-# if GPIO.event_detected(15):+     pygame.display.update() 
 +     while True: #main game loop 
 +        for event in pygame.event.get(): 
 +          if event.type == QUIT: 
 +                  pygame.quit() 
 +                  sys.exit() 
 +                 #Indispensable: prévoir de pouvoir quitter le mode plein écran  
 +  if event.type == pygame.KEYUP: 
 +  DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH,WINDOWHEIGHT), pygame.RESIZABLE) 
 +  cs14=GPIO.input(14) 
 +  cs15=GPIO.input(15) 
 +  if ps14!=cs14:  
 +  print('ps14', ps14) 
 +  print('cs14', cs14) 
 +  if(etat==0): 
 +  afficheInit('Disposez les pions sur le plateau', WINDOWWIDTH/2, WINDOWHEIGHT/2-300) 
 +  afficheInit('et appuyez sur SUIVANT', WINDOWWIDTH/2, (WINDOWHEIGHT/2-200))  
 +  afficheInit('Quelques exemples:', WINDOWWIDTH/2, WINDOWHEIGHT/2-100) 
 +  drawGridExample() 
 +  pygame.display.update() 
 +  #passage a etat suivant 
 +  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):
  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 293:
  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 301:
     main()     main()
  
- 
-'' 
 </code> </code>
 ======================================================= =======================================================
Ligne 316: Ligne 311:
  
 =====Retour d'expérience===== =====Retour d'expérience=====
-FSR: 
  
-Tests effectués en mesurant la valeur de la résistance selon la pression exercée :+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:** 
 + 
 +__ 
 +Tests effectués en mesurant la valeur de la résistance selon la pression exercée :__
  
 De 1  je passe à des valeurs plus ou moins pertinentes selon le poids. De 1  je passe à des valeurs plus ou moins pertinentes selon le poids.
Ligne 331: Ligne 335:
 Le mieux pour simuler la pression du doigt c’est une « goutte d’eau », pieds autocollants antidérapant en forme de demi-hémisphère sur les cylindres Le mieux pour simuler la pression du doigt c’est une « goutte d’eau », pieds autocollants antidérapant en forme de demi-hémisphère sur les cylindres
  
-> Le 19.07.2019 11:01, Guy Antoine a écrit : 
->> Bonjour Camille 
->> Pour la manip du jeu de la vie, les jetons font 18mm donc découpe à 
->> 19mm sur le support de 120x120 selon les plans ci-joint. 
->> Peux tu me valider cette option ? J'ai regardé pour les joncs de 20mm 
->> en plexi mais c'est très "moches" comparés à ceux en bois peints 
->> Donc on vérifieras au règlage s'il faut les lester. 
  
-Modifications en vue de la version 2:+__Modifications en vue de la version 2:__
 Il s'avère que la détection par les FSR n'est pas assez robuste. Il faut souvent un appui supplémentaire sur les billes de la part de l'utilisateur. Le mieux serait d'utiliser un contact mécanique du type contacteur ou interrupteur Il s'avère que la détection par les FSR n'est pas assez robuste. Il faut souvent un appui supplémentaire sur les billes de la part de l'utilisateur. Le mieux serait d'utiliser un contact mécanique du type contacteur ou interrupteur
  
jeu_de_la_vie.txt · Dernière modification : 2020/10/29 14:03 de serge