DIY Planet : Made in Fr

Voici ma première modélisation 3D avec OpenScad.
Il s'agit de la borne d'arcade Japonaise « Aero City de Sega » à l'échelle 1/10, basée sur ce papercraft.

Vous la retrouverez partagée sur thingiverse : http://www.thingiverse.com/thing:398356

Elle peut s'imprimer d'un bloc avec la fonction « support » de votre logiciel d'impression, sinon à vous d'éditer le modèle 3D source pour séparer les blocs existants. Toutefois ce premier essai imprimé de taille réduite, montre des problèmes potentiels avec l'impression de l'écran, c'est pourquoi je fourni aussi deux STL avec l'écran séparé.

Cette modélisation mérite sans doute d'être améliorée, donc n'hésitez pas à modifier le fichier source .SCAD.

Pour compléter la scène, il faudrait modéliser un petit tabouret ^_^

Depuis le temps que l'idée circule d'une hémisphère à l'autre de mon cerveau dérangé, j'ai eu l'occasion de jouer un peu avec le raspi, et de faire quelques tests…

• Essentiellement ce qui touche à la gestion des GPIO, de l'allumage de led en bash, en C et en python, aux boutons déclencheurs d'événements.
  

D'abord sur plaque labo, il me fallait envisager un câblage en dur pour faire des choses plus sérieuses et ainsi m'affranchir des faux contacts et autres problèmes de rebond.

• Sur une carte à trous, j'ai donc câblé 7 boutons de récup et un connecteur HE10 pour la relier au port GPIO du raspi.
  

Chaque bouton a donc sa résistance de pull-up de 10kΩ, et j'ai dû y adjoindre par la suite un condensateur de 100nF anti-rebond, car force est de constater que l'anti-rebond logiciel, bah c'est de la merde. (bouncetime=xxx ms)
Du coup la place n'étant pas prévue, il sont soudés à l'arrache… bah tant-pi.

Ajouté également un petit connecteur jack pour récupérer le 5V du Raspberry et alimenter un ampli audio mono à base de LM386, celui-là même que j'avais fabriqué en cours de techno^[1] au collège.

• Avec ceci et un script python je suis donc à même de déclencher une playliste contenant des adresses URL de webradio, chaque boutons ayant sa propre fonction.
  

L'inconvénient c'est que je prévoie pas mal de fonctions et qu'il n'y aura pas suffisamment de boutons… On pourrait donc être tenté de rajouter des GPIO au Raspberry Pi en utilisant une puce MCP23017 ou 23008, mais ça ferait trop de boutons sur un radio-réveil qu'on doit pouvoir manipuler dans la pénombre.

• On va donc assigner plusieurs fonctions pour chaque boutons, simplement en prenant en compte la durée d’appui sur un bouton.
  

 Voici un exemple pour deux boutons :

#!/usr/bin/env python2.7
# coding: utf-8
import time    # import des modules nécessaires
import os, sys
import RPi.GPIO as GPIO
 
CHANNEL = 17    # Définition de variables utiles
CHANNEL2 = 18
long_press = 1
very_long_press = 3
 
GPIO.setmode(GPIO.BCM)    # initialisation des GPIO
GPIO.setup(CHANNEL, GPIO.IN)
GPIO.setup(CHANNEL2, GPIO.IN)
 
def bouton17(a):    # Fonction pour GPIO 17
    button_press_timer = 0
    GPIO.remove_event_detect(CHANNEL)    # empêche le bouton d'être détecté x fois de plus
    while True:
        if(GPIO.input(a) == GPIO.LOW ):    # bouton appuyé
            button_press_timer += 0.2    # incrémente tant que le bouton est maintenu
            print button_press_timer
            print a
 
        else:    # bouton relaché
            if (button_press_timer > very_long_press):    # comparaison des durées
                print"very long press : ", button_press_timer
            elif (button_press_timer > long_press):
                print"long press : ", button_press_timer
            elif (button_press_timer > 0):
                print"short press : ", button_press_timer
            button_press_timer = 0
        time.sleep(0.2)
 
def bouton18(b):    # Fonction pour GPIO 18
    button_press_timer = 0
    GPIO.remove_event_detect(CHANNEL2) # empêche le bouton d'être détecté x fois de plus
    while True:
        if(GPIO.input(b) == GPIO.LOW ): # bouton appuyé
            button_press_timer += 0.2 # incrémente tant que le bouton est maintenu
            print button_press_timer
            print b
 
        else:    # bouton relaché
            if (button_press_timer > very_long_press):    # comparaison des durées
                print"very long press : ", button_press_timer
            elif (button_press_timer > long_press):
                print"long press : ", button_press_timer
            elif (button_press_timer > 0):
                print"short press : ", button_press_timer
            button_press_timer = 0
        time.sleep(0.2)
 
# Définition du déclenchement des boutons à la détection du front descendant
GPIO.add_event_detect(CHANNEL, GPIO.FALLING, callback=bouton17, bouncetime=100)
GPIO.add_event_detect(CHANNEL2, GPIO.FALLING, callback=bouton18, bouncetime=100)
 
while True:
 
    time.sleep (2)
GPIO.cleanup()    # Réinitialisation des GPIO en sortie de script

À charge donc de remplacer les print par les commandes désirées.
Voir aussi la doc de la librairie RPi.GPIO

À suivre…

Le projet OpenAlarm utilisera comme module de transmission des FunkyV3, des cartes de très petites tailles avec tout un tas de composants permettant la connexion à différents type de capteurs, la liaison radio avec la base, etc...

Les Funky V3 sont très petit, pourtant, ils embarquent un bon nombre de composants et pour faire tenir autant de monde sur une surface aussi réduite, pas de mystère, il faut utiliser des composants TRÈS petit, lorsque je dis très petit, je parle de la résistance au format 0402 tout à gauche de la photo ci-dessous :

Et j'en viens à parler d'une des choses qui fait que OpenAlarm à pris beaucoup de retard, c'est que pour pouvoir manipuler des composants aussi petit en quantité (je ne vais pas faire des cartes que pour moi), il faut du matériel approprié.

Impossible de manipuler de tels composants directement avec les mains, avec des brucelles, c'est faisable mais pas pratique, le plus adapté est d'utiliser une pompe de préhension qui n'est rien d'autre qu'une micro ventouse et si on y ajoute une table de placement, alors, là, on tend vers le parfait...

Mais c'est quoi une table de placement ?

C'est assez simple : on place la ou les cartes électroniques sur une surface, on dispose les composants à proximité, et à l'aide d'un support coulissant et par des mouvements de translation, on vient prendre les composants et on les dépose sur le pcb.

Les composants sont « pris » par un système de pompe à dépression pour une grande précision de positionnement et surtout permettant de prendre des composants dans de très petits formats.

Que trouve-t-on sur Internet ?

Un modèle commercial : ERMES - Table de positionnement CMS

Chez Selectronic, on peut trouver la table ci-dessous :

Je vois plusieurs points noirs à leur système :

• La surface sur laquelle on pose son bras est trop petite et non souple, ça sent les douleurs musculaires au bout de quelques heures d'utilisation
• Le stylo n'est pas maintenu droit par un quelconque mécanisme, je pense qu'il est difficile de manipuler des composants très petit comme des 0402
• Le prix n'est pas sérieux...

Le modèle en bois peu chère de vpapanik

Ce modèle est intéressant car il utilise principalement des matériaux de récupération...

Photo originale de http://vpapanik.blogspot.fr/2012/11/low-budget-manual-pick-place.html

Un point intéressant est que la pointe de préhension est solidaire du support coulissant, garantissant ainsi une pose plane du composant.

Au final, le système est ingénieux mais prend beaucoup de place (en hauteur) et j'ai un léger doute concernant la stabilité de l'ensemble, enfin, le support pour le bras n'est pas adapté et à la longue, le frottement de ce dernier sur le bord à angle droit du bois ne doit pas être agréable (voir la dernière photo de son article).

La table de Brian Dorey

Alors là, ça commence à devenir du lourd :

Elle est entièrement en aluminium, elle dispose d'un vrai support pour le bras en cuir / simili, sa tête est articulée et muni d'un moteur pas à pas permettant de choisir l'orientation du composant à l'aide de bouton poussoir se trouvant sur la flanc de la machine.

Il a même publié tous les plans de sa machine sur GitHub.

C'est du super boulot, par contre, elle est difficile d'accès à cause de ses pièces usinées et je la trouve encore assez imposante...

Brian Dorey, non content de sa table de placement manuel, à enchaîné par la suite sur une table de placement automatique plutôt impressionnante : http://www.briandorey.com/?tag=/manual+pick+and+place.

Autre machines...

Je ne vais pas toutes les passer en revue, il y en a trop mais voici quelques pointeurs :

• Une table de positionnement de CIF à 2000€ http://www.cif.fr/en/manual-pick-place-stations/118-station-de-placement-manuel-pour-cms-vegatec.html
• Un projet d'un hackerspace d'Atlanta http://blog.freesideatlanta.org/2014/03/manual-pick-and-place-project.html

Faisons un mix de tout ça

Prenons les bonnes idées, apprenons des erreurs et créons la notre :

• Je veux une table qui reste avec un faible encombrement en hauteur
• Avec le maximum de pièces imprimables à l'aide d'une imprimante 3D
• Le système d'aspiration doit être automatique, pas besoin de pédale ou de bouton supplémentaire en utilisation normale (avec tout de même un mode manuel)
• Un support pour bras suffisamment confortable pour travailler quelques heures de suite
• Un voyant indiquant si la pointe aspire ou non
• Une mécanique fluide (roulements linéaires)

Au moment ou j'écris ces lignes, ma table maison est terminée et parfaitement fonctionnelle, je fais donc durer le suspens et tâcherai de pondre des articles quand je le pourrai pour décrire la machine...