Tous les articles par Spi

Installation de l’Octopi

Au début de mon aventure, je vous avais promis un article sur l’Octopi, un compagnon de mon imprimante 3D. J’ai mis du temps à recevoir tout ce dont j’avais besoin, mais le voilà ! Comme toujours, l’idée n’est pas de vous faire une description complète, mais d’expliquer comment je l’ai installé et comment je m’en suis servi.

Qu’est-ce que c’est, un Octopi ?

Octopi, c’est un Raspberry Pi avec l’application Octoprint… Ca ne vous avance peut-être pas de savoir ça. Ok, je vais détailler un peu :

Un Raspberry Pi ?

Un Rapberry Pi est un ordinateur de la taille d’une carte de crédit assez puissant pour des opérations peu consommatrices en ressources comme de la bureautique ou un petit serveur. En l’occurrence, il va servir de serveur d’impression connecté à l’imprimante.

L’image promotionnelle du Raspberry Pi 4 (source : https://www.raspberrypi.org/)

Il existe plusieurs versions, ci-dessus vous voyez la 4 qui est la dernière au moment où j’écris ces lignes. Dans mon cas, j’ai recyclé une version 3. Si vous voulez voir les différences, comparez les modèles 3B et 4B sur la page Wikipedia.

Octoprint ?

Octoprint, c’est l’application web et le serveur qui permettent de manipuler à distance l’imprimante 3D.
Plus d’informations sur leur site : https://octoprint.org/

Si vous vous lancez, pensez à vérifier que votre imprimante est compatible avec Octopi.

Quel usage pour Octopi ?

Pourquoi utiliser ces deux larrons ? Et bien tout simplement parce que ça va me permettre de manipuler l’imprimante (qui n’est pas dans mon bureau) à distance et surtout de la monitorer : c’est bien de savoir qu’une impression est finie (ou qu’elle n’a pas pris feu) sans se déplacer.

Montage time !

Pour le montage, je me suis contenté de suivre les tutoriels ci-dessous. Ils sont en anglais, mais très bien fichus. Portez notamment votre attention sur la liste de produits à commander. Ce serait ballot qu’il vous en manque un lorsqu’il faut attendre la livraison pendant 3 semaines.

La partie la plus compliquée est la connexion du Raspberry en 5V à l’alimentation 24V de l’imprimante car il faut souder un convertisseur de tension LM2596. Elle est cependant facultative : vous pouvez utiliser un transfo de 5V si vous préférez. Ca ajoute juste un câble d’alim en plus.

Le convertisseur de tension à souder

Quelques images du résultat :

Tout cela n’était pas très difficile à assembler. Pour vous donner une idée, voici un résumé de ce que j’ai dû faire :

  1. Me faire livrer le matériel des tutos
  2. Télécharger l’image système d’Octopi
  3. Installer l’image système de Raspbian par Octopi sur le Raspberry Pi avec Win32DiskImager
  4. Configurer Raspbian (le système d’exploitation des Raspberry Pi) grâce à la commande sudo raspi-config
    1. définir les bonnes locales (clavier français)
    2. changer le mot de passe par défaut
    3. activer l’accès en SSH
    4. activer et configurer le Wifi
    5. activer la caméra
  5. Configurer Octopi tel qu’indiqué sur les tutos (notamment pour définir les propriétés de mon imprimante).
  6. Souder le LM2596 et ajuster son voltage.
  7. Imprimer les éléments 3D du tuto + un boitier pour le LM2596 puis ranger la caméra, le Pi et le LM2596 dans leurs boites et les fixer.
  8. Connecter le Raspberry Pi à l’alimentation via le LM2596, puis le Raspberry Pi à l’imprimante en USB.
  9. Régler l’angle de la caméra
  10. Pousser un soupir de soulagement quand tout est fini.

Et voilà !

Au sujet de la commande de matériel, le site de tutos fait beaucoup de liens vers Amazon. Je vous conseille de chercher plutôt sur des sites chinois comme AliExpress. Par exemple, la caméra vaut 30€ sur Amazon et 3€ chez AliExpress.

D’ailleurs parlons en de cette caméra !

Cette coquine de caméra

Je vais m’arrêter quelques instants sur le montage de la “caméra pi” car c’est le seul vrai point qui m’a fait suer. Je pense que j’ai bien essuyé les plâtres et voici les choses à retenir :

  1. Pensez à activer la caméra dans le raspi-config . Allez dans 5 Interfacing options puis dans P1 Camera et activez la.
  2. Faites attention au sens de la nappe :
    1. Sur la caméra, les connecteurs de la nappe (opposés au côté bleu) sont côté caméra.
    2. Sur le Pi, ces connecteurs sont du côté du port HDMI.
  3. La caméra est connectée à sa carte électronique par un petit connecteur clipsable comme celui que vous trouvez dans les téléphones mobiles. Si vous lui imprimez un boitier, prenez bien garde à ne pas le déconnecter lorsque vous insérerez la caméra dedans.
Le connecteur de la raspi-cam qui a tendance à se déclipser.

Je m’arrête là pour le montage, les tutos sont vraiment complets (bien qu’en anglais). Si vous avez des questions, les commentaires sont en-dessous. 🙂

Les fonctions de base

Ca fait quoi un Octopi ? Ca :

L’interface d’Octoprint

Ca offre surtout une interface plus conviviale à distance. Vous avez accès à :

  • une interface claire et assez détaillée,
  • un graph des températures,
  • une visualisation des couches l’impression,
  • une vidéo live du plateau de l’imprimante (si vous avez connecté une caméra compatible) voire même des timelapses,
  • vous pouvez télécharger vos fichiers directement sur Octopi sans avoir à trimbaler votre carte SD du PC à l’imprimante,
Mon premier timelapse avec Octopi.

Des plugins

Il est possible de faire beaucoup plus avec des plugins. Pour commencé, j’ai installé :

  • Change filament : pour changer plus facilement le filament
  • Cost : qui me permet d’estimer le coût de chaque impression
  • Heater timeout : qui coupe la chauffe des éléments pour éviter un bête incendie
  • Simple emergency stop : dit “le gros bouton rouge” pour tout arrêter en cas de problème.

Conclusion

Je viens de terminer l’installation et les tests et je pense que je vous donnerai un retour plus complet d’ici peu. Mais j’ai atteint mon but et c’est déjà super. 🙂

A bientôt !

Le phénix

Assez littéralement, le projet renaît de ses cendres. Souvenez-vous : j’avais fait fondre un câble Molex chinois dont la section était trop fine, puis j’avais mis fin prématurément à la vie de l’Arduino Due en lui proposant du 12V. Les dégâts ne se sont pas limités à l’Arduino et ont au moins attaqué l’écran dot matrix…

Passé une période d’exaspération, j’ai fait deux pas en arrière mais maintenant j’y retourne !

Début d’incendie

Constatation des dégâts

Dieu soit loué, après avoir vérifié l’ensemble du plateau, j’ai effectivement perdu l’écran, mais les flippers sont fonctionnels et le code les fait bouger !
J’avais un problème de retour des flippers en position basse et je l’ai réglé dans la foulée en ponçant le côté rugueux de la palette (en bleu ci-dessous). Pourquoi ce côté était-il rugueux ? Parce que c’est de ce côté qu’était le support d’impression.

Sur cette palette, j’ai poncé l’intérieur qui était rugueux.

C’est la (MOS)fête

Petite anecdote : j’ai acheté des MOSFETs sur Amazon qui me semblaient être basés sur le même schéma que ceux d’AliExpress. Erreur, à 17€, ils ont été livrés sans aucune documentation et chaque test a fait cramer un MOSFET. Donc c’est un fait avéré, je suis une quiche en électronique et je vais préférer le truc chinois moins cher qui marche.

L’écran est mort, vive l’écran !

L’article L’afficheur à LEDs avait été écrit avant le grand incendie d’avril 2020. Aujourd’hui, comme l’écran que vous avez pu voir ne répond plus, il va falloir que je trouve un autre système. Ca va me permettre de tester quelque chose de plus ambitieux (et lisible ?).

Du coup, je me lance dans un sous-projet avec un écran dot matrix haute résolution acheté chez mes potes chinois (ne croyez pas que je touche des coms pour ces liens ^^).

4 modules de 8×8 LEDs (256 LEDs), c’est finalement assez léger.

Le projet est très sympa car il consiste à manipuler un écran de 64×64 LEDs. Seulement, il y a quelques contraintes :

  • il faut de la puissance de calcul pour manipuler 4096 LEDs RGB.
  • le Due doit être dédié au fonctionnement du flipper et ne soit pas consacrer trop de CPU à l’affichage

Pour me familiariser avec cet écran, je vais commencer par (essayer de) créer un objet design : un “notificateur” un peu joli qui puisse s’intégrer dans un salon. Si ça fonctionne, je passerai sur un écran plus adapté au flipper.

Je vous parlerai de ce projet dés que j’aurai commencé à jouer avec les composants. Je sais déjà que je pourrai interroger une palanquée de web services (déjà fait dans un projet précédent) comme récupérer l’heure atomique, la météo, des news, etc.

Concernant le matos : je vais essayer de créer un écran autonome avec son propre contrôleur, un truc sobre mais assez coui**u : un WeMos D1 Mini boosté (sorte d’Arduino), car il faut ça pour alimenter de façon fluide 4096 LEDs.

Petit mais costaud, un ESP8266 ESP32

Et l’écran sera un pavé P2.5 160*160mm en 64*64 pixels de chez… Ali, ouiii, vous êtes forts ! Ce qui est amusant, c’est que ces écrans sont ceux utilisés pour monter des murs d’image. Heureusement, quand il n’y a qu’un seul module 64×64, pas besoin de recourir à des cartes “graphiques” chères, mon Wemos suffira.

Le panneau de test.

Côté planning, je vais donc commencer par ce projet autonome pour en faire un PoC, voire une oeuvre d’art (on se motive comme on peut). Ensuite, je vais probablement utiliser un écran de plus faible définition pour le flipper (qui peut le plus, peut le moins ^^) et tâcher de faire communiquer le Due du flipper avec un Wemos D1 de façon à ce que le Due soit toujours le plus libre possible.

Bon, la motivation revient, donc on y retourne ! (mais en même temps, je reprends le taff, donc à un train de sénateur). See ya !

L’afficheur A LEDs

Tout flipper qui se respecte a son afficheur de score. Et aujourd’hui, on utilise des afficheurs à matrice de LEDs (dot matrix). Ca tombe bien, j’en avais un petit d’avance :

L’afficheur LCD

Il s’agit d’un assemblage de 4 modules à LEDs déjà tout prêt et accessible en SPI. A terme, j’aimerais en avoir 4 autres. Pour le manipuler, on va le connecter sur l’Arduino :

  • VCC au +5V de l’Arduino,
  • GND au neutre,
  • CLK à une broche “clock”
  • DIN (ou MOSI) à une broche “données”
  • CS à une broche de sélection de l’esclave SPI avec lequel le maître souhaite discuter.

Il ne s’agit pas d’I2C, donc pas besoin a priori d’utiliser des broches spécifiques.

Pour coder l’affichage, j’ai utilisé MD_MAX72xx qui est téléchargeable dans la liste des bibliothèques d’Arduino. Elle permet de manipuler mon afficheur en ayant déjà prévu un jeu de caractères en matrice de points. Du coup, le code se limite à ceci :

1. L’initialisation du module en indiquant les pins utilisées et le nombre d’écrans connectés (ici 4).

MD_MAX72XX mx = MD_MAX72XX(DATA_PIN, CLK_PIN, CS_PIN, MAX_DEVICES);
...
mx.begin();

2. L’affichage de texte.

printText(0, MAX_DEVICES-1, "Salut !");

“printText” n’est pas disponible par défaut, mais vous avez un exemple sur le GitHub du projet.

Et voilà !

Vous pouvez intégrer des animations (scrolling, variation d’intensité), mais attention à ce qu’elles ne bloquent pas la boucle le temps qu’elles s’exécutent. Ce serait dommage de ne pas pouvoir lever un flipper parce qu’un texte scrolle. Il existe des bibliothèques comme “VariableTimedAction” qui sont censées permettre un simili multi-thread. J’ai testé rapidement, mais ça me semblait sortir l’artillerie lourde pour pas grand chose.

Vu qu’AliExpress fonctionne de nouveau, j’ai commandé un autre lot de 4 écrans. 8 est la maximum que commande la bibliothèque et ça permettra d’avoir un affichage lisible.

Le Lance bille

J’ai toujours le même problème : s’il est facile de trouver des pièces de flipper pour pas cher, il faut toujours réinventer la roue lorsqu’on n’est plus à l’échelle. Qu’à cela ne tienne, j’ai modélisé un lance bille basique qui fonctionne très bien :

J’avais peu de place et après méditation, j’ai réalisé que le flipper de mon enfance avait déjà résolu mon problème :

Atomic pinball
Atomic pinball

Et hop, c’est en place ! Ca n’a l’air de rien, mais ça vient après une paire d’échecs :

Les versions qui marchent… mal.

Une bonne chose de faite. 🙂

Brûleeeerrr !

Je mets le projet en pause jusqu’au 6 mai parce que décidément, je ne suis pas très doué avec mes petits doigts boudinés.

Pour tout vous dire, j’ai cramé l’Arduino à cause d’un bête court-circuit : deux brins de fils en 12V qui se touchent, un petit “pouf”, un ridicule nuage de fumée, et plus rien, plus de jus dans le Due. Je viens aussi de vérifier mes cartes de MOSFETS, 2 canaux sont HS car ils laissent toujours passer le courant. C’est ballot quand je pense que j’ai réussi à souder sans faire de court-jus jusqu’ici. C’est la vie “physique”, faut que je m’y fasse. ^^’

La prochaine étape est la réception d’un nouvel Arduino Due qui devrait arriver le 6 mai. D’ici là, je vais tout de même publier 2 articles sur l’écran LED (s’il n’a pas été atteint par le grand blackout) et sur le lance bille que j’ai enfin réussi à faire. Et peut-être, peut-être qu’ensuite, j’arriverai enfin à tester ces £#@%* de flippers !

Petite info du jour : manifestement certains vols chinois reprennent. J’ai reçu aujourd’hui plusieurs commandes AliExpress (dont mes cartes MOSFETs à 6€ que j’ai payées 17€ chez Amazon et que j’ai reçues hier, haha).

A bientôt 🙂

Les flippers ! – Partie 2

Installation du deuxième flipper

Ca se passe exactement comme pour le premier. Il me faut cependant m’assurer que les flippers au repos et levés seront bien symétriques.

Côté code, vu que je vais utiliser le PWM je passe d’un digitalWrite à un analogWrite.

Mise en place des boutons !

Après avoir vérifié les pattes au multimètre (faute de doc), on soude et on teste avec un bouton ! D’abord le petit code de test :

  int pushedSolenoidLeftButton = digitalRead(pinSolenoidLeftButton);

  if (pushedSolenoidLeftButton == 1)
  {
    Serial.println("LEFT PUSHED");  
    analogWrite(pinSolenoidRightFlipper, 255);
  }
  else
  {
    Serial.println("LEFT RELEASED");  
    analogWrite(pinSolenoidRightFlipper, 0);
  }

Et le résultat :

Ajout des ressorts

J’ai commandé quelques ressorts et rondelles, ça sert toujours quand on fait un flipper. Ils ont bravé le confinement pour venir me rejoindre et je les ai aussitôt montés. J’avais d’abord prévu de les accrocher sur le côté du support du solénoïde, mais ce qui est relou, c’est que ça aurait de nouveau ajouté une résistance à mes flippers déjà pas extrêmement puissants. Alors finalement, j’ai placé de petits ressorts que la tête du solénoïde et ça fonctionne très très bien ! C’est finalement le ressort du solénoïde lui-même qui ramène le flipper en position inactive.

Ajout des élastiques

Ca n’a l’air de rien, mais les élastiques vont apporter du confort et un look mieux fini aux flippers. Encore une fois, ceux-ci sont imprimés en PTU.

Ca commence à avoir de la figure !

Ajout des buttées

Et bien non ! Ce paragraphe saute car les flippers sont suffisamment retenus par les ressorts. S’ils continuent à faire leur job, pas besoin de buttées pour les empêcher de monter trop haut.

Tests !

On arrive maintenant à un moment “historique” : je vais tester pour la première fois le flipper !

Et là, c’est le drame*

Premier test pas très probant. Je pensais avoir dimensionné correctement les câbles, c’était sans penser au câble chinois ! Et pourtant tout le monde le sait : si ça vient d’AliExpress, de Banggood, de Wish ou de leurs potes, il faut toujours, toujours faire attention. Toujours vérifier que la qualité du produit est acceptable, et toujours le tester généreusement.

Dans mon cas, j’ai voulu éviter de dénuder une prise Molex de mon alim (sait-on jamais, elle pourrait resservir) et mettre un pont entre elle et la carte des MOSFETs. Pour cela, j’ai acheté un câble qui fournit du 12V (câble jaune) et j’ai coupé le connecteur PCI Express pour le connecter directement à la carte.

* : © Michel Creton, La Nuit des héros.

L’objet du drame

Haha. Bien mal m’en a pris car les câbles d’AliExpress sont mal sertis et trop fins… J’ai bêtement (faut admettre) supposé que les câbles d’alimentation de PC répondaient tous aux mêmes contraintes d’ampérage. Ben non, erreur de débutant, je n’ai pas fais assez attention.

Regardez ci-dessous la différence entre un câble “normal” et un “chinois”.

Je m’estime heureux, seul un MOSFET de la carte a brûlé. J’ai donc fini par dénuder la prise Molex de mon alim et connecter ses brins directement sur la carte. J’ai également recommandé des cartes de MOSFETs sur Amazon pour 3 fois leur prix :'(.

Deuxième test !

Il y aura donc une partie 3 à cet article. Ca montre aussi que quand on débute en électronique, on a beau manipuler des tensions faibles, il faut toujours être prudent.

Les flippers ! – Partie 1

C’est pour moi l’élément le plus important : le flipper ! Il s’agit de la partie mobile située en bas du plateau que vous actionnez pour renvoyer la balle (si si, je vous assure qu’il y en a qui ne savent pas 😉 ).

Si vous suivez ce blog, vous vous souvenez que j’avais testé quelques solénoïdes pour finalement retenir celui de 12 V / 8 A. J’avais ensuite passé du temps à imprimer en 3D le flipper, le boitier du solénoïde et la palette sous le plateau. Depuis, je les ai améliorés et là j’ai reçu les roulements que j’attendais impatiemment. Je vais donc enfin savoir si mes solénoïdes seront assez puissants !

Roule ma poule

Le roulement qui va maintenir l’axe du flipper

Le roulement devrait limiter le frottement et l’usure du bois. Il a un diamètre interne de 8 mm pour une hauteur de 14 mm. L’objet bleu me sert à tester différentes tailles pour le pied des palettes : 7.8, 7.9, ,7.95 et 8 mm. J’opte pour le 7.9 et j’imprime dans le sens de la longueur, ce qui solidifie considérablement le cylindre.

Les éléments à imprimer

Je peux maintenant me lancer dans l’impression des pièces :

Le boitier maintiendra le solénoïde sous le plateau et ce dernier poussera la palette qui fera bouger le flipper. Souvenez-vous de cette vidéo :

Cette fois, il va falloir que je sois précis dans la pose. J’ajoute un “bloque palette” empêchera le flipper d’aller trop haut (il devra balayer un angle de 70°).

J’ajouterai également un ressort léger pour ramener le flipper dans sa position initiale.

Montage

Le temps est venu d’assembler les pièces imprimées et le roulement :

Vous pouvez voir :

  • le boitier qui tient le solénoïde (maintenant légèrement écarté du panneau de bois pour compenser la présence du roulement),
  • la palette repoussée par le solénoïde,
  • le roulement fixé au plateau,
  • le flipper sur le plateau

La palette est disposée pour offrir un angle à 70°, son centre (35°) étant l’horizontale du flipper.

Connexion à l’alimentation

Pour le coup, c’est assez simple, on reprend ce qui a été fait pour les petits solénoïdes de gestion de la perte de bille : je connecte une sortie PWM de l’Arduino à la carte des MOSFETs, ainsi que l’alimentation 5V et la masse. De l”autre côté de la carte, je branche deux câbles reliés au solénoïde de 8 A.

La carte de MOSFETs (image des premiers tests).

Et ça me surprend toujours quand ça marche : le flipper bouge !

Connexion à l’Arduino

Tout d’abord, je vais vérifier que tout fonctionne avec un code très simple :

  digitalWrite(pinSolenoidRightFlipper, HIGH);
  delay(200);
  digitalWrite(pinSolenoidRightFlipper, LOW);
  delay(2000);

Je ne vous mets plus l’intégralité du code, vous connaissez à force. 🙂

Et maintenant, plusieurs choses à vérifier :

Les tests !

Est-ce que l’angle est bon ?

Oui, l’angle est nickel, il me restera juste à ajouter la butée haute du flipper.

Est-ce que la bille coule du guide vers le flipper sans rester bloquée ?

Oui, après une modification légère du guide bleu.

Est-ce que la puissance est suffisante ?

Non. Et c’est un drame, car c’est le solénoïde le plus costaud que j’ai trouvé en 12 V. Mais heureusement, après avoir limé le trou dans lequel passe l’axe du flipper, celui-ci n’a plus de friction notable et il semble avoir une puissance suffisante. Il faudra voir ce que ça donnera avec l’ajout du ressort qui servira à le faire redescendre en position inactive.

C’est donc une victoire relative. J’aurais aimé un peu plus de patate dans les flippers, mais il y a moyen de créer un plateau assez complexe tout de même. 🙂

Et ensuite ?

Plein de choses :

  • imprimer les élastiques des flippers,
  • estimer si la puissance est suffisante pour des rampes,
  • placer le second flipper,
  • voir comment placer des bumpers latéraux avec les gros solénoïdes encombrants sous le plateau.
  • modifier la programmation de l’Arduino pour gérer les balles perdues, moduler l’alimentation des flips et vérifier la réactivité avec un bouton.
  • etc.

Je posterai sans doute un prochain article avec les boutons connectés et les deux flippers opérationnels. A bientôt tout le monde !

Point d’étape du 18 avril

Je n’ai pas fait d’avancée majeure ces dernier temps, mais je ne glande pas ! 😉 Le confinement fait que mes commandes Ali Express sont vraisemblablement bloquées alors je me débrouille, j’avance à tâton. Mais j’avance :

  • J’ai percé les emplacements des flippers, non sans une certaine fébrilité car j’ai l’habitude de trouer puis de dire “Ah merde, c’était pas là, ça va faire con…”
  • J’ai corrigé l’angle des flippers qui ne sera plus de 25 mais de 35° (on voit la différence sur la photo suivante). Je me tâte aussi sur les 6.5° d’inclinaison, mais ça dépendra de la puissance des flippers.
  • J’ai ajouté les guides vers le trou de la perte de balle (en noir).
  • J’ai ajouté quelques menues améliorations comme la tour de rebond dans le trou de perte, et des éléments de maintien des solénoïdes de 2 A.
  • J’attends la livraison de roulements à bille de 8 mm pour maintenir les flippers et monter tout ça. Ca sera un article à part entière !
Le bas du flipper
  • J’ai fait ce qui devrait être le design final du pied du flipper qui sera actionné par le solénoïde de 8 A. Je considère que c’est vraiment LE truc à ne pas rater sur le flipper.
Le pied de flipper qui sera actionné par le gros solénoïde sous le plateau
  • J’ai créé des couloirs latéraux en PLA et à ma grande surprise, ça se comporte de façon satisfaisante. Les gros guides bleus vers les flippers fonctionnent, je vais juste les épaissir si la bille reste bloquée par le flipper lors de mes prochains tests.
Couloirs létéraux
  • J’ai créé un gabarit pour réaliser les bumpers latéraux (sur la photo ci-dessus).
  • J’ai testé l’impression en TPU des gros élastiques. J’ai découvert (mais sans surprise) qu’il va me falloir étirer l’élastique au-delà de la taille prévue pour qu’il soit bien tendu. J’espère que le TPU ne perd pas son élasticité avec le temps (je teste).
  • J’ai galéré à trouver la vitesse d’impression et la température idéale avec le TPU SUNLU. Ce qui fonctionne pour moi :
    • une rétractation faible
    • une vitesse d’impression lente à 20 mm/s
    • une température de 220° pour que la première couche adhère et 210 ensuite.
    • une température de 70° pour mon bed et de 60 ensuite (je pense que les beds des Ender 3 Pro chauffent moins fort que les beds en verre).
    • Une hauteur de couche de 0.28 mm.
    • une rétractation nulle ou très faible.
    • un cierge de prière, magnum édition.
  • Pour les bumpers latéraux : j’ai commencé à réfléchir au montage d’un capteur et d’un solénoïde de renvoi de la bille. Ca sera moins chaud qu’un bumper champignon, mais quand même…
  • J’ai monté un squelette de bumper latéral avec mes poteaux maison :
Un début de bumper. Il est étiré de 1cm de plus sur son côté le plus long pour que l’élastique soit tendu.
  • Je n’ai pas encore réussi à créer un lance-bille compact, mais j’y travaille…
  • J’ai de bonnes idées pour les bumpers champignons avec une grille métallique qui fera le contact sur une autre grille. On en reparlera.
  • J’ai réfléchi à la couverture de la zone basse et à lui ajouter un bandeau de leds qui me permettra au passage d’illuminer les photorésistances.
  • Je pense vous faire une section avec les STL qui fonctionnent bien pour la conception des pièces en 3D.
  • Faudrait que je ne tarde pas à vernir le plateau ! ^^
  • Etc.

Bref, je suis sur tous les fronts en ce moment. 🙂
Le prochain article parlera normalement des flippers. Suspense !

Poteau de flipper en PLA et TPU

Cet article va vous sembler anecdotique (et il l’est dans la conception globale du flipper), mais il parle d’un élément important du plateau : le “poteau de flipper” ou “pinball post”.

Il s’agit d’un objet omniprésent sur tous les flips :

Un “pinball post” tel que vendu chez Pinball Center.

Ce poteau est généralement entourée d’un élastique circulaire ou fait le relais pour un grand élastique. Son but est d’amortir ou de faire rebondir la balle.

Evidemment, dans le cas d’un flipper à l’échelle 2/3, ça ne se trouve pas dans le commerce. Heureusement, quelques camarades de Thingiverse en ont réalisé en 3D. J’ai alors pu récupérer le modèle, réduire sa taille et après quelques essais j’ai obtenu ce que je voulais :

Le modèle final est à droite.

Bien entendu, il manque un élastique que vous voyez en rose ci-dessus. Et bien c’est le moment d’utiliser le TPU !

PLA et TPU

Pour imprimer, j’utilisais jusqu’ici exclusivement du PLA, C’est un plastique dur, assez résistant et recyclable. C’est le standard pour des applications qui n’ont pas de contraintes particulières.

Le TPU est un plastique élastique qui va me permettre de créer des élastiques à la taille que je souhaite. Mon premier test a été de créer la couronne de mon “post” :

Ca marche plutôt pas mal. Je ferai bientôt des tests pour les bumpers latéraux.

Système de retour de bille – Partie 2

Bonjour à tous. Ces derniers jours, je me suis lancé dans une tâche assez nouvelle pour moi (depuis les cours de techno de 6ème en tous cas) : la soudure ! Et avec ça, beaucoup de choses ont avancé.

L’Arduino Due

J’ai remplacé l’Arduino Uno que j’utilisais jusqu’ici par un clone de l’Arduino Due (remplaçant de l’Arduino Mega). Il a plus de connecteurs, ce qui me laisse le temps de voir venir. Vous pouvez lire l’article dédié au Due.

J’ai soudé (et c’est moche) !

J’ai cherché des solutions pour faire quelque chose de propre question circuit, mais soit c’est cher, soit il faut du matériel que je n’ai pas en confinement… En réalité, c’est surtout par flemme et parce que je n’ai pas encore décidé de ce que la partie haute du plateau contiendra.

Pour compenser, j’essaye de ranger le dessous du plateau avec des petites impressions 3D fort efficaces.

J’ai testé (et là ça roxe du poney) !

Et c’est là où je m’étonne moi-même : ça fonctionne ! Dans le jeu, lorsque qu’une bille est perdue, elle est détectée par la photorésistance et elle est renvoyée dans l’injecteur. Ce dernier la détecte à son tour et la remet en jeu. Voyez plutôt :

Les photos résistances fonctionnent !

Et voici le code de test :

int pinSolenoid0 = 8;
int pinSolenoid1 = 11;
int pinPhoto0 = 0;
int pinPhoto1 = 1;
int photocellReading0;
int photocellReading1;

void setup()
{
  // Init Serial
  Serial.begin(9600);
  while(!Serial); // Waiting for serial...
  Serial.println("Starting...");  

  // Set pin mode
  pinMode(pinSolenoid0, OUTPUT);
  pinMode(pinSolenoid1, OUTPUT);
}

void loop()
{
  Serial.println("Sequence");  

  // Read photo
  Serial.print("Photo 0: ");
  photocellReading0 = analogRead(pinPhoto0);
  Serial.println(photocellReading0);
  
  Serial.print("Photo 1: ");
  photocellReading1 = analogRead(pinPhoto1);
  Serial.println(photocellReading1);

  if (photocellReading0 < 300)
  {
    digitalWrite(pinSolenoid0, HIGH);
    delay(100);
    digitalWrite(pinSolenoid0, LOW);
  }
  else
  {
    digitalWrite(pinSolenoid0, LOW);
  }

  if (photocellReading1 < 300)
  {
    digitalWrite(pinSolenoid1, HIGH);
    delay(100);
    digitalWrite(pinSolenoid1, LOW);
  }
  else
  {
    digitalWrite(pinSolenoid1, LOW);
  }
  delay(10);
}

Une nouvelle grande étape de franchie puisque ça signifie que je peux connecter les composants à peu prés comme je le veux ! je vais pouvoir revenir sur les flippers (qui sont sans doute l’élément le plus important du plateau). A très vite !