je souhaite de l’aide pour la fabrication d’un flipper mécanique
Pour la partie fabrication, je n’ai aucun problème
c’est la partie informatique programmation car je ne maitrise pas du tout
Je voudrai contrôler le flipper avec un raspberry 4
Il y aura un écran 20 à 24" qui affichera les 4 joueurs avec leurs scores respectifs et pourquoi pas une animation
un 1er bouton qui appuie prolonger 3 sec = remise à zero des scores et nombre de joueurs
et simple appuie monte le nombre de joueur de 1 à 4
lors du jeu
chaque bumper et autres cibles seront montés avec un interrupteur à levier
quand la bille tapera les élastiques et cibles cela fera une pression sur le levier
et le raspberry détectera chaque impulsion pour compter les points et jouera un son
Comme un vrai flipper chaque joueur joue une bille chacun son tour jusqu’à 3 parties
bien entendu le raspberry devra detecter également le bille qui sort du jeu pour passer au joueur suivant voir la fin de partie si les 3 billes par joueur ont été jouées
puis les scores affichés, pourquoi ne pas faire une liste des meilleurs scores avec rajout du nom (15 meilleurs scores devrait suffire)
Le programme se lancera tout seul au démarrage en plein ecran avec une animation
Voila mon projet mais pour la partie informatique la je bute vraiment. je me suis arrêté au langage turbo pascal et au basic…
une fois le projet lancé, je mettrai en ligne son avancé et les plans à disposition de tous
Comme ça, à l’arrach’ entre le footing de 10 km et la préparation du repas, je vois un code python qui envoie des actions lors de la pression sur des boutons poussoirs.
Mais :
Sauf pour la partie « détecter également le bille qui sort du jeu »
Combien de bouton va-t-il falloir car le nombre de GPIO n’est pas illimité
pour la bille qui sort du jeu j’ai pensé
soit à un détecteur de présence infrarouge
soit un cercle de métal et au centre une autre partie métallique (la bille faisant contact entre les deux comme un interrupteur)
pour le nombre de GPIO
je pense que 5 devraient suffire, un qui compte 1 points 5,10, 15 et 20 points
rien n’empêche de connecter plusieurs leviers interrupteurs sur la borne GPIO 5 points par exemple
un GPIO pour un reset, et la definition du nombre de joueur de 1 à 4
il y aura surement un, pour envoyer la bille de la sortie vers le rail de lancement (declenchement d’une bobine avec une tige qui pousse la bille vers le rail) lorsque on définie le nombre de joueurs (la partie commence) ou quand elle sort et que les 3 tours ne sont pas joués
Super projet ! comme je n’imagine même pas comment on fabrique un bumper ni les élastiques ni même les targets je n’ai que deux remarques:
. oublie pas le tilt
. comme le souligne Nabla tu vas avoir besoin d’un paquets de GPIO en entrée.
pour le tilt un composant doit faire le job ( SW-520D ) sur cette page Raspberry Pi Starter Kit Lesson 14: SW520D Tilt Switch with Raspberry Pi « osoyoo.com tu trouveras des explications et les programmes ( C++ et python )
à noter que ce composant SW520D qui est en fait un interrupteur se trouve sous la forme d’un simple composant. ( pas d’une carte )
Une solution plus simple, quoique un peu plus lente que le duo 74hc165 et 595 (sur SPI) est le MCP23017 (bidirectionnel, comme les ports du RPi; ladyADA a fait une bibliothèquepour le RPi qui m’a satisfait, et des tutoriaux simples Overview | Using MCP23008 & MCP23017 with CircuitPython | Adafruit Learning System)
Il est plus lent, mais mange moins de ports du RPi (I2C: 2fils vs SPI 3/4 fils) et se gére pratiquement comme une patte de RPi. On peut rajouter jusqu’à 8 MCP23017 (adresse configurable), gerant jusqu’a 8*16 128 fils…
je voudrai un raspberry en mode kiosk
qui lance une video animation au demarrage puis player 1 2 3 et 4 apparait
puis on choisi le nombre de joueurs en appuyant sur un bouton en mettant en surbrillance les joueurs
et enfin 5 GPIO relié à des interrupteurs lamelles qui comptent des points à chaque touché chaque GPIO comptent différemment les point un pour 1 points un autres 5 puis 10 15 et 20
une animation pour chaque tour de joueur style « PLAYER ONE » etc…
c’est le programme en python qui me pose problème je ne sais pas programmer
le but du jeu étant de détailler au plus possible les traitements (saisie des entrée, calcul des points, les tests ( ponctuels ou indiquant une boucle ))
une fois le programme ainsi organisé, la programmation devrait être plus simple ( enfin en théorie au moins )
Cela va te prendre du temps.
Dans l’idée, je pense qu’il faut une boucle While et des définitions d’action
En gros, le programme se lance et balance une vidéo puis attend
Si bouton 1 pressé = action 1
Si bouton 2 pressé = action 2
Si bouton 3 pressé = action 3 puis attente
Si bouton 4 pressé = action 4 (possible que si action 3 lancé)
Si bouton 5 pressé = action 5 (possible que si action 3 lancé)
Si bouton 6 pressé = action 6
Maintenant, va falloir lire et coder de petits trucs pour apprendre
Perso, j’ai « appris » sur le tas = bcp de temps d’investi ; un réel apprentissage par cours et/ou lecture est nettement préférable.
Malgré mon âge frôlant le 1/2 siècle, je suis resté un jeune con tout feu tout flamme (hyper-actif ??? ), mais le conseil est VRAIMENT de lire des ouvrages de référence.
pour rebondir sur le post de Nabla il y a aussi outre l’apprentissage nécessaire du langage, la copie des ressource qu’offre le net; l’idée étant que plutôt que de réinventer l’eau chaude, on gagne a réutiliser les exemples qui pullule sur le web …
par exemple l’affichage d une video en python avec tkinter :
from tkinter import *
import imageio
from PIL import Image, ImageTk
def stream():
try:
image = video.get_next_data()
frame_image = Image.fromarray(image)
frame_image=ImageTk.PhotoImage(frame_image)
l1.config(image=frame_image)
l1.image = frame_image
l1.after(delay, lambda: stream())
except:
video.close()
return
########### Main Program ############
root = Tk()
root.title('Video in a Frame')
f1=Frame()
l1 = Label(f1)
l1.pack()
f1.pack()
video_name = "video.mp4" #Image-path
video = imageio.get_reader(video_name)
delay = int(1000 / video.get_meta_data()['fps'])
stream()
root.mainloop()
je vais procéder pas à pas
l’organigramme est pas mal
je vais l’exploiter et l’améliorer puis je vais essayer de programmer chaque partie et vous l’exposer
pour la video j’avais trouvé un code cet AM
import pyglet
window = pyglet.window.Window(1920,1080) # dimension de la fenetre
player = pyglet.media.Player() # création d’un player
MediaLoad = pyglet.media.load(« test.mp4 ») # chargement de la video
player.queue(MediaLoad) # insertion de la video la dans le player
player.play() # jouer le media @window.event
def on_draw(): # affichage
window.clear()
player.get_texture().blit(0,0)
pyglet.app.run()
Dans un premier temp si tu veux t’affranchir de la partie développement en python, je me permets de te proposer d’utiliser un logiciel fullweb d’affichage dynamique que j’ai développé.
Personnellement j’ai choisi de développer celui-ci en NODEJS (javascript).
J’y ai inclus récemment la possibilité de gérer les ports GPIO sans devoir passer par de la programmation externe.
En étudiant la faisabilité de ton projet et des difficultés qui t’inquiètent dû fait de l’absence de connaissance en développement que tu as pour le moment.
j’ai trouver une solution qui permet de faire du développement « no-code » avec le raspberry.
Cette solution s’appuie sur « Blockly » qui est une bibliothèque logicielle JavaScript permettant de créer des environnements de développement utilisant un langage graphique.
C’est un projet open source de Google.
C’est en fait, un équivalent à « Scratch » qui est également un langage de programmation graphique.
Mais contrairement à « Scratch », « Blockly » permet de générer du code source python ou javascript.
La solution « Bipes » a été conçue pour également programmer ce qui est connecté aux GPIO des raspberry
)
), mais le conseil est VRAIMENT de lire des ouvrages de référence.