SinS is not Simon

Mis à jour : juil. 20


C'est dans le cadre du concours #ChallengeDesMakers2020 organisé par OuiAreMakers que nous avons constitué l'équipe #OuiAreSins, avec François de Framboise314, Frédéric de Garatronic, Dominique du shop MC Hobby et moi-même. Nous réalisons un petit jeux électronique rigolo et collaboratif où il faut retrouver 10 clés qui ouvrent des coffres à trésors, planquées dans un immense labyrinthe où se succèdent des pièces avec 4 portes de sorties de 4 couleurs distinctes. Un guide nous montre les 3 prochaines portes à emprunter, et continue de nous guider tant qu'on arrive à recommencer depuis le début sans se perdre, car il faut rapporter les clés à chaque fois. Le jeux se termine quand on a trouvé les 10 clés, ou qu'on s'est perdu, et il est conseillé d'y jouer de manière collaborative à plusieurs pour retenir les séquences de portes à ouvrir de plus en plus longues. Il s'agit d'un jeu de mémoire visuelle et auditive, mais ne vous y trompez pas: Sins Is Not Simon!

Les sources du projet sont disponibles et téléchargeables sur mon GitHub. Ce jeux peut être réalisé au choix sur une breadboard, ou bien sur un circuit imprimé dédié, avec en option un superbe boîtier imprimé 3D réalisé sur mesure par François.


Circuit électronique


Matériel nécessaire

  • 1 PYBStick26 standard avec ses deux barrettes femelles 13 pins soudées. Conçue par Frédéric de Garatronic, disponible sur le shop de MC Hobby, c'est une petite merveille made in France pour les makers à base micro-contrôleur SMT32.

  • 4 leds 5mm (Verte, Bleue, Jaune, Rouge)

  • 4 résistances 220 Ω (pour les leds)

  • 1 résistance 330 Ω (pour le buzzer), sinon 220 Ω sera aussi valable.

  • 1 diode de redressement 1N4148 (optionnel, le prototype fonctionne sans: c'est une diode de roue libre pour protéger le buzzer)

  • 1 petit buzzer passif (attention à bien prendre un passif)

  • 4 boutons poussoirs (6mm pour une breadboard, ou 12mm avec capuchons colorés ronds vert, bleu, jaune et rouge pour le circuit imprimé)

  • 1 écran LCD 1602 avec backpack I2C

  • 1 nappe souple femelle/femelle 4 pins, pour connecter le LCD au circuit.

  • 1 connecteur pin header coudé 4 pins mâles 2.54mm, pour relier le LCD (impérativement coudé pour le circuit imprimé)

  • Un bon paquet des câbles colorés souples Dupont mâle/mâle pour la breadboard uniquement

Si vous préférez souder les composants sur le circuit imprimé proposé, au lieu d'utiliser une breadboard (pleine de câbles), il vous faudra en plus:

  • 1 circuit imprimé, à faire fabriquer à partir des fichiers GERBER_SINS.zip fournis sur mon Github.

  • 1 alimentation 5V avec Jack DC (1A est suffisant).

  • 1 diode Schottky SB560 (elle protège l'alimentation externe 5V quand l'USB est connectée en même temps)

  • 1 connecteur Barrel JackDC mâle, 3 points de soudure

  • 2 pin header mâle 13 pins 2.54mm à souder (pour y brancher la PYBStick)

  • quelques entretoises M2.5 (ou M2 aussi ça passera): 8 * M/F 15mm + 6 écrous + 2 vis


Prototype sur breadboard


C'est simple à réaliser sur une breadboard, en vous référant au schéma ci-dessous. Il faut utiliser dans ce cas des boutons poussoirs 6mm et veiller à positionner judicieusement les câbles pour ne pas gêner lors de l'utilisation. Ne vous trompez pas avec le branchement du LCD sinon il est mort ... La diode de roue libre 1N4148 est optionnelle, plutôt conseillée sur le long terme sur le circuit imprimé. Vous pouvez utiliser 5 résistances de 220Ω ça fonctionne très bien comme ça.




Réalisation sur circuit imprimé


Vous pouvez faire fabriquer le circuit imprimé chez n'importe quel fabriquant de PCB de vote choix à partir des fichiers GERBER zippés fourni dans les sources Github. N'oubliez pas le matériel supplémentaire nécessaire (diode schottky, entretoise etc ..)



Seuls le jack DC et les 2 rangées de pin headers 13 pins mâles seront disposées au dessous du PCB, tout le reste des composants électroniques sont disposés au dessus.


Pour souder les composants, il faut toujours commencer par les plus petits: les 5 résistances, puis la diode 1N4148 en respectant bien le sens (l'anneau de la cathode est sérigraphié sur le circuit). Ensuite les 4 boutons poussoirs 12mm, puis le buzzer, le connecteur coudés 4 pins pour y relier l'écran LCD, la petite capacité 100nF. Avant de souder la grosse diode Schottky, je conseille d'abord de souder les 2 pin headers mâles de 13 pins à disposer au dessous du PCB (soudures au dessus donc), en utilisant une breadboard pour les souder parfaitement perpendiculaires au support. Vous pouvez alors souder la grosse diode Schottky en la plaçant au dessus du PCB dans le bon sens (anneau de la cathode sérigraphiée), bien disposer les pattes sinon elle ne rentre pas. Il reste à souder le jack DC disposé par dessous (soudures au dessus donc),


Concernant les leds (patte la plus courte dirigée vers les boutons poussoirs), il ne faut pas les souder à raz bord du PCB, surtout si vous comptez imprimer le boîtier 3D: il faut les disposer de façon à ce qu'elles soient au même niveau des capuchons plastiques, le résultat est plus joli. Si vous comptez imprimer le boîtier 3D réalisé par François: un gabarit pour souder les leds est à imprimer, sinon vous pouvez les ajuster à l’œil en tordant un peu les pattes en V au dessous qui les maintiendrons en place pendant la soudure.



Deux petites remarques de conception qui devrait titiller les électroniciens:

  • Je n'utilise aucune résistance de protection avec les boutons poussoirs. En regardant le schéma électronique de près, vous pouvez vous demander si je ne suis pas fou ... En effet l'entrée de la PYBStick n'est reliée à rien du tout quand le bouton est en position "Off" et se retrouve court-circuitée direct à la masse quand il est en position "On". Normalement on utilise un montage de type pull-up où l'entrée est reliée via une résistance à Vcc en position Off. Et bien c'est parce que cette résistance pull-up est déjà intégrée dans la PYBStick: on peut configurer les entrées de la PYBStick en mode "pull-up", ce qui est très pratique et nous évite d'avoir à ajouter nos résistances.

  • Toujours au sujet des boutons poussoirs: il faut aussi filtrer le signal avec des condensateurs et des résistances (encore!) pour éviter les faux-rebonds électro-mécaniques générés lors d'un appui: on croit avoir appuyé 1 fois sur le bouton, mais pendant un laps de temps de quelques dizaines de ms cela génère plusieurs changements d'états ON-OFF-ON-OFF-ON-OFF ... et le système non filtré va croire qu'on a appuyé comme un malade des dizaines de fois sur le bouton. Et bien on peut gérer cela de manière logicielle et se passer des résistances et condensateurs de filtrage.

Donc soyez rassurés je ne suis pas fou: les boutons poussoirs sont bien à relier comme ça sans aucune résistance supplémentaire ni aucun filtrage, et je vous expliquerais dans la partie des scripts #MicroPython comment ne pas se faire piéger par les faux rebonds électro-mécaniques.

Une fois les entretoises positionnées et l'afficheur LCD connecté (ne pas vous tromper avec les branchements ...), le jeux devrait ressembler à ceci. Pour le faire fonctionner il faut préalablement installer les scripts MicroPython sur la PYBStick et brancher le Jack DC 5V: le jeux se lance immédiatement.





Boitier imprimé 3D


Un superbe boitier en 2 parties clipsées, ainsi qu'un gabarit pour pouvoir souder parfaitement les leds ont été réalisés par François. Pour imprimer ces éléments vous pouvez télécharger les fichiers STL ici. Merci à François de Framboise314 pour ce superbe travail.




Scripts MicroPython


De nombreuses bibliothèques #MicroPython ont été écrites par Dominique et disponible sur le GitHub de la PYBStick26. On y retrouve beaucoup d'exemples de câblages et exemples de scripts pour piloter des leds, des Neopixels RGB, des moteurs, des switch, des écrans, des buzzers etc ... et des projets complets.


Tous les scripts *.py sont à récupérer sur mon Github et doivent être déposés à la racine du lecteur PYBFLASH qui apparaît lorsque vous connectez la PYBStick26 sur un port USB libre de votre ordinateur. Ensuite vous pouvez déconnecter la PYBStick26, et la remettre sur son circuit imprimé: en branchant le JackDC 5V le jeux démarre immédiatement.


Ces deux bibliothèques à installer ont été écrites par Dominique et permettent respectivement de piloter l'écran LCD et les sorties PWM de la PYBstick26 qui vont nous permettre de moduler l'éclairage des leds.

  • lcdi2c.py

  • pwm.py

Les autres scripts MicroPython à installer:


leds.py


Ce script est composé de deux classes: Led() et RackLeds().


En instanciant un objet led de la classe Led(), des méthodes vont permettre d’allumer ou d’éteindre une led brutalement: led.on() et led.off(), ou avec un effet variateur: led.smooth_on(), led.smooth_off(). La méthode led.clignote(n) va faire clignoter la led n fois (avec un effet variateur)


Un objet de la classe Rackleds représente le rack de 4 leds du jeux, identifiées par 4 codes couleur respectifs ‘V’, ‘B’, ‘J’, ‘R’. Les méthodes permettent d’accéder à une led précise rackleds.get_led(color), et de les allumer toutes en même temps avec des effets de variation, clignotement etc. Enfin les méthodes rackleds.win() et rackleds.loose() vont faire clignoter la led Verte ou la Rouge quand on a gagné ou perdu.


buzzer.py


Dans ce script nous gérons la classe Buzz() qui va gérer le buzzer du jeux.


Une instance buzz de la classe Buzz() est composée de méthodes lui permettant de jouer des notes et des animations musicales. Ainsi buzz.play() et buzz.mute() vont activer ou mettre en mute le buzzer, le volume sonore est quand à lui défini dans la variable buzz.level (par défaut à 25%). La méthode buzz.chg_freq(freq) va modifier la fréquence (440 pour jouer un La, 523 un DO etc …). La méthode buzz.buzz_id(color) va jouer une note en fonction de la couleur choisie. Enfin buzz.welcome_sound() et buzz.loose_sound() vont jouer des animations musicales qui portent bien leurs noms.


buttons.py


À l’image du script leds.py, ce script regroupe deux classes Button_led() et RackButtons() correspondants aux boutons poussoirs qui commandent chaque led, et au rack de 4 boutons poussoirs utilisé par le jeux.


C’est dans un objet button instancié de la classe Button_led() que l’on va gérer de manière logicielle la capture d’un appui sur le bouton poussoir par l’utilisateur sans se faire piéger par les faux rebonds électro-mécaniques. Pour se faire, nous allons déclarer dans notre objet une variable self.extint qui est une instance de la classe Extint : elle permet via interruption logicielle d’appeler une fonction self.callback lorsque l’entrée configurée en PULL-UP change d’état. Dans cette fonction button.callback(line), la première chose à faire est d’attendre 50 à 100ms pour attendre que le signal soit stabilisé, puis de tester à l’issue de ce délais que le bouton est toujours appuyé. En positionnant le délais à 50ms j’arrive à éviter l’intégralité des faux rebonds, et ce délais de 50ms est invisible pour l’utilisateur qui ne s’en rend pas compte. Il faut utiliser un délais de plus de 150ms pour que ça commence à se ressentir par l’utilisateur.


Enfin l’objet RackButtons va contenir deux méthodes rackbuttons.activate_buzzer() et rackbuttons.desactivate_buzzer() qui vont activer ou désactiver le buzzer du jeux lorsque que l’utilisateur appuie sur les boutons poussoirs.


lcd.py


Ce script va gérer la classe Lcd() du jeux avec laquelle nous allons pouvoir écrire des messages sur l’écran LCD avec des caractères personnalisés. Les méthodes lcd.clear() , lcd.msg_centre(lig1, lig2) et lcd_msg(lig1, li2) vont respectivement effacer l’écran, et afficher deux lignes de texte centrées ou non.


Les deux méthodes lcd.write_char(label, pos) et lcd_write_key(n, l) vont respectivement afficher un caractère spécial et une série de n dessins de clés centrées à droite sur la ligne l.


La bibliothèque lcd2ic.py développée par MCHobby permet de créer des caractères spéciaux: ils sont en définition 8 lignes de 5 pixels, donc on utilise pour cela une liste de 8 codes binaires de 5 bits chacun. Pour générer les codes binaires ce site est très utile.


main.py


C’est le script principal que la PYBStick26 va exécuter au démarrage. Elle est composée de la classe Jeux_sins() qui va instancier tous les objets dont nous avons besoin et gérer la boucle principale du jeux.


Au tout début, un message d'accueil avec une musique apparaît, ainsi qu'une petite animation colorée des leds.



Le joueur est ensuite invité à choisir un mode de jeux en appuyant sur l’un des boutons vert, bleu, jaune ou rouge.


  • Vert : facile. De nouvelles séquences de 3 portes à ouvrir sont rajoutées sans modifier les précédentes. Chaque porte est associée à un son.

  • Bleu : moyen, idem que le mode vert mais sans les sons: il faut se fier à sa mémoire visuelle uniquement.

  • Jaune: difficile. Dans ce mode, la séquence de portes à ouvrir est réinitialisée au hasard depuis le début, avec les sons activés.

  • Rouge: expert. Idem mode Jaune mais sans les sons.


Le mode choisi est alors confirmé sur l'écran LCD.




Le joueur est alors invité à observer la séquence de portes (avec ou sans son, selon le mode choisi) à ouvrir, indiquée par le guide, puis reproduire la même séquence, à l'aide du rack de boutons poussoirs.


S'il a ouvert les portes dans le bon ordre sans se tromper: la led verte va clignoter 3 fois, une clé est trouvée, et si le record du mode est battu il est aussi mis à jour.


S'il s’est trompé, il est alors perdu dans le labyrinthe de la PybStick26! Une musique de la loose est jouée, la led rouge clignote 3 fois, et un message est indiqué sur l'écran. Le jeux retourne alors sur l'écran de choix du mode.


Si vous avez trouvé les 10 clés: bravo et respect car c'est vraiment très dur! Le jeux retourne sur l’écran de choix du mode.

logo_papsdroid_64x64.png
suivre l'acutalité du blog sur Facebook:
  • Facebook Social Icône

© 2019, de papsdroid.fr,  administré depuis un Raspberry pi4