• Alexis

    Bonjour à tous,
    Dans ce tutoriel nous allons voir comment préparer son impression 3D et la lancer sur l’imprimante 3D upbox.

    Les prérequis

    • Un fichier model 3D
    • Si le fichier n’est pas un .stl : le logiciel blender
    • Si le ficher est pour solidworks vous pouvez facilement le convertir en .stl
    • Du temps (certain impression peuvent prendre plusieurs jours)
    • Une clef USB

    Avis à ceux qui suivent ce tutoriel:
    Ces machines sont dangereuses, il y a des mesures de sécurités a connaitre et a suivre avant de pouvoir s’en servir !

    Mesure de sécurités

    • La tête d’impression est a une température avoisinant les 267°C NE PAS Y TOUCHER !
    • Le plateau d’impression peux atteindre les 70°C de température. Prenez des précautions avant !
    • Les pièces qui viennent d’être finis d’imprimé sont souvent encore chaude. Attendez un peu avant de les sortir.
    • En cas de problème demandé a quelqu’un.

    SOMMAIRE

    1. Mettre en route l’imprimante

    2. Mettre en route l’ordinateur de contrôle

    3. Préparer l’impression

    4. Lancer son impression

    5. Sortir son model

      1) Mettre en route l’imprimante

      • Vérifié d’abord que le plateau est propre. Si il ne l’est pas vous pouvez utilisé la spatule.
        nettoyer le plateau
      • Vérifié l’alimentation: soyer sur que le courant arrive bien a l’ordinateur et a l’imprimante.
      • Mise en route : Il y a un boutton a l’arrière de l’imprimante sur le coté droit.
        boutton arrière
      • Maintenant appuyer longuement sur le bouton power sur le coté droit.
        bouton power

      2) Mettre en route l’ordinateur de contrôle

      • Lancer l’ordinateur en appuyant sur le bouton de démarrage.
        ordinateur
      • Et normalement quand il est prêt sa dois ressembler a sa.
        ready

      3) Préparé l’impression

      • clicker sur le bouton " open " en haut à droite et choisier votre modèle.
        open file
      • Essayer si possible de ne pas mettre vorte model sur les carrés orange ( Ce sont les emplacements des vis du support ).
        placement
        Attention
        Faite bien attention a ce que votre model sois plus petit que le plateau !!

      4) Lancé l’impression

      • Pour lancer l’impression appuyer sur le bouton " imprimer " en haut a droite et choisisser si vous voulez des supports ou non.
        Attention!
        Ne toucher a aucune autre paramètre !!

        parametre
      • Il se peux que cette fenetre apparaisse. Répondez juste non.
        popup
      • Votre impression débuteras toute seul. Une fenetre apparaitras pour vous indiquer le temps estimer et la quantité de matière consomer.
        popup

      5) Sortir son model

      • Lorsque l’impression est terminé vous pouvez retirer le plateau en le faisant glisser vers vous et vous pouvez le décoller avec la spatule.
        plateau
        plateau retirer
        décollage
      • VOILA !
        model sortie
      • Maintenant nettoyer le plateau et remetter le en place.
        nettoyage
        placing back

    posté dans Tutoriels En lire plus
  • Alexis

    Voici un grosse découpe " press-fit " avec la CNC
    Server rack

    Salut à tous !
    Dans ce post je vais documenté la construction de mon serveur rack fait a la CNC pour la FabAcademy .

    Cette construction a été réalisé pour le devoir “Make something big” , litteralement “faite quelque chose de grand”.
    a cette époque j’avais besoin d’un armoir pour serveur qui puisse etre insonorisé et sur les armoire standard il n’y avais pas assez de place pour de l’ isolant phonique. J’ai donc décidé de la crée moi même.

    La construction a commencé par la création de plan sur papier. (Dans mon cas je préfère les tableau blanc.)

    plan
    La seconde chose a faire fut de généré a partir des plans et des mesures calculé dans models 3D me permétant de vérifié si toute les mesures sont bonne.




    Et voilà l’assemblage complet


    Maintenant que les mesures sont vérifié il faut préparer les planches a mettre sur la CNC.





    Comme les planches sont prête on peux commencer a préparré la CNC. La première chose a faire est de la mettre sous tention et de pré-chauffer le moteur.



    Une fois la pré-chauffe terminé on peux monter la fraise.



    La fraise est monté donc il reste plus qu’à faire le niveaux de la fraise.


    Ensuite on place les visses pour maintenir la planche.


    C’est l’heure de lancé le fraisage ! il nous faut mettre le gcode dans l’ordinateur de controle de la CNC et faire les derniers réglages et de lancé le job !





    AELRT(info): On met le X et Y a zero.


    On refresh la preview de March3 et GO !



    Une fois la découpe terminé on retirer les pieces de la planche en enlevant les attaches.






    Voilà les pièces limer et propre .





    On peux mainteant les assembler !



    Je sais , il manque des pièces mais c’est normal, je n’ai eu que peux de temps pour le réalisé et je n’ai pas pus faire les autres morceaux. Mais qui sait, peux etre qu’un jour je le finirai.

    posté dans Projets En lire plus
  • Alexis

    Salut à tous,
    Dans ce tutoriel, nous allons voir comment accéder à votre RPI sans avoir besoin d’écran à portée de main.

    Les prérequis

    • Un câble ethernet
    • Votre Raspberry PI
    • Votre ordinateur

    Sommaire

    1. Les premiers branchements
    2. Le setup du driver réseau
    3. La suite des branchements
    4. La recherche de notre IP
    5. L’installation du logiciel nmap
    6. La recherche de l’IP de la RPI
    7. La connexion en mode console

    1) Les premiers branchements

    Commencer par brancher le câble ethernet à l’ordinateur puis à la RPI
    ![text alternatif](url de l’image)

    2) Le setup du driver réseau

    Ouvrir le panneau de configuration (Control panel ).
    Cliquer sur “centre réseau et partage”.
    Sélectionner votre réseau wifi, puis on accède aux propriétés droit dessus.
    En haut, cliquer sur l’onglet “Partage”, cocher la première case et choisir “Ethernet” dans le menu déroulant juste en dessous.
    On clique OK et c’est bon !

    3) La suite des branchements

    Maintenant, on peut démarrer la RPI en branchant l’alimentation.

    4) La recherche de notre IP

    Pour trouver l’IP ethernet, ouvrir une “cmd” Windows et taper “ipconfig” puis Entrée.
    En lisant ce que ça nous affiche, on peut facilement trouver l’ipv4 de l’ethernet au format X.X.X.1 .

    5) L’installation de nmap

    Lien de téléchargement :
    Pour l’installation, rien de particulier. Cliquer simplement sur “Next” pour continuer l’installation.

    6) A la recherche de la PI !

    Pour trouver l’IP de la RPI, taper “nmap -sn X.X.X.1/24” dans la cmd.
    X.X.X.1 est l’ipv4 de l’ethernet précédemment obtenu (cf. étape 4)

    7) Se connecter a la PI

    Ouvrir “PUTTY”.
    Taper l’ip trouvée de la RPI, puis valider avec la touche Entrée.
    ET VOILA !
    Vous pouvez à présent vous identifiez dans la RPI !

    posté dans Tutoriels En lire plus
  • Alexis

    Protomaton
    Bonjour à tous,
    Dans ce sujet, je vais parler du protomaton, comment il a été construit et programmé.

    Avis à ceux qui suivent ce tutoriel:
    Ce post ne parle que de la partie électronique et informatique du protomaton !

    Avis à ceux qui suivent ce tutoriel:
    Ce post explique très brièvement l’installation de l’image Raspbian !


    Sommaire:

    1. Qu’est ce que le protomaton ?
    2. Les composants
    3. Le montage
    4. Le setup de l’environnement
    5. Le code


    1) Qu’est ce que le protomaton ?

    Le protomaton est un photomaton installé au Proto204 pour les deux ans de celui-ci. Pour prendre une photo, il suffit d’appuyer sur le bouton, d’attendre la fin du décompte, puis l’imprimante imprime votre photo. Les photos prises sont aussi stockées numériquement et sont accessibles via le wifi.


    2) Les composants

    • Raspberry PI 3 model B

    Raspberry Pi
    • PI camera V2

    PI camera
    • Carte micro SD 32Gb
    • un momentary button

    bouton
    • des câbles
    • une imprimante (en USB si possible, c’est plus pratique)
    • un écran (en HDMI si possible sinon il vous faudra trouver un adaptateur)
    • Pour les gens qui utilisent une Raspberry PI 2 et que vous voulez utiliser la fonction d’accès des photos à distance ou tout simplement les poster sur Twitter par exemple, un wifi dungle est requis pour avoir une connexion internet ou pour ceux qui préfèrent un câble ethernet.

    wifi dungle

    Lien matériel :


    3) Le montage

    Le montage est plutôt simple. Un PI avec un écran sur le port HDMI, une imprimante branchée en USB, un bouton câblé sur un GPIO et la pi camera sur le port camera prévu. La PI camera peut être remplacée par une webcam sans aucun souci.

    system monté
    Dessin simplifié :
    croquis du montage


    4) Le setup de l’environement

    En premier lieu, si vous ne l’avez pas encore fait ou ne savez pas comment, il nous faut installer un OS pour notre Raspberry PI.
    Je ne vais traiter ici que très brièvement la question !
    Un tutoriel avec plus de détails est en cours de création. Il sera référencé ici quand il sera prêt.
    Pour faire simple, vous téléchargez win32diskImager ici et aussi l’image à flasher de raspbian ici.

    Maintenant, vous pluggez votre micro SD (ou plutôt son adaptateur) dans votre ordinateur.
    Puis vous ouvrez win32diskimager.
    screenshot de win32diskimager
    Et enfin, vous choisissez le .img de raspbian que vous avez téléchargé et vous cliquer sur write. Simple !
    Ça peut prendre beaucoup de temps, dépendant de la vitesse de transfert.
    INFO ! : Le premier démarrage de votre PI ne sera que de la pré-configuration ! Il vous faudra attendre le second démarrage pour avoir l’interface graphique.
    Une fois terminé, on peut commencer la mise en place des dépendances logiciel et librairie. Mais avant, il faut la mettre à jour.
    Pour ça, simple, tapez les commandes suivantes :

    sudo apt-get update
    sudo apt-get upgrade -y
    sudo apt-get dist-upgrade -y
    sudo apt-get clean

    Le " -y " dans les commandes sert juste a esquiver les questions comme " êtes-vous sûr ? "

    Une fois la mise à jour terminée, je vous conseille de redémarrer la PI en utilisant :

    sudo reboot

    Une fois le redémarrage terminé, il est enfin temps d’installer tous les programmes et librairies dont nous allons avoir besoin.
    Je sais , ça va faire beaucoup de choses à faire. Mais pas de panique, je vous met un " executable " en bash sur le github ici .
    Pour le lancer, simple, juste à taper ces commandes. (Je sais, encore des commandes.):

    git clone https://github.com/PROTO204/Protomaton

    ou juste:

    wget https://github.com/PROTO204/Protomaton/blob/master/setup.sh

    chmod +x setup.sh
    ./setup.sh

    Et voilà, tout fait tout seul ^^.

    Ce petit programme installera tout ce dont vous avez besoin comme python, pygame, picamera, wiringPi et beaucoup d’autres !


    5) le code

    C’est là qu’on attaque le code. Mais avant je vais vous expliquer comment il fonctionne.
    Je sais, j’ai la fâcheuse tendance a détailler les codes en le commentant. Désolé “XD” .
    le début
    On commence par préparer les imports de librairies et les variables:

    # importing libs
    import os # utiliser pour l'interaction avec l'OS
    import sys # nous permet de contrôler les pins GPIO
    import picamera # nous sert a contrôler la camera
    import time # nous sert essentiellement a crée des delay
    import RPi.GPIO as GPIO # on utilise wiringPi pour simplifier le contrôle des GPIOs
    import twitter as tw # le module twitter en python pour poster automatiquement les photos
    import cups # nous sert a contrôler l'imprimante
    from PIL import Image, ImageDraw, ImageFont # nous sert a créer des rendus pour les textes et images
    import io # nous sert a dessiner sur les photos , essentiellement du texte
    import pygame # nous sert a créer une fenêtre plein écran
    
    #-----------------------------------------------------------#
    # 			VARS SETUP     			    #
    #
    pin_button_pic = 17      # pin GPIO pour le bouton pour prendre les photos
    pin_button_stop = 23    # pin GPIO pour le bouton d'arrêt d'urgence du programme
    
    on_screen_text = "Urban Move mentoring"     # le texte à afficher sur la photo
    
    screen_w = 1280       # la largeur de l'écran sur lequel on affiche 
    screen_h = 1024        # la hauteur 
    
    picam_w = 3280       # la résolution de la photo à prendre
    picam_h = 2464
    
    photo_dir = "/home/pi/Desktop/protomaton/photos/"     # le dossier de sauvegarde des photos
    
    pic_ratio = 14.8/10.0        # le ratio pour les calculs de résolution
    
    # Préparation de la police d'écriture
    pygame.font.init()
    fontused = pygame.font.SysFont("monospace", 30)
    txt_font = ImageFont.truetype('/usr/share/fonts/truetype/digital/digital-7.ttf', 100)
    # pré-rendu du texte pour accélérer le programme
    message = fontused.render("Photo prise, patientez...", 1, (255, 255, 255))
    
    stream = io.BytesIO() # création de la mémoire tampon pour les photos
    
    #-----------------------------------------------------------#
    

    Les derniers préparatif :
    Ici, on termine les préparatifs des variables, des fonctions de la caméra etc …

    # calcul de la résolution par rapport au ratio
    ratio_screen = float(screen_w)/float(screen_h)
    ratio_cam = float(picam_w)/float(picam_h)
    
    if ( pic_ratio < ratio_screen ):
    	preview_w = int( float(screen_h) * pic_ratio )
    	preview_h = screen_h
    else :
    	preview_w = screen_w
    	preview_h = int( float(screen_w) / pic_ratio )
    	
    if ( pic_ratio < ratio_cam ):
    	width = int( float(picam_h) * pic_ratio )
    	height = picam_h
    else :
    	width = picam_w
    	height = int( float(picam_w) / pic_ratio )
    	
    	
    # Préparation des GPIO
    #		MODES : BOARD use pysical numbering
    #               BCM use virtual numbering
    GPIO.setmode(GPIO.BCM)
    GPIO.setwarnings(False)
    
    GPIO.setup(18, GPIO.OUT)
    GPIO.output(18, GPIO.HIGH)
    GPIO.setup(24, GPIO.OUT)
    GPIO.output(24, GPIO.HIGH)
    
    GPIO.setup(pin_button_pic, GPIO.IN, pull_up_down=GPIO.PUD_UP)
    GPIO.setup(pin_button_stop, GPIO.IN, pull_up_down=GPIO.PUD_UP)
    
    
    
    #--------------- Préparation de la connexion avec l'imprimante --------------
    printer_conn = cups.Connection()
    printers = printer_conn.getPrinters()
    printer_name = printers.keys()[0]
    
    
    
    #--------- Préparation de la caméra --------------
    
    # preview_hFlip "True" or "False" defines if the preview is flipped or not, picture taken will not be flipped
    preview_hFlip = False
    camera = picamera.PiCamera()
    camera.hflip = preview_hFlip
    camera.resolution = (preview_w, preview_h)
    
    camera.sharpness = 0
    camera.contrast = 0
    camera.brightness = 50
    camera.saturation = 0
    camera.iso = 100
    camera.video_stabilization = False
    camera.exposure_compensation = 0
    camera.exposure_mode = 'auto'
    camera.meter_mode = 'average'
    camera.awb_mode = 'auto'
    #camera.awb_mode = 'off'
    #camera.awb_gains = (0.8,2.6)
    camera.image_effect = 'none'
    
    ##'none'
    ##'negative'
    ##'solarize'
    ##'sketch'
    ##'denoise'
    ##'emboss'
    ##'oilpaint'
    ##'hatch'
    ##'gpen'
    ##'pastel'
    ##'watercolor'
    ##'film'
    ##'blur'
    ##'saturation'
    ##'colorswap'
    ##'washedout'
    ##'posterise'
    ##'colorpoint'
    ##'colorbalance'
    ##'cartoon'
    
    camera.color_effects = None
    camera.rotation = 0
    camera.vflip = False
    camera.zoom = (0.0, 0.0, 1.0, 1.0)
    

    Je sais, la caméra a vraiment une énorme palette de paramètres. Mais ça permet de faire de superbes effets ^_^ !

    Définition des fonctions :
    Ici, on crée les fonctions dont on va avoir besoin

    def countDown(): # sert a dessiner le compte à rebours à l'écran
    	camera.annotate_background = picamera.Color('black')
        	camera.annotate_foreground = picamera.Color('white')
        	camera.annotate_text_size = 100
        	camera.annotate_text = '3'
        	time.sleep(1)
        	camera.annotate_text = '2'
        	time.sleep(1)
        	camera.annotate_text = '1'
        	time.sleep(1)
        	camera.annotate_text = ''
    	
    
    def takePhoto():  # fonction principale de prise de photo
            # on écrit "patientez " à l'écran
    	screen.blit( message, ( ( screen_w - message.get_rect().width ) / 2, ( screen_h - message.get_rect().height ) / 2) )
    	pygame.display.flip()
    	
            # on lance le compte à rebours
    	countDown()
    	
            # ON PREND UNE PHOTO ! ^_^
    	camera.stop_preview()
    	camera.hflip = False
    	camera.resolution = (width, height)
    	stream = io.BytesIO()
    	current_time = time.strftime("%d %m %Y")
    	file_name = time.strftime("%Y%m%d-%H%M%S")
    	print "filename : " + file_name
    	camera.capture( stream, format='jpeg' )
    	stream.seek(0)
    	photo_final = Image.open( stream )
    	photo_final = photo_final.convert( 'RGBA' )
    	stream.flush()
    
            # on ajoute le texte
    	txt_layer = Image.new( 'RGBA', photo_final.size, ( 255, 255, 255, 0 ) ) 
    	draw = ImageDraw.Draw( txt_layer )
    	draw.text( ( width - 550, height - 250 ), current_time[:8] + current_time[10:], font=txt_font, fill=( 255, 60, 0, 150 ) )
    	draw.text( (200, height - 250 ), on_screen_text, font=txt_font, fill=( 255, 60, 0, 150 ) )
    	out = Image.alpha_composite( photo_final, txt_layer )
    
            # on saugarde la photo
    	out.save( photo_dir + file_name + ".jpg", "JPEG" )
            # on l'imprime !
    	printer_conn.printFile( printer_name, photo_dir + file_name + ".jpg", "RPI Printing photo ...", {} )
             # et on affiche une preview a l'écran
    	display_img = pygame.image.load( photo_dir + file_name + ".jpg" )
    	display_img = pygame.transform.scale( display_img, ( preview_w, preview_h ) )
    	
    	if ( pic_ratio < ratio_screen ):
    		screen.blit( display_img, ( ( screen_w - display_img.get_rect().width ) / 2, 0 ) )
    	else :
    		screen.blit( display_img, ( 0, ( screen_h - display_img.get_rect().height ) / 2 ) )
    		
    	pygame.display.flip()
    	time.sleep(5)
    	
    	# on nettoie l'écran
    	screen.fill( ( 0, 0, 0 ) )
    	pygame.display.flip()
    	
            # on relance le mode standby du protomaton
    	camera.hflip = preview_hFlip
    	camera.resolution = ( preview_w, preview_h )
    	camera.start_preview()
    
    
    
    def Stop(): # nous sert à arréter la caméra
    	camera.stop_preview()
    	camera.close()
    	pygame.quit()
    	GPIO.cleanup()
    	stream.close()
    	
    	
    	
    def Photo():  # déclencheur de la prise de photo (plus vraiment utile mais bon ...)
    	takePhoto()
    	
    

    THE END
    Pour finir, la mise en standby du protomaton et la loop boucle !

    	
    pygame.display.init()   # initialisation du système de fenêtre
    screen = pygame.display.set_mode( ( screen_w, screen_h ), pygame.FULLSCREEN )     # création de la fenêtre
    pygame.mouse.set_visible( False )     # on cache la souris
    camera.start_preview() # on lance l'affichage en temps réel de la caméra
    
    
    # la boucle principale
    while True:
    	if (GPIO.input(pin_button_pic) == False):   # on prend une photo ? hein, dis !
    		Photo()
    	elif (GPIO.input(pin_button_stop) == False):    # quoi ? on s'en va déjà ? 
    		Stop()
    
    

    Le code complet est disponible sur le github du smallLab : protomaton_rewrited.py

    posté dans Projets En lire plus

Il semble que votre connexion ait été perdue, veuillez patienter pendant que nous vous re-connectons.